kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/core/network/protocols/internalProtocol.d.ts

@@ -0,0 +1,27 @@
+export = InternalProtocol;
+/**
+ * Internal protocol to use SDK realtime subscription from plugins.
+ *
+ * This protocol only use one connection. This connection is always open.
+ *
+ * Messages to the embedded SDK are dispatched with the following event:
+ *  - 'core:network:internal:message'
+ */
+declare class InternalProtocol extends Protocol {
+    constructor();
+    connection: ClientConnection;
+    /**
+     * List of channel IDs
+     * @type {Set<string>}
+     */
+    channels: Set<string>;
+    init(entryPoint: any): Promise<void>;
+    joinChannel(channel: any, connectionId: any): void;
+    leaveChannel(channel: any, connectionId: any): void;
+    disconnect(connectionId: any): void;
+    broadcast(data: any): void;
+    notify(data: any): void;
+    _send(data: any): void;
+}
+import Protocol = require("./protocol");
+import ClientConnection = require("../clientConnection");

package/dist/lib/core/network/protocols/internalProtocol.js

@@ -0,0 +1,82 @@
+/*
+ * 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 Protocol = require("./protocol");
+const ClientConnection = require("../clientConnection");
+const debug = require("../../../util/debug")("kuzzle:network:protocols:internal");
+/**
+ * Internal protocol to use SDK realtime subscription from plugins.
+ *
+ * This protocol only use one connection. This connection is always open.
+ *
+ * Messages to the embedded SDK are dispatched with the following event:
+ *  - 'core:network:internal:message'
+ */
+class InternalProtocol extends Protocol {
+    constructor() {
+        super("internal");
+        this.connection = new ClientConnection(this.name, ["127.0.0.1"]);
+        /**
+         * List of channel IDs
+         * @type {Set<string>}
+         */
+        this.channels = new Set();
+    }
+    async init(entryPoint) {
+        await super.init(null, entryPoint);
+        debug("initializing InternalProtocol");
+        this.entryPoint.newConnection(this.connection);
+        /**
+         * Returns the internal connection ID used by the protocol.
+         *
+         * @returns {string} connectionId
+         */
+        global.kuzzle.onAsk("core:network:internal:connectionId:get", () => this.connection.id);
+    }
+    joinChannel(channel, connectionId) {
+        debug("joinChannel: %s", channel, connectionId);
+        this.channels.add(channel);
+    }
+    leaveChannel(channel, connectionId) {
+        debug("leaveChannel: %s", channel, connectionId);
+        this.channels.delete(channel);
+    }
+    disconnect(connectionId) {
+        debug("disconnect: %s", connectionId);
+        // Never happens, the InternalProtocol always keep his only connection open
+    }
+    broadcast(data) {
+        debug("broadcast: %a", data);
+        this._send(data);
+    }
+    notify(data) {
+        debug("notify: %a", data);
+        this._send(data);
+    }
+    _send(data) {
+        for (let i = 0; i < data.channels.length; i++) {
+            const message = { ...data.payload, room: data.channels[i] };
+            global.kuzzle.emit("core:network:internal:message", message);
+        }
+    }
+}
+module.exports = InternalProtocol;
+//# sourceMappingURL=internalProtocol.js.map

package/dist/lib/core/network/protocols/mqttProtocol.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+export = MqttProtocol;
+/**
+ * @class MqttProtocol
+ */
+declare class MqttProtocol extends Protocol {
+    constructor();
+    aedes: any;
+    server: net.Server;
+    connections: Map<any, any>;
+    connectionsById: Map<any, any>;
+    logger: import("../../../kuzzle/Logger").Logger;
+    publishCallback: (error: any) => void;
+    init(entryPoint: any): Promise<boolean>;
+    broadcast(data: any): void;
+    disconnect(connectionId: any, message?: string): void;
+    joinChannel(): void;
+    leaveChannel(): void;
+    notify(data: any): void;
+    /**
+     * @param {Client} client
+     */
+    onConnection(client: Client): void;
+    /**
+     * @param {Client} client
+     */
+    onDisconnection(client: Client): void;
+    /**
+     * @param packet
+     * @param client
+     */
+    onMessage(packet: any, client: any): void;
+    _respond(client: any, response: any): void;
+    _respondError(client: any, error: any): void;
+    _authorizePublish(client: any, packet: any, callback: any): void;
+    _authorizeSubscribe(client: any, sub: any, callback: any): void;
+}
+import Protocol = require("./protocol");
+import net = require("net");

