kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/core/network/entryPoint.d.ts

@@ -0,0 +1,62 @@
+export = EntryPoint;
+declare class EntryPoint {
+    config: import("../../..").ServerConfiguration;
+    protocols: Map<any, any>;
+    _clients: Map<any, any>;
+    accessLogger: AccessLogger;
+    isShuttingDown: boolean;
+    logger: import("../../kuzzle/Logger").Logger;
+    dispatch(event: any, data: any): void;
+    /**
+     * Initializes the InternalProtocol first to allow subscriptions
+     * in plugins init() method.
+     *
+     * @returns {Promise}
+     */
+    init(): Promise<any>;
+    /**
+     * Starts the network protocols.
+     * Every protocol is listening for request after this call
+     *
+     * @returns {Promise}
+     */
+    startListening(): Promise<any>;
+    /**
+     * On client subscribing to a channel, dispatch the information
+     * to the protocol.
+     *
+     * @param {string} channel
+     * @param {string} connectionId
+     */
+    joinChannel(channel: string, connectionId: string): void;
+    leaveChannel(channel: any, connectionId: any): void;
+    /**
+     * Loads installed protocols in memory
+     */
+    loadMoreProtocols(): Promise<void>;
+    /**
+     * @param {ClientConnection} connection
+     * @param {Request} request
+     * @param {object} extra
+     */
+    logAccess(connection: ClientConnection, request: Request, extra?: object): void;
+    /**
+     * @param {ClientConnection} connection
+     * @param {Request} request
+     * @param cb
+     */
+    execute(connection: ClientConnection, request: Request, cb: any): void;
+    /**
+     *
+     * @param {ClientConnection} connection
+     */
+    newConnection(connection: ClientConnection): void;
+    /**
+     * @param {string} connectionId
+     */
+    removeConnection(connectionId: string): void;
+    _broadcast(data: any): void;
+    _isShuttingDownError(connection: any, request: any, cb: any): void;
+    _notify(data: any): void;
+}
+import { AccessLogger } from "./accessLogger";

package/dist/lib/core/network/entryPoint.js

@@ -0,0 +1,261 @@
+/*
+ * 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;
+//# sourceMappingURL=entryPoint.js.map

package/dist/lib/core/network/httpRouter/index.d.ts

@@ -0,0 +1,85 @@
+export = 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
+ */
+declare class Router {
+    defaultHeaders: {
+        "Accept-Encoding": string;
+        "Access-Control-Allow-Headers": string;
+        "Access-Control-Allow-Methods": string;
+        "content-type": string;
+    };
+    routes: {
+        DELETE: RoutePart;
+        GET: RoutePart;
+        HEAD: RoutePart;
+        PATCH: RoutePart;
+        POST: RoutePart;
+        PUT: RoutePart;
+    };
+    /**
+     * Attach a handler to a GET HTTP route
+     *
+     * @param {string} path
+     * @param {Function} handler
+     */
+    get(path: string, handler: Function): void;
+    /**
+     * Attach a handler to a POST HTTP route
+     *
+     * @param {string} path
+     * @param {Function} handler
+     */
+    post(path: string, handler: Function): void;
+    /**
+     * Attach a handler to a PUT HTTP route
+     *
+     * @param {string} path
+     * @param {Function} handler
+     */
+    put(path: string, handler: Function): void;
+    /**
+     * Attach a handler to a PATCH HTTP route
+     *
+     * @param {string} path
+     * @param {Function} handler
+     */
+    patch(path: string, handler: Function): void;
+    /**
+     * Attach a handler to a DELETE HTTP route
+     *
+     * @param {string} path
+     * @param {Function} handler
+     */
+    delete(path: string, handler: Function): void;
+    /**
+     * Attach a handler to a HEAD HTTP route
+     *
+     * @param {string} path
+     * @param {Function} handler
+     */
+    head(path: string, handler: Function): void;
+    /**
+     * Route an incoming HTTP message to the right handler
+     *
+     * @param {HttpMessage} message - Parsed HTTP message
+     * @param {function} cb
+     */
+    route(message: HttpMessage, cb: Function): void;
+    /**
+     * 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: HttpMessage, cb: Function): void;
+}
+import RoutePart = require("./routePart");

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

@@ -0,0 +1,258 @@
+/*
+ * 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;
+//# sourceMappingURL=index.js.map