kuzzle 2.49.1 → 2.50.0-beta.4

package/lib/core/network/entryPoint.js

@@ -1,358 +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 fs = require("fs");
-const path = require("path");
-
-const Bluebird = require("bluebird");
-
-const { RequestContext } = require("../../api/request");
-const Context = require("./context");
-const debug = require("../../util/debug")("kuzzle:network:embedded");
-const MqttProtocol = require("./protocols/mqttProtocol");
-const InternalProtocol = require("./protocols/internalProtocol");
-const HttpWsProtocol = require("./protocols/httpwsProtocol");
-const Manifest = require("./protocolManifest");
-const { removeStacktrace } = require("../../util/stackTrace");
-const kerror = require("../../kerror");
-const { AccessLogger } = require("./accessLogger");
-
-const networkError = kerror.wrap("network", "entrypoint");
-
-const DEFAULT_PROTOCOLS = [HttpWsProtocol, MqttProtocol, InternalProtocol];
-
-class EntryPoint {
-  constructor() {
-    this.config = global.kuzzle.config.server;
-
-    this.protocols = new Map();
-
-    this._clients = new Map();
-
-    this.accessLogger = new AccessLogger();
-
-    this.isShuttingDown = false;
-
-    this.logger = global.kuzzle.log.child("core:network:entrypoint");
-  }
-
-  dispatch(event, data) {
-    switch (event) {
-      case "notify":
-        this._notify(data);
-        return;
-      case "broadcast":
-        this._broadcast(data);
-        return;
-      case "shutdown":
-        this.isShuttingDown = true;
-        return;
-      default:
-        throw networkError.get("unexpected_event", event);
-    }
-  }
-
-  /**
-   * Initializes the InternalProtocol first to allow subscriptions
-   * in plugins init() method.
-   *
-   * @returns {Promise}
-   */
-  async init() {
-    for (const ProtocolClass of DEFAULT_PROTOCOLS) {
-      const protocol = new ProtocolClass();
-
-      this.protocols.set(protocol.name, protocol);
-    }
-
-    return this.protocols.get("internal").init(this);
-  }
-
-  /**
-   * Starts the network protocols.
-   * Every protocol is listening for request after this call
-   *
-   * @returns {Promise}
-   */
-  async startListening() {
-    // We need to verify the port ourselves, to make sure Node.js won't open
-    // a named pipe if the provided port number is a string
-    if (!Number.isInteger(this.config.port)) {
-      throw networkError.get("invalid_port", this.config.port);
-    }
-
-    await this.accessLogger.init();
-
-    const initPromises = [];
-
-    for (const protocol of this.protocols.values()) {
-      // InternalProtocol is already initialized
-      if (protocol.initCalled) {
-        continue;
-      }
-
-      initPromises.push(
-        protocol.init(this).then((enabled) => {
-          if (!enabled) {
-            this.protocols.delete(protocol.name);
-          }
-        }),
-      );
-    }
-
-    await Bluebird.all(initPromises);
-
-    await this.loadMoreProtocols();
-  }
-
-  /**
-   * On client subscribing to a channel, dispatch the information
-   * to the protocol.
-   *
-   * @param {string} channel
-   * @param {string} connectionId
-   */
-  joinChannel(channel, connectionId) {
-    debug('[server] client "%s" joining channel "%s"', connectionId, channel);
-
-    const client = this._clients.get(connectionId);
-
-    if (!client || !client.protocol) {
-      return;
-    }
-
-    try {
-      this.protocols.get(client.protocol).joinChannel(channel, connectionId);
-    } catch (e) {
-      this.logger.error(
-        `[join] protocol ${client && client.protocol} failed: ${e.message}`,
-      );
-    }
-  }
-
-  leaveChannel(channel, connectionId) {
-    debug(
-      '[server] connection "%s" leaving channel "%s"',
-      connectionId,
-      channel,
-    );
-
-    const client = this._clients.get(connectionId);
-
-    if (!client || !client.protocol) {
-      return;
-    }
-
-    try {
-      this.protocols.get(client.protocol).leaveChannel(channel, connectionId);
-    } catch (e) {
-      this.logger.error(
-        `[leave channel] protocol ${client && client.protocol} failed: ${
-          e.message
-        }`,
-      );
-    }
-  }
-
-  /**
-   * Loads installed protocols in memory
-   */
-  async loadMoreProtocols() {
-    const dir = path.join(__dirname, "../../../protocols/enabled");
-    let dirs;
-
-    try {
-      dirs = fs.readdirSync(dir);
-    } catch (e) {
-      // ignore if there is no protocols directory
-      return;
-    }
-
-    dirs = dirs
-      .map((d) => path.join(dir, d))
-      .filter((d) => fs.statSync(d).isDirectory());
-
-    await Bluebird.map(dirs, (protoDir) => {
-      const protocol = new (require(protoDir))();
-      const manifest = new Manifest(protoDir, protocol);
-
-      manifest.load();
-
-      const initTimeout =
-        global.kuzzle.config.services.common.defaultInitTimeout;
-
-      return Bluebird.resolve()
-        .then(() => protocol.init(this, new Context()))
-        .catch((error) => {
-          this.logger.error(`Error during "${manifest.name}" protocol init:`);
-          throw error;
-        })
-        .timeout(
-          initTimeout,
-          `Protocol "${manifest.name}" initialization timed out after ${initTimeout}ms. Try to increase the configuration "services.common.defaultInitTimeout".`,
-        )
-        .then(() => {
-          if (this.protocols.has(manifest.name)) {
-            throw kerror.get(
-              "protocol",
-              "runtime",
-              "already_exists",
-              manifest.name,
-            );
-          }
-
-          this.protocols.set(manifest.name, protocol);
-        });
-    });
-  }
-
-  /**
-   * @param {ClientConnection} connection
-   * @param {Request} request
-   * @param {object} extra
-   */
-  logAccess(connection, request, extra = null) {
-    this.accessLogger.log(connection, request, extra);
-  }
-
-  /*
-  -----------------------------------------------------------------------
-  methods exposed to protocols
-  -----------------------------------------------------------------------
-  */
-
-  /**
-   * @param {ClientConnection} connection
-   * @param {Request} request
-   * @param cb
-   */
-  execute(connection, request, cb) {
-    if (this.isShuttingDown) {
-      debug("Shutting down. Dropping request: %a", request);
-      this._isShuttingDownError(connection, request, cb);
-      return;
-    }
-
-    debug("Funneling request: %a", request);
-
-    global.kuzzle.funnel.execute(request, (error, result) => {
-      const _res = result || request;
-
-      if (error && !_res.error) {
-        _res.setError(error);
-      }
-
-      this.logAccess(connection, _res);
-
-      const response = _res.response.toJSON();
-
-      cb(removeStacktrace(response));
-    });
-  }
-
-  /**
-   *
-   * @param {ClientConnection} connection
-   */
-  newConnection(connection) {
-    this._clients.set(connection.id, connection);
-
-    global.kuzzle.emit("connection:new", connection);
-    global.kuzzle.router.newConnection(new RequestContext({ connection }));
-    debug(
-      "New connection created: %s (protocol: %s)",
-      connection.id,
-      connection.protocol,
-    );
-  }
-
-  /**
-   * @param {string} connectionId
-   */
-  removeConnection(connectionId) {
-    const connection = this._clients.get(connectionId);
-
-    if (connection) {
-      global.kuzzle.emit("connection:remove", connection);
-
-      global.kuzzle.router.removeConnection(new RequestContext({ connection }));
-
-      this._clients.delete(connectionId);
-
-      debug(
-        "Removed connection: %s (protocol: %s)",
-        connection.id,
-        connection.protocol,
-      );
-    }
-  }
-
-  // --------------------------------------------------------------------
-
-  _broadcast(data) {
-    const sanitized = removeStacktrace(data);
-
-    debug("[server] broadcasting data through all protocols: %a", sanitized);
-
-    for (const [name, protocol] of this.protocols.entries()) {
-      try {
-        protocol.broadcast(sanitized);
-      } catch (e) {
-        this.logger.error(
-          `[broadcast] protocol ${name} failed: ${e.message}\n${e.stack}`,
-        );
-      }
-    }
-  }
-
-  _isShuttingDownError(connection, request, cb) {
-    request.setError(networkError.get("shutting_down"));
-    this.logAccess(connection, request);
-
-    cb(removeStacktrace(request.response.toJSON()));
-  }
-
-  _notify(data) {
-    debug(
-      '[server] sending notification to client with connection id "%s": %a',
-      data.connectionId,
-      data,
-    );
-
-    const client = this._clients.get(data.connectionId);
-
-    if (!client || !client.protocol) {
-      return;
-    }
-
-    try {
-      this.protocols.get(client.protocol).notify(removeStacktrace(data));
-    } catch (e) {
-      this.logger.error(
-        `[notify] protocol ${client.protocol} failed: ${e.message}`,
-      );
-    }
-  }
-}
-
-module.exports = EntryPoint;