package/dist/lib/core/network/protocols/mqttProtocol.js

@@ -0,0 +1,219 @@
+/*
+ * 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 net = require("net");
+const Aedes = require("aedes");
+const ClientConnection = require("../clientConnection");
+const Protocol = require("./protocol");
+const { Request } = require("../../../api/request");
+const { removeStacktrace } = require("../../../util/stackTrace");
+const kerror = require("../../../kerror").wrap("network", "mqtt");
+const debug = require("../../../util/debug")("kuzzle:network:protocols:mqtt");
+/**
+ * @class MqttProtocol
+ */
+class MqttProtocol extends Protocol {
+    constructor() {
+        super("mqtt");
+        // eslint-disable-next-line new-cap
+        this.aedes = new Aedes();
+        this.server = net.createServer(this.aedes.handle);
+        this.connections = new Map();
+        this.connectionsById = new Map();
+        this.logger = global.kuzzle.log.child("core:network:protocols:mqtt");
+        // needs to be bound to this object's context
+        this.publishCallback = function pubcb(error) {
+            if (error) {
+                this.logger.info(`[MQTT] Publishing message failed: ${error}`);
+            }
+        };
+    }
+    async init(entryPoint) {
+        await super.init(null, entryPoint);
+        if (this.config.enabled === false) {
+            return false;
+        }
+        debug("initializing MQTT Server with config: %a", this.config);
+        this.config = Object.assign({
+            allowPubSub: false,
+            developmentMode: false,
+            disconnectDelay: 250,
+            requestTopic: "Kuzzle/request",
+            responseTopic: "Kuzzle/response",
+            server: {
+                port: 1883,
+            },
+        }, this.config);
+        /*
+         * To avoid ill-use of our topics, we need to configure authorizations:
+         * "requestTopic": should be publish-only, so no one but this plugin can
+         *                 listen to this topic
+         * "responseTopic": should be subscribe-only, so no one but this plugin can
+         *                  write in it
+         */
+        this.aedes.authorizePublish = this._authorizePublish.bind(this);
+        this.aedes.authorizeSubscribe = this._authorizeSubscribe.bind(this);
+        // Message events
+        this.aedes.on("client", this.onConnection.bind(this));
+        this.aedes.on("clientError", this.onDisconnection.bind(this));
+        this.aedes.on("clientDisconnect", this.onDisconnection.bind(this));
+        this.aedes.on("publish", this.onMessage.bind(this));
+        await new Promise((res) => this.server.listen(this.config.server.port, res));
+        return true;
+    }
+    broadcast(data) {
+        debug("broadcast %a", data);
+        const payload = JSON.stringify(data.payload);
+        for (const channel of data.channels) {
+            this.aedes.publish({ payload, topic: channel }, this.publishCallback);
+        }
+    }
+    disconnect(connectionId, message = "Connection closed by remote host") {
+        debug("disconnect: connection id: %s, message %s", connectionId, message);
+        const client = this.connectionsById.get(connectionId);
+        if (client) {
+            client.close(undefined, message);
+        }
+    }
+    joinChannel() {
+        // do nothing
+    }
+    leaveChannel() {
+        // do nothing
+    }
+    notify(data) {
+        debug("notify %a", data);
+        const client = this.connectionsById.get(data.connectionId);
+        if (!client) {
+            return;
+        }
+        const payload = Buffer.from(JSON.stringify(data.payload));
+        data.channels.forEach((topic) => {
+            client.publish({ payload, topic }, this.publishCallback);
+        });
+    }
+    /**
+     * @param {Client} client
+     */
+    onConnection(client) {
+        debug("onConnection: %s", client.id);
+        const connection = new ClientConnection(this.name, [client.conn.remoteAddress], {});
+        this.entryPoint.newConnection(connection);
+        this.connections.set(client, connection);
+        this.connectionsById.set(connection.id, client);
+    }
+    /**
+     * @param {Client} client
+     */
+    onDisconnection(client) {
+        debug("onDisconnection %s", client.id);
+        if (this.connections.has(client)) {
+            setTimeout(() => {
+                const connection = this.connections.get(client);
+                if (connection) {
+                    this.connections.delete(client);
+                    this.connectionsById.delete(connection.id);
+                    this.entryPoint.removeConnection(connection.id);
+                }
+            }, this.config.disconnectDelay);
+        }
+    }
+    /**
+     * @param packet
+     * @param client
+     */
+    onMessage(packet, client) {
+        if (packet.topic !== this.config.requestTopic ||
+            packet.payload === null ||
+            client.id === null) {
+            return;
+        }
+        const connection = this.connections.get(client);
+        if (connection === undefined) {
+            debug("no connection id for client id %s - packet: %o", client.id, packet);
+            this.logger.error(`[MQTT] Received a packet from an unregistered client: ${client.id}`);
+            return;
+        }
+        try {
+            const payload = JSON.parse(packet.payload.toString());
+            debug("onMessage payload: %o", payload);
+            const request = new Request(payload, { connection });
+            this.entryPoint.execute(connection, request, (response) => this._respond(client, response));
+        }
+        catch (error) {
+            this._respondError(client, error);
+        }
+    }
+    _respond(client, response) {
+        debug("sending response: %o", response.content);
+        if (global.NODE_ENV === "development" && this.config.developmentMode) {
+            this.broadcast({
+                channels: [this.config.responseTopic],
+                payload: response.content,
+            });
+            return;
+        }
+        client.publish({
+            payload: Buffer.from(JSON.stringify(response.content)),
+            topic: this.config.responseTopic,
+        }, this.publishCallback);
+    }
+    _respondError(client, error) {
+        const connection = this.connections.get(client);
+        const errReq = new Request({}, {
+            connection,
+            error: kerror.getFrom(error, "unexpected_error", error.message),
+        });
+        this._respond(client, removeStacktrace(errReq.response.toJSON()));
+    }
+    _authorizePublish(client, packet, callback) {
+        const topic = packet.topic.toString();
+        if (this.config.allowPubSub) {
+            if (topic === this.config.responseTopic) {
+                callback(new Error("Cannot publish: this topic is read-only"));
+            }
+            else if (topic.includes("#") || topic.includes("+")) {
+                callback(new Error("Cannot publish: wildcards are disabled"));
+            }
+            else {
+                callback(null);
+            }
+        }
+        else {
+            callback(topic === this.config.requestTopic
+                ? null
+                : new Error("Cannot publish on this topic: unauthorized"));
+        }
+    }
+    _authorizeSubscribe(client, sub, callback) {
+        if (sub.topic === this.config.requestTopic) {
+            callback(new Error("Cannot subscribe: this topic is write-only"));
+        }
+        else if (sub.topic.includes("#") || sub.topic.includes("+")) {
+            callback(new Error("Cannot subscribe: wildcards are disabled"));
+        }
+        else {
+            callback(null, sub);
+        }
+    }
+}
+module.exports = MqttProtocol;
+//# sourceMappingURL=mqttProtocol.js.map

