fixed index cache feature

bin/kuzzle-start.js

@@ -35,18 +35,45 @@ module.exports = function () {
       );
 
       console.log(`
-████████████████████████████████████
-██     KUZZLE ` + (kuzzle.isServer ? 'SERVER' : 'WORKER') + ` STARTED      ██
-████████████████████████████████████`);
+ ████████████████████████████████████
+ ██     KUZZLE ` + (kuzzle.isServer ? 'SERVER' : 'WORKER') + ` STARTED      ██`);
+
+      if (kuzzle.isServer) {
+        console.log(`
+ ██   ...WAITING FOR WORKERS...    ██
+ ████████████████████████████████████`);
+      } else {
+        console.log(' ████████████████████████████████████');
+      }
     })
     .then(() => {
       /*
        Waits for at least one write worker to be connected to the server before trying to use them
        */
       return kuzzle.services.list.broker.waitForListeners(kuzzle.config.queues.workerWriteTaskQueue);
     })
-    .then(() => { return kuzzle.cleanDb(); })
-    .then(() => { return kuzzle.prepareDb(); })
+    .then(() => {
+      if (kuzzle.isServer) {
+        console.log(`
+ ████████████████████████████████████
+ ██        WORKER CONNECTED        ██
+ ██    ...PREPARING DATABASE...    ██
+ ████████████████████████████████████`);
+      }
+
+      return kuzzle.cleanDb(kuzzle);
+    })
+    .then(() => {
+      return kuzzle.prepareDb(kuzzle);
+    })
+    .then(() => {
+      if (kuzzle.isServer) {
+        console.log(`
+ ████████████████████████████████████
+ ██          KUZZLE READY          ██
+ ████████████████████████████████████`);
+      }
+    })
     .catch(error => {
       console.error(error);
       process.exit(1);

lib/api/Kuzzle.js

@@ -26,8 +26,6 @@ function Kuzzle () {
   this.workers = new Workers(this);
   this.services = new Services(this);
 
-  this.indexes = {};
-
   // Add methods
   this.cleanDb = require('./cleanDb');
   this.prepareDb = require('./prepareDb');

lib/api/cleanDb.js

@@ -2,28 +2,29 @@ var
   RequestObject = require('./core/models/requestObject'),
   q = require('q');
 
-module.exports = function () {
+module.exports = function (kuzzle) {
   var
     deferred = q.defer(),
     requestObject = new RequestObject({controller: 'admin', action: 'deleteIndexes'});
 
   // is a reset has been asked and we are launching a server ?
-  if (process.env.LIKE_A_VIRGIN !== '1' || !this.isServer) {
+  if (process.env.LIKE_A_VIRGIN !== '1' || !kuzzle.isServer) {
     deferred.resolve();
     return deferred.promise;
   }
 
   // @todo : manage internal index properly
-  this.pluginsManager.trigger('data:deleteIndexes', requestObject);
+  kuzzle.pluginsManager.trigger('data:deleteIndexes', requestObject);
 
-  this.workerListener.add(requestObject)
+  kuzzle.workerListener.add(requestObject)
     .then(() => {
-      this.pluginsManager.trigger('cleanDb:done', 'Reset done: Kuzzle is now like a virgin, touched for the very first time !');
+      kuzzle.indexCache.reset();
+      kuzzle.pluginsManager.trigger('cleanDb:done', 'Reset done: Kuzzle is now like a virgin, touched for the very first time !');
 
       deferred.resolve();
     })
     .catch(err => {
-      this.pluginsManager.trigger('cleanDb:error', err);
+      kuzzle.pluginsManager.trigger('cleanDb:error', err);
 
       // We resolve the promise, because we don't want stop the start process just because reset didn't work.
       // (can fail if the database is pristine)

lib/api/controllers/adminController.js

@@ -6,7 +6,11 @@ module.exports = function AdminController (kuzzle) {
    */
   this.deleteCollection = function (requestObject) {
     kuzzle.pluginsManager.trigger('data:deleteCollection', requestObject);
-    return kuzzle.workerListener.add(requestObject);
+    return kuzzle.workerListener.add(requestObject)
+      .then(response => {
+        kuzzle.indexCache.remove(requestObject.index, requestObject.collection);
+        return response;
+      });
   };
 
   /**
@@ -16,7 +20,11 @@ module.exports = function AdminController (kuzzle) {
    */
   this.updateMapping = function (requestObject) {
     kuzzle.pluginsManager.trigger('data:updateMapping', requestObject);
-    return kuzzle.workerListener.add(requestObject);
+    return kuzzle.workerListener.add(requestObject)
+      .then(response => {
+        kuzzle.indexCache.add(requestObject.index, requestObject.collection);
+        return response;
+      });
   };
 
   /**
@@ -81,7 +89,11 @@ module.exports = function AdminController (kuzzle) {
    */
   this.deleteIndexes = function (requestObject) {
     kuzzle.pluginsManager.trigger('data:deleteIndexes', requestObject);
-    return kuzzle.workerListener.add(requestObject);
+    return kuzzle.workerListener.add(requestObject)
+      .then(response => {
+        kuzzle.indexCache.reset();
+        return response;
+      });
   };
 
   /**
@@ -91,7 +103,11 @@ module.exports = function AdminController (kuzzle) {
    */
   this.createIndex = function (requestObject) {
     kuzzle.pluginsManager.trigger('data:createIndex', requestObject);
-    return kuzzle.workerListener.add(requestObject);
+    return kuzzle.workerListener.add(requestObject)
+      .then(response => {
+        kuzzle.indexCache.add(requestObject.index);
+        return response;
+      });
   };
 
   /**
@@ -101,7 +117,11 @@ module.exports = function AdminController (kuzzle) {
    */
   this.deleteIndex = function (requestObject) {
     kuzzle.pluginsManager.trigger('data:deleteIndex', requestObject);
-    return kuzzle.workerListener.add(requestObject);
+    return kuzzle.workerListener.add(requestObject)
+      .then(response => {
+        kuzzle.indexCache.remove(requestObject.index);
+        return response;
+      });
   };
 
   /**

lib/api/controllers/funnelController.js

@@ -53,7 +53,7 @@ module.exports = function FunnelController (kuzzle) {
         }
 
         // check if the current user is allowed to process
-        if (context.token.user.profile.isActionAllowed(requestObject, context, kuzzle.indexes) === false) {
+        if (context.token.user.profile.isActionAllowed(requestObject, context, kuzzle.indexCache.indexes) === false) {
           return q.reject(new UnauthorizedError('Unauthorized action [' + requestObject.index + '/' + requestObject.collection + '/' + requestObject.controller + '/' + requestObject.action + '] for user ' + context.token.user._id, 401));
         }
 

lib/api/controllers/writeController.js

@@ -1,4 +1,4 @@
-module.exports = function WriteController(kuzzle) {
+module.exports = function WriteController (kuzzle) {
   /**
    * Create a new document
    *
@@ -34,9 +34,13 @@ module.exports = function WriteController(kuzzle) {
    */
   this.createOrReplace = function (requestObject) {
     return requestObject.isValid()
-      .then(function () {
+      .then(() => {
         kuzzle.pluginsManager.trigger('data:createOrReplace', requestObject);
         return kuzzle.workerListener.add(requestObject);
+      })
+      .then(response => {
+        kuzzle.indexCache.add(requestObject.index, requestObject.collection);
+        return response;
       });
   };
 
@@ -95,6 +99,10 @@ module.exports = function WriteController(kuzzle) {
    */
   this.createCollection = function (requestObject) {
     kuzzle.pluginsManager.trigger('data:createCollection', requestObject);
-    return kuzzle.workerListener.add(requestObject);
+    return kuzzle.workerListener.add(requestObject)
+      .then(response => {
+        kuzzle.indexCache.add(requestObject.index, requestObject.collection);
+        return response;
+      });
   };
 };

lib/api/core/hotelClerk.js

@@ -231,7 +231,7 @@ module.exports = function HotelClerk (kuzzle) {
       requestObjectCollection.index = room.index;
       requestObjectCollection.collection = room.collection;
 
-      if (context.token.user.profile.isActionAllowed(requestObjectCollection, context, kuzzle.indexes) === false) {
+      if (context.token.user.profile.isActionAllowed(requestObjectCollection, context, kuzzle.indexCache.indexes) === false) {
         collectionNotAllowed.push(room.index + '.' + room.collection);
         return true;
       }

lib/api/core/indexCache.js

@@ -0,0 +1,63 @@
+var
+  RequestObject = require('./models/requestObject');
+
+/**
+ * Index/collection cache management
+ */
+module.exports = function indexCache (kuzzle) {
+  this.indexes = {};
+
+  this.init = function () {
+    kuzzle.services.list.readEngine.listIndexes(new RequestObject({}))
+      .then(result => {
+        result.data.body.indexes.forEach(index => {
+          this.indexes[index] = [];
+
+          kuzzle.services.list.readEngine.listCollections(new RequestObject({index: index}))
+            .then(resultCollections => {
+              this.indexes[index] = resultCollections.data.body.collections.stored;
+            });
+        });
+      });
+  };
+
+  this.add = function (index, collection) {
+    if (index !== undefined) {
+      if (!this.indexes[index]) {
+        this.indexes[index] = [];
+      }
+
+      if (collection) {
+        if (this.indexes[index].indexOf(collection) === -1) {
+          this.indexes[index].push(collection);
+        }
+      }
+    }
+  };
+
+  this.remove = function (index, collection) {
+    var position;
+
+    if (index && this.indexes[index]) {
+      if (collection) {
+        position = this.indexes[index].indexOf(collection);
+
+        if (position >= 0) {
+          this.indexes[index].splice(position, 1);
+        }
+      }
+      else {
+        delete this.indexes[index];
+      }
+    }
+  };
+
+  this.reset = function (index) {
+    if (index !== undefined) {
+      this.indexes[index] = [];
+    }
+    else {
+      this.indexes = {};
+    }
+  };
+};

lib/api/core/models/security/role.js

@@ -13,17 +13,17 @@ function Role () {
 }
 
 function doesIndexExist(requestObject, indexes) {
-  return indexes[requestObject.index] !== undefined;
+  return indexes && indexes[requestObject.index] !== undefined;
 }
 
 function doesCollectionExist(requestObject, indexes) {
-  return _.contains(indexes[requestObject.index], requestObject.collection);
+  return indexes && _.contains(indexes[requestObject.index], requestObject.collection);
 }
 
 /**
  * @param requestObject
- * @param context
- * @param indexes
+ * @param context - user's context
+ * @param indexes - list of existing indexes/collections
  * @returns {*}
  */
 Role.prototype.isActionAllowed = function (requestObject, context, indexes) {
@@ -62,10 +62,10 @@ Role.prototype.isActionAllowed = function (requestObject, context, indexes) {
     return false;
   }
 
-  if (this.indexes._canCreate !== undefined &&
+  if (!doesIndexExist(requestObject, indexes) &&
+    this.indexes._canCreate !== undefined &&
     !this.indexes._canCreate &&
-    _.contains(['import', 'create', 'createCollection', 'updateMapping', 'createOrReplace'], requestObject.action) &&
-    !doesIndexExist(requestObject, indexes)) {
+    _.contains(['import', 'create', 'createCollection', 'updateMapping', 'createOrReplace'], requestObject.action)) {
     return false;
   }
 
@@ -86,10 +86,10 @@ Role.prototype.isActionAllowed = function (requestObject, context, indexes) {
     return false;
   }
 
-  if (indexRights.collections._canCreate !== undefined &&
+  if (!doesCollectionExist(requestObject, indexes) &&
+    indexRights.collections._canCreate !== undefined &&
     !indexRights.collections._canCreate &&
-    _.contains(['import', 'create', 'createCollection', 'updateMapping', 'createOrReplace'], requestObject.action) &&
-    !doesCollectionExist(requestObject, indexes)) {
+    _.contains(['import', 'create', 'createCollection', 'updateMapping', 'createOrReplace'], requestObject.action)) {
     return false;
   }