@delali/narsil 0.3.1-next.72 → 0.3.1-next.73

package/dist/distribution/coordinator/etcd.mjs

@@ -1,13 +1,20 @@
 import { MAX_NODE_ID_LENGTH, MAX_WATCHERS } from '../../chunk-ORBLD3EL.mjs';
 import { compareCodePoints } from '../../chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from '../../chunk-RV77FR2F.mjs';
+import { NarsilError, ErrorCodes } from '../../chunk-I64LXKO3.mjs';
 import { decode, encode } from '@msgpack/msgpack';
 
+// src/distribution/coordinator/etcd/constants.ts
+var DEFAULT_ETCD_MAX_REQUEST_BYTES = 1572864;
+var MAX_ETCD_REQUEST_BYTES = 2147483647;
+var ETCD_REQUEST_FRAMING_BYTES = 1024;
+var ETCD_MAX_RESPONSE_BYTES = 2147483647;
+
 // src/distribution/coordinator/etcd/types.ts
 var DEFAULT_ETCD_CONFIG = {
   endpoints: ["http://localhost:2379"],
   keyPrefix: "_narsil",
-  nodeHeartbeatTtlSeconds: 30
+  nodeHeartbeatTtlSeconds: 30,
+  maxRequestBytes: DEFAULT_ETCD_MAX_REQUEST_BYTES
 };
 var ETCD_KEY_NODES = "nodes";
 var ETCD_KEY_ALLOCATION = "allocation";
