node:http: make closeAllConnections()/closeIdleConnections() leave the listener alone and work after close()

src/js/node/_http_server.ts

@@ -494,17 +494,29 @@ Server.prototype.unref = function () {
   return this;
 };
 
+// Node.js's ConnectionsList (what closeAllConnections/closeIdleConnections walk)
+// is parser-keyed, and freeParser() removes a connection once its 'connect' or
+// 'upgrade' request has been received in full: at the handoff for CONNECT and
+// body-less upgrades, after the body for an upgrade that carries one.
+// releaseServerParserShim() nulls socket.parser at the handoff in every case,
+// so a handed-off socket still counts as listed while that body is arriving
+// (hasIncompleteRequest stays set until the message completes).
+function isOutsideConnectionsList(socket) {
+  return socket.parser == null && !socket[kHandle]?.hasIncompleteRequest;
+}
+
 Server.prototype.closeAllConnections = function () {
   closeAllHttp1Connections(this);
-  const server = this[serverSymbol];
-  if (!server) {
+  const connections = this[kTrackedConnections];
+  if (!connections) {
     return;
   }
-  this[serverSymbol] = undefined;
-  clearInterval(this[kConnectionsCheckingInterval]);
-  this.listening = false;
-
-  server.stop(true);
+  for (const socket of connections) {
+    if (isOutsideConnectionsList(socket)) {
+      continue;
+    }
+    socket.destroy();
+  }
 };
 
 Server.prototype.getConnections = function (callback) {
@@ -519,8 +531,33 @@ Server.prototype.getConnections = function (callback) {
 
 Server.prototype.closeIdleConnections = function () {
   closeIdleHttp1Connections(this);
-  const server = this[serverSymbol];
-  server?.closeIdleConnections();
+  const connections = this[kTrackedConnections];
+  if (!connections) {
+    return;
+  }
+  for (const socket of connections) {
+    if (isOutsideConnectionsList(socket)) {
+      continue;
+    }
+    const message = socket._httpMessage;
+    if (message && !message.finished) {
+      continue;
+    }
+    // Deliberately unlike Node.js, which destroys the connection here and
+    // drops the queued responses: a pipelined queue counts as in flight, as it
+    // does for the native idle sweep that close() runs.
+    if (socket[kPipelinedResponses]?.length) {
+      continue;
+    }
+    // Node.js's ConnectionsList.idle() also skips parsers whose
+    // last_message_start_ is set, i.e. a request head or body is still being
+    // received (a connection that has not sent its first request yet counts
+    // too); hasIncompleteRequest is the native handle's view of the same state.
+    if (socket[kHandle]?.hasIncompleteRequest) {
+      continue;
+    }
+    socket.destroy();
+  }
 };
 
 Server.prototype.close = function (optionalCallback?) {

src/jsc/bindings/node/JSNodeHTTPServerSocket.cpp

@@ -300,6 +300,27 @@ bool JSNodeHTTPServerSocket::isRequestTimedOut(uint64_t headersTimeoutMs, uint64
     return isRequestTimedOutImpl<false>(socket, headersTimeoutMs, requestTimeoutMs);
 }
 
+template<bool SSL>
+static bool hasIncompleteRequestImpl(us_socket_t* socket)
+{
+    auto* httpResponseData = reinterpret_cast<uWS::NodeHttpResponseData<SSL>*>(us_socket_ext(socket));
+    if (httpResponseData->isConnectRequest) {
+        return false;
+    }
+    return httpResponseData->lastMessageStartMs != 0;
+}
+
+bool JSNodeHTTPServerSocket::hasIncompleteRequest() const
+{
+    if (!socket || upgraded || us_socket_is_closed(socket)) {
+        return false;
+    }
+    if (is_ssl) {
+        return hasIncompleteRequestImpl<true>(socket);
+    }
+    return hasIncompleteRequestImpl<false>(socket);
+}
+
 bool JSNodeHTTPServerSocket::isAuthorized() const
 {
     // is secure means that tls was established successfully

src/jsc/bindings/node/JSNodeHTTPServerSocket.h

@@ -88,6 +88,10 @@ class JSNodeHTTPServerSocket : public JSC::JSDestructibleObject {
      * (both in milliseconds; 0 disables the respective check). */
     bool isRequestTimedOut(uint64_t headersTimeoutMs, uint64_t requestTimeoutMs) const;
 
+    /* node:http server compat: whether a request message is currently being
+     * received on this connection (Node's parser.last_message_start_ != 0). */
+    bool hasIncompleteRequest() const;
+
     /* node:http server compat - HTTP/1.1 pipelining. Responses for requests
      * that were parsed while an earlier response on this connection was still
      * in flight are queued here (in arrival order) and become the connection's

src/jsc/bindings/node/JSNodeHTTPServerSocketPrototype.cpp

@@ -23,6 +23,7 @@ using namespace WebCore;
 JSC_DECLARE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterOnClose);
 JSC_DECLARE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterOnDrain);
 JSC_DECLARE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterClosed);
+JSC_DECLARE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterHasIncompleteRequest);
 JSC_DECLARE_CUSTOM_SETTER(jsNodeHttpServerSocketSetterOnClose);
 JSC_DECLARE_CUSTOM_SETTER(jsNodeHttpServerSocketSetterOnDrain);
 JSC_DECLARE_CUSTOM_SETTER(jsNodeHttpServerSocketSetterOnData);
@@ -60,6 +61,7 @@ static const JSC::HashTableValue JSNodeHTTPServerSocketPrototypeTableValues[] =
     { "ondata"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterOnData, jsNodeHttpServerSocketSetterOnData } },
     { "bytesWritten"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterBytesWritten, noOpSetter } },
     { "closed"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::ReadOnly), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterClosed, noOpSetter } },
+    { "hasIncompleteRequest"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::ReadOnly), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterHasIncompleteRequest, noOpSetter } },
     { "response"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::ReadOnly), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterResponse, noOpSetter } },
     { "duplex"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterDuplex, jsNodeHttpServerSocketSetterDuplex } },
     { "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::ReadOnly), JSC::NoIntrinsic, { JSC::HashTableValue::GetterSetterType, jsNodeHttpServerSocketGetterRemoteAddress, noOpSetter } },
@@ -513,6 +515,15 @@ JSC_DEFINE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterClosed, (JSC::JSGlobalObjec
     return JSValue::encode(JSC::jsBoolean(thisObject->isClosed()));
 }
 
+JSC_DEFINE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterHasIncompleteRequest, (JSC::JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName propertyName))
+{
+    auto* thisObject = dynamicDowncast<JSNodeHTTPServerSocket>(JSC::JSValue::decode(thisValue));
+    if (!thisObject) [[unlikely]] {
+        return JSValue::encode(JSC::jsUndefined());
+    }
+    return JSValue::encode(JSC::jsBoolean(thisObject->hasIncompleteRequest()));
+}
+
 JSC_DEFINE_CUSTOM_GETTER(jsNodeHttpServerSocketGetterBytesWritten, (JSC::JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName propertyName))
 {
     auto* thisObject = dynamicDowncast<JSNodeHTTPServerSocket>(JSC::JSValue::decode(thisValue));

test/js/bun/http/node-http-halfclose-midupload.test.ts

@@ -67,8 +67,6 @@ async function runTeardownStages(bind: string | undefined, url: (port: number) =
   try {
     expect(await withTimeout(writeResult.promise, "write-after-end")).toBeTrue();
     await withTimeout(fetchSettled, "fetch-settled");
-    // Not server.closeAllConnections(): bun's implementation also stops the
-    // server, which makes the disposal/close below reject.
     socket?.destroy();
     await withTimeout(connectionClosed.promise, "connection-closed");
     const serverClosed = new Promise<void>((resolve, reject) => server.close(err => (err ? reject(err) : resolve())));

test/js/bun/test/parallel/test-http-server.listening-should-work.ts

@@ -6,5 +6,9 @@ const { expect } = createTest(import.meta.path);
 const server = http.createServer();
 await once(server.listen(0), "listening");
 expect(server.listening).toBe(true);
+// closeAllConnections() destroys the connections; it does not stop listening.
 server.closeAllConnections();
+expect(server.listening).toBe(true);
+server.close();
 expect(server.listening).toBe(false);
+await once(server, "close");

test/js/bun/test/parallel/test-http-timeout-destruction-should-be-visible-using-kConnectionsCheckingInterval.ts

@@ -6,5 +6,10 @@ const { expect } = createTest(import.meta.path);
 const { kConnectionsCheckingInterval } = require("_http_server");
 const server = http.createServer();
 await once(server.listen(0), "listening");
+expect(server[kConnectionsCheckingInterval]._destroyed).toBe(false);
+// Only close() tears the interval down; closeAllConnections() keeps listening.
 server.closeAllConnections();
+expect(server[kConnectionsCheckingInterval]._destroyed).toBe(false);
+server.close();
 expect(server[kConnectionsCheckingInterval]._destroyed).toBe(true);
+await once(server, "close");

test/js/first_party/ws/ws.test.ts

@@ -771,6 +771,7 @@ it("Server should be able to send empty pings", async () => {
       return await promise;
     } finally {
       httpServer.closeAllConnections();
+      httpServer.close();
     }
   }
   {