kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/kuzzle/dumpGenerator.js

@@ -0,0 +1,180 @@
+/*
+ * 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 path = require("path");
+const fs = require("fs");
+const os = require("os");
+const Bluebird = require("bluebird");
+const moment = require("moment");
+const dumpme = require("dumpme");
+const zlib = require("zlib");
+const { Request } = require("../api/request");
+const kerror = require("../kerror");
+class DumpGenerator {
+    constructor() {
+        this._dump = false;
+        this.logger = global.kuzzle.log.child("dump:dumpGenerator");
+    }
+    /**
+     * Create a dump
+     *
+     * @param {string} suffix
+     * @returns {Promise}
+     */
+    async dump(suffix) {
+        if (this._dump) {
+            throw kerror.get("api", "process", "action_locked", "dump");
+        }
+        this._dump = true;
+        const dumpPath = path.join(path.normalize(global.kuzzle.config.dump.path), moment()
+            .format(global.kuzzle.config.dump.dateFormat)
+            .concat(`-${suffix}`)
+            .substring(0, 200));
+        this.logger.info("=".repeat(79));
+        this.logger.info(`Generating dump in ${dumpPath}`);
+        this._cleanUpHistory();
+        try {
+            fs.mkdirSync(dumpPath, { recursive: true });
+        }
+        catch (e) {
+            const message = e.message.startsWith("EEXIST")
+                ? "Dump directory already exists. Skipping.."
+                : `Unable to create dump folder: ${e.message}`;
+            this.logger.error(message);
+            throw new Error(message);
+        }
+        // dump kuzzle information
+        this.logger.info("> dumping kuzzle configuration");
+        fs.writeFileSync(path.join(dumpPath, "kuzzle.json"), JSON.stringify({
+            config: global.kuzzle.config,
+            version: require("../../package.json").version,
+        }, null, " ").concat("\n"));
+        // dump plugins configuration
+        this.logger.info("> dumping plugins configuration");
+        fs.writeFileSync(path.join(dumpPath, "plugins.json"), JSON.stringify(global.kuzzle.pluginsManager.getPluginsDescription(), null, " ").concat("\n"));
+        // dump Node.js configuration
+        this.logger.info("> dumping Node.js configuration");
+        fs.writeFileSync(path.join(dumpPath, "nodejs.json"), JSON.stringify({
+            argv: process.argv,
+            config: process.config,
+            env: process.env,
+            moduleLoadList: process.moduleLoadList,
+            release: process.release,
+            versions: process.versions,
+        }, null, " ").concat("\n"));
+        // dump os configuration
+        this.logger.info("> dumping os configuration");
+        fs.writeFileSync(path.join(dumpPath, "os.json"), JSON.stringify({
+            cpus: os.cpus(),
+            loadavg: os.loadavg(),
+            mem: {
+                free: os.freemem(),
+                total: os.totalmem(),
+            },
+            networkInterfaces: os.networkInterfaces(),
+            platform: os.platform(),
+            uptime: os.uptime(),
+        }, null, " ").concat("\n"));
+        // core-dump
+        this.logger.info("> generating core-dump");
+        dumpme(global.kuzzle.config.dump.gcore || "gcore", `${dumpPath}/core`);
+        // Gzip the core
+        try {
+            const corefiles = this._listFilesMatching(dumpPath, "core");
+            if (corefiles[0]) {
+                const readStream = fs.createReadStream(corefiles[0]);
+                const writeStream = fs.createWriteStream(`${dumpPath}/core.gz`);
+                await new Bluebird((resolve) => readStream
+                    .pipe(zlib.createGzip())
+                    .pipe(writeStream)
+                    .on("finish", () => {
+                    // rm the original core file
+                    try {
+                        fs.unlinkSync(corefiles[0]);
+                    }
+                    catch (e) {
+                        this.logger.warn(`> unable to clean up core file ${corefiles[0]}`);
+                    }
+                    resolve();
+                }));
+            }
+            else {
+                this.logger.warn("> could not generate dump");
+            }
+        }
+        catch (error) {
+            this.logger.error(error);
+        }
+        // copy node binary
+        this.logger.info("> copy node binary");
+        fs.copyFileSync(process.execPath, path.join(dumpPath, "node"));
+        // dumping Kuzzle's stats
+        this.logger.info("> dumping kuzzle's stats");
+        const statistics = await global.kuzzle.statistics.getAllStats(new Request({ action: "getAllStats", controller: "statistics" }));
+        fs.writeFileSync(path.join(dumpPath, "statistics.json"), JSON.stringify(statistics.hits, null, " ").concat("\n"));
+        this.logger.info("Done.");
+        this.logger.info("[ℹ] You can send the folder to the kuzzle core team at support@kuzzle.io");
+        this.logger.info("=".repeat(79));
+        this._dump = false;
+        return dumpPath;
+    }
+    _cleanUpHistory() {
+        const config = global.kuzzle.config.dump, dumpPath = path.normalize(global.kuzzle.config.dump.path);
+        try {
+            fs.accessSync(dumpPath, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
+        }
+        catch (e) {
+            return;
+        }
+        const dumps = fs
+            .readdirSync(dumpPath)
+            .map((file) => {
+            const filepath = `${dumpPath}/${file}`;
+            return { path: filepath, stat: fs.statSync(filepath) };
+        })
+            .filter((prop) => prop.stat.isDirectory())
+            .sort((a, b) => {
+            if (a.stat.birthtime.getTime() === b.stat.birthtime.getTime()) {
+                return 0;
+            }
+            return a.stat.birthtime < b.stat.birthtime ? -1 : 1;
+        });
+        while (dumps.length >= config.history.reports) {
+            const dir = dumps.shift().path;
+            fs.rmdirSync(dir, { recursive: true });
+        }
+        for (let i = 0; i < dumps.length - config.history.coredump; i++) {
+            const corefiles = this._listFilesMatching(path.normalize(dumps[i].path), "core");
+            if (corefiles[0]) {
+                fs.unlinkSync(corefiles[0]);
+            }
+        }
+    }
+    _listFilesMatching(directory, start) {
+        return fs
+            .readdirSync(directory)
+            .filter((entry) => fs.lstatSync(`${directory}/${entry}`).isFile() &&
+            entry.startsWith(start))
+            .map((file) => path.join(directory, file));
+    }
+}
+module.exports = DumpGenerator;
+//# sourceMappingURL=dumpGenerator.js.map

