kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/api/rateLimiter.d.ts

@@ -0,0 +1,18 @@
+export = RateLimiter;
+declare class RateLimiter {
+    loginsPerSecond: number;
+    frame: {};
+    frameResetTimer: NodeJS.Timeout;
+    init(): void;
+    /**
+     * Return a boolean indicating whether a request execution is allowed as per
+     * the rate restriction configuration.
+     *
+     * auth:login is limited by the limits.loginsPerSecond configuration
+     * auth:logout is NOT limited for authenticated users
+     *
+     * @param  {Request}  request
+     * @returns {Boolean}
+     */
+    isAllowed(request: Request): boolean;
+}

package/dist/lib/api/rateLimiter.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";
+class RateLimiter {
+    constructor() {
+        this.loginsPerSecond = global.kuzzle.config.limits.loginsPerSecond;
+        this.frame = {};
+        this.frameResetTimer = null;
+    }
+    init() {
+        this.frameResetTimer = setInterval(() => (this.frame = {}), 1000);
+    }
+    /**
+     * Return a boolean indicating whether a request execution is allowed as per
+     * the rate restriction configuration.
+     *
+     * auth:login is limited by the limits.loginsPerSecond configuration
+     * auth:logout is NOT limited for authenticated users
+     *
+     * @param  {Request}  request
+     * @returns {Boolean}
+     */
+    async isAllowed(request) {
+        const { controller, action } = request.input;
+        let count = 0;
+        let limit = -1;
+        if (controller === "auth" && action === "login") {
+            const cid = request.context.connection.id;
+            count = this.frame[cid] = (this.frame[cid] || 0) + 1;
+            limit = this.loginsPerSecond;
+        }
+        else {
+            const { _id, profileIds } = request.context.user;
+            // By definition, auth:logout should be unrestricted
+            if (_id !== "-1" && controller === "auth" && action === "logout") {
+                return true;
+            }
+            const profiles = await global.kuzzle.ask("core:security:profile:mGet", profileIds);
+            for (let i = 0; i < profiles.length; i++) {
+                const { rateLimit = 0 } = profiles[i];
+                if (limit === 0 || rateLimit === 0) {
+                    limit = 0;
+                }
+                else {
+                    limit = Math.max(limit, rateLimit);
+                }
+            }
+            if (limit > 0) {
+                count = this.frame[_id] = (this.frame[_id] || 0) + 1;
+            }
+        }
+        return limit === 0 || count <= limit;
+    }
+}
+module.exports = RateLimiter;
+//# sourceMappingURL=rateLimiter.js.map

package/{lib → dist/lib}/api/request/kuzzleRequest.d.ts

