@jsenv/server 15.5.3 → 16.0.1

package/src/start_server.js

@@ -8,13 +8,13 @@ import {
   applyRedirectionToRequest,
   createPushRequest,
   fromNodeRequest,
-} from "./interfacing_with_node/request_factory.js";
+} from "./interfacing_with_node/from_node_request.js";
 import { writeNodeResponse } from "./interfacing_with_node/write_node_response.js";
+import { websocketSuffixColorized } from "./internal/colorizeResponseStatus.js";
 import {
-  colorizeResponseStatus,
-  statusToType,
-} from "./internal/colorizeResponseStatus.js";
-import { composeTwoHeaders } from "./internal/headers_composition.js";
+  composeTwoHeaders,
+  composeTwoHeaderValues,
+} from "./internal/headers_composition.js";
 import { listen, stopListening } from "./internal/listen.js";
 import { listenEvent } from "./internal/listenEvent.js";
 import { listenRequest } from "./internal/listenRequest.js";
@@ -23,8 +23,17 @@ import { composeTwoResponses } from "./internal/response_composition.js";
 import { createPolyglotServer } from "./internal/server-polyglot.js";
 import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js";
 import { trackServerPendingRequests } from "./internal/trackServerPendingRequests.js";
+import { createRouter } from "./router/router.js";
 import { timingToServerTimingResponseHeaders } from "./server_timing/timing_header.js";