@@ -211,6 +218,8 @@ function writeNodeRegistration(context, registration) {
 async function writeUnderLease(context, registration) {
   const payload = serializeNodeRegistration(registration);
   const data = Buffer.from(payload);
+  const write = { key: context.key, value: data, expected: null };
+  context.guard.requireFits(write);
   const tracked = context.leaseManager.getByNodeId(context.key, registration.nodeId);
   if (tracked !== void 0) {
     try {
@@ -227,7 +236,13 @@ async function writeUnderLease(context, registration) {
   }
   const lease = context.client.lease(context.ttlSeconds);
   await lease.grant();
-  await lease.put(context.key).value(data).exec();
+  try {
+    await context.guard.send(write, () => lease.put(context.key).value(data).exec());
+  } catch (error) {
+    await lease.revoke().catch(() => {
+    });
+    throw error;
+  }
   const existing = context.leaseManager.get(context.key);
   if (existing !== void 0) {
     await existing.lease.revoke().catch(() => {
@@ -236,6 +251,132 @@ async function writeUnderLease(context, registration) {
   context.leaseManager.track(context.key, lease, registration.nodeId, payload);
 }
 
+// src/distribution/coordinator/etcd/request-size.ts
+var ETCD_REQUEST_TOO_LARGE = "etcdserver: request is too large";
+var GRPC_MESSAGE_TOO_LARGE = "larger than max";
+function requireEtcdMaxRequestBytes(maxRequestBytes) {
+  if (Number.isSafeInteger(maxRequestBytes) && maxRequestBytes > ETCD_REQUEST_FRAMING_BYTES && maxRequestBytes <= MAX_ETCD_REQUEST_BYTES) {
+    return;
+  }
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `maxRequestBytes must be a whole number above ${ETCD_REQUEST_FRAMING_BYTES} and at most ${MAX_ETCD_REQUEST_BYTES}`,
+    { maxRequestBytes }
+  );
+}
+function requestBytesOf(write) {
+  const keyBytes = Buffer.byteLength(write.key);
+  return write.value.byteLength + (write.expected?.byteLength ?? 0) + 2 * keyBytes + ETCD_REQUEST_FRAMING_BYTES;
+}
+function refusedForSize(etcd3, error) {
+  if (error instanceof etcd3.GRPCInvalidArgumentError) return error.message.includes(ETCD_REQUEST_TOO_LARGE);
+  if (error instanceof etcd3.GRPCResourceExhastedError) return error.message.includes(GRPC_MESSAGE_TOO_LARGE);
+  return false;
+}
+function createEtcdWriteGuard(etcd3, maxRequestBytes) {
+  function requireFits(write) {
+    const bytes = requestBytesOf(write);
+    if (bytes <= maxRequestBytes) return bytes;
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      `The request to write "${write.key}" would be ${bytes} bytes, more than the maxRequestBytes of ${maxRequestBytes}. Raise maxRequestBytes in createEtcdCoordinator together with the --max-request-bytes value of etcd.`,
+      { key: write.key, bytes, maxRequestBytes }
+    );
+  }
+  return {
+    requireFits,
+    async send(write, perform) {
+      const bytes = requireFits(write);
+      try {
+        return await perform();
+      } catch (error) {
+        if (!refusedForSize(etcd3, error)) throw error;
+        throw new NarsilError(
+          ErrorCodes.CONFIG_INVALID,
+          `etcd reports the ${bytes}-byte request to write "${write.key}" as too large, so its --max-request-bytes value is below the maxRequestBytes of ${maxRequestBytes}. Set both to the same value.`,
+          { key: write.key, bytes, maxRequestBytes }
+        );
+      }
+    }
+  };
+}
+
+// src/distribution/coordinator/etcd/stored-values.ts
+function storedValueMethods(context) {
+  const { client, keys, guard, assertNotShutdown, addWatcher, removeWatcher } = context;
+  return {
+    async get(key) {
+      assertNotShutdown();
+      const etcdKey = keys.generic(key);
+      const buf = await client.get(etcdKey).buffer();
+      if (buf === null) {
+        return null;
+      }
+      return new Uint8Array(buf);
+    },
+    async compareAndSet(key, expected, value) {
+      assertNotShutdown();
+      const etcdKey = keys.generic(key);
+      const newValue = Buffer.from(value);
+      return guard.send({ key: etcdKey, value: newValue, expected }, async () => {
+        if (expected === null) {
+          const txn2 = await client.if(etcdKey, "Create", "==", 0).then(client.put(etcdKey).value(newValue)).commit();
+          return txn2.succeeded;
+        }
+        const expectedBuf = Buffer.from(expected);
+        const txn = await client.if(etcdKey, "Value", "==", expectedBuf).then(client.put(etcdKey).value(newValue)).commit();
+        return txn.succeeded;
+      });
+    },
+    async getSchema(indexName) {
+      assertNotShutdown();
+      const key = keys.schema(indexName);
+      const buf = await client.get(key).buffer();
+      if (buf === null) {
+        return null;
+      }
+      return deserializeSchema(buf);
+    },
+    async putSchema(indexName, schema) {
+      assertNotShutdown();
+      const key = keys.schema(indexName);
+      const value = serializeSchema(schema);
+      await guard.send({ key, value, expected: null }, () => client.put(key).value(value).exec());
+    },
+    async dropSchema(indexName) {
+      assertNotShutdown();
+      await client.delete().key(keys.schema(indexName)).exec();
+    },
+    async listSchemas() {
+      assertNotShutdown();
+      const prefix = keys.schemaPrefix();
+      const result = await client.getAll().prefix(prefix).keys();
+      return result.map((fullKey) => extractSuffix(fullKey, prefix)).sort(compareCodePoints);
+    },
+    async watchSchemas(handler) {
+      assertNotShutdown();
+      const prefix = keys.schemaPrefix();
+      const watcher = await client.watch().prefix(prefix).create();
+      addWatcher(watcher);
+      watcher.on("put", (kv) => {
+        try {
+          const schema = deserializeSchema(kv.value);
+          const fullKey = kv.key.toString();
+          const indexName = extractSuffix(fullKey, prefix);
+          handler({ type: "schema_created", indexName, schema });
+        } catch (_) {
+        }
+      });
+      watcher.on("delete", (kv) => {
+        const fullKey = kv.key.toString();
+        const indexName = extractSuffix(fullKey, prefix);
+        handler({ type: "schema_dropped", indexName, schema: null });
+      });
+      return () => removeWatcher(watcher);
+    }
+  };
+}
+
 // src/distribution/coordinator/etcd/validation.ts
 var VALID_PARTITION_STATES = /* @__PURE__ */ new Set(["UNASSIGNED", "INITIALISING", "ACTIVE", "MIGRATING", "DECOMMISSIONING"]);
 function validateNodeId(nodeId) {
@@ -274,8 +415,13 @@ async function createEtcdCoordinator(config) {
     ...DEFAULT_ETCD_CONFIG,
     ...config
   };
+  requireEtcdMaxRequestBytes(resolvedConfig.maxRequestBytes);
   const etcd3Module = await loadEtcd3Module();
-  const client = new etcd3Module.Etcd3({ hosts: resolvedConfig.endpoints });
+  const client = new etcd3Module.Etcd3({
+    hosts: resolvedConfig.endpoints,
+    grpcOptions: { "grpc.max_receive_message_length": ETCD_MAX_RESPONSE_BYTES }
+  });
+  const guard = createEtcdWriteGuard(etcd3Module, resolvedConfig.maxRequestBytes);
   const leaseManager = new LeaseManager();
   const watchers = /* @__PURE__ */ new Set();
   let isShutdown = false;
@@ -308,6 +454,7 @@ async function createEtcdCoordinator(config) {
         {
           client,
           leaseManager,
+          guard,
           key: keys.node(registration.nodeId),
           ttlSeconds: resolvedConfig.nodeHeartbeatTtlSeconds
         },
@@ -370,13 +517,16 @@ async function createEtcdCoordinator(config) {
       assertNotShutdown();
       const key = keys.allocation(indexName);
       const data = Buffer.from(serializeAllocationTable(table));
+      const write = { key, value: data, expected: null };
       if (expectedVersion === void 0) {
-        await client.put(key).value(data).exec();
+        await guard.send(write, () => client.put(key).value(data).exec());
         return true;
       }
       if (expectedVersion === null) {
-        const txn2 = await client.if(key, "Create", "==", 0).then(client.put(key).value(data)).commit();
-        return txn2.succeeded;
+        return guard.send(write, async () => {
+          const txn = await client.if(key, "Create", "==", 0).then(client.put(key).value(data)).commit();
+          return txn.succeeded;
+        });
       }
       const response = await client.get(key).exec();
       if (response.kvs.length === 0) {
@@ -387,8 +537,10 @@ async function createEtcdCoordinator(config) {
       if (currentTable.version !== expectedVersion) {
         return false;
       }
-      const txn = await client.if(key, "Mod", "==", kv.mod_revision).then(client.put(key).value(data)).commit();
-      return txn.succeeded;
+      return guard.send(write, async () => {
+        const txn = await client.if(key, "Mod", "==", kv.mod_revision).then(client.put(key).value(data)).commit();
+        return txn.succeeded;
+      });
     },
     async deleteAllocation(indexName) {
       assertNotShutdown();
@@ -472,72 +624,7 @@ async function createEtcdCoordinator(config) {
       await entry.lease.revoke().catch(() => {
       });
     },
-    async get(key) {
-      assertNotShutdown();
-      const etcdKey = keys.generic(key);
-      const buf = await client.get(etcdKey).buffer();
-      if (buf === null) {
-        return null;
-      }
-      return new Uint8Array(buf);
-    },
-    async compareAndSet(key, expected, value) {
-      assertNotShutdown();
-      const etcdKey = keys.generic(key);
-      const newValue = Buffer.from(value);
-      if (expected === null) {
-        const txn2 = await client.if(etcdKey, "Create", "==", 0).then(client.put(etcdKey).value(newValue)).commit();
-        return txn2.succeeded;
-      }
-      const expectedBuf = Buffer.from(expected);
-      const txn = await client.if(etcdKey, "Value", "==", expectedBuf).then(client.put(etcdKey).value(newValue)).commit();
-      return txn.succeeded;
-    },
-    async getSchema(indexName) {
-      assertNotShutdown();
-      const key = keys.schema(indexName);
-      const buf = await client.get(key).buffer();
-      if (buf === null) {
-        return null;
-      }
-      return deserializeSchema(buf);
-    },
-    async putSchema(indexName, schema) {
-      assertNotShutdown();
-      const key = keys.schema(indexName);
-      await client.put(key).value(serializeSchema(schema)).exec();
-    },
-    async dropSchema(indexName) {
-      assertNotShutdown();
-      await client.delete().key(keys.schema(indexName)).exec();
-    },
-    async listSchemas() {
-      assertNotShutdown();
-      const prefix = keys.schemaPrefix();
-      const result = await client.getAll().prefix(prefix).keys();
-      return result.map((fullKey) => extractSuffix(fullKey, prefix)).sort(compareCodePoints);
-    },
-    async watchSchemas(handler) {
-      assertNotShutdown();
-      const prefix = keys.schemaPrefix();
-      const watcher = await client.watch().prefix(prefix).create();
-      addWatcher(watcher);
-      watcher.on("put", (kv) => {
-        try {
-          const schema = deserializeSchema(kv.value);
-          const fullKey = kv.key.toString();
-          const indexName = extractSuffix(fullKey, prefix);
-          handler({ type: "schema_created", indexName, schema });
-        } catch (_) {
-        }
-      });
-      watcher.on("delete", (kv) => {
-        const fullKey = kv.key.toString();
-        const indexName = extractSuffix(fullKey, prefix);
-        handler({ type: "schema_dropped", indexName, schema: null });
-      });
-      return () => removeWatcher(watcher);
-    },
+    ...storedValueMethods({ client, keys, guard, assertNotShutdown, addWatcher, removeWatcher }),
     async getLeaseHolder(key) {
       assertNotShutdown();
       const etcdKey = keys.lease(key);

package/dist/distribution/transport/grpc.d.ts

@@ -1,5 +1,5 @@
-import { T as TransportConfig, N as NodeTransport } from '../../types-D5OwhtsQ.js';
-import { a as TlsConfig } from '../../types-BQDlIvfS.js';
+import { T as TransportConfig, N as NodeTransport } from '../../types-Cb9kiY5P.js';
+import { a as TlsConfig } from '../../types-B3b68nfF.js';
 
 /**
  * How the gRPC transport listens and dials.

package/dist/distribution/transport/grpc.mjs

@@ -1,7 +1,7 @@
 import { decodeTransportMessage, encodeTransportMessage } from '../../chunk-OOSIDHA3.mjs';
 import { MAX_MESSAGE_SIZE_BYTES, GRPC_KEEPALIVE_TIMEOUT_MS, GRPC_KEEPALIVE_TIME_MS, GRPC_ENVELOPE_OVERHEAD_BYTES } from '../../chunk-UNEEFTEU.mjs';
 import { TransportError, TransportErrorCodes } from '../../chunk-GCM3JFVA.mjs';
-import { NarsilError, ErrorCodes } from '../../chunk-RV77FR2F.mjs';
+import { NarsilError, ErrorCodes } from '../../chunk-I64LXKO3.mjs';
 
 // src/distribution/transport/grpc/codec.ts
 var FIELD_ONE_LENGTH_DELIMITED_KEY = 10;
@@ -170,17 +170,37 @@ var GrpcClientPool = class {
       openStreamMethod.responseDeserialize,
       messageBytes,
       this.metadata(),
-      this.callOptions(this.config.snapshotTimeout)
+      {}
     );
     return new Promise((resolve, reject) => {
       let settled = false;
+      const timeoutMs = this.config.snapshotTimeout;
+      let idleTimer = null;
       const settle = (fn) => {
+        if (idleTimer !== null) clearTimeout(idleTimer);
         if (!settled) {
           settled = true;
           fn();
         }
       };
+      const rearm = () => {
+        if (idleTimer !== null) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          call.cancel();
+          settle(
+            () => reject(
+              new TransportError(
+                TransportErrorCodes.TIMEOUT,
+                `No chunk of the stream from '${target}' arrived within ${timeoutMs}ms`,
+                { target, requestId: message.requestId, timeoutMs }
+              )
+            )
+          );
+        }, timeoutMs);
+      };
+      rearm();
       call.on("data", (chunk) => {
+        rearm();
         try {
           handler(chunk);
         } catch (err) {

package/dist/distribution/transport/in-memory.d.ts

@@ -1,5 +1,5 @@
-import { N as NodeTransport, a as TransportMessage, R as RespondFn, T as TransportConfig } from '../../types-D5OwhtsQ.js';
-export { L as ListenHandler } from '../../types-D5OwhtsQ.js';
+import { N as NodeTransport, a as TransportMessage, R as RespondFn, T as TransportConfig } from '../../types-Cb9kiY5P.js';
+export { L as ListenHandler } from '../../types-Cb9kiY5P.js';
 
 /**
  * Receives a streamed response one chunk at a time.

package/dist/distribution/transport/in-memory.mjs

@@ -133,18 +133,19 @@ function createInMemoryTransport(nodeId, network, config) {
       const peer = lookupPeer(target);
       return new Promise((resolve, reject) => {
         let settled = false;
-        const timeoutId = setTimeout(() => {
+        const expire = () => {
           if (!settled) {
             settled = true;
             reject(
               new TransportError(
                 TransportErrorCodes.TIMEOUT,
-                `Stream to node '${target}' timed out after ${resolvedConfig.snapshotTimeout}ms`,
+                `No chunk of the stream from node '${target}' arrived within ${resolvedConfig.snapshotTimeout}ms`,
                 { target, requestId: message.requestId, timeoutMs: resolvedConfig.snapshotTimeout }
               )
             );
           }
-        }, resolvedConfig.snapshotTimeout);
+        };
+        let timeoutId = setTimeout(expire, resolvedConfig.snapshotTimeout);
         const settle = (action) => {
           if (settled) {
             return;
@@ -158,6 +159,8 @@ function createInMemoryTransport(nodeId, network, config) {
             if (settled) {
               return Promise.resolve();
             }
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(expire, resolvedConfig.snapshotTimeout);
             try {
               handler(payload);
             } catch (error) {

package/dist/distribution/transport/tcp.d.ts

@@ -1,5 +1,5 @@
-import { N as NodeTransport } from '../../types-D5OwhtsQ.js';
-import { T as TcpTransportConfig, a as TlsConfig } from '../../types-BQDlIvfS.js';
+import { N as NodeTransport } from '../../types-Cb9kiY5P.js';
+import { T as TcpTransportConfig, a as TlsConfig } from '../../types-B3b68nfF.js';
 
 /**
  * Builds the TCP transport a cluster node reaches its peers through, with

package/dist/distribution/transport/tcp.mjs

@@ -24,6 +24,33 @@ function parseAddress(address) {
   return [host, port];
 }
 
+// src/distribution/transport/tcp/pending-stream.ts
+function createPendingStream(input) {
+  const { target, requestId, timeoutMs, reject } = input;
+  const expire = () => {
+    input.forget();
+    reject(
+      new TransportError(
+        TransportErrorCodes.TIMEOUT,
+        `No chunk of the stream from '${target}' arrived within ${timeoutMs}ms`,
+        { target, requestId, timeoutMs }
+      )
+    );
+  };
+  const pending = {
+    target,
+    handler: input.handler,
+    resolve: input.resolve,
+    reject,
+    timer: setTimeout(expire, timeoutMs),
+    rearm: () => {
+      clearTimeout(pending.timer);
+      pending.timer = setTimeout(expire, timeoutMs);
+    }
+  };
+  return pending;
+}
+
 // src/distribution/transport/tcp/connection.ts
 var TcpConnectionPool = class {
   connections = /* @__PURE__ */ new Map();
@@ -95,24 +122,19 @@ var TcpConnectionPool = class {
     const frame = encodeFrame(FRAME_TYPE_REQUEST, message.requestId, messageBytes);
     const pendingKey = `${target}:${message.requestId}`;
     return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pendingStreams.delete(pendingKey);
-        reject(
-          new TransportError(
-            TransportErrorCodes.TIMEOUT,
-            `Stream to '${target}' timed out after ${this.config.snapshotTimeout}ms`,
-            {
-              target,
-              requestId: message.requestId,
-              timeoutMs: this.config.snapshotTimeout
-            }
-          )
-        );
-      }, this.config.snapshotTimeout);
-      this.pendingStreams.set(pendingKey, { target, handler, resolve, reject, timer });
+      const pending = createPendingStream({
+        target,
+        requestId: message.requestId,
+        timeoutMs: this.config.snapshotTimeout,
+        handler,
+        resolve,
+        reject,
+        forget: () => this.pendingStreams.delete(pendingKey)
+      });
+      this.pendingStreams.set(pendingKey, pending);
       socket.write(frame, (err) => {
         if (err) {
-          clearTimeout(timer);
+          clearTimeout(pending.timer);
           this.pendingStreams.delete(pendingKey);
           reject(
             new TransportError(
@@ -239,6 +261,7 @@ var TcpConnectionPool = class {
       }
       const pendingStream = this.pendingStreams.get(pendingKey);
       if (pendingStream !== void 0) {
+        pendingStream.rearm();
         try {
           const message = decodeTransportMessage(frame.data);
           pendingStream.handler(message.payload);
@@ -259,6 +282,7 @@ var TcpConnectionPool = class {
     if (frame.frameType === FRAME_TYPE_STREAM_CHUNK) {
       const pending = this.pendingStreams.get(pendingKey);
       if (pending !== void 0) {
+        pending.rearm();
         pending.handler(frame.data);
       }
       return;

package/dist/distribution.d.ts

@@ -1,12 +1,12 @@
-import { a as CreateIndexOptions, C as ClusterNamespace, b as ClusterNodeConfig } from './config-BLguB-om.js';
-export { c as ClusterControllerConfig, d as ClusterNodeInfo, e as ClusterQueryConfig, N as NodeReadiness, R as ReplicationConfig } from './config-BLguB-om.js';
-import { N as NarsilEventMap, a as Narsil } from './engine-Dm4446j1.js';
-import { B as BatchResult, L as ListParams, g as ListResult, j as SuggestParams, k as SuggestResult, Q as QueryParams, h as PreflightResult, f as IndexStats, P as PartitionStatsResult, M as MemoryStats, e as QueryResult } from './memory-CKHTU1CL.js';
+import { a as CreateIndexOptions, C as ClusterNamespace, b as ClusterNodeConfig } from './config-Bv8etwUZ.js';
+export { c as ClusterControllerConfig, d as ClusterNodeInfo, e as ClusterQueryConfig, N as NodeReadiness, R as ReplicationConfig } from './config-Bv8etwUZ.js';
+import { B as BatchResult, L as ListParams, h as ListResult, k as SuggestParams, l as SuggestResult, Q as QueryParams, j as PreflightResult, g as IndexStats, P as PartitionStatsResult, M as MemoryStats, m as NarsilEventMap, e as QueryResult } from './memory-B4jMmygw.js';
 import { I as IndexConfig, A as AnyDocument, a as InsertOptions } from './schema-BBOCdhND.js';
 import { b as NodeCapacity, N as NodeRole } from './types-BiUmaiWT.js';
 export { c as AllocationConstraints, d as AllocationEvent, A as AllocationTable, C as ClusterCoordinator, e as NodeEvent, a as NodeRegistration, P as PartitionAssignment, f as PartitionState, S as SchemaEvent, U as UnassignedReason } from './types-BiUmaiWT.js';
-export { L as ListenHandler, N as NodeTransport, R as RespondFn, T as TransportConfig, a as TransportMessage } from './types-D5OwhtsQ.js';
-import './config-C7Ip8Ife.js';
+import { N as Narsil } from './engine-D_OzKZ-6.js';
+export { L as ListenHandler, N as NodeTransport, R as RespondFn, T as TransportConfig, a as TransportMessage } from './types-Cb9kiY5P.js';
+import './config-QXU3HMpq.js';
 import './adapters-79OIa4xm.js';
 
 /**