package/lib/core/network/httpRouter/index.js

@@ -1,316 +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 { Request } = require("../../../api/request");
-const { KuzzleError } = require("../../../kerror/errors");
-const RoutePart = require("./routePart");
-const { has } = require("../../../util/safeObject");
-
-const kerror = require("../../../kerror").wrap("network", "http");
-const debug = require("../../../util/debug")("kuzzle:http:router");
-
-/**
- * Attach handler to routes and dispatch a HTTP
- * message to the right handler
- *
- * Handlers will be called with the following arguments:
- *   - request: received HTTP request
- *   - response: HTTP response object
- *   - data: URL query arguments and/or POST data, if any
- *
- * @class Router
- */
-class Router {
-  constructor() {
-    this.defaultHeaders = {
-      "Accept-Encoding": "identity",
-      "Access-Control-Allow-Headers":
-        global.kuzzle.config.http.accessControlAllowHeaders,
-      "Access-Control-Allow-Methods":
-        global.kuzzle.config.http.accessControlAllowMethods,
-      "content-type": "application/json",
-    };
-
-    if (global.kuzzle.config.http.cookieAuthentication) {
-      this.defaultHeaders["Access-Control-Allow-Credentials"] = "true";
-    }
-
-    if (global.kuzzle.config.server.protocols.http.allowCompression === true) {
-      this.defaultHeaders["Accept-Encoding"] = "gzip,deflate,identity";
-    }
-
-    this.routes = {
-      DELETE: new RoutePart(),
-      GET: new RoutePart(),
-      HEAD: new RoutePart(),
-      PATCH: new RoutePart(),
-      POST: new RoutePart(),
-      PUT: new RoutePart(),
-    };
-
-    // Add an automatic HEAD route on the '/' url, answering with default headers
-    attach(
-      "/",
-      (request, cb) => {
-        request.setResult({}, 200);
-        cb(request);
-      },
-      this.routes.HEAD,
-    );
-  }
-
-  /**
-   * Attach a handler to a GET HTTP route
-   *
-   * @param {string} path
-   * @param {Function} handler
-   */
-  get(path, handler) {
-    attach(path, handler, this.routes.GET);
-  }
-
-  /**
-   * Attach a handler to a POST HTTP route
-   *
-   * @param {string} path
-   * @param {Function} handler
-   */
-  post(path, handler) {
-    attach(path, handler, this.routes.POST);
-  }
-
-  /**
-   * Attach a handler to a PUT HTTP route
-   *
-   * @param {string} path
-   * @param {Function} handler
-   */
-  put(path, handler) {
-    attach(path, handler, this.routes.PUT);
-  }
-
-  /**
-   * Attach a handler to a PATCH HTTP route
-   *
-   * @param {string} path
-   * @param {Function} handler
-   */
-  patch(path, handler) {
-    attach(path, handler, this.routes.PATCH);
-  }
-
-  /**
-   * Attach a handler to a DELETE HTTP route
-   *
-   * @param {string} path
-   * @param {Function} handler
-   */
-  delete(path, handler) {
-    attach(path, handler, this.routes.DELETE);
-  }
-
-  /**
-   * Attach a handler to a HEAD HTTP route
-   *
-   * @param {string} path
-   * @param {Function} handler
-   */
-  head(path, handler) {
-    attach(path, handler, this.routes.HEAD);
-  }
-
-  /**
-   * Route an incoming HTTP message to the right handler
-   *
-   * @param {HttpMessage} message - Parsed HTTP message
-   * @param {function} cb
-   */
-  route(message, cb) {
-    debug("Routing HTTP message: %a", message);
-
-    if (!has(this.routes, message.method)) {
-      this.routeUnhandledHttpMethod(message, cb);
-      return;
-    }
-
-    let routeHandler;
-
-    try {
-      routeHandler = this.routes[message.method].getHandler(message);
-
-      // Set Headers if not present
-      routeHandler.request.response.setHeaders(this.defaultHeaders, true);
-
-      applyACAOHeader(message, routeHandler.request);
-
-      if (routeHandler.handler === null) {
-        throw kerror.get("url_not_found", routeHandler.url);
-      }
-
-      routeHandler.invokeHandler(cb);
-    } catch (err) {
-      let request;
-      if (!routeHandler || !routeHandler._request) {
-        request = new Request({ requestId: message.requestId }, {});
-        // Set Headers if not present
-        request.response.setHeaders(this.defaultHeaders, true);
-
-        applyACAOHeader(message, request);
-      } else {
-        request = routeHandler.request;
-      }
-
-      const e =
-        err instanceof KuzzleError
-          ? err
-          : kerror.getFrom(err, "unexpected_error", err.message);
-
-      replyWithError(cb, request, e);
-    }
-  }
-
-  /**
-   * Route HTTP messages using an HTTP method that is not handled by Kuzzle's
-   * API, such as OPTIONS.
-   * @param  {HttpMessage} message
-   * @param {function} cb
-   */
-  routeUnhandledHttpMethod(message, cb) {
-    const requestContext = global.kuzzle.router.connections.get(
-        message.connection.id,
-      ),
-      request = new Request(
-        { requestId: message.requestId },
-        requestContext && requestContext.toJSON(),
-      );
-
-    // Set Headers if not present
-    request.response.setHeaders(this.defaultHeaders, true);
-
-    applyACAOHeader(message, request);
-
-    if (message.method === "OPTIONS") {
-      request.input.headers = message.headers;
-      request.setResult({}, 200);
-
-      global.kuzzle.pipe("http:options", request, (error, result) => {
-        if (error) {
-          replyWithError(cb, request, error);
-        } else {
-          cb(result);
-        }
-      });
-
-      return;
-    }
-
-    replyWithError(cb, request, kerror.get("unsupported_verb", message.method));
-  }
-}
-
-/**
- * Set the Header Access-Control-Allow-Origin based on the kuzzle configuration and request origin
- *
- * @param {HttpMessage} message
- * @param {Request} request
- */
-function applyACAOHeader(message, request) {
-  if (message.headers && message.headers.origin) {
-    request.response.setHeaders(
-      {
-        "Access-Control-Allow-Origin": message.headers.origin,
-        Vary: "Origin",
-      },
-      true,
-    );
-  }
-}
-
-/**
- * Attach a handler to an path and stores it to the target object
- *
- * @param {string} path
- * @param {Function} handler
- * @param {RoutePart} target
- */
-function attach(path, handler, target) {
-  const sanitized = path[path.length - 1] === "/" ? path.slice(0, -1) : path;
-
-  if (!attachParts(sanitized.split("/"), handler, target)) {
-    throw kerror.get("duplicate_url", sanitized);
-  }
-}
-
-/**
- *
- * @param {Array<string>} parts
- * @param {Function} routeHandler
- * @param {RoutePart} target
- * @param {Array<string>} placeholders
- * @returns {Boolean} If false, failed to attach because of a duplicate
- */
-function attachParts(parts, handler, target, placeholders = []) {
-  let part;
-
-  do {
-    part = parts.shift();
-  } while (parts.length > 0 && part.length === 0);
-
-  if (part && part[0] === ":") {
-    placeholders.push(part.substring(1));
-    part = "*";
-  }
-
-  const next = target.getNext(part);
-
-  if (parts.length > 0) {
-    return attachParts(parts, handler, next, placeholders);
-  }
-
-  if (target.exists(part)) {
-    return false;
-  }
-
-  next.handler = handler;
-  next.placeholders = placeholders;
-
-  return true;
-}
-
-/**
- * Reply to a callback function with an HTTP error
- *
- * @param {function} cb
- * @param {Request} request
- * @param {Error} error
- */
-function replyWithError(cb, request, error) {
-  request.setError(error);
-
-  cb(request);
-}
-
-/**
- * @type {Router}
- */
-module.exports = Router;