-import { createServiceController } from "./service_controller.js";
+import {
+  createServiceController,
+  flattenAndFilterServices,
+} from "./service_controller.js";
+import { jsenvServiceAutoreloadOnRestart } from "./services/autoreload_on_server_restart/jsenv_service_autoreload_on_server_restart.js";
+import { jsenvServiceDefaultBody4xx5xx } from "./services/default_body_4xx_5xx/jsenv_service_default_body_4xx_5xx.js";
+import { jsenvServiceInternalClientFiles } from "./services/internal_client_files/jsenv_service_internal_client_files.js";
+import { jsenvServiceOpenFile } from "./services/open_file/jsenv_service_open_file.js";
+import { jsenvServiceRouteInspector } from "./services/route_inspector/jsenv_service_route_inspector.js";
 import {
   STOP_REASON_INTERNAL_ERROR,
   STOP_REASON_NOT_SPECIFIED,
@@ -34,11 +43,16 @@ import {
   STOP_REASON_PROCESS_SIGINT,
   STOP_REASON_PROCESS_SIGTERM,
 } from "./stopReasons.js";
+import { getWebSocketHandler } from "./web_socket_response.js";
 
 import { applyDnsResolution } from "./internal/dns_resolution.js";
 import { parseHostname } from "./internal/hostname_parser.js";
 import { createIpGetters } from "./internal/server_ips.js";
 
+const TIMING_NOOP = () => {
+  return { end: () => {} };
+};
+
 export const startServer = async ({
   signal = new AbortController().signal,
   logLevel,
@@ -65,12 +79,13 @@ export const startServer = async ({
   // auto close when requestToResponse throw an error
   stopOnInternalError = false,
   keepProcessAlive = true,
+  routes = [],
   services = [],
   nagle = true,
   serverTiming = false,
   requestWaitingMs = 0,
-  requestWaitingCallback = ({ request, warn, requestWaitingMs }) => {
-    warn(
+  requestWaitingCallback = ({ request, requestWaitingMs }) => {
+    request.logger.warn(
       createDetailedMessage(
         `still no response found for request after ${requestWaitingMs} ms`,
         {
@@ -139,7 +154,35 @@ export const startServer = async ({
     }
   }
 
+  services = [
+    jsenvServiceOpenFile(),
+    jsenvServiceDefaultBody4xx5xx(),
+    jsenvServiceRouteInspector(),
+    jsenvServiceInternalClientFiles(),
+    jsenvServiceAutoreloadOnRestart(),
+    ...flattenAndFilterServices(services),
+  ];
+
+  const allRouteArray = [];
+  for (const route of routes) {
+    allRouteArray.push(route);
+  }
+  for (const service of services) {
+    const serviceRoutes = service.routes;
+    if (serviceRoutes) {
+      for (const serviceRoute of serviceRoutes) {
+        serviceRoute.service = service;
+        allRouteArray.push(serviceRoute);
+      }
+    }
+  }
+
+  const router = createRouter(allRouteArray, {
+    optionsFallback: true,
+  });
+
   const server = {};
+
   const serviceController = createServiceController(services);
   const processTeardownEvents = {
     SIGHUP: stopOnExit,
@@ -277,7 +320,9 @@ export const startServer = async ({
   // we can proceed to create a stop function to stop it gacefully
   // and add a request handler
   stopCallbackSet.add(({ reason }) => {
-    logger.info(`${serverName} stopping server (reason: ${reason})`);
+    if (reason !== STOP_REASON_PROCESS_BEFORE_EXIT) {
+      logger.info(`${serverName} stopping server (reason: ${reason})`);
+    }
   });
   stopCallbackSet.add(async () => {
     await stopListening(nodeServer);
@@ -348,15 +393,279 @@ export const startServer = async ({
     });
   });
 
-  request: {
-    const requestCallback = async (nodeRequest, nodeResponse) => {
-      // pause the stream to let a chance to "requestToResponse"
-      // to call "requestRequestBody". Without this the request body readable stream
-      // might be closed when we'll try to attach "data" and "end" listeners to it
-      nodeRequest.pause();
-      if (!nagle) {
-        nodeRequest.connection.setNoDelay(true);
+  const applyRequestInternalRedirection = (request) => {
+    serviceController.callHooks(
+      "redirectRequest",
+      request,
+      {},
+      (newRequestProperties) => {
+        if (newRequestProperties) {
+          request = applyRedirectionToRequest(request, {
+            original: request.original || request,
+            previous: request,
+            ...newRequestProperties,
+          });
+        }
+      },
+    );
+    return request;
+  };
+
+  const prepareHandleRequestOperations = (nodeRequest, nodeResponse) => {
+    const receiveRequestOperation = Abort.startOperation();
+    receiveRequestOperation.addAbortSignal(stopAbortSignal);
+    const sendResponseOperation = Abort.startOperation();
+    sendResponseOperation.addAbortSignal(stopAbortSignal);
+    receiveRequestOperation.addAbortSource((abort) => {
+      const closeEventCallback = () => {
+        if (nodeRequest.complete) {
+          receiveRequestOperation.end();
+        } else {
+          nodeResponse.destroy();
+          abort();
+        }
+      };
+      nodeRequest.once("close", closeEventCallback);
+      return () => {
+        nodeRequest.removeListener("close", closeEventCallback);
+      };
+    });
+    sendResponseOperation.addAbortSignal(receiveRequestOperation.signal);
+    return [receiveRequestOperation, sendResponseOperation];
+  };
+  const getResponseProperties = async (request, { pushResponse }) => {
+    const timings = {};
+    const timing = serverTiming
+      ? (name) => {
+          const start = performance.now();
+          timings[name] = null;
+          return {
+            name,
+            end: () => {
+              const end = performance.now();
+              const duration = end - start;
+              timings[name] = duration;
+            },
+          };
+        }
+      : TIMING_NOOP;
+    const startRespondingTiming = timing("time to start responding");
+
+    request.logger.info(
+      request.headers["upgrade"] === "websocket"
+        ? `GET ${request.url} ${websocketSuffixColorized}`
+        : request.parent
+          ? `Push ${request.resource}`
+          : `${request.method} ${request.url}`,
+    );
+    let requestWaitingTimeout;
+    if (requestWaitingMs) {
+      requestWaitingTimeout = setTimeout(
+        () =>
+          requestWaitingCallback({
+            request,
+            requestWaitingMs,
+          }),
+        requestWaitingMs,
+      ).unref();
+    }
+
+    let headersToInject;
+    const finalizeResponseProperties = (responseProperties) => {
+      if (serverTiming) {
+        startRespondingTiming.end();
+        responseProperties.headers = composeTwoHeaders(
+          responseProperties.headers,
+          timingToServerTimingResponseHeaders(timings),
+        );
+      }
+      if (requestWaitingMs) {
+        clearTimeout(requestWaitingTimeout);
+      }
+      if (
+        request.method !== "HEAD" &&
+        responseProperties.headers &&
+        responseProperties.headers["content-length"] > 0 &&
+        !responseProperties.body
+      ) {
+        request.logger.warn(
+          `content-length response header found without body`,
+        );
+      }
+
+      if (headersToInject) {
+        responseProperties.headers = composeTwoHeaders(
+          responseProperties.headers,
+          headersToInject,
+        );
+      }
+      serviceController.callHooks(
+        "injectResponseProperties",
+        request,
+        responseProperties,
+        (returnValue) => {
+          if (!returnValue) {
+            return;
+          }
+          responseProperties = composeTwoResponses(
+            responseProperties,
+            returnValue,
+          );
+        },
+      );
+      // the node request readable stream is never closed because
+      // the response headers contains "connection: keep-alive"
+      // In this scenario we want to disable READABLE_STREAM_TIMEOUT warning
+      if (
+        responseProperties.headers.connection === "keep-alive" &&
+        request.body
+      ) {
+        clearTimeout(request.body.timeout);
+      }
+      return responseProperties;
+    };
+
+    let timeout;
+    try {
+      request = applyRequestInternalRedirection(request);
+      const timeoutResponsePropertiesPromise = new Promise((resolve) => {
+        timeout = setTimeout(() => {
+          resolve({
+            // the correct status code should be 500 because it's
+            // we don't really know what takes time
+            // in practice it's often because server is trying to reach an other server
+            // that is not responding so 504 is more correct
+            status: 504,
+            statusText: `server timeout after ${
+              responseTimeout / 1000
+            }s waiting to handle request`,
+          });
+        }, responseTimeout);
+      });
+      const routerResponsePropertiesPromise = (async () => {
+        const fetchSecondArg = {
+          timing,
+          pushResponse,
+          injectResponseHeader: (name, value) => {
+            if (!headersToInject) {
+              headersToInject = {};
+            }
+            headersToInject[name] = composeTwoHeaderValues(
+              name,
+              headersToInject[name],
+              value,
+            );
+          },
+        };
+        serviceController.callHooks(
+          "augmentRouteFetchSecondArg",
+          request,
+          fetchSecondArg,
+          (properties) => {
+            if (properties) {
+              Object.assign(fetchSecondArg, properties);
+            }
+          },
+        );
+        const routerResponseProperties = await router.match(
+          request,
+          fetchSecondArg,
+        );
+        return routerResponseProperties;
+      })();
+      const responseProperties = await Promise.race([
+        timeoutResponsePropertiesPromise,
+        routerResponsePropertiesPromise,
+      ]);
+      clearTimeout(timeout);
+      return finalizeResponseProperties(responseProperties);
+    } catch (e) {
+      clearTimeout(timeout);
+      if (e.name === "AbortError" && request.signal.aborted) {
+        // let it propagate to the caller that should catch this
+        throw e;
+      }
+      // internal error, create 500 response
+      if (
+        // stopOnInternalError stops server only if requestToResponse generated
+        // a non controlled error (internal error).
+        // if requestToResponse gracefully produced a 500 response (it did not throw)
+        // then we can assume we are still in control of what we are doing
+        stopOnInternalError
+      ) {
+        // il faudrais pouvoir stop que les autres response ?
+        stop(STOP_REASON_INTERNAL_ERROR);
       }
+      const handleErrorReturnValue =
+        await serviceController.callAsyncHooksUntil("handleError", e, {
+          request,
+        });
+      if (!handleErrorReturnValue) {
+        throw e;
+      }
+      request.logger.error(
+        createDetailedMessage(`internal error while handling request`, {
+          "error stack": e.stack,
+        }),
+      );
+      const responseProperties = composeTwoResponses(
+        {
+          status: 500,
+          statusText: "Internal Server Error",
+          headers: {
+            // ensure error are not cached
+            "cache-control": "no-store",
+          },
+        },
+        handleErrorReturnValue,
+      );
+      return finalizeResponseProperties(responseProperties);
+    }
+  };
+  const sendResponse = async (
+    responseStream,
+    responseProperties,
+    { signal, request },
+  ) => {
+    // When "pushResponse" is called and the parent response has no body
+    // the parent response is immediatly ended. It means child responses (pushed streams)
+    // won't get a chance to be pushed.
+    // To let a chance to pushed streams we wait a little before sending the response
+    const ignoreBody = request.method === "HEAD";
+    const bodyIsEmpty = !responseProperties.body || ignoreBody;
+    if (bodyIsEmpty && request.logger.hasPushChild) {
+      await new Promise((resolve) => setTimeout(resolve));
+    }
+    await writeNodeResponse(responseStream, responseProperties, {
+      signal,
+      ignoreBody,
+      onAbort: () => {
+        request.logger.info(`response aborted`);
+        request.logger.end();
+      },
+      onError: (error) => {
+        request.logger.error(
+          createDetailedMessage(`An error occured while sending response`, {
+            "error stack": error.stack,
+          }),
+        );
+        request.logger.end();
+      },
+      onHeadersSent: ({ status, statusText }) => {
+        request.logger.onHeadersSent({
+          status,
+          statusText: responseProperties.statusMessage || statusText,
+        });
+        request.logger.end();
+      },
+      onEnd: () => {
+        request.logger.end();
+      },
+    });
+  };
+
+  request: {
+    const requestEventHandler = async (nodeRequest, nodeResponse) => {
       if (redirectHttpToHttps && !nodeRequest.connection.encrypted) {
         nodeResponse.writeHead(301, {
           location: `${serverOrigin}${nodeRequest.url}`,
@@ -373,642 +682,301 @@ export const startServer = async ({
         return;
       }
 
-      const receiveRequestOperation = Abort.startOperation();
-      receiveRequestOperation.addAbortSignal(stopAbortSignal);
-      const sendResponseOperation = Abort.startOperation();
-      sendResponseOperation.addAbortSignal(stopAbortSignal);
-      receiveRequestOperation.addAbortSource((abort) => {
-        const closeEventCallback = () => {
-          if (nodeRequest.complete) {
-            receiveRequestOperation.end();
-          } else {
-            nodeResponse.destroy();
-            abort();
-          }
-        };
-        nodeRequest.once("close", closeEventCallback);
-        return () => {
-          nodeRequest.removeListener("close", closeEventCallback);
-        };
-      });
-      sendResponseOperation.addAbortSignal(receiveRequestOperation.signal);
-
+      const [receiveRequestOperation, sendResponseOperation] =
+        prepareHandleRequestOperations(nodeRequest, nodeResponse);
       const request = fromNodeRequest(nodeRequest, {
         signal: stopAbortSignal,
         serverOrigin,
+        requestBodyLifetime,
+        logger,
+        nagle,
       });
 
-      // Handling request is asynchronous, we buffer logs for that request
-      // until we know what happens with that request
-      // It delays logs until we know of the request will be handled
-      // but it's mandatory to make logs readable.
-      const rootRequestNode = {
-        logs: [],
-        children: [],
-      };
-      const addRequestLog = (node, { type, value }) => {
-        node.logs.push({ type, value });
-      };
-      const onRequestHandled = (node) => {
-        if (node !== rootRequestNode) {
-          // keep buffering until root request write logs for everyone
-          return;
-        }
-        const prefixLines = (string, prefix) => {
-          return string.replace(/^(?!\s*$)/gm, prefix);
-        };
-        const writeLog = (
-          { type, value },
-          { someLogIsError, someLogIsWarn, depth },
-        ) => {
-          if (depth > 0) {
-            value = prefixLines(value, "  ".repeat(depth));
-          }
-          if (type === "info") {
-            if (someLogIsError) {
-              type = "error";
-            } else if (someLogIsWarn) {
-              type = "warn";
+      try {
+        const responseProperties = await getResponseProperties(request, {
+          pushResponse: async ({ path, method }) => {
+            const pushRequestLogger = request.logger.forPush();
+            if (typeof path !== "string" || path[0] !== "/") {
+              pushRequestLogger.warn(
+                `response push ignored because path is invalid (must be a string starting with "/", found ${path})`,
+              );
+              return;
             }
-          }
-          logger[type](value);
-        };
-        const visitRequestNodeToLog = (requestNode, depth) => {
-          let someLogIsError = false;
-          let someLogIsWarn = false;
-          requestNode.logs.forEach((log) => {
-            if (log.type === "error") {
-              someLogIsError = true;
+            if (!request.http2) {
+              pushRequestLogger.warn(
+                `response push ignored because request is not http2`,
+              );
+              return;
             }
-            if (log.type === "warn") {
-              someLogIsWarn = true;
+            const canPushStream = testCanPushStream(nodeResponse.stream);
+            if (!canPushStream.can) {
+              pushRequestLogger.debug(
+                `response push ignored because ${canPushStream.reason}`,
+              );
+              return;
             }
-          });
-
-          const firstLog = requestNode.logs.shift();
-          const lastLog = requestNode.logs.pop();
-          const middleLogs = requestNode.logs;
-
-          writeLog(firstLog, { someLogIsError, someLogIsWarn, depth });
-          middleLogs.forEach((log) => {
-            writeLog(log, { someLogIsError, someLogIsWarn, depth });
-          });
-          requestNode.children.forEach((child) => {
-            visitRequestNodeToLog(child, depth + 1);
-          });
-          if (lastLog) {
-            writeLog(lastLog, {
-              someLogIsError,
-              someLogIsWarn,
-              depth: depth + 1,
-            });
-          }
-        };
-        visitRequestNodeToLog(rootRequestNode, 0);
-      };
-      nodeRequest.on("error", (error) => {
-        if (error.message === "aborted") {
-          addRequestLog(rootRequestNode, {
-            type: "debug",
-            value: createDetailedMessage(`request aborted by client`, {
-              "error message": error.message,
-            }),
-          });
-        } else {
-          // I'm not sure this can happen but it's here in case
-          addRequestLog(rootRequestNode, {
-            type: "error",
-            value: createDetailedMessage(`"error" event emitted on request`, {
-              "error stack": error.stack,
-            }),
-          });
-        }
-      });
-
-      const pushResponse = async ({ path, method }, { requestNode }) => {
-        const http2Stream = nodeResponse.stream;
 
-        // being able to push a stream is nice to have
-        // so when it fails it's not critical
-        const onPushStreamError = (e) => {
-          addRequestLog(requestNode, {
-            type: "error",
-            value: createDetailedMessage(
-              `An error occured while pushing a stream to the response for ${request.resource}`,
-              {
-                "error stack": e.stack,
-              },
-            ),
-          });
-        };
-
-        // not aborted, let's try to push a stream into that response
-        // https://nodejs.org/docs/latest-v16.x/api/http2.html#http2streampushstreamheaders-options-callback
-        let pushStream;
-        try {
-          pushStream = await new Promise((resolve, reject) => {
-            http2Stream.pushStream(
-              {
-                ":path": path,
-                ...(method ? { ":method": method } : {}),
-              },
-              async (
-                error,
-                pushStream,
-                // headers
-              ) => {
-                if (error) {
-                  reject(error);
-                }
-                resolve(pushStream);
-              },
+            let preventedByService = null;
+            const prevent = () => {
+              preventedByService = serviceController.getCurrentService();
+            };
+            serviceController.callHooksUntil(
+              "onResponsePush",
+              { path, method },
+              { request, prevent },
+              () => preventedByService,
             );
-          });
-        } catch (e) {
-          onPushStreamError(e);
-          return;
-        }
-
-        const abortController = new AbortController();
-        // It's possible to get NGHTTP2_REFUSED_STREAM errors here
-        // https://github.com/nodejs/node/issues/20824
-        const pushErrorCallback = (error) => {
-          onPushStreamError(error);
-          abortController.abort();
-        };
-        pushStream.on("error", pushErrorCallback);
-        sendResponseOperation.addEndCallback(() => {
-          pushStream.removeListener("error", onPushStreamError);
-        });
-
-        await sendResponseOperation.withSignal(async (signal) => {
-          const pushResponseOperation = Abort.startOperation();
-          pushResponseOperation.addAbortSignal(signal);
-          pushResponseOperation.addAbortSignal(abortController.signal);
-
-          const pushRequest = createPushRequest(request, {
-            signal: pushResponseOperation.signal,
-            pathname: path,
-            method,
-          });
-
-          try {
-            const responseProperties = await handleRequest(pushRequest, {
-              requestNode,
-            });
-            if (!abortController.signal.aborted) {
-              if (pushStream.destroyed) {
-                abortController.abort();
-              } else if (!http2Stream.pushAllowed) {
-                abortController.abort();
-              } else if (responseProperties.requestAborted) {
-              } else {
-                const responseLength =
-                  responseProperties.headers["content-length"] || 0;
-                const { effectiveRecvDataLength, remoteWindowSize } =
-                  http2Stream.session.state;
-                if (
-                  effectiveRecvDataLength + responseLength >
-                  remoteWindowSize
-                ) {
-                  addRequestLog(requestNode, {
-                    type: "debug",
-                    value: `Aborting stream to prevent exceeding remoteWindowSize`,
-                  });
-                  abortController.abort();
-                }
-              }
+            if (preventedByService) {
+              pushRequestLogger.debug(
+                `response push prevented by "${preventedByService.name}" service`,
+              );
+              return;
             }
-            await sendResponse({
-              signal: pushResponseOperation.signal,
-              request: pushRequest,
-              requestNode,
-              responseStream: pushStream,
-              responseProperties,
-            });
-          } finally {
-            await pushResponseOperation.end();
-          }
-        });
-      };
 
-      const handleRequest = async (request, { requestNode }) => {
-        let requestReceivedMeasure;
-        if (serverTiming) {
-          requestReceivedMeasure = performance.now();
-        }
-        addRequestLog(requestNode, {
-          type: "info",
-          value: request.parent
-            ? `Push ${request.resource}`
-            : `${request.method} ${request.url}`,
-        });
-        const warn = (value) => {
-          addRequestLog(requestNode, {
-            type: "warn",
-            value,
-          });
-        };
+            const http2Stream = nodeResponse.stream;
 
-        let requestWaitingTimeout;
-        if (requestWaitingMs) {
-          requestWaitingTimeout = setTimeout(
-            () => requestWaitingCallback({ request, warn, requestWaitingMs }),
-            requestWaitingMs,
-          ).unref();
-        }
+            // being able to push a stream is nice to have
+            // so when it fails it's not critical
+            const onPushStreamError = (e) => {
+              pushRequestLogger.error(
+                createDetailedMessage(
+                  `An error occured while pushing a stream to the response for ${request.resource}`,
+                  {
+                    "error stack": e.stack,
+                  },
+                ),
+              );
+            };
 
-        serviceController.callHooks(
-          "redirectRequest",
-          request,
-          { warn },
-          (newRequestProperties) => {
-            if (newRequestProperties) {
-              request = applyRedirectionToRequest(request, {
-                original: request.original || request,
-                previous: request,
-                ...newRequestProperties,
+            // not aborted, let's try to push a stream into that response
+            // https://nodejs.org/docs/latest-v16.x/api/http2.html#http2streampushstreamheaders-options-callback
+            let pushStream;
+            try {
+              pushStream = await new Promise((resolve, reject) => {
+                http2Stream.pushStream(
+                  {
+                    ":path": path,
+                    ...(method ? { ":method": method } : {}),
+                  },
+                  async (
+                    error,
+                    pushStream,
+                    // headers
+                  ) => {
+                    if (error) {
+                      reject(error);
+                    }
+                    resolve(pushStream);
+                  },
+                );
               });
+            } catch (e) {
+              onPushStreamError(e);
+              return;
             }
-          },
-        );
 
-        let handleRequestReturnValue;
-        let errorWhileHandlingRequest = null;
-        let handleRequestTimings = serverTiming ? {} : null;
-
-        let timeout;
-        const timeoutPromise = new Promise((resolve) => {
-          timeout = setTimeout(() => {
-            resolve({
-              // the correct status code should be 500 because it's
-              // we don't really know what takes time
-              // in practice it's often because server is trying to reach an other server
-              // that is not responding so 504 is more correct
-              status: 504,
-              statusText: `server timeout after ${
-                responseTimeout / 1000
-              }s waiting to handle request`,
+            const abortController = new AbortController();
+            // It's possible to get NGHTTP2_REFUSED_STREAM errors here
+            // https://github.com/nodejs/node/issues/20824
+            const pushErrorCallback = (error) => {
+              onPushStreamError(error);
+              abortController.abort();
+            };
+            pushStream.on("error", pushErrorCallback);
+            sendResponseOperation.addEndCallback(() => {
+              pushStream.removeListener("error", onPushStreamError);
             });
-          }, responseTimeout);
-        });
-        const handleRequestPromise = serviceController.callAsyncHooksUntil(
-          "handleRequest",
-          request,
-          {
-            timing: handleRequestTimings,
-            warn,
-            pushResponse: async ({ path, method }) => {
-              if (typeof path !== "string" || path[0] !== "/") {
-                addRequestLog(requestNode, {
-                  type: "warn",
-                  value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`,
-                });
-                return;
-              }
-              if (!request.http2) {
-                addRequestLog(requestNode, {
-                  type: "warn",
-                  value: `response push ignored because request is not http2`,
-                });
-                return;
-              }
-              const canPushStream = testCanPushStream(nodeResponse.stream);
-              if (!canPushStream.can) {
-                addRequestLog(requestNode, {
-                  type: "debug",
-                  value: `response push ignored because ${canPushStream.reason}`,
-                });
-                return;
-              }
 
-              let preventedByService = null;
-              const prevent = () => {
-                preventedByService = serviceController.getCurrentService();
-              };
-              serviceController.callHooksUntil(
-                "onResponsePush",
-                { path, method },
-                {
-                  request,
-                  warn,
-                  prevent,
-                },
-                () => preventedByService,
-              );
-              if (preventedByService) {
-                addRequestLog(requestNode, {
-                  type: "debug",
-                  value: `response push prevented by "${preventedByService.name}" service`,
-                });
-                return;
-              }
+            await sendResponseOperation.withSignal(async (signal) => {
+              const pushResponseOperation = Abort.startOperation();
+              pushResponseOperation.addAbortSignal(signal);
+              pushResponseOperation.addAbortSignal(abortController.signal);
 
-              const requestChildNode = { logs: [], children: [] };
-              requestNode.children.push(requestChildNode);
-              await pushResponse(
-                { path, method },
-                {
-                  requestNode: requestChildNode,
-                  parentHttp2Stream: nodeResponse.stream,
-                },
-              );
-            },
-          },
-        );
-        try {
-          handleRequestReturnValue = await Promise.race([
-            timeoutPromise,
-            handleRequestPromise,
-          ]);
-        } catch (e) {
-          errorWhileHandlingRequest = e;
-        }
-        clearTimeout(timeout);
-
-        let responseProperties;
-        if (errorWhileHandlingRequest) {
-          if (
-            errorWhileHandlingRequest.name === "AbortError" &&
-            request.signal.aborted
-          ) {
-            responseProperties = { requestAborted: true };
-          } else {
-            // internal error, create 500 response
-            if (
-              // stopOnInternalError stops server only if requestToResponse generated
-              // a non controlled error (internal error).
-              // if requestToResponse gracefully produced a 500 response (it did not throw)
-              // then we can assume we are still in control of what we are doing
-              stopOnInternalError
-            ) {
-              // il faudrais pouvoir stop que les autres response ?
-              stop(STOP_REASON_INTERNAL_ERROR);
-            }
-            const handleErrorReturnValue =
-              await serviceController.callAsyncHooksUntil(
-                "handleError",
-                errorWhileHandlingRequest,
-                {
-                  request,
-                  warn,
-                },
-              );
-            if (!handleErrorReturnValue) {
-              throw errorWhileHandlingRequest;
-            }
-            addRequestLog(requestNode, {
-              type: "error",
-              value: createDetailedMessage(
-                `internal error while handling request`,
-                {
-                  "error stack": errorWhileHandlingRequest.stack,
-                },
-              ),
-            });
-            responseProperties = composeTwoResponses(
-              {
-                status: 500,
-                statusText: "Internal Server Error",
-                headers: {
-                  // ensure error are not cached
-                  "cache-control": "no-store",
-                  "content-type": "text/plain",
-                },
-              },
-              handleErrorReturnValue,
-            );
-          }
-        } else {
-          const {
-            status = 501,
-            statusText,
-            statusMessage,
-            headers = {},
-            body,
-            ...rest
-          } = handleRequestReturnValue || {};
-          responseProperties = {
-            status,
-            statusText,
-            statusMessage,
-            headers,
-            body,
-            ...rest,
-          };
-        }
-
-        if (serverTiming) {
-          const responseReadyMeasure = performance.now();
-          const timeToStartResponding =
-            responseReadyMeasure - requestReceivedMeasure;
-          const serverTiming = {
-            ...handleRequestTimings,
-            ...responseProperties.timing,
-            "time to start responding": timeToStartResponding,
-          };
-          responseProperties.headers = composeTwoHeaders(
-            responseProperties.headers,
-            timingToServerTimingResponseHeaders(serverTiming),
-          );
-        }
-        if (requestWaitingMs) {
-          clearTimeout(requestWaitingTimeout);
-        }
-        if (
-          request.method !== "HEAD" &&
-          responseProperties.headers["content-length"] > 0 &&
-          !responseProperties.body
-        ) {
-          addRequestLog(requestNode, {
-            type: "warn",
-            value: `content-length header is ${responseProperties.headers["content-length"]} but body is empty`,
-          });
-        }
-        serviceController.callHooks(
-          "injectResponseHeaders",
-          responseProperties,
-          {
-            request,
-            warn,
-          },
-          (returnValue) => {
-            if (returnValue) {
-              responseProperties.headers = composeTwoHeaders(
-                responseProperties.headers,
-                returnValue,
-              );
-            }
-          },
-        );
-        serviceController.callHooks("responseReady", responseProperties, {
-          request,
-          warn,
-        });
-        return responseProperties;
-      };
-
-      const sendResponse = async ({
-        signal,
-        request,
-        requestNode,
-        responseStream,
-        responseProperties,
-      }) => {
-        // When "pushResponse" is called and the parent response has no body
-        // the parent response is immediatly ended. It means child responses (pushed streams)
-        // won't get a chance to be pushed.
-        // To let a chance to pushed streams we wait a little before sending the response
-        const ignoreBody = request.method === "HEAD";
-        const bodyIsEmpty = !responseProperties.body || ignoreBody;
-        if (bodyIsEmpty && requestNode.children.length > 0) {
-          await new Promise((resolve) => setTimeout(resolve));
-        }
+              const pushRequest = createPushRequest(request, {
+                signal: pushResponseOperation.signal,
+                pathname: path,
+                method,
+                logger: pushRequestLogger,
+              });
 
-        await writeNodeResponse(responseStream, responseProperties, {
-          signal,
-          ignoreBody,
-          onAbort: () => {
-            addRequestLog(requestNode, {
-              type: "info",
-              value: `response aborted`,
-            });
-            onRequestHandled(requestNode);
-          },
-          onError: (error) => {
-            addRequestLog(requestNode, {
-              type: "error",
-              value: createDetailedMessage(
-                `An error occured while sending response`,
-                {
-                  "error stack": error.stack,
-                },
-              ),
-            });
-            onRequestHandled(requestNode);
-          },
-          onHeadersSent: ({ status, statusText }) => {
-            const statusType = statusToType(status);
-            addRequestLog(requestNode, {
-              type:
-                status === 404 && request.pathname === "/favicon.ico"
-                  ? "debug"
-                  : {
-                      information: "info",
-                      success: "info",
-                      redirection: "info",
-                      client_error: "warn",
-                      server_error: "error",
-                    }[statusType],
-              value: `${colorizeResponseStatus(status)} ${
-                responseProperties.statusMessage || statusText
-              }`,
+              try {
+                const responseProperties = await getResponseProperties(
+                  pushRequest,
+                  {
+                    pushResponse: () => {
+                      pushRequest.logger.warn(
+                        `response push ignored because nested push is not supported`,
+                      );
+                    },
+                  },
+                );
+                if (!abortController.signal.aborted) {
+                  if (pushStream.destroyed) {
+                    abortController.abort();
+                  } else if (!http2Stream.pushAllowed) {
+                    abortController.abort();
+                  } else if (responseProperties.requestAborted) {
+                  } else {
+                    const responseLength =
+                      responseProperties.headers["content-length"] || 0;
+                    const { effectiveRecvDataLength, remoteWindowSize } =
+                      http2Stream.session.state;
+                    if (
+                      effectiveRecvDataLength + responseLength >
+                      remoteWindowSize
+                    ) {
+                      pushRequest.logger.debug(
+                        `Aborting stream to prevent exceeding remoteWindowSize`,
+                      );
+                      abortController.abort();
+                    }
+                  }
+                }
+                await sendResponse(pushStream, responseProperties, {
+                  signal: pushResponseOperation.signal,
+                  request: pushRequest,
+                });
+              } finally {
+                await pushResponseOperation.end();
+              }
             });
           },
-          onEnd: () => {
-            onRequestHandled(requestNode);
-          },
         });
-      };
-
-      try {
-        if (receiveRequestOperation.signal.aborted) {
-          return;
+        const webSocketHandler = getWebSocketHandler(responseProperties);
+        if (webSocketHandler) {
+          throw new Error(
+            "unexpected websocketResponse received for request that does not want to be upgraded to websocket. A regular response was expected.",
+          );
         }
-        const responseProperties = await handleRequest(request, {
-          requestNode: rootRequestNode,
-        });
-        nodeRequest.resume();
         if (receiveRequestOperation.signal.aborted) {
           return;
         }
-
-        // the node request readable stream is never closed because
-        // the response headers contains "connection: keep-alive"
-        // In this scenario we want to disable READABLE_STREAM_TIMEOUT warning
-        if (responseProperties.headers.connection === "keep-alive") {
-          clearTimeout(request.body.timeout);
-        }
-
-        await sendResponse({
+        await sendResponse(nodeResponse, responseProperties, {
           signal: sendResponseOperation.signal,
           request,
-          requestNode: rootRequestNode,
-          responseStream: nodeResponse,
-          responseProperties,
         });
       } finally {
         await sendResponseOperation.end();
       }
     };
-    const removeRequestListener = listenRequest(nodeServer, requestCallback);
+    const removeRequestListener = listenRequest(
+      nodeServer,
+      requestEventHandler,
+    );
     // ensure we don't try to handle new requests while server is stopping
     stopCallbackSet.add(removeRequestListener);
   }
 
   websocket: {
     // https://github.com/websockets/ws/blob/master/doc/ws.md#class-websocket
-    const websocketHandlers = [];
-    serviceController.services.forEach((service) => {
-      const { handleWebsocket } = service;
-      if (handleWebsocket) {
-        websocketHandlers.push(handleWebsocket);
+    const webSocketOrigin = https
+      ? `wss://${hostname}:${port}`
+      : `ws://${hostname}:${port}`;
+    server.webSocketOrigin = webSocketOrigin;
+    const webSocketSet = new Set();
+    let upgradeRequestToWebSocketPromise;
+    let upgradeRequestToWebSocket;
+    const loadUpgradeRequestToWebSocket = async () => {
+      if (upgradeRequestToWebSocketPromise) {
+        await upgradeRequestToWebSocketPromise;
+        return;
       }
-    });
-    if (websocketHandlers.length > 0) {
-      const websocketClients = new Set();
       const { WebSocketServer } = await import("ws");
-      let websocketServer = new WebSocketServer({ noServer: true });
-      const websocketOrigin = https
-        ? `wss://${hostname}:${port}`
-        : `ws://${hostname}:${port}`;
-      server.websocketOrigin = websocketOrigin;
-      const upgradeCallback = (nodeRequest, socket, head) => {
-        websocketServer.handleUpgrade(
-          nodeRequest,
-          socket,
-          head,
-          async (websocket) => {
-            const websocketAbortController = new AbortController();
-            websocketClients.add(websocket);
-            websocket.signal = websocketAbortController.signal;
-            websocket.once("close", () => {
-              websocketClients.delete(websocket);
-              websocketAbortController.abort();
-            });
-            const request = fromNodeRequest(nodeRequest, {
-              signal: stopAbortSignal,
-              serverOrigin: websocketOrigin,
-              requestBodyLifetime,
-            });
-            serviceController.callAsyncHooksUntil(
-              "handleWebsocket",
-              websocket,
-              {
-                request,
-              },
-            );
-          },
-        );
-      };
-
-      // see server-polyglot.js, upgrade must be listened on https server when used
-      const facadeServer = nodeServer._tlsServer || nodeServer;
-      const removeUpgradeCallback = listenEvent(
-        facadeServer,
-        "upgrade",
-        upgradeCallback,
-      );
-      stopCallbackSet.add(removeUpgradeCallback);
+      let webSocketServer = new WebSocketServer({ noServer: true });
       stopCallbackSet.add(() => {
-        websocketClients.forEach((websocketClient) => {
-          websocketClient.close();
+        webSocketServer.close();
+        webSocketServer = null;
+      });
+      upgradeRequestToWebSocket = async ({ nodeRequest, socket, head }) => {
+        const websocket = await new Promise((resolve) => {
+          webSocketServer.handleUpgrade(nodeRequest, socket, head, resolve);
         });
-        websocketClients.clear();
-        websocketServer.close();
-        websocketServer = null;
+        return websocket;
+      };
+    };
+    // https://github.com/websockets/ws/blob/b92745a9d6760e6b4b2394bfac78cbcd258a8c8d/lib/websocket-server.js#L491
+    const upgradeEventHandler = async (nodeRequest, socket, head) => {
+      let request = fromNodeRequest(nodeRequest, {
+        signal: stopAbortSignal,
+        serverOrigin,
+        requestBodyLifetime,
+        logger,
+        nagle,
       });
-    }
+      const [receiveRequestOperation, sendResponseOperation] =
+        prepareHandleRequestOperations(nodeRequest, socket);
+      const responseProperties = await getResponseProperties(request, {
+        pushResponse: () => {
+          request.logger.warn(
+            `pushResponse ignored because it's not supported in websocket`,
+          );
+        },
+      });
+      if (receiveRequestOperation.signal.aborted) {
+        return;
+      }
+      if (responseProperties.status !== 101) {
+        await sendResponse(socket, responseProperties, {
+          signal: sendResponseOperation.signal,
+          request,
+        });
+        return;
+      }
+      const webSocketHandler = getWebSocketHandler(responseProperties);
+      if (!webSocketHandler) {
+        throw new Error(
+          "unexpected response received for request that wants to be upgraded to websocket. A webSocketResponse was expected.",
+        );
+      }
+      if (!upgradeRequestToWebSocket) {
+        await loadUpgradeRequestToWebSocket();
+      }
+      if (sendResponseOperation.signal.aborted) {
+        return;
+      }
+      const webSocket = await upgradeRequestToWebSocket({
+        nodeRequest,
+        socket,
+        head,
+      });
+      if (sendResponseOperation.signal.aborted) {
+        webSocket.destroy();
+        return;
+      }
+      const webSocketAbortController = new AbortController();
+      webSocketSet.add(webSocket);
+      webSocket.once("close", () => {
+        webSocketSet.delete(webSocket);
+        webSocketAbortController.abort();
+      });
+      request.logger.onHeadersSent({
+        status: 101,
+        statusText: "Switching Protocols",
+      });
+      request.logger.end();
+      let websocketHandlerReturnValue = await webSocketHandler(webSocket);
+      if (typeof websocketHandlerReturnValue === "function") {
+        webSocket.once("close", () => {
+          websocketHandlerReturnValue();
+          websocketHandlerReturnValue = undefined;
+        });
+      }
+      return;
+    };
+    // see server-polyglot.js, upgrade must be listened on https server when used
+    const facadeServer = nodeServer._tlsServer || nodeServer;
+    const removeUpgradeCallback = listenEvent(
+      facadeServer,
+      "upgrade",
+      upgradeEventHandler,
+    );
+    stopCallbackSet.add(removeUpgradeCallback);
+    stopCallbackSet.add(() => {
+      for (const websocket of webSocketSet) {
+        websocket.close();
+      }
+      webSocketSet.clear();
+    });
   }
 
   if (startLog) {