Merge pull request #2595 from kuzzleio/2-dev

release: 2-dev to master

Author: Juiced66

doc/2/api/controllers/collection/get-settings/index.md

@@ -0,0 +1,80 @@
+---
+code: true
+type: page
+title: getSettings | API | Core
+---
+
+# getSettings
+
+Retrieves the Elasticsearch index settings for the specified Kuzzle collection.
+
+---
+
+## Query Syntax
+
+### HTTP
+
+```http
+URL: http://kuzzle:7512/<index>/<collection>/_settings
+Method: GET
+```
+
+### Other protocols
+
+```js
+{
+  "index": "<index>",
+  "collection": "<collection>",
+  "controller": "collection",
+  "action": "getSettings",
+}
+```
+
+---
+
+## Arguments
+
+- `collection`: collection name
+- `index`: index name
+
+---
+
+## Response
+
+Returns a setting object with the following structure:
+
+```js
+{
+  "status": 200,
+  "error": null,
+  "action": "getSettings",
+  "controller": "collection",
+  "collection": "<collection>",
+  "index": "<index>",
+  "headers": {},
+  "result": {
+    "routing": {
+      "allocation": {
+        "include": {
+          "_tier_preference": "data_content"
+        }
+      }
+    },
+    "number_of_shards": "1",
+    "provided_name": "&platform.config",
+    "creation_date": "1738682329397",
+    "number_of_replicas": "1",
+    "uuid": "aY0IBbKJSvuIrwqqYyKkUw",
+    "version": {
+      "created": "7160299"
+    }
+  },
+}
+```
+
+---
+
+## Possible errors
+
+- [Common errors](/core/2/api/errors/types#common-errors)
+- [NotFoundError](/core/2/api/errors/types#notfounderror)

doc/2/guides/main-concepts/api/index.md

@@ -98,9 +98,29 @@ This endpoint is accessible with the route `GET /_healthcheck`.
 curl "http://localhost:7512/_healthcheck"
 ```
 
-This route does not require any authentication. It returns a `200` status code if the server is up and running.
+This route does not require any authentication. It returns a `200` status code if the Kuzzle server is started.
 
-This is useful when kuzzle is deployed inside a Kubernetes cluster and you want to configure probes to check the server.
+This is useful when Kuzzle is deployed inside a Kubernetes cluster and you want to configure a [`livenessProbe`](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/#define-a-liveness-http-request) to check the Kuzzle server is started.
+
+#### Ready endpoint
+
+Kuzzle exposes a readiness endpoint.
+
+This endpoint is accessible with the route `GET /_ready`.
+
+```bash
+curl "http://localhost:7512/_ready"
+```
+
+This route does not require any authentication. It returns a `200` status code if the server is running and ready to accept new incoming requests.
+It returns a `503` status code if:
+- The Kuzzle server state is one of the following:
+  - Node starting procedure has not finished yet.
+  - Node is shutting down.
+  - The cluster does not have enough nodes to be considered as healthy.
+- The Kuzzle server is overloaded (meaning the number of requests in the queue is above the [configured threshold](https://github.com/kuzzleio/kuzzle/blob/c33f0dcb904b01941c0967450dc52848ba3456d7/.kuzzlerc.sample.jsonc#L92)).
+
+This is useful when Kuzzle is deployed inside a Kubernetes cluster and you want to configure a [`readinessProbe`](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/#define-readiness-probes) to check the Kuzzle server is ready to accept new incoming requests.
 
 ---
 

docker/images/elasticsearch/Dockerfile

@@ -1,4 +1,4 @@
-ARG ELASTICSEARCH_VERSION="7.17.25"
+ARG ELASTICSEARCH_VERSION="7.17.26"
 FROM docker.elastic.co/elasticsearch/elasticsearch:${ELASTICSEARCH_VERSION}
 
 LABEL maintainer="kuzzle" contact="<[email protected]>"

docker/scripts/start-kuzzle-test.ts

@@ -490,6 +490,30 @@ app.controller.register("tests", {
         });
       },
     },
+    simulateOutage: {
+      http: [{ verb: "get", path: "/tests/simulate-outage" }],
+      handler: async (request: KuzzleRequest) => {
+        const outageType = request.getString("type");
+
+        switch (outageType) {
+          case "overload":
+            global.kuzzle.funnel.overloaded = true;
+            break;
+          case "nodeNotStarted":
+            global.kuzzle.state = 1;
+            break;
+          default:
+            break;
+        }
+      },
+    },
+    clearOutage: {
+      http: [{ verb: "get", path: "/tests/clear-outage" }],
+      handler: async () => {
+        global.kuzzle.funnel.overloaded = false;
+        global.kuzzle.state = 2;
+      },
+    },
   },
 });
 

features/CollectionController.feature

@@ -69,6 +69,19 @@ Feature: Collection Controller
       | createdAt | { "type": "date" }    |
       | updatedAt | { "type": "date" }    |
 
+
+  # collection:getSettings =====================================================
+  
+  Scenario: Get collection settings
+    Given an index "nyc-open-data"
+    And I "create" the collection "nyc-open-data":"green-taxi" with:
+      | mappings | { "dynamic": "strict", "properties": { "name": { "type": "keyword" } } } |
+    When I successfully execute the action "collection":"getSettings" with args:
+      | index      | "nyc-open-data" |
+      | collection | "green-taxi"    |
+    Then I should receive a result matching:
+      | number_of_shards | "1" |
+
   # collection:delete ==========================================================
 
   Scenario: Delete a collection

jest/network/network/ready.test.ts

@@ -0,0 +1,42 @@
+import rp from "request-promise";
+
+test("Check _ready result", async () => {
+  const response = rp.get({
+    uri: "http://localhost:17510/_ready",
+  });
+  
+  await expect(response).resolves.not.toThrow(); // Should return 200
+});
+
+test("Check _ready during node startup", async () => {
+  await rp.get({
+    uri: "http://localhost:17510/tests/simulate-outage?type=nodeNotStarted",
+  });
+
+  const response = rp.get({
+    uri: "http://localhost:17510/_ready",
+  });
+  
+  await expect(response).rejects; // Should return 503
+
+  await rp.get({
+    uri: "http://localhost:17510/tests/clear-outage",
+  });
+});
+
+test("Check _ready during node overload", async () => {
+  await rp.get({
+    uri: "http://localhost:17510/tests/simulate-outage?type=overload",
+  });
+
+  const response = rp.get({
+    uri: "http://localhost:17510/_ready",
+  });
+  
+  await expect(response).rejects; // Should return 503
+
+  await rp.get({
+    uri: "http://localhost:17510/tests/clear-outage",
+  });
+});
+

lib/api/controllers/collectionController.js

@@ -36,6 +36,7 @@ class CollectionController extends NativeController {
       "deleteSpecifications",
       "exists",
       "getMapping",
+      "getSettings",
       "getSpecifications",
       "list",
       "refresh",
@@ -97,6 +98,23 @@ class CollectionController extends NativeController {
     return this._filterMappingResponse(mapping);
   }
 
+  /**
+   * Get the collection settings
+   *
+   * @param {Request} request
+   * @returns {Promise.<Object>}
+   */
+  async getSettings(request) {
+    const { index, collection } = request.getIndexAndCollection();
+
+    return this.ask(
+      "core:storage:public:collection:settings:get",
+      index,
+      collection,
+      {},
+    );
+  }
+
   /**
    * Get the collection validation specifications
    *

lib/api/httpRoutes.js

@@ -140,6 +140,12 @@ const routes = [
     controller: "collection",
     action: "getMapping",
   },
+  {
+    verb: "get",
+    path: "/:index/:collection/_settings",
+    controller: "collection",
+    action: "getSettings",
+  },
   {
     verb: "get",
     path: "/:index/:collection/_search",

lib/core/backend/backend.ts

@@ -76,8 +76,7 @@ export class Backend {
   private _kuzzle: any;
   private _name: string;
   private _sdk: EmbeddedSDK;
-
-  protected started = false;
+  private _started: boolean;
 
   protected _pipes = {};
   protected _hooks = {};
@@ -431,6 +430,14 @@ export class Backend {
     };
   }
 
+  get started() {
+    return this._started;
+  }
+
+  protected set started(started: boolean) {
+    this._started = started;
+  }
+
   /**
    * Try to read the current commit hash.
    */

lib/core/network/router.js

@@ -25,6 +25,7 @@ const { Request } = require("../../api/request");
 const kerror = require("../../kerror");
 const HttpRouter = require("./httpRouter");
 const { removeStacktrace } = require("../../util/stackTrace");
+const kuzzleStateEnum = require("../../kuzzle/kuzzleStateEnum");
 
 /**
  * @class Router
@@ -148,6 +149,27 @@ class Router {
       cb(request);
     });
 
+    this.http.get("_ready", (request, cb) => {
+      let status = 200;
+
+      if (
+        global.kuzzle.state !== kuzzleStateEnum.RUNNING ||
+        global.kuzzle.funnel.overloaded
+      ) {
+        status = 503;
+      }
+
+      request.response.configure({
+        status: status,
+      });
+
+      /**
+       * By avoiding using the funnel, we avoid the request to be logged
+       * This is useful for ochestrators healthchecks
+       */
+      cb(request);
+    });
+
     for (const route of routes) {
       const verb = route.verb.toLowerCase();
 

test/api/controllers/collectionController.test.js

@@ -651,7 +651,6 @@ describe("Test: collection controller", () => {
         index,
         collection,
       );
-
       should(response).be.instanceof(Object);
       should(response).match({
         acknowledged: true,