kuzzle 2.20.2 → 2.21.0

package/lib/api/controllers/debugController.d.ts

@@ -4,23 +4,10 @@ import { NativeController } from "./baseController";
  * @class DebugController
  */
 export declare class DebugController extends NativeController {
-    private inspector;
-    private debuggerStatus;
-    /**
-     * Map<eventName, Set<connectionId>>
-     */
-    private events;
-    /**
-     * Map of functions from the DebugModules
-     */
-    private kuzzlePostMethods;
+    constructor();
     /**
-     * List of DebugModule for DebugController
-     * Used to add new methods and events to the protocol
+     * Return the node version of the current Kuzzle instance
      */
-    private modules;
-    constructor();
-    init(): Promise<void>;
     nodeVersion(): Promise<string>;
     /**
      * Connect the debugger
@@ -44,16 +31,4 @@ export declare class DebugController extends NativeController {
      * Remove the websocket connection from the events' listeners
      */
     removeListener(request: KuzzleRequest): Promise<void>;
-    /**
-     * Execute a method using the Chrome Debug Protocol
-     * @param method Chrome Debug Protocol method to execute
-     * @param params
-     * @returns
-     */
-    private inspectorPost;
-    /**
-     * Sends a direct notification to a websocket connection without having to listen to a specific room
-     */
-    private notifyConnection;
-    private notifyGlobalListeners;
 }

package/lib/api/controllers/debugController.js

@@ -42,16 +42,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DebugController = void 0;
 const baseController_1 = require("./baseController");
-const inspector_1 = __importDefault(require("inspector"));
 const kerror = __importStar(require("../../kerror"));
-const get_1 = __importDefault(require("lodash/get"));
-const DEBUGGER_EVENT = "kuzzle-debugger-event";
 /**
  * @class DebugController
  */
@@ -65,53 +59,10 @@ class DebugController extends baseController_1.NativeController {
             "addListener",
             "removeListener",
         ]);
-        this.debuggerStatus = false;
-        /**
-         * Map<eventName, Set<connectionId>>
-         */
-        this.events = new Map();
-        /**
-         * Map of functions from the DebugModules
-         */
-        this.kuzzlePostMethods = new Map();
-        /**
-         * List of DebugModule for DebugController
-         * Used to add new methods and events to the protocol
-         */
-        this.modules = [];
-    }
-    async init() {
-        super.init();
-        this.inspector = new inspector_1.default.Session();
-        // Remove connection id from the list of listeners for each event
-        global.kuzzle.on("connection:remove", (connectionId) => {
-            if (!this.debuggerStatus) {
-                return;
-            }
-            for (const listener of this.events.values()) {
-                listener.delete(connectionId);
-            }
-        });
-        this.inspector.on("inspectorNotification", async (payload) => {
-            if (!this.debuggerStatus) {
-                return;
-            }
-            await this.notifyGlobalListeners(payload.method, payload);
-            const listeners = this.events.get(payload.method);
-            if (!listeners) {
-                return;
-            }
-            const promises = [];
-            for (const connectionId of listeners) {
-                promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
-                    event: payload.method,
-                    result: payload,
-                }));
-            }
-            // No need to catch, notify is already try-catched
-            await Promise.all(promises);
-        });
     }
+    /**
+     * Return the node version of the current Kuzzle instance
+     */
     async nodeVersion() {
         return process.version;
     }
