kuzzle 2.49.1 → 2.50.0-beta.4

package/lib/core/network/protocols/httpwsProtocol.js

@@ -1,1254 +0,0 @@
-/*
- * Kuzzle, a backend software, self-hostable and ready to use
- * to power modern apps
- *
- * Copyright 2015-2022 Kuzzle
- * mailto: support AT kuzzle.io
- * website: http://kuzzle.io
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-"use strict";
-
-const querystring = require("querystring");
-const url = require("url");
-const zlib = require("zlib");
-
-const uWS = require("uWebSockets.js");
-
-const { HttpStream } = require("../../../types");
-const { Request } = require("../../../api/request");
-const { KuzzleError } = require("../../../kerror/errors");
-const Protocol = require("./protocol");
-const ClientConnection = require("../clientConnection");
-const { removeStacktrace } = require("../../../util/stackTrace");
-const debug = require("../../../util/debug");
-const kerror = require("../../../kerror");
-const HttpMessage = require("./httpMessage");
-
-const kerrorWS = kerror.wrap("network", "websocket");
-const kerrorHTTP = kerror.wrap("network", "http");
-const debugWS = debug("kuzzle:network:protocols:websocket");
-const debugHTTP = debug("kuzzle:network:protocols:http");
-
-// The idleTimeout option should never be deactivated, so instead we use
-// a default value for backward-compatibility
-const DEFAULT_IDLE_TIMEOUT = 60000;
-
-// Size (in bytes) of backpressure an individual socket can handle before
-// needing to drain
-const WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE = 4096;
-
-// Size of the backpressure buffer: if a client is too slow to absorb the amount
-// of data we need to send to it, then we forcibly close its socket to prevent
-// the server to be impacted by it
-const WS_BACKPRESSURE_BUFFER_MAX_LENGTH = 50;
-
-// Applicative WebSocket PONG message for browsers
-const WS_APP_PONG_RESPONSE = Buffer.from('{"p":2}');
-
-// Used by the broadcast method to build JSON payloads while limiting the
-// number of JSON serializations
-const JSON_ROOM_PROPERTY = ',"room":"';
-const JSON_ENDER = '"}';
-
-// Pre-computed messages & errors
-const WS_FORCED_TERMINATION_CODE = 1011;
-const WS_BACKPRESSURE_MESSAGE = Buffer.from(
-  "too much backpressure: client is too slow",
-);
-const WS_GENERIC_CLOSE_MESSAGE = Buffer.from(
-  "Connection closed by remote host",
-);
-const WS_RATE_LIMIT_EXCEEDED_ERROR = kerrorWS.get("ratelimit_exceeded");
-const HTTP_REQUEST_TOO_LARGE_ERROR = kerrorHTTP.get("request_too_large");
-const HTTP_FILE_TOO_LARGE_ERROR = kerrorHTTP.get("file_too_large");
-
-// HTTP-related constants
-const HTTP_ALLOWED_CONTENT_TYPES = [
-  "application/json",
-  "application/x-www-form-urlencoded",
-  "multipart/form-data",
-];
-const HTTP_SKIPPED_HEADERS = ["content-length", "set-cookie"];
-const HTTP_HEADER_CONNECTION = Buffer.from("Connection");
-const HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN = Buffer.from(
-  "Access-Control-Allow-Origin",
-);
-const HTTP_HEADER_SET_COOKIE = Buffer.from("Set-Cookie");
-const HTTP_HEADER_VARY = Buffer.from("Vary");
-const WILDCARD = Buffer.from("*");
-const ORIGIN = Buffer.from("Origin");
-const X_KUZZLE_REQUEST_ID = Buffer.from("X-Kuzzle-Request-Id");
-const CLOSE = Buffer.from("close");
-const CHARSET_REGEX = /charset=([\w-]+)/i;
-
-/**
- * @class HTTPWS
- * Handles both HTTP and WebSocket connections
- */
-class HttpWsProtocol extends Protocol {
-  constructor() {
-    super("websocket");
-
-    this.server = null;
-    this.wsConfig = null;
-    this.httpConfig = null;
-
-    // Used to limit the rate of messages on websocket
-    this.now = Date.now();
-    this.nowInterval = setInterval(() => {
-      this.now = Date.now();
-    }, 1000);
-
-    // Map<uWS.WebSocket, ClientConnection>
-    this.connectionBySocket = new Map();
-
-    // Map<uWS.WebSocket, Array.<Buffer>>
-    this.backpressureBuffer = new Map();
-
-    // Map<string, uWS.WebSocket>
-    this.socketByConnectionId = new Map();
-
-    this.logger = global.kuzzle.log.child("core:network:protocols:httpws");
-  }
-
-  async init(entrypoint) {
-    super.init(null, entrypoint);
-
-    this.config = entrypoint.config.protocols;
-
-    this.wsConfig = this.parseWebSocketOptions();
-    this.httpConfig = this.parseHttpOptions();
-
-    if (!this.wsConfig.enabled && !this.httpConfig.enabled) {
-      return false;
-    }
-
-    // eslint-disable-next-line new-cap
-    this.server = uWS.App();
-
-    if (this.wsConfig.enabled) {
-      this.initWebSocket();
-    }
-
-    if (this.httpConfig.enabled) {
-      this.initHttp();
-    }
-
-    this.server.listen(entrypoint.config.port, (socket) => {
-      if (!socket) {
-        throw new Error(
-          `[http/websocket] fatal: unable to listen to port ${entrypoint.config.port}`,
-        );
-      }
-    });
-
-    return true;
-  }
-
-  initWebSocket() {
-    /* eslint-disable sort-keys */
-    this.server.ws("/*", {
-      ...this.wsConfig.opts,
-      maxBackPressure: WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE,
-      upgrade: this.wsOnUpgradeHandler.bind(this),
-      open: this.wsOnOpenHandler.bind(this),
-      close: this.wsOnCloseHandler.bind(this),
-      message: this.wsOnMessageHandler.bind(this),
-      drain: this.wsOnDrainHandler.bind(this),
-    });
-    /* eslint-enable sort-keys */
-  }
-
-  initHttp() {
-    this.server.any("/*", this.httpOnMessageHandler.bind(this));
-  }
-
-  broadcast(data) {
-    const stringified = JSON.stringify(data.payload);
-    const payloadByteSize = Buffer.from(stringified).byteLength;
-    // 255 bytes should be enough to hold the following:
-    //     ,"room":"<channel identifier>"
-    // (with current channel encoding, this is less than 100 bytes)
-    const payload = Buffer.allocUnsafe(payloadByteSize + 255);
-
-    let offset = payloadByteSize - 1;
-
-    payload.write(stringified, 0);
-    payload.write(JSON_ROOM_PROPERTY, offset);
-
-    offset += JSON_ROOM_PROPERTY.length;
-
-    for (const channel of data.channels) {
-      // Adds the room property to the message
-      payload.write(channel, offset);
-      payload.write(JSON_ENDER, offset + channel.length);
-
-      // prevent buffer overwrites due to sending packets being an
-      // async method (race condition)
-      const payloadLength = offset + channel.length + JSON_ENDER.length;
-      const payloadSafeCopy = Buffer.allocUnsafe(payloadLength);
-
-      payload.copy(payloadSafeCopy, 0, 0, payloadLength);
-
-      debugWS(
-        'Publishing to channel "realtime/%s": %s',
-        channel,
-        payloadSafeCopy,
-      );
-      this.server.publish(`realtime/${channel}`, payloadSafeCopy, false);
-    }
-  }
-
-  notify(data) {
-    const socket = this.socketByConnectionId.get(data.connectionId);
-    debugWS("notify: %a", data);
-
-    if (!socket) {
-      return;
-    }
-
-    const payload = data.payload;
-
-    for (let i = 0; i < data.channels.length; i++) {
-      payload.room = data.channels[i];
-      this.wsSend(socket, Buffer.from(JSON.stringify(payload)));
-    }
-  }
-
-  joinChannel(channel, connectionId) {
-    const socket = this.socketByConnectionId.get(connectionId);
-
-    if (!socket) {
-      return;
-    }
-
-    debugWS(
-      'Subscribing connection ID "%s" to channel "realtime/%s"',
-      connectionId,
-      channel,
-    );
-    socket.subscribe(`realtime/${channel}`);
-  }
-
-  leaveChannel(channel, connectionId) {
-    const socket = this.socketByConnectionId.get(connectionId);
-
-    if (!socket) {
-      return;
-    }
-
-    debugWS(
-      'Removing connection ID "%s" from channel "realtime/%s"',
-      connectionId,
-      channel,
-    );
-
-    socket.unsubscribe(`realtime/${channel}`);
-  }
-
-  disconnect(connectionId, message = null) {
-    debugWS("[%s] forced disconnect", connectionId);
-
-    const socket = this.socketByConnectionId.get(connectionId);
-
-    if (!socket) {
-      return;
-    }
-
-    socket.end(
-      WS_FORCED_TERMINATION_CODE,
-      message ? Buffer.from(message) : WS_GENERIC_CLOSE_MESSAGE,
-    );
-  }
-
-  wsOnUpgradeHandler(res, req, context) {
-    const headers = {};
-    // Extract headers from uWS request
-    req.forEach((header, value) => {
-      headers[header] = value;
-    });
-
-    res.upgrade(
-      {
-        headers,
-        internal: {},
-      },
-      req.getHeader("sec-websocket-key"),
-      req.getHeader("sec-websocket-protocol"),
-      req.getHeader("sec-websocket-extensions"),
-      context,
-    );
-  }
-
-  wsOnOpenHandler(socket) {
-    const ip = Buffer.from(socket.getRemoteAddressAsText()).toString();
-    const connection = new ClientConnection(
-      this.name,
-      [ip],
-      socket.headers,
-      socket.internal,
-    );
-
-    this.entryPoint.newConnection(connection);
-    this.connectionBySocket.set(socket, connection);
-    this.socketByConnectionId.set(connection.id, socket);
-    this.backpressureBuffer.set(socket, []);
-  }
-
-  wsOnCloseHandler(socket, code, message) {
-    const connection = this.connectionBySocket.get(socket);
-
-    if (!connection) {
-      return;
-    }
-
-    const reason = Buffer.from(message || "").toString();
-
-    // This hack is only here to indicate that uWebSockets killed the connection early
-    // because the received payload exceeded the configured threshold.
-    if (code === 1006 && reason.startsWith("Received too big message")) {
-      this.logger.error(
-        `[${connection.id}] connection closed: payload exceeded the threshold`,
-      );
-    }
-
-    if (debugWS.enabled) {
-      debugWS(
-        "[%s] received a `close` event (CODE: %d, REASON: %s)",
-        connection.id,
-        code,
-        reason,
-      );
-    }
-    this.entryPoint.removeConnection(connection.id);
-    this.connectionBySocket.delete(socket);
-    this.backpressureBuffer.delete(socket);
-    this.socketByConnectionId.delete(connection.id);
-  }
-
-  async wsOnMessageHandler(socket, data) {
-    if (!data || data.byteLength === 0) {
-      return;
-    }
-
-    const connection = this.connectionBySocket.get(socket);
-
-    // enforce rate limits
-    if (this.wsConfig.rateLimit > 0) {
-      if (socket.last === this.now) {
-        socket.count++;
-
-        if (socket.count > this.wsConfig.rateLimit) {
-          this.wsSendError(socket, connection, WS_RATE_LIMIT_EXCEEDED_ERROR);
-          return;
-        }
-      } else {
-        socket.last = this.now;
-        socket.count = 1;
-      }
-    }
-
-    let parsed;
-    let message = Buffer.from(data).toString();
-
-    debugWS("[%s] client message: %s", connection.id, message);
-
-    ({ payload: message } = await global.kuzzle.pipe(
-      "protocol:websocket:beforeParsingPayload",
-      { connection, payload: message },
-    ));
-
-    try {
-      ({ payload: parsed } = await global.kuzzle.pipe(
-        "protocol:websocket:afterParsingPayload",
-        { connection, payload: JSON.parse(message) },
-      ));
-    } catch (e) {
-      /*
-       we cannot add a "room" information since we need to extract
-       a request ID from the incoming data, which is apparently
-       not a valid JSON
-       So... the error is forwarded to the client, hoping they know
-       what to do with it.
-       */
-      this.wsSendError(
-        socket,
-        connection,
-        kerrorWS.getFrom(e, "unexpected_error", e.message),
-      );
-      return;
-    }
-
-    if (parsed.p && parsed.p === 1 && Object.keys(parsed).length === 1) {
-      debugWS('[%s] sending back a "pong" message', connection.id);
-      this.wsSend(socket, WS_APP_PONG_RESPONSE);
-      return;
-    }
-
-    let request;
-
-    try {
-      request = new Request(parsed, { connection });
-    } catch (e) {
-      this.wsSendError(socket, connection, e, parsed.requestId);
-      return;
-    }
-
-    this.entryPoint.execute(connection, request, (result) => {
-      if (result.content) {
-        if (typeof result.content === "object") {
-          result.content.room = result.requestId;
-        }
-      } else {
-        result.content = "";
-      }
-
-      this.wsSend(socket, Buffer.from(JSON.stringify(result.content)));
-    });
-  }
-
-  /**
-   * Absorb as much of the backpressure buffer as possible
-   * @param  {uWS.WebSocket} socket
-   */
-  wsOnDrainHandler(socket) {
-    socket.cork(() => {
-      const buffer = this.backpressureBuffer.get(socket);
-
-      while (
-        buffer.length > 0 &&
-        socket.getBufferedAmount() < WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE
-      ) {
-        const payload = buffer.shift();
-        socket.send(payload);
-      }
-    });
-  }
-
-  /**
-   * Forwards an error to a socket
-   *
-   * @param  {uWS.WebSocket} socket
-   * @param  {ClientConnection} connection
-   * @param  {Error} error
-   * @param  {String} requestId @optional
-   */
-  wsSendError(socket, connection, error, requestId) {
-    const request = new Request({}, { connection, error });
-
-    // If a requestId is provided we use it instead of the generated one
-    request.id = requestId || request.id;
-
-    const sanitized = removeStacktrace(request.response.toJSON()).content;
-
-    this.wsSend(socket, Buffer.from(JSON.stringify(sanitized)));
-  }
-
-  /**
-   * Sends a message immediately, or queue it up for later if backpressure built
-   * up
-   *
-   * @param  {uWS.WebSocket} socket
-   * @param  {Buffer} payload
-   */
-  wsSend(socket, payload) {
-    if (!this.connectionBySocket.has(socket)) {
-      return;
-    }
-
-    if (socket.getBufferedAmount() < WS_PER_SOCKET_BACKPRESSURE_BUFFER_SIZE) {
-      socket.cork(() => socket.send(payload));
-    } else {
-      const buffer = this.backpressureBuffer.get(socket);
-      buffer.push(payload);
-
-      /**
-       * Client socket too slow: we need to close it
-       *
-       * If the socket is marked as a debugSession, we don't close it
-       * the debugger might send a lot of messages and we don't want to
-       * loose the connection while debugging and loose important information.
-       */
-      if (
-        !socket.internal.debugSession &&
-        buffer.length > WS_BACKPRESSURE_BUFFER_MAX_LENGTH
-      ) {
-        socket.end(WS_FORCED_TERMINATION_CODE, WS_BACKPRESSURE_MESSAGE);
-      }
-    }
-  }
-
-  /**
-   * @param  {uWS.HttpResponse} response
-   * @param  {uWS.HttpRequest} request
-   */
-  httpOnMessageHandler(response, request) {
-    const connection = new ClientConnection(
-      "HTTP/1.1",
-      getHttpIps(response, request),
-      request.headers,
-    );
-    const message = new HttpMessage(connection, request);
-
-    debugHTTP("[%s] Received HTTP request: %a", connection.id, message);
-
-    if (message.headers["content-length"] > this.maxRequestSize) {
-      this.httpSendError(message, response, HTTP_REQUEST_TOO_LARGE_ERROR);
-      return;
-    }
-
-    const contentTypeHeader = message.headers["content-type"];
-
-    if (contentTypeHeader) {
-      const contentTypeParamIndex = contentTypeHeader.indexOf(";");
-      const contentType =
-        contentTypeParamIndex !== -1
-          ? contentTypeHeader.slice(0, contentTypeParamIndex).trim()
-          : contentTypeHeader.trim();
-
-      if (
-        !this.httpConfig.opts.allowedContentTypes.some(
-          (allowed) => contentType === allowed,
-        )
-      ) {
-        this.httpSendError(
-          message,
-          response,
-          kerrorHTTP.get("unsupported_content", contentType),
-        );
-        return;
-      }
-    }
-
-    const encoding = CHARSET_REGEX.exec(contentTypeHeader);
-
-    if (encoding !== null && encoding[1].toLowerCase() !== "utf-8") {
-      this.httpSendError(
-        message,
-        response,
-        kerrorHTTP.get("unsupported_charset", encoding[1].toLowerCase()),
-      );
-      return;
-    }
-
-    this.httpReadData(message, response, (err) => {
-      if (err) {
-        this.httpSendError(message, response, err);
-        return;
-      }
-
-      this.httpProcessRequest(response, message);
-    });
-  }
-
-  /**
-   * Read an HTTP payload data
-   *
-   * @param  {HttpMessage} message
-   * @param  {uWS.HttpResponse} response
-   * @param  {Function} cb
-   */
-  httpReadData(message, response, cb) {
-    let payload = null;
-    response.aborted = false;
-
-    response.onData((data, isLast) => {
-      const chunk = Buffer.from(data);
-
-      payload = payload
-        ? Buffer.concat([payload, chunk])
-        : Buffer.concat([chunk]);
-
-      /*
-       * The content-length header can be bypassed and
-       * is not reliable enough. We have to enforce the HTTP
-       * max size limit while reading chunks too
-       */
-      if (payload.byteLength > this.maxRequestSize) {
-        cb(HTTP_REQUEST_TOO_LARGE_ERROR);
-        return;
-      }
-
-      if (!isLast) {
-        return;
-      }
-
-      if (payload.byteLength === 0) {
-        cb();
-        return;
-      }
-
-      let resolve;
-      let promise = new Promise((res) => (resolve = res));
-
-      this.httpUncompress(message, payload, async (err, inflated) => {
-        if (err) {
-          cb(err);
-          resolve();
-          return;
-        }
-
-        const { payload: newPayload } = await global.kuzzle.pipe(
-          "protocol:http:beforeParsingPayload",
-          { message, payload: inflated },
-        );
-        await this.httpParseContent(message, newPayload, cb);
-        resolve();
-      });
-
-      return promise;
-    });
-
-    // Beware: the "response" object might be invalidated at any point of time,
-    // whenever the connection gets closed by the client for instance
-    response.onAborted(() => {
-      response.aborted = true;
-    });
-  }
-
-  async httpParseContent(message, content, cb) {
-    const type = message.headers["content-type"] || "";
-
-    if (type.includes("multipart/form-data")) {
-      const parts = uWS.getParts(content, message.headers["content-type"]);
-      message.content = {};
-
-      if (!parts) {
-        cb();
-        return;
-      }
-
-      for (const part of parts) {
-        if (part.data.byteLength > this.maxFormFileSize) {
-          cb(HTTP_FILE_TOO_LARGE_ERROR);
-          return;
-        }
-
-        if (part.filename) {
-          message.content[part.name] = {
-            encoding: part.type,
-            file: Buffer.from(part.data).toString("base64"),
-            filename: part.filename,
-          };
-        } else {
-          message.content[part.name] = Buffer.from(part.data).toString();
-        }
-      }
-    } else if (type.includes("application/x-www-form-urlencoded")) {
-      message.content = querystring.parse(content.toString());
-    } else {
-      try {
-        const { payload } = await global.kuzzle.pipe(
-          "protocol:http:afterParsingPayload",
-          { message, payload: JSON.parse(content.toString()) },
-        );
-        message.content = payload;
-      } catch (e) {
-        cb(
-          kerrorHTTP.get("body_parse_failed", content.toString().slice(0, 50)),
-        );
-        return;
-      }
-    }
-
-    cb();
-  }
-
-  httpProcessRequest(response, message) {
-    debugHTTP("[%s] httpProcessRequest: %a", message.connection.id, message);
-
-    if (response.aborted) {
-      return;
-    }
-
-    this.entryPoint.newConnection(message.connection);
-
-    global.kuzzle.router.http.route(message, (request) => {
-      this.entryPoint.logAccess(message.connection, request, message);
-      this.entryPoint.removeConnection(message.connection.id);
-
-      if (response.aborted) {
-        return;
-      }
-
-      if (request.result instanceof HttpStream) {
-        this.httpSendStream(request, response, request.result, message);
-        return;
-      }
-
-      // Send the response in one go
-
-      const data = this.httpRequestToResponse(request, message);
-
-      this.httpCompress(message, data, (result) => {
-        if (response.aborted) {
-          return;
-        }
-
-        request.response.setHeader("Content-Encoding", result.encoding);
-
-        response.cork(() => {
-          this.httpWriteRequestHeaders(request, response, message);
-
-          const [success] = response.tryEnd(
-            result.compressed,
-            result.compressed.length,
-          );
-
-          if (!success) {
-            response.onWritable((offset) => {
-              const retryData = result.compressed.subarray(offset);
-              const [retrySuccess] = response.tryEnd(
-                retryData,
-                retryData.length,
-              );
-
-              return retrySuccess;
-            });
-          }
-        });
-      });
-    });
-  }
-
-  /**
-   *
-   * @param {uWS.HttpRequest} request
-   * @param {uWS.HttpResponse} response
-   * @param {HttpMessage} message
-   */
-  httpWriteRequestHeaders(request, response, message) {
-    response.writeStatus(Buffer.from(request.response.status.toString()));
-
-    response.writeHeader(HTTP_HEADER_CONNECTION, CLOSE);
-    response.writeHeader(X_KUZZLE_REQUEST_ID, message.requestId);
-
-    for (const header of this.httpConfig.headers) {
-      // If header is missing, add the default one
-      if (request.response.headers[header[2]] === undefined) {
-        response.writeHeader(header[0], header[1]);
-      }
-    }
-
-    // Access-Control-Allow-Origin Logic
-    if (
-      request.response.headers["Access-Control-Allow-Origin"] === undefined &&
-      message.headers &&
-      message.headers.origin
-    ) {
-      response.writeHeader(
-        HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-        Buffer.from(message.headers.origin),
-      );
-
-      response.writeHeader(HTTP_HEADER_VARY, ORIGIN);
-    }
-
-    if (request.response.headers["set-cookie"]) {
-      for (const cookie of request.response.headers["set-cookie"]) {
-        response.writeHeader(HTTP_HEADER_SET_COOKIE, Buffer.from(cookie));
-      }
-    }
-
-    for (const [key, value] of Object.entries(request.response.headers)) {
-      // Skip some headers that are not allowed to be sent or modified
-      if (HTTP_SKIPPED_HEADERS.includes(key.toLowerCase())) {
-        continue;
-      }
-
-      response.writeHeader(Buffer.from(key), Buffer.from(value.toString()));
-    }
-  }
-
-  /**
-   * Send stream data thorugh the HTTP response
-   * @param {HttpRequest} request
-   * @param {HttpStream} httpStream - The data stream to send
-   * @param {uWS.HttpResponse} response
-   * @param {HttpMessage} message
-   */
-  httpSendStream(request, response, httpStream, message) {
-    const streamSizeFixed =
-      typeof httpStream.totalBytes === "number" && httpStream.totalBytes > 0;
-
-    if (httpStream.errored) {
-      this.httpSendError(
-        message,
-        response,
-        kerror.get(
-          "network",
-          "http",
-          "stream_errored",
-          httpStream.error.message,
-        ),
-      );
-      return;
-    }
-
-    if (httpStream.destroyed) {
-      this.httpSendError(
-        message,
-        response,
-        kerror.get("network", "http", "stream_closed"),
-      );
-      return;
-    }
-
-    // Remove Content-Length header to avoid conflic with Transfer-Encoding header
-    request.response.setHeader("Content-Length", null);
-
-    // Send Headers in one go
-    response.cork(() => {
-      this.httpWriteRequestHeaders(request, response, message);
-    });
-
-    httpStream.stream.on("data", (chunk) => {
-      // Make a copy of the array buffer
-      const arrayBuffer = chunk.buffer.slice(
-        chunk.byteOffset,
-        chunk.byteOffset + chunk.byteLength,
-      );
-
-      const arrayBufferOffset = response.getWriteOffset();
-
-      let backpressure = false;
-
-      /**
-       * Switch method of writing data to the response
-       * based on the size of the stream.
-       * If the stream has a fixed size we can use the tryEnd method
-       */
-      if (streamSizeFixed) {
-        const [success, done] = response.tryEnd(
-          arrayBuffer,
-          httpStream.totalBytes,
-        );
-        backpressure = !success;
-
-        if (done) {
-          httpStream.destroy();
-          return;
-        }
-      } else {
-        const success = response.write(arrayBuffer);
-
-        backpressure = !success;
-      }
-
-      // In case of backpressure we need to wait for drainage before sending more data
-      if (backpressure) {
-        response.arrayBufferOffset = arrayBufferOffset;
-        response.arrayBuffer = arrayBuffer;
-        httpStream.stream.pause();
-
-        /**
-         * When the stream is drained we can resume sending data,
-         * only if the is no backpressure after we wrote the missing chunk data.
-         */
-        response.onWritable((offset) => {
-          if (!streamSizeFixed && offset - response.arrayBufferOffset === 0) {
-            httpStream.stream.resume();
-            return true;
-          }
-
-          let retryBackpressure = false;
-          const remainingChunkData = response.arrayBuffer.slice(
-            offset - response.arrayBufferOffset,
-          );
-
-          if (streamSizeFixed) {
-            const [success] = response.tryEnd(
-              remainingChunkData,
-              httpStream.totalBytes,
-            );
-
-            retryBackpressure = !success;
-          } else {
-            const success = response.write(remainingChunkData);
-
-            retryBackpressure = !success;
-          }
-
-          if (!retryBackpressure) {
-            httpStream.stream.resume();
-          }
-
-          return !retryBackpressure;
-        });
-      }
-    });
-
-    httpStream.stream.on("end", () => {
-      if (httpStream.destroy()) {
-        response.end();
-      }
-    });
-
-    httpStream.stream.on("close", () => {
-      if (httpStream.destroy()) {
-        response.end();
-      }
-    });
-
-    httpStream.stream.on("error", (err) => {
-      if (httpStream.destroy()) {
-        response.end();
-      }
-
-      debugHTTP(
-        "[%s] httpSendStream: %s",
-        httpStream.connection.id,
-        err.message,
-      );
-    });
-
-    response.onAborted(() => {
-      httpStream.destroy();
-    });
-  }
-
-  /**
-   * Forward an error response to the client
-   *
-   * @param {HttpMessage} message
-   * @param {uWS.HttpResponse} response
-   * @param {Error} error
-   */
-  httpSendError(message, response, error) {
-    const kerr =
-      error instanceof KuzzleError
-        ? error
-        : kerrorHTTP.getFrom(error, "unexpected_error", error.message);
-
-    const content = Buffer.from(JSON.stringify(removeStacktrace(kerr)));
-
-    debugHTTP("[%s] httpSendError: %a", message.connection.id, kerr);
-
-    this.entryPoint.logAccess(
-      message.connection,
-      new Request(message, {
-        connectionId: message.connection.id,
-        error: kerr,
-      }),
-      message,
-    );
-    this.entryPoint.removeConnection(message.connection.id);
-
-    if (response.aborted) {
-      return;
-    }
-
-    response.cork(() => {
-      response.writeStatus(Buffer.from(kerr.status.toString()));
-
-      for (const header of this.httpConfig.headers) {
-        response.writeHeader(header[0], header[1]);
-      }
-
-      // Access-Control-Allow-Origin Logic
-      if (message.headers && message.headers.origin) {
-        if (global.kuzzle.config.internal.allowAllOrigins) {
-          response.writeHeader(
-            HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-            WILDCARD,
-          );
-        } else {
-          response.writeHeader(
-            HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
-            Buffer.from(message.headers.origin),
-          );
-          response.writeHeader(HTTP_HEADER_VARY, ORIGIN);
-        }
-      }
-
-      response.end(content);
-    });
-  }
-
-  /**
-   * Convert a Kuzzle query result into an appropriate payload format
-   * to send back to the client
-   *
-   * @param {Request} request
-   * @param {HttpMessage} message
-   * @returns {Buffer}
-   */
-  httpRequestToResponse(request, message) {
-    let data = removeStacktrace(request.response.toJSON());
-
-    if (message.requestId !== data.requestId) {
-      data.requestId = message.requestId;
-
-      if (!data.raw) {
-        data.content.requestId = message.requestId;
-      }
-    }
-
-    debugHTTP("HTTP request response: %a", data);
-
-    if (data.raw) {
-      if (data.content === null || data.content === undefined) {
-        data = "";
-      } else if (typeof data.content === "object") {
-        /*
-         This object can be either a Buffer object, a stringified Buffer object,
-         or anything else.
-         In the former two cases, we create a new Buffer object, and in the
-         latter, we stringify t he content.
-         */
-        if (
-          data.content instanceof Buffer ||
-          (data.content.type === "Buffer" && Array.isArray(data.content.data))
-        ) {
-          data = data.content;
-        } else {
-          data = JSON.stringify(data.content);
-        }
-      } else {
-        // scalars are sent as strings
-        data = data.content.toString();
-      }
-    } else {
-      let indent = 0;
-      const parsedUrl = url.parse(message.url, true);
-
-      if (parsedUrl.query && parsedUrl.query.pretty !== undefined) {
-        indent = 2;
-      }
-
-      data = JSON.stringify(data.content, undefined, indent);
-    }
-
-    return Buffer.from(data);
-  }
-
-  /**
-   * Compress an outgoing message according to the
-   * specified accept-encoding HTTP header
-   *
-   * @param  {HttpMessage} message
-   * @param  {Buffer} data
-   * @param  {Function} callback
-   */
-  httpCompress(message, data, callback) {
-    if (message.headers["accept-encoding"]) {
-      const encodings = message.headers["accept-encoding"]
-        .split(",")
-        .map((e) => e.trim().toLowerCase());
-
-      let algorithm;
-      let priority = -1;
-
-      for (const encoding of encodings) {
-        if (encoding.startsWith("gzip") || encoding.startsWith("deflate")) {
-          let [_algorithm, _priority = "q=0"] = encoding.split(";");
-          _priority = Number.parseFloat(_priority.split("=")[1] || 0);
-
-          if (_priority > priority) {
-            algorithm = _algorithm;
-            priority = _priority;
-          }
-          // gzip should be the preferred algorithm in case of a tie
-          else if (
-            Math.abs(priority - _priority) < 10e-3 &&
-            _algorithm === "gzip"
-          ) {
-            algorithm = "gzip";
-          }
-        }
-      }
-
-      if (algorithm === "gzip") {
-        zlib.gzip(data, (err, compressed) =>
-          callback({
-            compressed: !err ? compressed : data,
-            encoding: !err ? "gzip" : "identity",
-          }),
-        );
-        return;
-      } else if (algorithm === "deflate") {
-        zlib.deflate(data, (err, compressed) =>
-          callback({
-            compressed: !err ? compressed : data,
-            encoding: !err ? "deflate" : "identity",
-          }),
-        );
-        return;
-      }
-    }
-
-    callback({
-      compressed: data,
-      encoding: "identity",
-    });
-  }
-
-  httpUncompress(message, payload, cb) {
-    let encodings = message.headers["content-encoding"];
-    if (!encodings) {
-      cb(null, payload);
-      return;
-    }
-
-    encodings = encodings.split(",").map((e) => e.trim().toLowerCase());
-
-    if (encodings.length > this.httpConfig.opts.maxEncodingLayers) {
-      cb(kerrorHTTP.get("too_many_encodings"));
-      return;
-    }
-
-    // encodings are listed in the same order they have been applied
-    // this means that we need to invert the list to correctly
-    // decode the message
-    encodings.reverse();
-
-    this.httpUncompressStep(encodings, payload, cb, 0);
-  }
-
-  httpUncompressStep(encodings, payload, cb, index) {
-    if (index === encodings.length) {
-      cb(null, payload);
-      return;
-    }
-
-    const encoding = encodings[index];
-
-    if (encoding === "identity") {
-      this.httpUncompressStep(encodings, payload, cb, index + 1);
-    } else if (encoding === "gzip" || encoding === "deflate") {
-      const fn = encoding === "gzip" ? zlib.gunzip : zlib.inflate;
-
-      fn(payload, (err, inflated) => {
-        if (err) {
-          cb(err);
-          return;
-        }
-
-        this.httpUncompressStep(encodings, inflated, cb, index + 1);
-      });
-    } else {
-      cb(kerrorHTTP.get("unsupported_compression", encoding));
-    }
-  }
-
-  parseWebSocketOptions() {
-    const cfg = this.config.websocket;
-
-    if (cfg === undefined) {
-      this.logger.warn(
-        "[websocket] no configuration found for websocket: disabling it",
-      );
-      return { enabled: false };
-    }
-
-    let idleTimeout = cfg.idleTimeout;
-    const compression = cfg.compression ? uWS.SHARED_COMPRESSOR : uWS.DISABLED;
-
-    if (idleTimeout === 0 || idleTimeout < 1000) {
-      idleTimeout = DEFAULT_IDLE_TIMEOUT;
-      this.logger.warn(
-        `[websocket] The "idleTimeout" parameter can neither be deactivated or be set with a value lower than 1000. Defaulted to ${DEFAULT_IDLE_TIMEOUT}.`,
-      );
-    }
-
-    const idleTimeoutInSecond = Math.round(idleTimeout / 1000);
-
-    /**
-     * @deprecated -- to be removed in the next major version
-     */
-    if (cfg.heartbeat) {
-      this.logger.warn(
-        '[websocket] The "heartbeat" parameter has been deprecated and is now ignored. The "idleTimeout" parameter should now be configured instead.',
-      );
-    }
-
-    return {
-      enabled: cfg.enabled,
-      opts: {
-        compression,
-        idleTimeout: idleTimeoutInSecond,
-        maxPayloadLength: this.maxRequestSize,
-        resetIdleTimeoutOnSend: cfg.resetIdleTimeoutOnSend,
-        sendPingsAutomatically: cfg.sendPingsAutomatically,
-      },
-      rateLimit: cfg.rateLimit,
-    };
-  }
-
-  parseHttpOptions() {
-    const cfg = this.config.http;
-
-    if (cfg === undefined) {
-      this.logger.warn("[http] no configuration found for http: disabling it");
-      return { enabled: false };
-    }
-
-    // precomputes default headers
-    const httpCfg = global.kuzzle.config.http;
-    const headers = [
-      ["Access-Control-Allow-Headers", httpCfg.accessControlAllowHeaders],
-      ["Access-Control-Allow-Methods", httpCfg.accessControlAllowMethods],
-      ["Content-Type", "application/json"],
-    ];
-
-    for (const header of headers) {
-      header[2] = header[0]; // Save the raw header name in the third slot
-      header[0] = Buffer.from(header[0]);
-      header[1] = Buffer.from(header[1]);
-    }
-
-    return {
-      enabled: cfg.enabled,
-      headers,
-      opts: {
-        allowCompression: cfg.allowCompression,
-        allowedContentTypes: [
-          ...HTTP_ALLOWED_CONTENT_TYPES,
-          ...cfg.additionalContentTypes,
-        ],
-        maxEncodingLayers: cfg.maxEncodingLayers,
-        maxFormFileSize: cfg.maxFormFileSize,
-      },
-    };
-  }
-}
-
-/**
- * Returns the list of IP addresses
- *
- * @param {uWS.HttpResponse} response
- * @param {uWS.HttpRequest} request
- * @return {Array.<string>}
- */
-function getHttpIps(response, request) {
-  const ips = [Buffer.from(response.getRemoteAddressAsText()).toString()];
-
-  const forwardHeader = request.getHeader("x-forwarded-for");
-
-  if (forwardHeader && forwardHeader.length > 0) {
-    for (const header of forwardHeader.split(",")) {
-      const trimmed = header.trim();
-
-      if (trimmed.length > 0) {
-        ips.push(trimmed);
-      }
-    }
-  }
-
-  return ips;
-}
-
-module.exports = HttpWsProtocol;