kuzzle 2.14.16 → 2.16.0

package/lib/cluster/workers/IDCardRenewer.js

@@ -15,14 +15,15 @@ class IDCardRenewer {
   }
 
   async init (config) {
-    if (!this.disposed) {
-      return; // Already intialized
+    if (! this.disposed) {
+      return; // Already initialized
     }
 
     this.disposed = false;
     this.nodeIdKey = config.nodeIdKey;
     this.refreshDelay = config.refreshDelay || 2000;
-    
+    this.refreshMultiplier = config.refreshMultiplier;
+
     /**
     * Since we do not have access to the Kuzzle Context we can't use kuzzle.ask('core:cache:internal:*',...),
     * so we need to have an instance of Redis similar to the one used in the Cache Engine
@@ -48,6 +49,9 @@ class IDCardRenewer {
         this.renewIDCard.bind(this),
         this.refreshDelay);
     }
+
+    // Notify that the worker is running and updating the ID Card
+    this.parentPort.postMessage({ initialized: true });
   }
 
   async initRedis (config, name) {
@@ -63,7 +67,7 @@ class IDCardRenewer {
     try {
       const refreshed = await this.redis.commands.pexpire(
         this.nodeIdKey,
-        this.refreshDelay * 3);
+        this.refreshDelay * this.refreshMultiplier);
       // Unable to refresh the key in time before it expires
       // => this node is too slow, we need to remove it from the cluster
       if (refreshed === 0) {
@@ -99,7 +103,8 @@ class IDCardRenewer {
 
 if (!isMainThread) {
   const idCardRenewer = new IDCardRenewer();
-  parentPort.on('message', async (message) => {
+
+  parentPort.on('message', async message => {
     if (message.action === 'start') {
       // Simulate basic global Kuzzle Context
       global.kuzzle = { ...message.kuzzle };
@@ -111,11 +116,12 @@ if (!isMainThread) {
       };
       // Should never throw
       await idCardRenewer.init(message);
-    } else if (message.action === 'dispose') {
+    }
+    else if (message.action === 'dispose') {
       // Should never throw
       await idCardRenewer.dispose();
     }
-  });  
+  });
 }
 
 module.exports = { IDCardRenewer };

package/lib/config/default.config.js

@@ -46,7 +46,7 @@ module.exports = {
        (see https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS)
    */
   http: {
-    routes: require('./httpRoutes'),
+    routes: require('./../api/httpRoutes'),
     accessControlAllowOrigin: '*',
     accessControlAllowOriginUseRegExp: false,
     accessControlAllowMethods: 'GET,POST,PUT,PATCH,DELETE,OPTIONS,HEAD',

package/lib/core/network/router.js

@@ -138,6 +138,39 @@ class Router {
         this._executeFromHttp(route.verb, request, cb);
       });
     }
+
+    /**
+     * Returns inner metrics from the router
+     * @returns {Object}
+     */
+    global.kuzzle.onAsk(
+      'core:network:router:metrics',
+      () => this.metrics());
+  }
+
+  /**
+   * Returns the metrics of the router
+   * @returns {Object}
+   */
+  metrics () {
+    const connectionsByProtocol = {};
+
+    for (const connection of this.connections.values()) {
+      const protocol = connection.connection.protocol.toLowerCase();
+      if (protocol === 'internal') {
+        continue;
+      }
+
+      if (connectionsByProtocol[protocol] === undefined) {
+        connectionsByProtocol[protocol] = 0;
+      }
+
+      connectionsByProtocol[protocol]++;
+    }
+
+    return {
+      connections: connectionsByProtocol,
+    };
   }
 
   /**

package/lib/core/plugin/pluginsManager.js

@@ -265,7 +265,9 @@ class PluginsManager {
 
           debug('[%s] plugin started', plugin.name);
 
-          this.loadedPlugins.push(plugin.name);
+          if (! plugin.application) {
+            this.loadedPlugins.push(plugin.name);
+          }
 
           return null;
         });

package/lib/core/realtime/hotelClerk.d.ts

@@ -118,6 +118,13 @@ export declare class HotelClerk {
      *
      */
     unsubscribe(connectionId: string, roomId: string, notify?: boolean): Promise<void>;