package/dist/lib/kuzzle/event/pipeRunner.d.ts

@@ -0,0 +1,30 @@
+export = PipeRunner;
+/**
+ * @class PipeRunner
+ * Runs pipe chains if the number of already running concurrent pipes allows it.
+ * Otherwise, delays the pipe chain until a slot is freed. If the storage
+ * buffer is full, rejects the provided callback and discard the pipe chain.
+ *
+ * @param {Number} concurrent - max number of concurrent pipes
+ * @param {Number} bufferSize - max number of delayed pipe chains
+ */
+declare class PipeRunner {
+    constructor(concurrent: any, bufferSize: any);
+    maxConcurrent: number;
+    running: number;
+    maxBufferSize: number;
+    buffer: Denque<any>;
+    _boundRunNext: any;
+    /**
+     * @warning Critical code section
+     *
+     * Pipes can be run thousands of times per seconds
+     * @param {Array} chain - functions chain
+     * @param {Array} args  - functions arguments
+     * @param {Function} callback - end-of-chain callback
+     * @param {Object} callbackContext - functions/callback context
+     */
+    run(chain: any[], args: any[], callback: Function, callbackContext: any): void;
+    _runNext(): void;
+}
+import Denque = require("denque");

package/dist/lib/kuzzle/event/pipeRunner.js