package/dist/lib/core/network/protocols/protocol.d.ts

@@ -0,0 +1,26 @@
+export = Protocol;
+declare class Protocol {
+    constructor(name: any);
+    maxRequestSize: number;
+    entryPoint: any;
+    name: any;
+    config: {};
+    initCalled: boolean;
+    /**
+     * @param {string} name - Protocol name (used for accessor) @deprecated
+     * @param {EmbeddedEntryPoint} entryPoint
+     *
+     * @returns {Promise<boolean>}
+     */
+    init(name: string, entryPoint: EmbeddedEntryPoint): Promise<boolean>;
+    broadcast(): void;
+    joinChannel(channel: any, connectionId: any): {
+        channel: any;
+        connectionId: any;
+    };
+    leaveChannel(channel: any, connectionId: any): {
+        channel: any;
+        connectionId: any;
+    };
+    notify(): void;
+}

package/dist/lib/core/network/protocols/protocol.js

@@ -0,0 +1,74 @@
+/*
+ * 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 assert = require("assert");
+const bytes = require("../../../util/bytes");
+class Protocol {
+    constructor(name) {
+        this.maxRequestSize = null;
+        this.entryPoint = null;
+        this.name = name;
+        this.config = {};
+        this.initCalled = false;
+        Reflect.defineProperty(this, "_kuzzle", {
+            value: null,
+            writable: true,
+        });
+    }
+    /**
+     * @param {string} name - Protocol name (used for accessor) @deprecated
+     * @param {EmbeddedEntryPoint} entryPoint
+     *
+     * @returns {Promise<boolean>}
+     */
+    async init(name, entryPoint) {
+        this.entryPoint = entryPoint;
+        // name should be passed in the constructor
+        assert(this.name && !name, "A name has been given in the constructor and init method. Passing the name in the init method is deprecated.");
+        if (!this.name) {
+            this.name = name;
+        }
+        this.maxRequestSize = bytes(entryPoint.config.maxRequestSize);
+        assert(typeof this.name === "string" && this.name.length > 0, 'Invalid "name" parameter value: expected a non empty string value');
+        if (entryPoint.config.protocols && entryPoint.config.protocols[this.name]) {
+            this.config = entryPoint.config.protocols[this.name];
+        }
+        assert(Number.isInteger(this.maxRequestSize), 'Invalid "maxRequestSize" parameter value: expected a numeric value');
+        this.initCalled = true;
+        return true;
+    }
+    broadcast() {
+        // do nothing by default
+    }
+    joinChannel(channel, connectionId) {
+        // do nothing by default
+        return { channel, connectionId };
+    }
+    leaveChannel(channel, connectionId) {
+        // do nothing by default
+        return { channel, connectionId };
+    }
+    notify() {
+        // do nothing by default
+    }
+}
+module.exports = Protocol;
+//# sourceMappingURL=protocol.js.map

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