+    /**
+     * Returns inner metrics from the HotelClerk
+     */
+    metrics(): {
+        rooms: number;
+        subscriptions: number;
+    };
     /**
      * Deletes a room if no user has subscribed to it, and removes it also from the
      * real-time engine

package/lib/core/realtime/hotelClerk.js

@@ -136,6 +136,11 @@ class HotelClerk {
         global.kuzzle.onAsk('core:realtime:unsubscribe', (connectionId, roomId, notify) => {
             return this.unsubscribe(connectionId, roomId, notify);
         });
+        /**
+         * Returns inner metrics from the HotelClerk
+         * @return {{rooms: number, subscriptions: number}}
+         */
+        global.kuzzle.onAsk('core:realtime:hotelClerk:metrics', () => this.metrics());
         /**
          * Clear the hotel clerk and properly disconnect connections.
          */
@@ -410,6 +415,15 @@ class HotelClerk {
             subscription,
         });
     }
+    /**
+     * Returns inner metrics from the HotelClerk
+     */
+    metrics() {
+        return {
+            rooms: this.roomsCount,
+            subscriptions: this.subscriptions.size,
+        };
+    }
     /**
      * Deletes a room if no user has subscribed to it, and removes it also from the
      * real-time engine

package/lib/core/realtime/notifier.js

@@ -249,9 +249,7 @@ class NotifierController {
     if (cache !== null) {
       const stopListening = difference(JSON.parse(cache), rooms);
 
-      await this.notifyDocument(stopListening, request, 'out', 'replace', {
-        _id: document._id,
-      });
+      await this.notifyDocument(stopListening, request, 'out', 'replace', document);
     }
 
     return rooms;
@@ -281,25 +279,29 @@ class NotifierController {
       : [];
 
     const result = await Bluebird.map(documents, (doc, index) => {
-      switch(action) {
+      switch (action) {
         case actionEnum.CREATE:
           return this.notifyDocumentCreate(request, doc);
+
         case actionEnum.DELETE:
           return this.notifyDocumentDelete(request, doc);
+
         case actionEnum.REPLACE:
           return this.notifyDocumentReplace(request, doc, cache[index]);
+
         case actionEnum.UPDATE:
           return this.notifyDocumentUpdate(request, doc, cache[index]);
+
         case actionEnum.UPSERT:
-          if (doc.created) {
-            return this.notifyDocumentCreate(request, doc);
-          }
-          return this.notifyDocumentUpdate(request, doc, cache[index]);
+          return doc.created
+            ? this.notifyDocumentCreate(request, doc)
+            : this.notifyDocumentUpdate(request, doc, cache[index]);
+
         case actionEnum.WRITE:
-          if (doc.created) {
-            return this.notifyDocumentCreate(request, doc);
-          }
-          return this.notifyDocumentReplace(request, doc, cache[index]);
+          return doc.created
+            ? this.notifyDocumentCreate(request, doc)
+            : this.notifyDocumentReplace(request, doc, cache[index]);
+
         default:
           throw kerror.get('core', 'fatal', 'assertion_failed', `unknown notify action "${doc.action}"`);
       }
@@ -342,9 +344,7 @@ class NotifierController {
     if (cache !== null) {
       const stopListening = difference(JSON.parse(cache), rooms);
 
-      await this.notifyDocument(stopListening, request, 'out', 'update', {
-        _id: document._id,
-      });
+      await this.notifyDocument(stopListening, request, 'out', 'update', document);
     }
 
     return rooms;
@@ -361,9 +361,7 @@ class NotifierController {
     const rooms = this._test(request, document._source, document._id);
 
     if (rooms.length > 0) {
-      await this.notifyDocument(rooms, request, 'out', 'delete', {
-        _id: document._id,
-      });
+      await this.notifyDocument(rooms, request, 'out', 'delete', document);
     }
 
     return [];

package/lib/core/storage/clientAdapter.js

@@ -22,7 +22,7 @@
 'use strict';
 
 const Elasticsearch = require('../../service/storage/elasticsearch');
-const IndexCache = require('./indexCache');
+const { IndexCache } = require('./indexCache');
 const { isPlainObject } = require('../../util/safeObject');
 const kerror = require('../../kerror');
 const { Mutex } = require('../../util/mutex');
@@ -42,7 +42,7 @@ class ClientAdapter {
       global.kuzzle.config.services.storageEngine,
       scope);
     this.scope = scope;
-    this.cache = new IndexCache(scope);
+    this.cache = new IndexCache();
   }
 
   async init () {
@@ -57,6 +57,13 @@ class ClientAdapter {
 
     // Global store events registration
 
+    /**
+     * Manually refresh the index cache (e.g. after alias creation)
+     */
+    global.kuzzle.onAsk(
+      `core:storage:${this.scope}:cache:refresh`,
+      () => this.populateCache());
+
     /**
      * Return information about the instantiated ES service
      * @returns {Promise.<Object>}
@@ -77,7 +84,6 @@ class ClientAdapter {
   }
 
   async createIndex (index, { indexCacheOnly=false, propagate=true } = {}) {
-
     if (this.cache.hasIndex(index)) {
       throw servicesError.get('index_already_exists', this.scope, index);
     }
@@ -264,7 +270,7 @@ class ClientAdapter {
       `core:storage:${this.scope}:collection:update`,
       (index, collection, changes) => {
         this.cache.assertCollectionExists(index, collection);
-        this.client.updateCollection(index, collection, changes);
+        return this.client.updateCollection(index, collection, changes);
       });
   }
 
@@ -856,7 +862,7 @@ class ClientAdapter {
    * @returns {Promise}
    */
   async loadMappings (
-    fixtures = {}, 
+    fixtures = {},
     options = {
       indexCacheOnly: false,
       propagate: true,

package/lib/core/storage/indexCache.d.ts

@@ -0,0 +1,55 @@
+export declare class IndexCache {
+    /**
+     * Index map: each entry holds a set of collection names
+     *
+     * Map<index, Set<collection>>
+     */
+    private indexes;
+    constructor();
+    /**
+     * Cache a new index
+     *
+     * @return true if an index was added, false if there is no modification
+     */
+    addIndex(index: string): boolean;
+    /**
+     * Cache a new collection
+     */
+    addCollection(index: string, collection: string): void;
+    /**
+     * Check an index existence
+     */
+    hasIndex(index: string): boolean;
+    /**
+     * Check a collection existence
+     */
+    hasCollection(index: string, collection: string): boolean;
+    /**
+     * Return the list of cached indexes
+     */
+    listIndexes(): string[];
+    /**
+     * Return the list of an index collections
+     *
+     * @throws If the provided index does not exist
+     */
+    listCollections(index: string): string[];
+    /**
+     * Remove an index from the cache
+     */
+    removeIndex(index: string): void;
+    /**
+     * Remove a collection from the cache
+     */
+    removeCollection(index: string, collection: string): void;
+    /**
+     * Assert that the provided index exists
+     *
+     * @throws If the index does not exist
+     */
+    assertIndexExists(index: string): void;
+    /**
+     * Assert that the provided index and collection exist
+     */
+    assertCollectionExists(index: string, collection: string): void;
+}

package/lib/core/storage/indexCache.js

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,142 +19,108 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-'use strict';
-
-const kerror = require('../../kerror').wrap('services', 'storage');
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexCache = void 0;
+const kerror_1 = __importDefault(require("../../kerror"));
+const storageError = kerror_1.default.wrap('services', 'storage');
 class IndexCache {
-  /**
-   * @param  {storeScopeEnum} scope
-   */
-  constructor (scope) {
-    this.scope = scope;
-
+    constructor() {
+        /**
+         * Index map: each entry holds a set of collection names
+         *
+         * Map<index, Set<collection>>
+         */
+        this.indexes = new Map();
+        this.indexes = new Map();
+    }
+    /**
+     * Cache a new index
+     *
+     * @return true if an index was added, false if there is no modification
+     */
+    addIndex(index) {
+        if (this.indexes.has(index)) {
+            return false;
+        }
+        this.indexes.set(index, new Set());
+        return true;
+    }
+    /**
+     * Cache a new collection
+     */
+    addCollection(index, collection) {
+        this.addIndex(index);
+        const collections = this.indexes.get(index);
+        collections.add(collection);
+    }
+    /**
+     * Check an index existence
+     */
+    hasIndex(index) {
+        return this.indexes.has(index);
+    }
+    /**
+     * Check a collection existence
+     */
+    hasCollection(index, collection) {
+        const collections = this.indexes.get(index);
+        if (!collections) {
+            return false;
+        }
+        return collections.has(collection);
+    }
+    /**
+     * Return the list of cached indexes
+     */
+    listIndexes() {
+        return Array.from(this.indexes.keys());
+    }
     /**
-     * Index map: each entry holds a set of collection names
-     * @type {Map.<String, Set>}
+     * Return the list of an index collections
+     *
+     * @throws If the provided index does not exist
      */
-    this.indexes = new Map();
-  }
-
-  /**
-   * Cache a new index
-   * @param {string} index
-   * @return {boolean} true if an index was added, false if there is no
-   *                   modification
-   */
-  addIndex (index) {
-    if (this.indexes.has(index)) {
-      return false;
+    listCollections(index) {
+        this.assertIndexExists(index);
+        return Array.from(this.indexes.get(index));
     }
-
-    this.indexes.set(index, new Set());
-
-    return true;
-  }
-
-  /**
-   * Cache a new collection
-   * @param {string} index
-   * @param {string} collection
-   */
-  addCollection (index, collection) {
-    this.addIndex(index);
-    const collections = this.indexes.get(index);
-
-    collections.add(collection);
-  }
-
-  /**
-   * Check an index existence
-   * @param {string} index
-   * @returns {boolean}
-   */
-  hasIndex (index) {
-    return this.indexes.has(index);
-  }
-
-  /**
-   * Check a collection existence
-   * @param {string} index
-   * @param {string} collection
-   * @returns {boolean}
-   */
-  hasCollection (index, collection) {
-    const collections = this.indexes.get(index);
-
-    if (!collections) {
-      return false;
+    /**
+     * Remove an index from the cache
+     */
+    removeIndex(index) {
+        this.indexes.delete(index);
     }
-
-    return collections.has(collection);
-  }
-
-  /**
-   * Return the list of cached indexes
-   * @returns {string[]}
-   */
-  listIndexes () {
-    return Array.from(this.indexes.keys());
-  }
-
-  /**
-   * Return the list of an index' collections
-   * @param {string} index
-   * @returns {string[]}
-   * @throws If the provided index does not exist
-   */
-  listCollections (index) {
-    this.assertIndexExists(index);
-
-    return Array.from(this.indexes.get(index));
-  }
-
-  /**
-   * Remove an index from the cache
-   * @param  {string} index
-   */
-  removeIndex (index) {
-    this.indexes.delete(index);
-  }
-
-  /**
-   * Remove a collection from the cache
-   * @param {string} index
-   * @param {string} collection
-   */
-  removeCollection (index, collection) {
-    const collections = this.indexes.get(index);
-
-    if (collections) {
-      collections.delete(collection);
+    /**
+     * Remove a collection from the cache
+     */
+    removeCollection(index, collection) {
+        const collections = this.indexes.get(index);
+        if (collections) {
+            collections.delete(collection);
+        }
     }
-  }
-
-  /**
-   * Assert that the provided index exists
-   * @param  {string} index
-   * @throws If the index does not exist
-   */
-  assertIndexExists (index) {
-    if (!this.indexes.has(index)) {
-      throw kerror.get('unknown_index', index);
+    /**
+     * Assert that the provided index exists
+     *
+     * @throws If the index does not exist
+     */
+    assertIndexExists(index) {
+        if (!this.indexes.has(index)) {
+            throw storageError.get('unknown_index', index);
+        }
     }
-  }
-
-  /**
-   * Assert that the provided index and collection exist
-   * @param {string} index
-   * @param {string} collection
-   */
-  assertCollectionExists (index, collection) {
-    this.assertIndexExists(index);
-
-    if (!this.indexes.get(index).has(collection)) {
-      throw kerror.get('unknown_collection', index, collection);
+    /**
+     * Assert that the provided index and collection exist
+     */
+    assertCollectionExists(index, collection) {
+        this.assertIndexExists(index);
+        if (!this.indexes.get(index).has(collection)) {
+            throw storageError.get('unknown_collection', index, collection);
+        }
     }
-  }
 }
-
-module.exports = IndexCache;
+exports.IndexCache = IndexCache;
+//# sourceMappingURL=indexCache.js.map

package/lib/kuzzle/kuzzle.js

@@ -28,7 +28,7 @@ const murmurhash_native_1 = require("murmurhash-native");
 const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
 const koncorde_1 = require("koncorde");
 const bluebird_1 = __importDefault(require("bluebird"));
-const segfault_handler_1 = __importDefault(require("segfault-handler"));
+const node_segfault_handler_1 = __importDefault(require("node-segfault-handler"));
 const lodash_1 = __importDefault(require("lodash"));
 const kuzzleStateEnum_1 = __importDefault(require("./kuzzleStateEnum"));
 const kuzzleEventEmitter_1 = __importDefault(require("./event/kuzzleEventEmitter"));
@@ -54,21 +54,25 @@ const realtime_1 = __importDefault(require("../core/realtime"));
 const cluster_1 = __importDefault(require("../cluster"));
 const package_json_1 = require("../../package.json");
 const BACKEND_IMPORT_KEY = 'backend:init:import';
-let _kuzzle = null;
+Reflect.defineProperty(global, '_kuzzle', {
+    value: null,
+    writable: true,
+});
+/* eslint-disable dot-notation */
 Reflect.defineProperty(global, 'kuzzle', {
     configurable: true,
     enumerable: false,
     get() {
-        if (_kuzzle === null) {
+        if (global['_kuzzle'] === null) {
             throw new Error('Kuzzle instance not found. Did you try to use a live-only feature before starting your application?');
         }
-        return _kuzzle;
+        return global['_kuzzle'];
     },
     set(value) {
-        if (_kuzzle !== null) {
+        if (global['_kuzzle'] !== null) {
             throw new Error('Cannot build a Kuzzle instance: another one already exists');
         }
-        _kuzzle = value;
+        global['_kuzzle'] = value;
     },
 });
 class Kuzzle extends kuzzleEventEmitter_1.default {
@@ -444,7 +448,7 @@ class Kuzzle extends kuzzleEventEmitter_1.default {
                 this.shutdown();
             });
         }
-        segfault_handler_1.default.registerHandler();
+        node_segfault_handler_1.default.registerHandler();
     }
     async dumpAndExit(suffix) {
         if (this.config.dump.enabled) {

package/lib/service/storage/elasticsearch.js

@@ -128,12 +128,11 @@ class ElasticSearch extends Service {
       '_source_includes'
     ];
 
-    // Forbidden keys in a query
-    this.scriptKeys = [
-      'script',
-      '_script'
-    ];
-
+    /**
+     * Only allow stored-scripts in queries
+     */
+    this.scriptKeys = ['script', '_script'];
+    this.scriptAllowedArgs = ['id', 'params'];
 
     this.maxScrollDuration = this._loadMsConfig('maxScrollDuration');
 
@@ -2979,14 +2978,20 @@ class ElasticSearch extends Service {
   }
 
   /**
-   * Throw if any script keyword is contained in the object
+   * Throw if a script is used in the query.
+   *
+   * Only Stored Scripts are accepted
    *
    * @param {Object} object
    */
-  _scriptCheck(object) {
+  _scriptCheck (object) {
     for (const [key, value] of Object.entries(object)) {
       if (this.scriptKeys.includes(key)) {
-        throw kerror.get('invalid_query_keyword', key);
+        for (const scriptArg of Object.keys(value)) {
+          if (! this.scriptAllowedArgs.includes(scriptArg)) {
+            throw kerror.get('invalid_query_keyword', `${key}.${scriptArg}`);
+          }
+        }
       }
       // Every object must be checked here, even the ones nested into an array
       else if (typeof value === 'object' && value !== null) {