kuzzle 2.60.0-beta.2 → 2.60.0-beta.4

package/dist/lib/service/storage/8/elasticsearch.js

@@ -89,6 +89,9 @@ const HIDDEN_COLLECTION = "_kuzzle_keep";
 // is refreshed while held, so a live holder is never overtaken; a crashed
 // one leaves it for at most `ttl` (30 s).
 const HIDDEN_COLLECTION_LOCK = { retryAttempts: Number.POSITIVE_INFINITY };
+// How long `waitForCollectionShards` lets Elasticsearch wait for a
+// collection's primary shards, which is also Elasticsearch's own default
+const COLLECTION_SHARDS_TIMEOUT = "30s";
 const ALIAS_PREFIX = "@"; // @todo next major release: Add ALIAS_PREFIX in FORBIDDEN_CHARS
 const PRIVATE_PREFIX = "%";
 const PUBLIC_PREFIX = "&";
@@ -1168,6 +1171,9 @@ class ES8 {
         this._checkDynamicProperty(mappings);
         const exists = await this.hasCollection(index, collection);
         if (exists) {
+            // Another node created it, maybe so recently that its primary shards
+            // are still initializing
+            await this.waitForCollectionShards(index, collection);
             return this.updateCollection(index, collection, { mappings, settings });
         }
         this._checkMappings(mappings);
@@ -1189,7 +1195,9 @@ class ES8 {
             if (lodash_1.default.get(error, "meta.body.error.type") ===
                 "resource_already_exists_exception") {
                 // race condition: the indice has been created between the "exists"
-                // check above and this "create" attempt
+                // check above and this "create" attempt, by a request that may not
+                // have waited for its shards yet
+                await this.waitForCollectionShards(index, collection);
                 return null;
             }
             throw this._esWrapper.formatESError(error);
@@ -1209,6 +1217,29 @@ class ES8 {
         }
         return null;
     }
+    /**
+     * Waits until the primary shards of a collection are active, for at most
+     * `timeout`, and rejects if they are not by then.
+     *
+     * A collection another node has just created is in the cluster state, so
+     * it exists, before its primary shard is active: until then, Elasticsearch
+     * answers 503 to any document request on it. The node that creates a
+     * collection waits for its shards (`wait_for_active_shards`); a node that
+     * finds it already there calls this instead. It answers at once when the
+     * shards are already active.
+     */
+    async waitForCollectionShards(index, collection, timeout = COLLECTION_SHARDS_TIMEOUT) {
+        try {
+            await this._client.cluster.health({
+                index: this._getAlias(index, collection),
+                timeout,
+                wait_for_status: "yellow",
+            });
+        }
+        catch (error) {
+            throw this._esWrapper.formatESError(error);
+        }
+    }
     /**
      * Retrieves settings definition for index/type
      *

package/dist/lib/service/storage/8/esWrapper.js

@@ -35,6 +35,35 @@ const kerror = (0, kerror_1.wrap)("services", "storage");
 function isResponseError(error) {
     return Boolean(error.meta);
 }
+/**
+ * What the client puts in `message` when the response carried nothing it could
+ * read: this placeholder, or an empty string for a bodyless response.
+ */
+const CLIENT_PLACEHOLDER_MESSAGE = "Response Error";
+function isUsableMessage(message) {
+    return (typeof message === "string" &&
+        message.trim() !== "" &&
+        message !== CLIENT_PLACEHOLDER_MESSAGE);
+}
+/**
+ * A message for an error that came with none worth keeping (typically a 503
+ * with no body while shards initialize), built from what the error still
+ * carries: the client's error name, the HTTP status and the response body.
+ */
+function describeUnreadableError(error) {
+    const statusCode = error.meta?.statusCode;
+    const body = error.meta?.body;
+    const hasBody = body !== undefined && body !== null && body !== "";
+    let description = statusCode === undefined
+        ? "Elasticsearch request failed"
+        : `Elasticsearch responded ${statusCode}`;
+    description += hasBody
+        ? `: ${(0, node_util_1.inspect)(body, { breakLength: Infinity, depth: 3 })}`
+        : " (no body)";
+    return error.name && error.name !== "Error"
+        ? `${error.name}: ${description}`
+        : description;
+}
 const errorMessagesMapping = [
     {
         regex: /^\[es_rejected_execution_exception] rejected execution .*? on EsThreadPoolExecutor\[(.*?), .*$/,
@@ -258,8 +287,8 @@ class ESWrapper {
         return kerror.get("unexpected_bad_request", errorMessage);
     }
     _handleUnknownError(error, message) {
-        debug("unhandled elasticsearch error (unhandled type: %s): %o", (0, get_1.default)(error, "error.meta.statusCode", "<no status code>"), error);
-        return kerror.get("unexpected_error", message);
+        debug("unhandled elasticsearch error (unhandled type: %s): %o", (0, get_1.default)(error, "meta.statusCode", "<no status code>"), error);
+        return kerror.get("unexpected_error", isUsableMessage(message) ? message : describeUnreadableError(error));
     }
 }
 module.exports = ESWrapper;

package/dist/lib/types/events/EventGenericDocument.d.ts

@@ -1,6 +1,7 @@
 import type { KDocument, KDocumentContent } from "kuzzle-types";
 import type { JSONObject } from "../JSONObject";
-import type { KuzzleRequest, PipeEventHandler } from "../../../index";
+import type { KuzzleRequest } from "../../api/request";
+import type { PipeEventHandler } from "../EventHandler";
 /**
  * Events with documents only having the `_id`
  */

package/dist/lib/types/events/EventProtocol.d.ts

@@ -1,5 +1,5 @@
 import type { JSONObject } from "../JSONObject";
-import type { PipeEventHandler } from "../../../index";
+import type { PipeEventHandler } from "../EventHandler";
 import type { ClientConnection } from "../ClientConnection";
 import type { HttpMessage } from "../HttpMessage";
 export type EventHTTPBeforeParsingPayload = {

package/dist/lib/util/mutex.d.ts

@@ -101,7 +101,8 @@ export declare class Mutex {
      *
      * From then on, `lock()` never resolves: the process is about to exit, and
      * answering `false` would send its caller down a path meant for a lock
-     * held by another node.
+     * held by another node. And `unlock()` on a lock it already freed resolves
+     * without doing anything, since its holder may still try to give it back.
      */
     static releaseAllBeforeExit(): Promise<void>;
     get locked(): boolean;

package/dist/lib/util/mutex.js

@@ -165,6 +165,11 @@ class Mutex {
      * @return {Promise}
      */
     async unlock() {
+        // `releaseAllBeforeExit` already gave this lock back: its holder is only
+        // catching up, and throwing would turn a requested shutdown into a crash.
+        if (!this._locked && exiting) {
+            return;
+        }
         if (!this._locked) {
             throw fatal.get("assertion_failed", `tried to unlock the resource "${this.resource}", which is not locked (mutex id: ${this.mutexId})`);
         }
@@ -214,7 +219,8 @@ class Mutex {
      *
      * From then on, `lock()` never resolves: the process is about to exit, and
      * answering `false` would send its caller down a path meant for a lock
-     * held by another node.
+     * held by another node. And `unlock()` on a lock it already freed resolves
+     * without doing anything, since its holder may still try to give it back.
      */
     static async releaseAllBeforeExit() {
         exiting = true;

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "kuzzle",
     "author": "The Kuzzle Team <support@kuzzle.io>",
-    "version": "2.60.0-beta.2",
+    "version": "2.60.0-beta.4",
     "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
     "scripts": {
         "build": "rm -Rf ./dist && tsc && node -r ts-node/register/transpile-only ./bin/copy-binaries.ts",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
-  "version": "2.60.0-beta.2",
+  "version": "2.60.0-beta.4",
   "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
   "scripts": {
     "build": "rm -Rf ./dist && tsc && node -r ts-node/register/transpile-only ./bin/copy-binaries.ts",