@@ -119,82 +70,22 @@ class DebugController extends baseController_1.NativeController {
      * Connect the debugger
      */
     async enable() {
-        if (this.debuggerStatus) {
-            return;
-        }
-        this.inspector.connect();
-        this.debuggerStatus = true;
-        for (const module of this.modules) {
-            await module.init(this.inspector);
-            for (const methodName of module.methods) {
-                if (!module[methodName]) {
-                    throw new Error(`Missing implementation of method "${methodName}" inside DebugModule "${module.name}"`);
-                }
-                this.kuzzlePostMethods.set(`Kuzzle.${module.name}.${methodName}`, module[methodName].bind(module));
-            }
-            for (const eventName of module.events) {
-                module.on(eventName, async (payload) => {
-                    if (!this.debuggerStatus) {
-                        return;
-                    }
-                    const event = `Kuzzle.${module.name}.${eventName}`;
-                    await this.notifyGlobalListeners(event, payload);
-                    const listeners = this.events.get(event);
-                    if (!listeners) {
-                        return;
-                    }
-                    const promises = [];
-                    for (const connectionId of listeners) {
-                        promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
-                            event,
-                            result: payload,
-                        }));
-                    }
-                    // No need to catch, notify is already try-catched
-                    await Promise.all(promises);
-                });
-            }
-        }
+        await global.kuzzle.ask("core:debugger:enable");
     }
     /**
      * Disconnect the debugger and clears all the events listeners
      */
     async disable() {
-        if (!this.debuggerStatus) {
-            return;
-        }
-        for (const module of this.modules) {
-            for (const eventName of module.events) {
-                module.removeAllListeners(eventName);
-            }
-            await module.cleanup();
-        }
-        this.inspector.disconnect();
-        this.debuggerStatus = false;
-        this.events.clear();
-        this.kuzzlePostMethods.clear();
+        await global.kuzzle.ask("core:debugger:disable");
     }
     /**
      * Trigger action from debugger directly following the Chrome Debug Protocol
      * See: https://chromedevtools.github.io/devtools-protocol/v8/
      */
     async post(request) {
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
         const method = request.getBodyString("method");
         const params = request.getBodyObject("params", {});
-        if (method.startsWith("Kuzzle.")) {
-            const debugModuleMethod = this.kuzzlePostMethods.get(method);
-            if (debugModuleMethod) {
-                return debugModuleMethod(params);
-            }
-            throw kerror.get("core", "debugger", "method_not_found", method);
-        }
-        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
-            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
-        }
-        return this.inspectorPost(method, params);
+        return global.kuzzle.ask("core:debugger:post", method, params);
     }
     /**
      * Make the websocket connection listen and receive events from Chrome Debug Protocol
@@ -204,16 +95,8 @@ class DebugController extends baseController_1.NativeController {
         if (request.context.connection.protocol !== "websocket") {
             throw kerror.get("api", "assert", "unsupported_protocol", request.context.connection.protocol, "debug:addListener");
         }
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
         const event = request.getBodyString("event");
-        let listeners = this.events.get(event);
-        if (!listeners) {
-            listeners = new Set();
-            this.events.set(event, listeners);
-        }
-        listeners.add(request.context.connection.id);
+        await global.kuzzle.ask("core:debugger:addListener", event, request.context.connection.id);
     }
     /**
      * Remove the websocket connection from the events' listeners
@@ -222,65 +105,8 @@ class DebugController extends baseController_1.NativeController {
         if (request.context.connection.protocol !== "websocket") {
             throw kerror.get("api", "assert", "unsupported_protocol", request.context.connection.protocol, "debug:removeListener");
         }
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
         const event = request.getBodyString("event");
-        const listeners = this.events.get(event);
-        if (listeners) {
-            listeners.delete(request.context.connection.id);
-        }
-    }
-    /**
-     * Execute a method using the Chrome Debug Protocol
-     * @param method Chrome Debug Protocol method to execute
-     * @param params
-     * @returns
-     */
-    async inspectorPost(method, params) {
-        if (!this.debuggerStatus) {
-            throw kerror.get("core", "debugger", "not_enabled");
-        }
-        let resolve;
-        const promise = new Promise((res) => {
-            resolve = res;
-        });
-        this.inspector.post(method, params, (err, res) => {
-            if (err) {
-                resolve({
-                    error: JSON.stringify(Object.getOwnPropertyDescriptors(err)),
-                });
-            }
-            else {
-                resolve(res);
-            }
-        });
-        return promise;
-    }
-    /**
-     * Sends a direct notification to a websocket connection without having to listen to a specific room
-     */
-    async notifyConnection(connectionId, event, payload) {
-        global.kuzzle.entryPoint._notify({
-            channels: [event],
-            connectionId,
-            payload,
-        });
-    }
-    async notifyGlobalListeners(event, payload) {
-        const listeners = this.events.get("*");
-        if (!listeners) {
-            return;
-        }
-        const promises = [];
-        for (const connectionId of listeners) {
-            promises.push(this.notifyConnection(connectionId, DEBUGGER_EVENT, {
-                event,
-                result: payload,
-            }));
-        }
-        // No need to catch, notify is already try-catched
-        await Promise.all(promises);
+        await global.kuzzle.ask("core:debugger:removeListener", event, request.context.connection.id);
     }
 }
 exports.DebugController = DebugController;

package/lib/api/controllers/documentController.js