@@ -0,0 +1,119 @@
+/*
+ * 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 Denque = require("denque");
+const { KuzzleError } = require("../../kerror/errors");
+const waterfall = require("./waterfall");
+const kerror = require("../../kerror").wrap("plugin", "runtime");
+/**
+ * We declare the callback used by waterfall one time instead
+ * of redeclaring a closure each time we want to run the pipes.
+ *
+ * This callback must be called with the following object as context:
+ * { instance: (pipeRunner instance), callback: (callback after pipes execution) }
+ */
+/* eslint-disable no-invalid-this */
+function waterfallCallback(error, ...result) {
+    this.instance.running--;
+    if (!this.instance.buffer.isEmpty()) {
+        setImmediate(this.instance._boundRunNext);
+    }
+    if (error) {
+        const cbError = error instanceof KuzzleError
+            ? error
+            : kerror.getFrom(error, "unexpected_error", error.message);
+        this.callback.call(this.callbackContext, cbError);
+    }
+    else {
+        this.callback.call(this.callbackContext, null, ...result);
+    }
+}
+/* eslint-enable no-invalid-this */
+/**
+ * @private
+ * @class PipeChain
+ */
+class PipeChain {
+    constructor(chain, args, callback, callbackContext) {
+        this.chain = chain;
+        this.args = args;
+        this.callback = callback;
+        this.callbackContext = callbackContext;
+    }
+}
+/**
+ * @class PipeRunner
+ * Runs pipe chains if the number of already running concurrent pipes allows it.
+ * Otherwise, delays the pipe chain until a slot is freed. If the storage
+ * buffer is full, rejects the provided callback and discard the pipe chain.
+ *
+ * @param {Number} concurrent - max number of concurrent pipes
+ * @param {Number} bufferSize - max number of delayed pipe chains
+ */
+class PipeRunner {
+    constructor(concurrent, bufferSize) {
+        assert(typeof concurrent === "number" && concurrent > 0, "Cannot instantiate pipes executor: invalid maxConcurrentPipes parameter value");
+        assert(typeof bufferSize === "number" && bufferSize > 0, "Cannot instantiate pipes executor: invalid pipesBufferSize parameter value");
+        this.maxConcurrent = concurrent;
+        this.running = 0;
+        this.maxBufferSize = bufferSize;
+        this.buffer = new Denque();
+        this._boundRunNext = this._runNext.bind(this);
+    }
+    /**
+     * @warning Critical code section
+     *
+     * Pipes can be run thousands of times per seconds
+     * @param {Array} chain - functions chain
+     * @param {Array} args  - functions arguments
+     * @param {Function} callback - end-of-chain callback
+     * @param {Object} callbackContext - functions/callback context
+     */
+    run(chain, args, callback, callbackContext) {
+        if (this.running >= this.maxConcurrent) {
+            if (this.buffer.length >= this.maxBufferSize) {
+                callback.call(callbackContext, kerror.get("too_many_pipes"));
+            }
+            else {
+                this.buffer.push(new PipeChain(chain, args, callback, callbackContext));
+            }
+            return;
+        }
+        this.running++;
+        // Create a context for the waterfall callback
+        const waterfallCallbackCtx = {
+            callback,
+            callbackContext,
+            instance: this,
+        };
+        waterfall(chain, args, waterfallCallback, waterfallCallbackCtx);
+    }
+    _runNext() {
+        if (this.buffer.isEmpty() || this.running >= this.maxConcurrent) {
+            return;
+        }
+        const pipe = this.buffer.shift();
+        this.run(pipe.chain, pipe.args, pipe.callback, pipe.callbackContext);
+    }
+}
+module.exports = PipeRunner;
+//# sourceMappingURL=pipeRunner.js.map

package/dist/lib/kuzzle/event/waterfall.d.ts

@@ -0,0 +1,2 @@
+export = waterfall;
+declare function waterfall(chain: any, args: any, cb: any, context: any): void;

package/dist/lib/kuzzle/event/waterfall.js

