kuzzle 2.20.3 → 2.21.1

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

@@ -48,10 +48,8 @@ var __importDefault = (this && this.__importDefault) || function (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 +63,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,168 +74,58 @@ 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);
-                });
-            }
+        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
+            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
         }
+        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();
+        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
+            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
         }
-        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);
+        const method = request.getBodyString("method");
+        const params = request.getBodyObject("params", {});
+        return global.kuzzle.ask("core:debugger:post", method, params);
     }
     /**
      * Make the websocket connection listen and receive events from Chrome Debug Protocol
      * See events from: https://chromedevtools.github.io/devtools-protocol/v8/
      */
     async addListener(request) {
+        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
+            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
+        }
         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
      */
     async removeListener(request) {
+        if (!(0, get_1.default)(global.kuzzle.config, "security.debug.native_debug_protocol")) {
+            throw kerror.get("core", "debugger", "native_debug_protocol_usage_denied");
+        }
         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/funnel.js

@@ -51,6 +51,7 @@ const debug = require("../util/debug")("kuzzle:funnel");
 const processError = kerror.wrap("api", "process");
 const { has } = require("../util/safeObject");
 const { HttpStream } = require("../types");
+const get = require("lodash/get");
 
 // Actions of the auth controller that does not necessite to verify the token
 // when cookie auth is active
@@ -179,6 +180,12 @@ class Funnel {
       throw processError.get("not_enough_nodes");
     }
 
+    const isRequestFromDebugSession = get(
+      request,
+      "context.connection.misc.internal.debugSession",
+      false
+    );
+
     if (this.overloaded) {
       const now = Date.now();
 
@@ -226,7 +233,8 @@ class Funnel {
      */
     if (
       this.pendingRequestsQueue.length >=
-      global.kuzzle.config.limits.requestsBufferSize
+        global.kuzzle.config.limits.requestsBufferSize &&
+      !isRequestFromDebugSession
     ) {
       const error = processError.get("overloaded");
       global.kuzzle.emit("log:error", error);
@@ -239,7 +247,13 @@ class Funnel {
         request.internalId,
         new PendingRequest(request, fn, context)
       );
-      this.pendingRequestsQueue.push(request.internalId);
+
+      if (isRequestFromDebugSession) {
+        // Push at the front to prioritize debug requests
+        this.pendingRequestsQueue.unshift(request.internalId);
+      } else {
+        this.pendingRequestsQueue.push(request.internalId);
+      }
 
       if (!this.overloaded) {
         this.overloaded = true;

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,24 @@ class ClusterNode {
     this.command.dispose();
   }
 
+  /**
+   * Notify other nodes to not evict this node
+   *
+   * @param {bool} evictionPrevented
+   */
+  preventEviction(evictionPrevented) {
+    this.publisher.sendNodePreventEviction(evictionPrevented);
+    // This node is subscribed to the other node and might not receive their heartbeat while debugging
+    // so this node should not have the responsability of evicting others when his own eviction is prevented
+    // when debugging.
+    // Otherwise when recovering from a debug session, all the other nodes will be evicted.
+    for (const subscriber of this.remoteNodes.values()) {
+      subscriber.handleNodePreventEviction({
+        evictionPrevented,
+      });
+    }
+  }
+
   /**
    * Adds a new remote node, and subscribes to it.
    * @param {string} id            - remote node ID
@@ -678,6 +696,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 +838,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;