kuzzle 2.19.2 → 2.19.3

package/lib/api/controllers/serverController.js

@@ -19,34 +19,34 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const os = require('os');
-const jsonToYaml = require('json2yaml');
-const packagejson = require('../../../package.json');
+const os = require("os");
+const jsonToYaml = require("json2yaml");
+const packagejson = require("../../../package.json");
 
-const { NativeController } = require('./baseController');
+const { NativeController } = require("./baseController");
 
-const kerror = require('../../kerror');
+const kerror = require("../../kerror");
 
 /**
  * @class ServerController
  */
 class ServerController extends NativeController {
-  constructor () {
+  constructor() {
     super([
-      'adminExists',
-      'capabilities',
-      'getAllStats',
-      'getConfig',
-      'getLastStats',
-      'getStats',
-      'healthCheck',
-      'info',
-      'metrics',
-      'now',
-      'publicApi',
-      'openapi',
+      "adminExists",
+      "capabilities",
+      "getAllStats",
+      "getConfig",
+      "getLastStats",
+      "getStats",
+      "healthCheck",
+      "info",
+      "metrics",
+      "now",
+      "publicApi",
+      "openapi",
     ]);
 
     this._info = {
@@ -61,11 +61,11 @@ class ServerController extends NativeController {
    * for all controllers to be initialized before accepting requests.
    *
    * @returns {Promise}
-  */
-  async init () {
+   */
+  async init() {
     const [storageInfo, cacheInfo] = await Promise.all([
-      global.kuzzle.ask('core:storage:public:info:get'),
-      global.kuzzle.ask('core:cache:public:info:get'),
+      global.kuzzle.ask("core:storage:public:info:get"),
+      global.kuzzle.ask("core:cache:public:info:get"),
     ]);
     this._info.elasticsearch = storageInfo;
     this._info.redis = cacheInfo;
@@ -79,7 +79,7 @@ class ServerController extends NativeController {
    *
    * @deprecated
    */
-  getStats (request) {
+  getStats(request) {
     return global.kuzzle.statistics.getStats(request);
   }
 
@@ -90,7 +90,7 @@ class ServerController extends NativeController {
    *
    * @deprecated
    */
-  getLastStats () {
+  getLastStats() {
     return global.kuzzle.statistics.getLastStats();
   }
 
@@ -101,7 +101,7 @@ class ServerController extends NativeController {
    *
    * @deprecated
    */
-  getAllStats () {
+  getAllStats() {
     return global.kuzzle.statistics.getAllStats();
   }
 
@@ -110,7 +110,7 @@ class ServerController extends NativeController {
    *
    * @returns {Promise<Object>}
    */
-  async getConfig () {
+  async getConfig() {
     const config = JSON.parse(JSON.stringify(global.kuzzle.config));
 
     // Already and more appropriately returned by server:info
@@ -131,7 +131,7 @@ class ServerController extends NativeController {
    * Returns the Kuzzle capabilities
    * @returns {Promise<Object>}
    */
-  async capabilities () {
+  async capabilities() {
     const config = JSON.parse(JSON.stringify(global.kuzzle.config));
     const publicApi = await this.publicApi();
     const services = {};
@@ -139,7 +139,7 @@ class ServerController extends NativeController {
 
     for (const plugin of config.plugins.common.include) {
       plugins[plugin] = {
-        version: packagejson.dependencies[plugin]
+        version: packagejson.dependencies[plugin],
       };
     }
 
@@ -165,8 +165,8 @@ class ServerController extends NativeController {
    *
    * @returns {Promise<Object>}
    */
-  async adminExists () {
-    const exists = await global.kuzzle.ask('core:security:user:admin:exist');
+  async adminExists() {
+    const exists = await global.kuzzle.ask("core:security:user:admin:exist");
 
     return { exists };
   }
@@ -174,59 +174,58 @@ class ServerController extends NativeController {
   /**
    * @returns {Promise<Object>}
    */
-  async now () {
+  async now() {
     return { now: Date.now() };
   }
 
   /**
    * @returns {Promise<Object>}
    */
-  async healthCheck (request) {
-    const getServiceUnavailableError =
-      err => kerror.get('core', 'fatal', 'service_unavailable', err);
-    const result = { services: {}, status: 'green' };
+  async healthCheck(request) {
+    const getServiceUnavailableError = (err) =>
+      kerror.get("core", "fatal", "service_unavailable", err);
+    const result = { services: {}, status: "green" };
 
     let services;
-    if (typeof request.input.args.services === 'string') {
+    if (typeof request.input.args.services === "string") {
       // @deprecated Should be replaced with request.getArray('services')
-      services = request.getArrayLegacy('services');
+      services = request.getArrayLegacy("services");
     }
-    if (! services || services.includes('internalCache')) {
+    if (!services || services.includes("internalCache")) {
       try {
-        await global.kuzzle.ask('core:cache:internal:info:get');
-        result.services.internalCache = 'green';
-      }
-      catch (error) {
+        await global.kuzzle.ask("core:cache:internal:info:get");
+        result.services.internalCache = "green";
+      } catch (error) {
         request.setError(getServiceUnavailableError(error));
-        result.services.internalCache = 'red';
-        result.status = 'red';
+        result.services.internalCache = "red";
+        result.status = "red";
       }
     }
-    if (! services || services.includes('memoryStorage')) {
+    if (!services || services.includes("memoryStorage")) {
       try {
-        await global.kuzzle.ask('core:cache:public:info:get');
-        result.services.memoryStorage = 'green';
-      }
-      catch (error) {
+        await global.kuzzle.ask("core:cache:public:info:get");
+        result.services.memoryStorage = "green";
+      } catch (error) {
         request.setError(getServiceUnavailableError(error));
-        result.services.memoryStorage = 'red';
-        result.status = 'red';
+        result.services.memoryStorage = "red";
+        result.status = "red";
       }
     }
-    if (! services || services.includes('storageEngine')) {
+    if (!services || services.includes("storageEngine")) {
       try {
-        const response = await global.kuzzle.ask('core:storage:public:info:get');
+        const response = await global.kuzzle.ask(
+          "core:storage:public:info:get"
+        );
 
-        if (response.status !== 'yellow' && response.status !== 'green') {
+        if (response.status !== "yellow" && response.status !== "green") {
           throw new Error(`ElasticSearch is down: ${JSON.stringify(response)}`);
         }
 
-        result.services.storageEngine = 'green';
-      }
-      catch (error) {
+        result.services.storageEngine = "green";
+      } catch (error) {
         request.setError(getServiceUnavailableError(error));
-        result.services.storageEngine = 'red';
-        result.status = 'red';
+        result.services.storageEngine = "red";
+        result.status = "red";
       }
     }
     return result;
@@ -235,11 +234,11 @@ class ServerController extends NativeController {
   /**
    * @returns {Promise<Object>}
    */
-  async info () {
+  async info() {
     const response = {
       kuzzle: {
         api: {
-          routes: {}
+          routes: {},
         },
         application: {},
         memoryUsed: process.memoryUsage().rss,
@@ -249,115 +248,123 @@ class ServerController extends NativeController {
           cpus: os.cpus(),
           memory: {
             free: os.freemem(),
-            total: os.totalmem()
-          }
+            total: os.totalmem(),
+          },
         },
         uptime: `${process.uptime()}s`,
-        version: global.kuzzle.config.version
+        version: global.kuzzle.config.version,
       },
-      services: {}
+      services: {},
     };
 
     const kuzzleApi = this._buildApiDefinition(
       global.kuzzle.funnel.controllers,
-      global.kuzzle.config.http.routes);
+      global.kuzzle.config.http.routes
+    );
     const pluginsApi = this._buildApiDefinition(
       global.kuzzle.pluginsManager.controllers,
-      global.kuzzle.pluginsManager.routes);
+      global.kuzzle.pluginsManager.routes
+    );
     const apiDefinition = Object.assign({}, kuzzleApi, pluginsApi);
 
     // @todo kuzzle.api should contain the apiDefinition directly
     response.kuzzle.api.routes = apiDefinition;
 
-    response.kuzzle.plugins = global.kuzzle.pluginsManager.getPluginsDescription();
+    response.kuzzle.plugins =
+      global.kuzzle.pluginsManager.getPluginsDescription();
 
-    response.kuzzle.application = global.kuzzle.pluginsManager.application.info();
+    response.kuzzle.application =
+      global.kuzzle.pluginsManager.application.info();
 
     response.services = {
-      internalCache: await global.kuzzle.ask('core:cache:internal:info:get'),
-      internalStorage: await global.kuzzle.ask('core:storage:private:info:get'),
-      memoryStorage: await global.kuzzle.ask('core:cache:public:info:get'),
-      publicStorage: await global.kuzzle.ask('core:storage:public:info:get'),
+      internalCache: await global.kuzzle.ask("core:cache:internal:info:get"),
+      internalStorage: await global.kuzzle.ask("core:storage:private:info:get"),
+      memoryStorage: await global.kuzzle.ask("core:cache:public:info:get"),
+      publicStorage: await global.kuzzle.ask("core:storage:public:info:get"),
     };
 
     return {
-      serverInfo: response
+      serverInfo: response,
     };
   }
 
-  async publicApi () {
+  async publicApi() {
     const kuzzleApi = this._buildApiDefinition(
       global.kuzzle.funnel.controllers,
-      global.kuzzle.config.http.routes);
+      global.kuzzle.config.http.routes
+    );
     const pluginsApi = this._buildApiDefinition(
       global.kuzzle.pluginsManager.controllers,
-      global.kuzzle.pluginsManager.routes);
+      global.kuzzle.pluginsManager.routes
+    );
 
     return { ...kuzzleApi, ...pluginsApi };
   }
 
-  async openapi (request) {
-    const format = request.getString('format', 'json');
-    const scope = request.getString('scope', 'kuzzle');
+  async openapi(request) {
+    const format = request.getString("format", "json");
+    const scope = request.getString("scope", "kuzzle");
 
     let definition;
 
-    if (scope === 'kuzzle') {
-      definition = await global.kuzzle.ask('core:api:openapi:kuzzle');
-    }
-    else if (scope === 'app') {
-      definition = await global.kuzzle.ask('core:api:openapi:app');
-    }
-    else {
-      throw kerror.get('api', 'assert', 'unexpected_argument', scope, ['kuzzle', 'app']);
+    if (scope === "kuzzle") {
+      definition = await global.kuzzle.ask("core:api:openapi:kuzzle");
+    } else if (scope === "app") {
+      definition = await global.kuzzle.ask("core:api:openapi:app");
+    } else {
+      throw kerror.get("api", "assert", "unexpected_argument", scope, [
+        "kuzzle",
+        "app",
+      ]);
     }
 
     request.response.configure({
-      format: 'raw',
-      headers: { 'Content-Type': `application/${format}` },
+      format: "raw",
+      headers: { "Content-Type": `application/${format}` },
     });
 
-    return format === 'json' ? definition : jsonToYaml.stringify(definition);
+    return format === "json" ? definition : jsonToYaml.stringify(definition);
   }
 
   /**
    * Fetches and returns Kuzzle core metrics
    * @returns {Promise<Object>}
    */
-  async metrics () {
+  async metrics() {
     return {
-      api: await global.kuzzle.ask('kuzzle:api:funnel:metrics'),
-      network: await global.kuzzle.ask('core:network:router:metrics'),
-      realtime: await global.kuzzle.ask('core:realtime:hotelClerk:metrics'),
+      api: await global.kuzzle.ask("kuzzle:api:funnel:metrics"),
+      network: await global.kuzzle.ask("core:network:router:metrics"),
+      realtime: await global.kuzzle.ask("core:realtime:hotelClerk:metrics"),
     };
   }
 
-  _buildApiDefinition (controllers, httpRoutes) {
+  _buildApiDefinition(controllers, httpRoutes) {
     const apiDefinition = {};
 
-    for (const [ name, controller ] of controllers.entries()) {
+    for (const [name, controller] of controllers.entries()) {
       const actionList = {};
 
       for (const action of controller._actions) {
         actionList[action] = { action, controller: name };
 
         // resolve associated http route for each actions
-        const routes = httpRoutes.filter(route => {
+        const routes = httpRoutes.filter((route) => {
           return (
-            (route.controller === name
-              || (name === 'memoryStorage' && route.controller === 'ms'))
-            && route.action === action);
+            (route.controller === name ||
+              (name === "memoryStorage" && route.controller === "ms")) &&
+            route.action === action
+          );
         });
 
         for (const route of routes) {
-          if (! actionList[action].http) {
+          if (!actionList[action].http) {
             actionList[action].http = [];
           }
 
           actionList[action].http.push({
             path: route.path,
             url: route.path,
-            verb: route.verb.toUpperCase()
+            verb: route.verb.toUpperCase(),
           });
         }
       }