node:http: refresh the socket inactivity timer in the native write path

packages/bun-uws/src/AsyncSocket.h

@@ -274,6 +274,7 @@ struct AsyncSocket {
 
             /* Attempt to write data to the socket */
             int written = us_socket_write((us_socket_t *) this, asyncSocketData->buffer.data(), max_flush_len);
+            asyncSocketData->backlogMoved |= written > 0;
             total_written += written;
 
             /* Check if we couldn't write the entire buffer */
@@ -354,6 +355,7 @@ struct AsyncSocket {
 
             /* Write off as much as we can */
             int written = us_socket_write((us_socket_t *) this, asyncSocketData->buffer.data(), max_flush_len);
+            asyncSocketData->backlogMoved |= written > 0;
             /* On failure return, otherwise continue down the function */
             if ((unsigned int) written < buffer_len) {
                 /* Update buffering (todo: we can do better here if we keep track of what happens to this guy later on) */

packages/bun-uws/src/AsyncSocketData.h

@@ -179,8 +179,14 @@ struct AsyncSocketData {
     /* Whether it has fired the filter with -3 (HttpResponse::setNodeHttpTunnelIdle).
      * +3 undoes it, and an idle socket fires -4 in place of -2. */
     bool filteredIdleTunnel = false;
+    /* Bytes of a write that was pending have reached the kernel: the sends of `buffer` in
+     * AsyncSocket::flush() and write() set it. node:http reads and clears it at a writable
+     * event and when a socket inactivity timeout fires. */
+    bool backlogMoved = false;
 };
 
+static_assert(sizeof(AsyncSocketData<false>) == 48 && sizeof(AsyncSocketData<true>) == 48, "the flags fit in the padding behind peerCertVerifyErrorCode");
+
 }
 
 #endif // UWS_ASYNCSOCKETDATA_H

packages/bun-uws/src/HttpContext.h

@@ -39,6 +39,7 @@
 
 extern "C" void Bun__NodeHTTP__onReadsResumable(int ssl, struct us_socket_t *s);
 extern "C" void Bun__NodeHTTP__onReadParsed(int ssl, struct us_socket_t *s);
+extern "C" void Bun__NodeHTTP__touchInactivityTimer(int ssl, struct us_socket_t *s);
 
 namespace uWS {
 
@@ -896,9 +897,15 @@ struct HttpContext {
 
         /* Attempt to drain the socket buffer before triggering onWritable callback */
         size_t bufferedAmount = asyncSocket->getBufferedAmount();
+        /* Try to flush pending data from the socket's buffer to the network */
+        size_t flushed = bufferedAmount > 0 ? asyncSocket->flush() : 0;
+        if constexpr (IsNodeHttp) {
+            /* node:http compat: bytes of a pending write left, in this flush or in a write() before it. That is activity for an armed socket inactivity timeout. */
+            if ((httpResponseData->state & HttpResponseData<SSL>::HTTP_NODE_TRACKS_ACTIVITY) && httpResponseData->backlogMoved) [[unlikely]] {
+                Bun__NodeHTTP__touchInactivityTimer(SSL, s);
+            }
+        }
         if (bufferedAmount > 0) {
-            /* Try to flush pending data from the socket's buffer to the network */
-            size_t flushed = asyncSocket->flush();
             /* Check if there's still data waiting to be sent after flush attempt */
             if (asyncSocket->getBufferedAmount() > 0) {
                 /* onEnd deferred close for these bytes; a writable event that

packages/bun-uws/src/HttpResponse.h

@@ -921,7 +921,12 @@ struct HttpResponse : public AsyncSocket<SSL> {
         bool chunked = !(httpResponseData->state & (HttpResponseData<SSL>::HTTP_WROTE_CONTENT_LENGTH_HEADER | HttpResponseData<SSL>::HTTP_ANCIENT_REQUEST | HttpResponseData<SSL>::HTTP_CLOSE_DELIMITED));
 
         if (!data.empty()) {
+            /* With nothing buffered the tail is sent directly, which AsyncSocket::write() does not record. */
+            size_t bufferedBefore = Super::getBufferedAmount();
             Super::write(data.data(), data.length());
+            if (Super::getBufferedAmount() < bufferedBefore + data.length()) {
+                httpResponseData->backlogMoved = true;
+            }
         }
         if (chunked) {
             Super::write("\r\n", 2);

packages/bun-uws/src/HttpResponseData.h

@@ -178,11 +178,13 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
          * word (resetResponseState) - these have to survive that. */
         /* node:http: call Bun__NodeHTTP__onReadParsed once the read being parsed is consumed. */
         HTTP_NODE_NOTIFY_READ_PARSED = 1 << 19,
+        /* node:http: JSNodeHTTPServerSocket holds the Timeout of an armed socket inactivity timeout. Server writes and their progress refresh it (Bun__NodeHTTP__touchInactivityTimer). */
+        HTTP_NODE_TRACKS_ACTIVITY = 1 << 24,
 
         HTTP_CONNECTION_SCOPED = HTTP_NODE_PARSING_STOPPED | HTTP_NODE_READS_PAUSED
             | HTTP_NODE_TUNNEL_AFTER_BODY | HTTP_NODE_RECEIVED_FIN | HTTP_CLOSE_WHEN_IDLE
             | HTTP_NODE_CLOSE_AFTER_MESSAGE | HTTP_NODE_CLOSE_AFTER_DRAIN | HTTP_NODE_PEER_ENDED
-            | HTTP_NODE_HALF_CLOSED,
+            | HTTP_NODE_HALF_CLOSED | HTTP_NODE_TRACKS_ACTIVITY,
     };
 
     /* Begin a new response on this connection. Clearing the word in one go is

src/js/ahead-of-time/node/_http_server.ts

@@ -1,5 +1,5 @@
 // What the compiler reads in place of src/js/node/_http_server.ts, which `bun run` evaluates. The two do the same.
-// Written against that file with the SHA-256 ff5fd0cf3ffd5e9a3fb246c83dbbefe854e635a64472500199657149d7819c82.
+// Written against that file with the SHA-256 afe1fa727e188edb03f07d531760d32176b6cf4ddc3b2febb8751ce16f71a6d5.
 // When that file changes, bring the change here and write the new hash: test/internal/second-texts-of-modules.test.ts.
 
 // Hardcoded module "node:_http_server"
@@ -2741,13 +2741,18 @@ function getNodeHTTPServerSocket(): NodeHTTPServerSocketConstructor {
 
     _onTimeout() {
       const handle = this[kHandle];
-      const response = handle?.response;
-      // If there is a response, and it has pending data,
-      // we suppress the timeout because a write is in progress.
-      if (response && response.writableLength! > 0) {
-        // Re-arm so the timeout still fires once the write actually stalls.
-        this._unrefTimer();
-        return;
+      if (handle) {
+        // The connection has closed, and 'close' comes next.
+        if (handle.closed) return;
+        // Node looks at the write queue here: https://github.com/nodejs/node/blob/v26.3.0/lib/net.js#L596-L611
+        // Not under the keep-alive timeout: nothing writes there, and the native connection does not have that timer.
+        if (
+          !this[kKeepAliveTimeoutSet] &&
+          handle.holdTimeoutBackOnce(this.writableLength > 0 || (handle.response?.bufferedAmount ?? 0) > 0)
+        ) {
+          this._unrefTimer();
+          return;
+        }
       }
       this.emit("timeout");
     }
@@ -2968,6 +2973,7 @@ function getNodeHTTPServerSocket(): NodeHTTPServerSocketConstructor {
           clearTimeout(existingTimer);
           this[kSocketTimeoutTimer] = undefined;
           this.$armedTimeout = 0;
+          this[kHandle]?.setInactivityTimer(undefined);
         }
         if (callback !== undefined) {
           validateFunction(callback, "callback");
@@ -2985,6 +2991,10 @@ function getNodeHTTPServerSocket(): NodeHTTPServerSocketConstructor {
           this[kSocketTimeoutTimer] = timer;
           this.$armedTimeout = msecs;
         }
+        // Server writes refresh it there (Node: https://github.com/nodejs/node/blob/v26.3.0/lib/net.js#L1019). Never the keep-alive timer: nothing writes under it.
+        if (!this[kKeepAliveTimeoutSet]) {
+          this[kHandle]?.setInactivityTimer(this[kSocketTimeoutTimer]);
+        }
         if (callback !== undefined) {
           validateFunction(callback, "callback");
           this.once("timeout", callback);
@@ -3881,13 +3891,18 @@ function onResponseFinishHandleSocket(
     // idle period started; onSocketTimeoutTimerExpired grants the remaining
     // budget if the timer fires early, so the socket still closes after
     // exactly `total` ms of idle.
-    if (socket.$armedTimeout === total || isArmedWith(socket, total)) {
+    // The native connection has the timer of a timeout that was armed for this request. Nothing writes under the keep-alive one.
+    const armed = socket.timeout !== 0;
+    if (armed) socket[kHandle]?.setInactivityTimer(undefined);
+    // Before setTimeout(), which hands any other timer to the native connection.
+    socket[kKeepAliveTimeoutSet] = true;
+    // The timer of an armed timeout can have fired, with a 'timeout' listener that kept the socket: setTimeout() starts it again.
+    if (!armed && (socket.$armedTimeout === total || isArmedWith(socket, total))) {
       socket.timeout = total;
     } else {
       socket.setTimeout(total);
     }
     socket[kKeepAliveIdleStart] = DateNow();
-    socket[kKeepAliveTimeoutSet] = true;
   }
 }
 
@@ -4970,7 +4985,8 @@ const finishExchange = function emitResponseFinished(exchange: Exchange): void {
     return finishExchangeInSteps(exchange, flags);
   }
   const idleTimeout = keepAliveTimeout + keepAliveTimeoutBuffer;
-  if (socket.$armedTimeout !== idleTimeout && socket.setTimeout !== serverSocketSetTimeout) {
+  // finishConnection() calls setTimeout() in these two cases.
+  if ((socket.$armedTimeout !== idleTimeout || socket.timeout !== 0) && socket.setTimeout !== serverSocketSetTimeout) {
     ("unlikely");
     return finishExchangeInSteps(exchange, flags);
   }
@@ -5067,13 +5083,19 @@ const finishConnection = function onResponseFinishHandleSocket(
     if (parser != null && parser.incoming === req && req.readableEnded) parser.incoming = null;
   }
   const idleTimeout = exchange.idleTimeout;
-  if (socket.$armedTimeout === idleTimeout || isArmedWith(socket, idleTimeout)) socket.timeout = idleTimeout;
-  else {
+  // The native connection has the timer of a timeout that was armed for this request. Nothing writes under the keep-alive one.
+  const armed = socket.timeout !== 0;
+  if (armed) socket[kHandle]?.setInactivityTimer(undefined);
+  // Before setTimeout(), which hands any other timer to the native connection.
+  socket[kKeepAliveTimeoutSet] = true;
+  // The timer of an armed timeout can have fired, with a 'timeout' listener that kept the socket: setTimeout() starts it again.
+  if (!armed && (socket.$armedTimeout === idleTimeout || isArmedWith(socket, idleTimeout))) {
+    socket.timeout = idleTimeout;
+  } else {
     ("unlikely");
     socket.setTimeout(idleTimeout);
   }
   socket[kKeepAliveIdleStart] = DateNow();
-  socket[kKeepAliveTimeoutSet] = true;
   if (exchange.detachedFrom === null) {
     if (socket._httpMessage === res) {
       socket[kCloseCallback] = undefined;

src/js/node/_http_server.ts

@@ -1966,13 +1966,18 @@ function getNodeHTTPServerSocket() {
 
     _onTimeout() {
       const handle = this[kHandle];
-      const response = handle?.response;
-      // If there is a response, and it has pending data,
-      // we suppress the timeout because a write is in progress.
-      if (response && response.writableLength > 0) {
-        // Re-arm so the timeout still fires once the write actually stalls.
-        this._unrefTimer();
-        return;
+      if (handle) {
+        // The connection has closed, and 'close' comes next.
+        if (handle.closed) return;
+        // Node looks at the write queue here: https://github.com/nodejs/node/blob/v26.3.0/lib/net.js#L596-L611
+        // Not under the keep-alive timeout: nothing writes there, and the native connection does not have that timer.
+        if (
+          !this[kKeepAliveTimeoutSet] &&
+          handle.holdTimeoutBackOnce(this.writableLength > 0 || (handle.response?.bufferedAmount ?? 0) > 0)
+        ) {
+          this._unrefTimer();
+          return;
+        }
       }
       this.emit("timeout");
     }
@@ -2187,6 +2192,7 @@ function getNodeHTTPServerSocket() {
         if (existingTimer) {
           clearTimeout(existingTimer);
           this[kSocketTimeoutTimer] = undefined;
+          this[kHandle]?.setInactivityTimer(undefined);
         }
         if (callback !== undefined) {
           validateFunction(callback, "callback");
@@ -2203,6 +2209,10 @@ function getNodeHTTPServerSocket() {
           timer.unref();
           this[kSocketTimeoutTimer] = timer;
         }
+        // Server writes refresh it there (Node: https://github.com/nodejs/node/blob/v26.3.0/lib/net.js#L1019). Never the keep-alive timer: nothing writes under it.
+        if (!this[kKeepAliveTimeoutSet]) {
+          this[kHandle]?.setInactivityTimer(this[kSocketTimeoutTimer]);
+        }
         if (callback !== undefined) {
           validateFunction(callback, "callback");
           this.once("timeout", callback);
@@ -2755,13 +2765,18 @@ function onResponseFinishHandleSocket(server, socket, res) {
     // budget if the timer fires early, so the socket still closes after
     // exactly `total` ms of idle.
     const timer = socket[kSocketTimeoutTimer];
-    if (timer !== undefined && timer._idleTimeout === total) {
+    // The native connection has the timer of a timeout that was armed for this request. Nothing writes under the keep-alive one.
+    const armed = socket.timeout !== 0;
+    if (armed) socket[kHandle]?.setInactivityTimer(undefined);
+    // Before setTimeout(), which hands any other timer to the native connection.
+    socket[kKeepAliveTimeoutSet] = true;
+    // The timer of an armed timeout can have fired, with a 'timeout' listener that kept the socket: setTimeout() starts it again.
+    if (!armed && timer !== undefined && timer._idleTimeout === total) {
       socket.timeout = total;
     } else {
       socket.setTimeout(total);
     }
     socket[kKeepAliveIdleStart] = DateNow();
-    socket[kKeepAliveTimeoutSet] = true;
   }
 }
 

src/js/private.d.ts

@@ -2440,8 +2440,6 @@ declare namespace $Node {
     takeRequestTrailers(lenient: boolean): string[] | undefined;
     takeRawHeaders(headers: IncomingHttpHeaders | null): string[] | undefined;
     headersObject(): IncomingHttpHeaders | undefined;
-    /** No member of the native class. The server's socket asks for it in `_onTimeout()`. */
-    readonly writableLength?: number;
   }
 
   /** The native class `NodeHTTPServerSocket` (src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp): one connection. */
@@ -2481,6 +2479,10 @@ declare namespace $Node {
     stopParsing(): void;
     closeWhenDrained(): void;
     closeIfIdle(): boolean;
+    /** Hands over the `Timeout` of an armed socket inactivity timeout, or takes it back. While the connection holds it, the writes of the server and their progress refresh it. */
+    setInactivityTimer(timer: Timeout | undefined): void;
+    /** For a timer that fired. True when bytes of a pending write left since the last call or refresh, and for the first look at a write that is `pending`. Always false while the connection holds no timer, as under the keep-alive timeout. */
+    holdTimeoutBackOnce(pending: boolean): boolean;
   }
 
   interface Timeout {