@@ -390,12 +390,34 @@ class DocumentController extends NativeController {
 
     const validated = await global.kuzzle.validation.validate(request, false);
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          author: userId,
+          createdAt: Date.now(),
+          updatedAt: null,
+          updater: null,
+        },
+        request,
+      }
+    );
+
     const created = await this.ask(
       "core:storage:public:document:create",
       index,
       collection,
-      validated.getBody(),
-      { id, refresh, userId }
+      {
+        ...validated.getBody(),
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        id,
+        injectKuzzleMeta: false,
+        refresh,
+        userId,
+      }
     );
 
     if (!silent) {
@@ -440,13 +462,34 @@ class DocumentController extends NativeController {
       false
     );
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          author: userId,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const response = await this.ask(
       "core:storage:public:document:createOrReplace",
       index,
       collection,
       id,
-      content,
-      { refresh, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        injectKuzzleMeta: false,
+        refresh,
+        userId,
+      }
     );
 
     if (!silent) {
@@ -493,13 +536,33 @@ class DocumentController extends NativeController {
       false
     );
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const updatedDocument = await this.ask(
       "core:storage:public:document:update",
       index,
       collection,
       id,
-      content,
-      { refresh, retryOnConflict, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        injectKuzzleMeta: false,
+        refresh,
+        retryOnConflict,
+        userId,
+      }
     );
 
     const _updatedFields = extractFields(content, {
@@ -548,13 +611,41 @@ class DocumentController extends NativeController {
     const source = request.getBoolean("source");
     const { index, collection } = request.getIndexAndCollection();
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        defaultMetadata: {
+          author: userId,
+          createdAt: Date.now(),
+        },
+        metadata: {
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const updatedDocument = await this.ask(
       "core:storage:public:document:upsert",
       index,
       collection,
       id,
-      content,
-      { defaultValues, refresh, retryOnConflict, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        defaultValues: {
+          ...defaultValues,
+          _kuzzle_info: pipeMetadataResult.defaultMetadata,
+        },
+        injectKuzzleMeta: false,
+        refresh,
+        retryOnConflict,
+        userId,
+      }
     );
 
     if (!silent && updatedDocument.created) {
@@ -633,13 +724,34 @@ class DocumentController extends NativeController {
       false
     );
 
+    // Add metadata
+    const pipeMetadataResult = await this.pipe(
+      "generic:document:injectMetadata",
+      {
+        metadata: {
+          author: userId,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          updater: userId,
+        },
+        request,
+      }
+    );
+
     const response = await this.ask(
       "core:storage:public:document:replace",
       index,
       collection,
       id,
-      content,
-      { refresh, userId }
+      {
+        ...content,
+        _kuzzle_info: pipeMetadataResult.metadata,
+      },
+      {
+        injectKuzzleMeta: false,
+        refresh,
+        userId,
+      }
     );
 
     if (!silent) {

package/lib/api/request/kuzzleRequest.d.ts

@@ -135,6 +135,14 @@ export declare class KuzzleRequest {
         status: number;
         timestamp: number;
     };
+    /**
+     * Return the requested controller
+     */
+    getController(): string;
+    /**
+     * Returns the requested controller's action
+     */
+    getAction(): string;
     /**
      * Returns the `lang` param of the request.
      *

package/lib/api/request/kuzzleRequest.js

@@ -324,6 +324,18 @@ class KuzzleRequest {
             timestamp: this.timestamp,
         };
     }
+    /**
+     * Return the requested controller
+     */
+    getController() {
+        return this[_input].controller;
+    }
+    /**
+     * Returns the requested controller's action
+     */
+    getAction() {
+        return this[_input].action;
+    }
     /**
      * Returns the `lang` param of the request.
      *

package/lib/cluster/idCardHandler.js

@@ -25,7 +25,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClusterIdCardHandler = exports.IdCard = void 0;
 const name_generator_1 = require("../util/name-generator");
-const worker_threads_1 = require("worker_threads");
+const child_process_1 = require("child_process");
 const bluebird_1 = __importDefault(require("bluebird"));
 require("../types");
 const REDIS_PREFIX = "{cluster/node}/";
@@ -110,14 +110,16 @@ class ClusterIdCardHandler {
         } while (!reserved);
         await this.addIdCardToIndex();
         this.refreshWorker = this.constructWorker(`${__dirname}/workers/IDCardRenewer.js`);
-        this.refreshWorker.unref();
         this.refreshWorker.on("message", async (message) => {
             if (message.error) {
                 await this.node.evictSelf(message.error);
             }
         });
+        this.refreshWorker.on("close", () => {
+            this.disposed = true;
+        });
         // Transfer informations to the worker
-        this.refreshWorker.postMessage({
+        this.refreshWorker.send({
             action: "start",
             kuzzle: {
                 config: global.kuzzle.config,
@@ -138,7 +140,7 @@ class ClusterIdCardHandler {
      * Helper method to mock worker instantiation in unit tests
      */
     constructWorker(path) {
-        return new worker_threads_1.Worker(path);
+        return (0, child_process_1.fork)(path);
     }
     /**
      * Start refreshing the ID Card before the worker starts to ensure the ID Card
@@ -163,9 +165,20 @@ class ClusterIdCardHandler {
         });
     }
     async dispose() {
+        if (this.disposed) {
+            return;
+        }
         this.disposed = true;
-        if (this.refreshWorker) {
-            this.refreshWorker.postMessage({ action: "dispose" });
+        if (this.refreshWorker &&
+            this.refreshWorker.connected &&
+            !this.refreshWorker.killed &&
+            this.refreshWorker.channel) {
+            try {
+                this.refreshWorker.send({ action: "dispose" });
+            }
+            catch (e) {
+                // It could happens that the worker has been killed before the dispose causing send to fail
+            }
         }
     }
     /**

package/lib/cluster/node.js

@@ -249,6 +249,15 @@ class ClusterNode {
     this.command.dispose();
   }
 
+  /**
+   * Notify other nodes to not evict this node
+   *
+   * @param {bool} evictionPrevented
+   */
+  preventEviction(evictionPrevented) {
+    this.publisher.sendNodePreventEviction(evictionPrevented);
+  }
+
   /**
    * Adds a new remote node, and subscribes to it.
    * @param {string} id            - remote node ID
@@ -678,6 +687,10 @@ class ClusterNode {
    * Registers ask events
    */
   registerAskEvents() {
+    global.kuzzle.onAsk("cluster:node:preventEviction", (state) => {
+      this.preventEviction(state);
+    });
+
     /**
      * Removes a room from the full state, and only for this node.
      * Removes the room from Koncorde if, and only if, no other node uses it.
@@ -816,7 +829,11 @@ class ClusterNode {
       this.onAuthStrategyRemoved(name, pluginName)
     );
 
-    global.kuzzle.on("admin:afterDump", (suffix) => this.onDumpRequest(suffix));
+    global.kuzzle.on("admin:afterDump", (request) => {
+      const suffix = request.getString("suffix", "manual-api-action");
+
+      return this.onDumpRequest(suffix);
+    });
 
     global.kuzzle.on("admin:afterResetSecurity", () => this.onSecurityReset());
 

package/lib/cluster/protobuf/sync.proto

@@ -21,6 +21,11 @@ message NodeShutdown {
   string nodeId = 2;
 }
 
+message NodePreventEviction {
+  uint64 messageId = 1;
+  bool evictionPrevented = 2;
+}
+
 message NewRealtimeRoom {
   uint64 messageId = 1;
   string index = 2;

package/lib/cluster/publisher.js

@@ -270,6 +270,16 @@ class ClusterPublisher {
     return this.send("NodeShutdown", { nodeId });
   }
 
+  /**
+   * Publishes an event about the node being in debug mode
+   * @param {bool} evictionPrevented
+   *
+   * @returns {Long} ID of the message sent
+   */
+  sendNodePreventEviction(evictionPrevented) {
+    return this.send("NodePreventEviction", { evictionPrevented });
+  }
+
   /**
    * Publishes an event about a node being evicted
    *

package/lib/cluster/subscriber.js

@@ -55,6 +55,8 @@ class ClusterSubscriber {
     this.remoteNodeIP = remoteNodeIP;
     this.remoteNodeAddress = `tcp://${remoteNodeIP}:${this.localNode.config.ports.sync}`;
     this.remoteNodeId = remoteNodeId;
+    // Used in debug mode when the node might be slower
+    this.remoteNodeEvictionPrevented = false;
     this.socket = null;
     this.protoroot = null;
 
@@ -87,6 +89,7 @@ class ClusterSubscriber {
       NewAuthStrategy: this.handleNewAuthStrategy,
       NewRealtimeRoom: this.handleNewRealtimeRoom,
       NodeEvicted: this.handleNodeEviction,
+      NodePreventEviction: this.handleNodePreventEviction,
       NodeShutdown: this.handleNodeShutdown,
       RefreshIndexCache: this.handleRefreshIndexCache,
       RefreshValidators: this.handleRefreshValidators,
@@ -229,6 +232,10 @@ class ClusterSubscriber {
     }
   }
 
+  async handleNodePreventEviction(message) {
+    this.remoteNodeEvictionPrevented = message.evictionPrevented;
+  }
+
   /**
    * Handles a heartbeat from the remote node
    *
@@ -673,7 +680,7 @@ class ClusterSubscriber {
    * to recover, otherwise we evict it from the cluster.
    */
   async checkHeartbeat() {
-    if (this.state === stateEnum.EVICTED) {
+    if (this.state === stateEnum.EVICTED || this.remoteNodeEvictionPrevented) {
       return;
     }