@@ -0,0 +1,90 @@
+/*
+ * 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 WaterfallContext {
+    /**
+     * @param  {Array}    chain  - list of functions to call
+     * @param  {Array}    args   - function arguments
+     * @param  {Function} cb     - end of waterfall callback
+     * @param  {Object}   cbCtx  - functions context
+     */
+    constructor(chain, args, cb, cbCtx) {
+        this.chain = chain;
+        this.cb = cb;
+        this.cbCtx = cbCtx;
+        this.index = 0;
+        // since we always add a callback, and since after the 1st chain function
+        // there is always at least 1 arg which is the 1st function result (it
+        // can be undefined), then we need to force at least 1 argument to make
+        // sure that all pipe methods receive the same payload
+        this.args = args.length ? args : [null];
+    }
+    hasNext() {
+        return this.index < this.chain.length;
+    }
+    /**
+     * Each function in the waterfall chain returns a result. This result should
+     * always be the 1st payload argument (updated or left intact, it matters not)
+     */
+    set result(result) {
+        this.args[0] = result;
+    }
+    next(cb) {
+        this.index++;
+        this.chain[this.index - 1](...this.args, cb);
+    }
+    reject(error) {
+        this.cb.call(this.cbCtx, error);
+    }
+    // Resolves with the updated payload
+    resolve() {
+        this.cb.call(this.cbCtx, null, ...this.args);
+    }
+}
+/* eslint-disable no-invalid-this */
+function waterfallCB(err, res) {
+    if (err) {
+        this.reject(err);
+    }
+    else {
+        this.result = res;
+        waterfallNext(this);
+    }
+}
+/* eslint-enable no-invalid-this */
+function waterfallNext(ctx) {
+    if (!ctx.hasNext()) {
+        ctx.resolve();
+        return;
+    }
+    try {
+        ctx.next(waterfallCB.bind(ctx));
+    }
+    catch (error) {
+        ctx.reject(error);
+    }
+}
+function waterfall(chain, args, cb, context) {
+    const ctx = new WaterfallContext(chain, args, cb, context);
+    waterfallNext(ctx);
+}
+module.exports = waterfall;
+//# sourceMappingURL=waterfall.js.map

package/dist/lib/kuzzle/internalIndexHandler.d.ts

@@ -0,0 +1,186 @@
+export = InternalIndexHandler;
+declare class InternalIndexHandler extends Store {
+    constructor();
+    timeout: number;
+    config: {
+        name: string;
+        collections: {
+            users: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false" | "true" | "strict";
+                    properties: {
+                        profileIds: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            profiles: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: {
+                        tags: {
+                            type: "keyword";
+                        };
+                        policies: {
+                            properties: {
+                                roleId: {
+                                    type: "keyword";
+                                };
+                                restrictedTo: {
+                                    type: "nested";
+                                    properties: {
+                                        index: {
+                                            type: "keyword";
+                                        };
+                                        collections: {
+                                            type: "keyword";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            roles: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: {
+                        tags: {
+                            type: "keyword";
+                        };
+                        controllers: {
+                            dynamic: "false";
+                            properties: Record<string, unknown>;
+                        };
+                    };
+                };
+            };
+            validations: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    properties: {
+                        index: {
+                            type: "keyword";
+                        };
+                        collection: {
+                            type: "keyword";
+                        };
+                        validations: {
+                            dynamic: "false";
+                            properties: Record<string, unknown>;
+                        };
+                    };
+                };
+            };
+            config: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: Record<string, unknown>;
+                };
+            };
+            "api-keys": {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "false";
+                    properties: {
+                        userId: {
+                            type: "keyword";
+                        };
+                        hash: {
+                            type: "keyword";
+                        };
+                        description: {
+                            type: "text";
+                        };
+                        expiresAt: {
+                            type: "long";
+                        };
+                        ttl: {
+                            type: "keyword";
+                        };
+                        token: {
+                            type: "keyword";
+                        };
+                    };
+                };
+            };
+            installations: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "strict";
+                    properties: {
+                        description: {
+                            type: "text";
+                        };
+                        handler: {
+                            type: "text";
+                        };
+                        installedAt: {
+                            type: "date";
+                        };
+                    };
+                };
+            };
+            imports: {
+                settings: {
+                    number_of_shards: number;
+                    number_of_replicas: number;
+                };
+                mappings: {
+                    dynamic: "strict";
+                    properties: {
+                        hash: {
+                            type: "keyword";
+                        };
+                    };
+                };
+            };
+        };
+    };
+    _BOOTSTRAP_DONE_ID: string;
+    _DATAMODEL_VERSION_ID: string;
+    _JWT_SECRET_ID: string;
+    logger: import("./Logger").Logger;
+    /**
+     * @returns {Promise}
+     */
+    init(): Promise<any>;
+    /**
+     * @override
+     */
+    override _bootstrapSequence(): Promise<void>;
+    /**
+     * Creates initial roles and profiles as specified in Kuzzle configuration
+     */
+    createInitialSecurities(): Promise<void>;
+    createInitialValidations(): Promise<void>;
+    _initSecret(): Promise<void>;
+}
+import { Store } from "../core/shared/store";