kuzzle 2.14.14 → 2.15.2

package/lib/cluster/subscriber.js

@@ -88,6 +88,7 @@ class ClusterSubscriber {
       NewRealtimeRoom: this.handleNewRealtimeRoom,
       NodeEvicted: this.handleNodeEviction,
       NodeShutdown: this.handleNodeShutdown,
+      RefreshIndexCache: this.handleRefreshIndexCache,
       RefreshValidators: this.handleRefreshValidators,
       RemoveAuthStrategy: this.handleAuthStrategyRemoval,
       RemoveCollection: this.handleCollectionRemoval,
@@ -210,7 +211,7 @@ class ClusterSubscriber {
 
     const message = decoder.toObject(decoder.decode(data));
 
-    if (!await this.validateMessage(message)) {
+    if (! await this.validateMessage(message)) {
       return;
     }
 
@@ -497,6 +498,14 @@ class ClusterSubscriber {
     await global.kuzzle.validation.curateSpecification();
   }
 
+  /**
+   * Handles manual refresh of the index cache
+   */
+  async handleRefreshIndexCache () {
+    debug('Index cache manually refresh received from node %s', this.remoteNodeId);
+    await global.kuzzle.ask('core:storage:public:cache:refresh', { from: 'cluster' });
+  }
+
   /**
    * Invalidates a profile to force reloading it from the storage space
    *

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/httpRoutes.js

@@ -46,6 +46,7 @@ const routes = [
   { verb: 'get', path: '/validations/_scroll/:scrollId', controller: 'collection', action: 'scrollSpecifications' },
   { verb: 'get', path: '/:index/_list', controller: 'collection', action: 'list' },
 
+  { verb: 'post', path: '/admin/_refreshIndexCache', controller: 'admin', action: 'refreshIndexCache' },
   { verb: 'post', path: '/admin/_resetCache', controller: 'admin', action: 'resetCache' },
   { verb: 'post', path: '/admin/_resetSecurity', controller: 'admin', action: 'resetSecurity' },
   { verb: 'post', path: '/admin/_resetDatabase', controller: 'admin', action: 'resetDatabase' },

package/lib/core/cache/cacheEngine.js

@@ -180,6 +180,15 @@ class CacheEngine {
     global.kuzzle.onAsk(
       'core:cache:internal:store',
       (key, value, opts) => this.internal.store(key, value, opts));
+
+    /**
+     * Executes an arbitrary NATIVE cache command directly
+     * @param {string} command
+     * @param {Array} args -- command arguments
+     */
+    global.kuzzle.onAsk(
+      'core:cache:internal:execute',
+      (command, ...args) => this.internal.exec(command, ...args));
   }
 
   registerPublicEvents () {

package/lib/core/realtime/hotelClerk.js

@@ -381,7 +381,7 @@ class HotelClerk {
         }, requestContext);
         await this.module.notifier.notifyUser(roomId, request, 'out', { count: room.size });
         // Do not send an unsubscription notification if the room has been destroyed
-        // @aschen Why ?
+        // because the other nodes already had destroyed it in the full state
         if (notify
             && this.rooms.has(roomId)
             && room.channels.size > 0) {
@@ -417,6 +417,11 @@ class HotelClerk {
     async removeRoom(roomId) {
         this.roomsCount--;
         this.rooms.delete(roomId);
+        // We have to ask the cluster to dispatch the room removal event.
+        // The cluster will also remove the room from Koncorde if no other node
+        // uses it.
+        // (this node may have no subscribers on it, but other nodes might)
+        await global.kuzzle.ask('cluster:realtime:room:remove', roomId);
         // @deprecated -- to be removed in the next major version
         try {
             await global.kuzzle.pipe('room:remove', roomId);
@@ -424,11 +429,6 @@ class HotelClerk {
         catch (e) {
             return;
         }
-        // We have to ask the cluster to dispatch the room removal event.
-        // The cluster will also remove the room from Koncorde if no other node
-        // uses it.
-        // (this node may have no subscribers on it, but other nodes might)
-        await global.kuzzle.ask('cluster:realtime:room:remove', roomId);
     }
     /**
      * Subscribes a connection to an existing room.

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"));
@@ -444,7 +444,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) {