@@ -0,0 +1,49 @@
+export = Router;
+/**
+ * @class Router
+ * @property action
+ * @param {Kuzzle} kuzzle
+ */
+declare class Router {
+    connections: Map<any, any>;
+    http: HttpRouter;
+    logger: import("../../kuzzle/Logger").Logger;
+    /**
+     * Declares a new connection attached to a network protocol.
+     *
+     * @param {RequestContext} requestContext
+     */
+    newConnection(requestContext: RequestContext): void;
+    /**
+     * Removes a connection from the connection pool.
+     *
+     * @param {RequestContext} requestContext
+     */
+    removeConnection(requestContext: RequestContext): void;
+    /**
+     * Check that the provided connection id executing a request is still alive
+     *
+     * @param  {RequestContext} requestContext
+     */
+    isConnectionAlive(requestContext: RequestContext): boolean;
+    /**
+     * Initializes the HTTP routes for the Kuzzle HTTP API.
+     */
+    init(): void;
+    /**
+     * Returns the metrics of the router
+     * @returns {Object}
+     */
+    metrics(): any;
+    /**
+     * Transmit HTTP requests to the funnel controller and forward its response
+     * back to the client
+     *
+     * @param {String} verb
+     * @param {Request} request - includes URL and POST query data
+     * @param {function} cb - callback to invoke with the result
+     */
+    _executeFromHttp(verb: string, request: Request, cb: Function): void;
+}
+import HttpRouter = require("./httpRouter");
+import { Request } from "../../api/request/kuzzleRequest";