velocious 1.0.683 → 1.0.685

package/src/http-server/client/request.js

@@ -19,6 +19,17 @@ export default class VelociousHttpServerClientRequest {
     this.client = client
     this.configuration = configuration
     this.requestParser = new RequestParser({configuration})
+
+    /**
+     * Whether the owning client connection was torn down while this request
+     * was still running. Set once by the client on socket teardown and read
+     * by handlers that need to settle in-flight work (e.g. admission queue
+     * positions) without waiting for the response to be sent.
+     * @type {boolean} */
+    this.clientDisconnected = false
+
+    /** @type {Set<() => void>} */
+    this.clientDisconnectCallbacks = new Set()
   }
 
   baseURL() { return `${this.protocol()}://${this.hostWithPort()}` }
@@ -114,6 +125,39 @@ export default class VelociousHttpServerClientRequest {
   rawBody() { return this.getRequestBuffer().getRawBody() }
   socketRemoteAddress() { return this.client?.remoteAddress }
 
+  /**
+   * Marks this request as client-disconnected and runs every registered
+   * disconnect callback exactly once. The owning client invokes it when the
+   * socket tears down; handlers that register afterwards learn of the
+   * disconnect through the `clientDisconnected` field instead.
+   * @returns {void}
+   */
+  markClientDisconnected() {
+    if (this.clientDisconnected) return
+    this.clientDisconnected = true
+    for (const callback of this.clientDisconnectCallbacks) {
+      callback()
+    }
+    this.clientDisconnectCallbacks.clear()
+  }
+
+  /**
+   * Registers a callback that fires once when the client connection tears
+   * down while this request is still running. Buffered requests cannot rely
+   * on the streaming response's `onStreamClose` for that: no stream has
+   * been opened yet, so a queued request's queue position is otherwise
+   * stranded until its admission deadline.
+   * @param {() => void} callback - Disconnect callback.
+   * @returns {void}
+   */
+  onClientDisconnect(callback) {
+    if (this.clientDisconnected) {
+      callback()
+      return
+    }
+    this.clientDisconnectCallbacks.add(callback)
+  }
+
   getRequestBuffer() { return this.getRequestParser().getRequestBuffer() }
   getRequestParser() { return this.requestParser }
 }

package/src/http-server/client/websocket-request.js

@@ -50,6 +50,51 @@ export default class VelociousHttpServerClientWebsocketRequest {
     const queryParams = this._parseQueryParams()
 
     this.paramsObject = {...queryParams, ...this.paramsObject}
+
+    /**
+     * Whether the owning client connection was torn down while this request
+     * was still running. Websocket requests are session-owned and never
+     * enter the client's in-flight request list, so this stays false for
+     * them; the field exists so the request union shares one surface.
+     * @type {boolean} */
+    this.clientDisconnected = false
+
+    /** @type {Set<() => void>} */
+    this.clientDisconnectCallbacks = new Set()
+  }
+
+  /**
+   * Marks this request as client-disconnected and runs every registered
+   * disconnect callback exactly once. The owning client invokes it when the
+   * socket tears down; handlers that register afterwards learn of the
+   * disconnect through the `clientDisconnected` field instead. Websocket
+   * requests are session-owned and never enter the client's in-flight
+   * request list, so this is inert for them; the shared surface keeps the
+   * request union uniform.
+   * @returns {void}
+   */
+  markClientDisconnected() {
+    if (this.clientDisconnected) return
+    this.clientDisconnected = true
+    for (const callback of this.clientDisconnectCallbacks) {
+      callback()
+    }
+    this.clientDisconnectCallbacks.clear()
+  }
+
+  /**
+   * Registers a callback that fires once when the client connection tears
+   * down while this request is still running. See the HTTP request's
+   * {@linkcode markClientDisconnected} for the shared-surface note.
+   * @param {() => void} callback - Disconnect callback.
+   * @returns {void}
+   */
+  onClientDisconnect(callback) {
+    if (this.clientDisconnected) {
+      callback()
+      return
+    }
+    this.clientDisconnectCallbacks.add(callback)
   }
 
   baseURL() {

package/src/http-server/worker-handler/in-process.js

@@ -116,7 +116,13 @@ export default class VelociousHttpServerInProcessHandler {
         httpClient.abortPendingFileResponses(),
         httpClient.abortStreamResponses()
       ])
-        .then(() => {})
+        .then(() => {
+          // Buffered responses have no stream to abort, so their in-flight
+          // handlers never hear about the socket teardown through the
+          // streaming path: notify the running requests directly so they can
+          // settle resources (e.g. admission queue positions) in-process.
+          httpClient.notifyClientDisconnect()
+        })
         .catch((error) => {
           this.logger.warn("Failed to abort responses after client close", error)
         })

package/src/http-server/worker-handler/worker-thread.js

@@ -220,6 +220,11 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     if (client) {
       settlements.push(client.abortPendingFileResponses())
       settlements.push(client.abortStreamResponses())
+      // Buffered responses have no stream to abort, so their in-flight
+      // handlers never hear about the socket teardown through the streaming
+      // path: notify the running requests directly so they can settle
+      // resources (e.g. admission queue positions) in-process.
+      client.notifyClientDisconnect()
     }
 
     for (const [transferId, transfer] of this.fileTransfers) {