kuzzle 2.19.2 → 2.19.3

package/lib/api/controllers/adminController.js

@@ -19,54 +19,52 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
+const Bluebird = require("bluebird");
 
-const kerror = require('../../kerror');
-const { NativeController } = require('./baseController');
-const { Mutex } = require('../../util/mutex');
-const { BACKEND_IMPORT_KEY } = require('../../kuzzle/kuzzle');
+const kerror = require("../../kerror");
+const { NativeController } = require("./baseController");
+const { Mutex } = require("../../util/mutex");
+const { BACKEND_IMPORT_KEY } = require("../../kuzzle/kuzzle");
 
 /**
  * @class AdminController
  */
 class AdminController extends NativeController {
-  constructor () {
+  constructor() {
     super([
-      'dump',
-      'loadFixtures',
-      'loadMappings',
-      'loadSecurities',
-      'refreshIndexCache',
-      'resetCache',
-      'resetDatabase',
-      'resetSecurity',
-      'shutdown'
+      "dump",
+      "loadFixtures",
+      "loadMappings",
+      "loadSecurities",
+      "refreshIndexCache",
+      "resetCache",
+      "resetDatabase",
+      "resetSecurity",
+      "shutdown",
     ]);
 
     this.shuttingDown = false;
   }
 
-  async refreshIndexCache () {
-    await global.kuzzle.ask('core:storage:public:cache:refresh');
+  async refreshIndexCache() {
+    await global.kuzzle.ask("core:storage:public:cache:refresh");
   }
 
   /**
    * Reset Redis cache
    */
-  async resetCache (request) {
-    const database = request.getString('database');
+  async resetCache(request) {
+    const database = request.getString("database");
 
     // @todo allow only memoryStorage
-    if (database === 'internalCache') {
-      await this.ask('core:cache:internal:flushdb');
-    }
-    else if (database === 'memoryStorage') {
-      await this.ask('core:cache:public:flushdb');
-    }
-    else {
-      throw kerror.get('services', 'cache', 'database_not_found', database);
+    if (database === "internalCache") {
+      await this.ask("core:cache:internal:flushdb");
+    } else if (database === "memoryStorage") {
+      await this.ask("core:cache:public:flushdb");
+    } else {
+      throw kerror.get("services", "cache", "database_not_found", database);
     }
 
     return { acknowledge: true };
@@ -75,35 +73,43 @@ class AdminController extends NativeController {
   /**
    * Reset all roles, profiles and users
    */
-  async resetSecurity () {
-    const mutex = new Mutex('resetSecurity', { timeout: 0 });
-
-    if (! await mutex.lock()) {
-      throw kerror.get('api', 'process', 'action_locked', 'Kuzzle is already reseting roles, profiles and users.');
+  async resetSecurity() {
+    const mutex = new Mutex("resetSecurity", { timeout: 0 });
+
+    if (!(await mutex.lock())) {
+      throw kerror.get(
+        "api",
+        "process",
+        "action_locked",
+        "Kuzzle is already reseting roles, profiles and users."
+      );
     }
 
     const result = {};
 
     try {
-      const options = { refresh: 'wait_for' };
+      const options = { refresh: "wait_for" };
 
       result.deletedUsers = await this.ask(
-        'core:security:user:truncate',
-        options);
+        "core:security:user:truncate",
+        options
+      );
       result.deletedProfiles = await this.ask(
-        'core:security:profile:truncate',
-        options);
+        "core:security:profile:truncate",
+        options
+      );
       result.deletedRoles = await this.ask(
-        'core:security:role:truncate',
-        options);
+        "core:security:role:truncate",
+        options
+      );
 
       await global.kuzzle.internalIndex.createInitialSecurities();
 
       await this.ask(
-        'core:cache:internal:del',
-        `${BACKEND_IMPORT_KEY}:permissions`);
-    }
-    finally {
+        "core:cache:internal:del",
+        `${BACKEND_IMPORT_KEY}:permissions`
+      );
+    } finally {
       await mutex.unlock();
     }
 
@@ -113,24 +119,29 @@ class AdminController extends NativeController {
   /**
    * Reset all indexes created by users
    */
-  async resetDatabase () {
-    const mutex = new Mutex('resetDatabase', { timeout: 0 });
-
-    if (! await mutex.lock()) {
-      throw kerror.get('api', 'process', 'action_locked', 'Kuzzle is already reseting all indexes.');
+  async resetDatabase() {
+    const mutex = new Mutex("resetDatabase", { timeout: 0 });
+
+    if (!(await mutex.lock())) {
+      throw kerror.get(
+        "api",
+        "process",
+        "action_locked",
+        "Kuzzle is already reseting all indexes."
+      );
     }
 
     try {
-      const indexes = await this.ask('core:storage:public:index:list');
-      await this.ask('core:storage:public:index:mDelete', indexes);
+      const indexes = await this.ask("core:storage:public:index:list");
+      await this.ask("core:storage:public:index:mDelete", indexes);
 
       await this.ask(
-        'core:cache:internal:del',
-        `${BACKEND_IMPORT_KEY}:mappings`);
+        "core:cache:internal:del",
+        `${BACKEND_IMPORT_KEY}:mappings`
+      );
 
       return { acknowledge: true };
-    }
-    finally {
+    } finally {
       await mutex.unlock();
     }
   }
@@ -139,9 +150,9 @@ class AdminController extends NativeController {
    * Generate a dump
    * Kuzzle will throw a PreconditionError if a dump is already running
    */
-  dump (request) {
-    const waitForRefresh = request.input.args.refresh === 'wait_for';
-    const suffix = request.getString('suffix', 'manual-api-action');
+  dump(request) {
+    const waitForRefresh = request.input.args.refresh === "wait_for";
+    const suffix = request.getString("suffix", "manual-api-action");
 
     const promise = global.kuzzle.dump(suffix);
 
@@ -151,9 +162,14 @@ class AdminController extends NativeController {
   /**
    * Shutdown Kuzzle
    */
-  async shutdown () {
+  async shutdown() {
     if (this.shuttingDown) {
-      throw kerror.get('api', 'process', 'action_locked', 'Kuzzle is already shutting down.');
+      throw kerror.get(
+        "api",
+        "process",
+        "action_locked",
+        "Kuzzle is already shutting down."
+      );
     }
 
     global.kuzzle.shutdown();
@@ -161,34 +177,34 @@ class AdminController extends NativeController {
     return { acknowledge: true };
   }
 
-  loadFixtures (request) {
+  loadFixtures(request) {
     const fixtures = request.getBody();
-    const refresh = request.getRefresh('wait_for');
+    const refresh = request.getRefresh("wait_for");
 
-    return global.kuzzle.ask('core:storage:public:document:import', fixtures, {
-      refresh
+    return global.kuzzle.ask("core:storage:public:document:import", fixtures, {
+      refresh,
     });
   }
 
-  loadMappings (request) {
+  loadMappings(request) {
     const mappings = request.getBody();
 
     return this._waitForAction(
-      request.getRefresh('wait_for'),
-      global.kuzzle.ask(
-        'core:storage:public:mappings:import',
-        mappings,
-        { rawMappings: true }));
+      request.getRefresh("wait_for"),
+      global.kuzzle.ask("core:storage:public:mappings:import", mappings, {
+        rawMappings: true,
+      })
+    );
   }
 
-  async loadSecurities (request) {
+  async loadSecurities(request) {
     const permissions = request.getBody();
     const user = request.getUser();
     const onExistingUsers = request.input.args.onExistingUsers;
-    const force = request.getBoolean('force');
-    const waitForRefresh = request.getRefresh('wait_for');
+    const force = request.getBoolean("force");
+    const waitForRefresh = request.getRefresh("wait_for");
 
-    const promise = this.ask('core:security:load', permissions, {
+    const promise = this.ask("core:security:load", permissions, {
       force,
       onExistingUsers,
       refresh: waitForRefresh,
@@ -198,21 +214,19 @@ class AdminController extends NativeController {
     return this._waitForAction(waitForRefresh, promise);
   }
 
-  _waitForAction (waitForRefresh, promise) {
+  _waitForAction(waitForRefresh, promise) {
     const result = { acknowledge: true };
 
-    if (waitForRefresh === 'false') {
+    if (waitForRefresh === "false") {
       // Attaching an error handler to the provided promise to prevent
       // uncaught rejections
-      promise.catch(err => global.kuzzle.log.error(err));
+      promise.catch((err) => global.kuzzle.log.error(err));
 
       return Bluebird.resolve(result);
     }
 
-    return promise
-      .then(() => result);
+    return promise.then(() => result);
   }
-
 }
 
 module.exports = AdminController;