@@ -112,8 +112,8 @@ export declare class KuzzleRequest {
     pojo(): {
         context: {
             connection: import("./requestContext").Connection;
-            token: import("../../types").Token;
-            user: User;
+            token: import("../../model/security/token").Token;
+            user: import("../../model/security/user").User;
         };
         deprecations: void | Deprecation[];
         error: KuzzleError;

package/{lib → dist/lib}/api/request/requestContext.d.ts

@@ -1,5 +1,6 @@
 import { JSONObject } from "kuzzle-sdk";
-import { User, Token } from "../../types";
+import { Token } from "../../model/security/token";
+import { User } from "../../model/security/user";
 export type ContextMisc = {
     /**
      * HTTP url

package/dist/lib/cluster/command.d.ts

@@ -0,0 +1,73 @@
+export = ClusterCommand;
+declare class ClusterCommand {
+    /**
+     * @constructor
+     * @param {ClusterNode} localNode
+     */
+    constructor(localNode: ClusterNode);
+    node: ClusterNode;
+    server: Reply;
+    protoroot: protobuf.Root;
+    state: 1;
+    logger: import("../kuzzle/Logger").Logger;
+    init(): Promise<void>;
+    serve(): Promise<void>;
+    /**
+     * Listens to incoming requests and answer to them.
+     * Do NOT await this method, it's meant to run indefinitely until the close()
+     * method is invoked.
+     * This method can (and should) never return a rejected promise.
+     *
+     * @returns {void}
+     */
+    listen(): void;
+    /**
+     * Closes opened sockets and marks this server as closed.
+     * @return {void}
+     */
+    dispose(): void;
+    /**
+     * Sends back the full state to the requesting node
+     * @return {void}
+     */
+    sendFullState(): void;
+    /**
+     * Handles a handshake request from a remote node
+     * @return {void}
+     */
+    handleHandshake(data: any): void;
+    /**
+     * Request the full state from ONE of the remote nodes of the cluster, AT
+     * RANDOM (necessary to make sure we distribute the full state serialization
+     * load across all nodes)
+     *
+     * @param  {Array.<IdCard>} nodes
+     * @return {Object|null} Returns the fetched full state, or null if no node answered
+     */
+    getFullState(nodes: Array<IdCard>): any | null;
+    /**
+     * Sends a handshake request to other remote nodes and process their response
+     * Returns an object with the following structure:
+     *
+     * {
+     *   [nodeId]: { added: <boolean>, lastMessageId: <number> },
+     *   [nodeId]: null, // no response received, node is probably dead
+     * }
+     *
+     * @param  {Array.<IdCard>} nodes
+     * @return {Object}
+     */
+    broadcastHandshake(nodes: Array<IdCard>): any;
+    /**
+     * Sends a handshake payload to a remote node, and waits for its response
+     *
+     * @param  {string} id      - remote node ID
+     * @param  {string} ip      - remote node IP address
+     * @param  {Buffer} payload - handshake payload (protobuf encoded)
+     * @return {Object|null}    - handshake encoded response, or null if no
+     *                            response was received
+     */
+    _sendSingleHandshake(id: string, ip: string, payload: Buffer): any | null;
+}
+import { Reply } from "zeromq";
+import protobuf = require("protobufjs");

package/dist/lib/cluster/command.js

@@ -0,0 +1,236 @@
+/*
+ * 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 { Reply, Request } = require("zeromq");
+const protobuf = require("protobufjs");
+const Bluebird = require("bluebird");
+/* eslint-disable sort-keys */
+const stateEnum = Object.freeze({
+    INITIALIZING: 1,
+    RUNNING: 2,
+    CLOSED: 3,
+});
+const topicEnum = Object.freeze({
+    FULLSTATE: "fullstate",
+    HANDSHAKE: "handshake",
+    DISCARDED: "discarded", // 0 byte message expected
+});
+/* eslint-enable sort-keys */
+// Handles bidirectional requests between this node and other nodes
+class ClusterCommand {
+    /**
+     * @constructor
+     * @param {ClusterNode} localNode
+     */
+    constructor(localNode) {
+        this.node = localNode;
+        this.server = null;
+        this.protoroot = null;
+        this.state = stateEnum.INITIALIZING;
+        this.logger = global.kuzzle.log.child("cluster:command");
+    }
+    async init() {
+        this.protoroot = await protobuf.load(`${__dirname}/protobuf/command.proto`);
+        await this.serve();
+        this.listen();
+    }
+    async serve() {
+        this.server = new Reply();
+        await this.server.bind(`tcp://*:${this.node.config.ports.command}`);
+    }
+    /**
+     * Listens to incoming requests and answer to them.
+     * Do NOT await this method, it's meant to run indefinitely until the close()
+     * method is invoked.
+     * This method can (and should) never return a rejected promise.
+     *
+     * @returns {void}
+     */
+    async listen() {
+        this.state = stateEnum.RUNNING;
+        while (this.state === stateEnum.RUNNING) {
+            try {
+                const [type, data] = await this.server.receive();
+                switch (type.toString()) {
+                    case topicEnum.FULLSTATE:
+                        await this.sendFullState();
+                        break;
+                    case topicEnum.HANDSHAKE:
+                        await this.handleHandshake(data);
+                        break;
+                    default:
+                        // REP/REQ sockets expect a reply to each request made, so we have
+                        // to send some kind of response on an invalid request received
+                        await this.server.send([topicEnum.DISCARDED, null]);
+                }
+            }
+            catch (e) {
+                if (this.state !== stateEnum.CLOSED) {
+                    throw e;
+                }
+            }
+        }
+    }
+    /**
+     * Closes opened sockets and marks this server as closed.
+     * @return {void}
+     */
+    dispose() {
+        this.state = stateEnum.CLOSED;
+        this.server.close();
+    }
+    /**
+     * Sends back the full state to the requesting node
+     * @return {void}
+     */
+    async sendFullState() {
+        const fullState = this.node.fullState.serialize();
+        fullState.activity = this.node.activity;
+        fullState.nodesState = [];
+        for (const [id, subscriber] of this.node.remoteNodes.entries()) {
+            fullState.nodesState.push({
+                id,
+                lastMessageId: subscriber.lastMessageId,
+            });
+        }
+        fullState.nodesState.push({
+            id: this.node.nodeId,
+            lastMessageId: this.node.publisher.lastMessageId,
+        });
+        const protoEncode = this.protoroot.lookupType("FullStateResponse");
+        const buffer = protoEncode.encode(protoEncode.create(fullState)).finish();
+        await this.server.send([topicEnum.FULLSTATE, buffer]);
+    }
+    /**
+     * Handles a handshake request from a remote node
+     * @return {void}
+     */
+    async handleHandshake(data) {
+        const decoder = this.protoroot.lookupType("HandshakeRequest");
+        const { nodeId, ip, lastMessageId } = decoder.toObject(decoder.decode(data));
+        const added = await this.node.addNode(nodeId, ip, lastMessageId);
+        const encoder = this.protoroot.lookupType("HandshakeResponse");
+        const response = {
+            added,
+            lastMessageId: this.node.publisher.lastMessageId,
+        };
+        const buffer = encoder.encode(encoder.create(response)).finish();
+        await this.server.send([topicEnum.HANDSHAKE, buffer]);
+    }
+    /**
+     * Request the full state from ONE of the remote nodes of the cluster, AT
+     * RANDOM (necessary to make sure we distribute the full state serialization
+     * load across all nodes)
+     *
+     * @param  {Array.<IdCard>} nodes
+     * @return {Object|null} Returns the fetched full state, or null if no node answered
+     */
+    async getFullState(nodes) {
+        let idx = Math.floor(Math.random() * Math.floor(nodes.length));
+        let fullState = null;
+        for (let retries = 0; fullState === null && retries < nodes.length; retries++) {
+            const { id, ip } = nodes[idx];
+            const req = new Request();
+            req.receiveTimeout = this.node.config.syncTimeout;
+            req.connect(`tcp://${ip}:${this.node.config.ports.command}`);
+            // No payload message for a full state request
+            await req.send([topicEnum.FULLSTATE, null]);
+            try {
+                [, fullState] = await req.receive();
+            }
+            catch (e) {
+                // no response from the remote node in a timely fashion... retrying
+                // with another one
+                this.logger.warn(`Unable to fetch a full state from node ${id} (no response received)`);
+                idx = (idx + 1) % nodes.length;
+            }
+            finally {
+                req.close();
+            }
+        }
+        if (fullState === null) {
+            return null;
+        }
+        const decoder = this.protoroot.lookupType("FullStateResponse");
+        return decoder.toObject(decoder.decode(fullState));
+    }
+    /**
+     * Sends a handshake request to other remote nodes and process their response
+     * Returns an object with the following structure:
+     *
+     * {
+     *   [nodeId]: { added: <boolean>, lastMessageId: <number> },
+     *   [nodeId]: null, // no response received, node is probably dead
+     * }
+     *
+     * @param  {Array.<IdCard>} nodes
+     * @return {Object}
+     */
+    async broadcastHandshake(nodes) {
+        const payload = {
+            ip: this.node.ip,
+            lastMessageId: this.node.publisher.lastMessageId,
+            nodeId: this.node.nodeId,
+        };
+        const encoder = this.protoroot.lookupType("HandshakeRequest");
+        const encoded = encoder.encode(encoder.create(payload)).finish();
+        const responses = await Bluebird.map(nodes, ({ id, ip }) => this._sendSingleHandshake(id, ip, encoded));
+        const decoder = this.protoroot.lookupType("HandshakeResponse");
+        const result = {};
+        for (let i = 0; i < nodes.length; i++) {
+            if (responses[i] === null) {
+                result[nodes[i].id] = null;
+            }
+            else {
+                result[nodes[i].id] = decoder.toObject(decoder.decode(responses[i]));
+            }
+        }
+        return result;
+    }
+    /**
+     * Sends a handshake payload to a remote node, and waits for its response
+     *
+     * @param  {string} id      - remote node ID
+     * @param  {string} ip      - remote node IP address
+     * @param  {Buffer} payload - handshake payload (protobuf encoded)
+     * @return {Object|null}    - handshake encoded response, or null if no
+     *                            response was received
+     */
+    async _sendSingleHandshake(id, ip, payload) {
+        const req = new Request();
+        req.receiveTimeout = 2000;
+        req.connect(`tcp://${ip}:${this.node.config.ports.command}`);
+        await req.send([topicEnum.HANDSHAKE, payload]);
+        let response = null;
+        try {
+            [, response] = await req.receive();
+        }
+        catch (e) {
+            this.logger.warn(`Couldn't complete handshake with node ${id}: no response received`);
+        }
+        finally {
+            req.close();
+        }
+        return response;
+    }
+}
+module.exports = ClusterCommand;
+//# sourceMappingURL=command.js.map

package/dist/lib/cluster/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: typeof import("./node");
+export = _exports;

package/{lib → dist/lib}/cluster/index.js

@@ -18,7 +18,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 module.exports = require("./node");
+//# sourceMappingURL=index.js.map