@delali/narsil 0.2.2 → 0.2.3-next.33

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

@@ -1 +1,286 @@
-export { createInMemoryCoordinator } from '../../chunk-RQLXC2YS.mjs';
+import { compareCodePoints } from '../../chunk-BFIH7OV5.mjs';
+
+// src/distribution/coordinator/in-memory.ts
+var NODE_HEARTBEAT_PREFIX = "_narsil/node/";
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function createInMemoryCoordinator() {
+  const nodes = /* @__PURE__ */ new Map();
+  const allocations = /* @__PURE__ */ new Map();
+  const partitionStates = /* @__PURE__ */ new Map();
+  const leases = /* @__PURE__ */ new Map();
+  const schemas = /* @__PURE__ */ new Map();
+  const kvStore = /* @__PURE__ */ new Map();
+  const nodeWatchers = /* @__PURE__ */ new Set();
+  const allocationWatchers = /* @__PURE__ */ new Set();
+  const schemaWatchers = /* @__PURE__ */ new Set();
+  let isShutdown = false;
+  function assertNotShutdown() {
+    if (isShutdown) {
+      throw new Error("Coordinator has been shut down");
+    }
+  }
+  function emitNodeEvent(event) {
+    for (const handler of nodeWatchers) {
+      try {
+        handler(event);
+      } catch (_) {
+      }
+    }
+  }
+  function emitAllocationEvent(event) {
+    for (const handler of allocationWatchers) {
+      try {
+        handler(event);
+      } catch (_) {
+      }
+    }
+  }
+  function emitSchemaEvent(event) {
+    for (const handler of schemaWatchers) {
+      try {
+        handler(event);
+      } catch (_) {
+      }
+    }
+  }
+  function clearLeaseEntry(key) {
+    const entry = leases.get(key);
+    if (entry !== void 0) {
+      clearTimeout(entry.timer);
+      leases.delete(key);
+    }
+  }
+  function createLeaseTimer(key, ttlMs) {
+    return setTimeout(() => {
+      leases.delete(key);
+      if (key.startsWith(NODE_HEARTBEAT_PREFIX)) {
+        const expiredNodeId = key.slice(NODE_HEARTBEAT_PREFIX.length);
+        nodes.delete(expiredNodeId);
+        emitNodeEvent({ type: "node_left", nodeId: expiredNodeId, registration: null });
+      }
+    }, ttlMs);
+  }
+  function isLeaseValid(key) {
+    const entry = leases.get(key);
+    if (entry === void 0) {
+      return false;
+    }
+    return entry.expiresAt > Date.now();
+  }
+  const coordinator = {
+    async registerNode(registration) {
+      assertNotShutdown();
+      nodes.set(registration.nodeId, registration);
+      const heartbeatKey = `${NODE_HEARTBEAT_PREFIX}${registration.nodeId}`;
+      const defaultTtlMs = 3e4;
+      clearLeaseEntry(heartbeatKey);
+      const timer = createLeaseTimer(heartbeatKey, defaultTtlMs);
+      leases.set(heartbeatKey, {
+        nodeId: registration.nodeId,
+        expiresAt: Date.now() + defaultTtlMs,
+        timer
+      });
+      emitNodeEvent({ type: "node_joined", nodeId: registration.nodeId, registration });
+    },
+    async deregisterNode(nodeId) {
+      assertNotShutdown();
+      const existed = nodes.delete(nodeId);
+      const heartbeatKey = `${NODE_HEARTBEAT_PREFIX}${nodeId}`;
+      clearLeaseEntry(heartbeatKey);
+      if (existed) {
+        emitNodeEvent({ type: "node_left", nodeId, registration: null });
+      }
+    },
+    async listNodes() {
+      assertNotShutdown();
+      return Array.from(nodes.values());
+    },
+    async watchNodes(handler) {
+      assertNotShutdown();
+      nodeWatchers.add(handler);
+      return () => {
+        nodeWatchers.delete(handler);
+      };
+    },
+    async getAllocation(indexName) {
+      assertNotShutdown();
+      return allocations.get(indexName) ?? null;
+    },
+    async putAllocation(indexName, table, expectedVersion) {
+      assertNotShutdown();
+      if (expectedVersion !== void 0) {
+        const current = allocations.get(indexName);
+        if (expectedVersion === null) {
+          if (current !== void 0) {
+            return false;
+          }
+        } else {
+          if (current === void 0 || current.version !== expectedVersion) {
+            return false;
+          }
+        }
+      }
+      allocations.set(indexName, table);
+      emitAllocationEvent({ indexName, table });
+      return true;
+    },
+    async deleteAllocation(indexName) {
+      assertNotShutdown();
+      allocations.delete(indexName);
+    },
+    async watchAllocation(handler) {
+      assertNotShutdown();
+      allocationWatchers.add(handler);
+      return () => {
+        allocationWatchers.delete(handler);
+      };
+    },
+    async getPartitionState(indexName, partitionId) {
+      assertNotShutdown();
+      const indexStates = partitionStates.get(indexName);
+      if (indexStates === void 0) {
+        return "UNASSIGNED";
+      }
+      return indexStates.get(partitionId) ?? "UNASSIGNED";
+    },
+    async putPartitionState(indexName, partitionId, state) {
+      assertNotShutdown();
+      let indexStates = partitionStates.get(indexName);
+      if (indexStates === void 0) {
+        indexStates = /* @__PURE__ */ new Map();
+        partitionStates.set(indexName, indexStates);
+      }
+      indexStates.set(partitionId, state);
+    },
+    async acquireLease(key, nodeId, ttlMs) {
+      assertNotShutdown();
+      if (isLeaseValid(key)) {
+        const entry = leases.get(key);
+        if (entry !== void 0 && entry.nodeId !== nodeId) {
+          return false;
+        }
+        if (entry !== void 0 && entry.nodeId === nodeId) {
+          clearTimeout(entry.timer);
+          const timer2 = createLeaseTimer(key, ttlMs);
+          entry.expiresAt = Date.now() + ttlMs;
+          entry.timer = timer2;
+          return true;
+        }
+      }
+      clearLeaseEntry(key);
+      const timer = createLeaseTimer(key, ttlMs);
+      leases.set(key, { nodeId, expiresAt: Date.now() + ttlMs, timer });
+      return true;
+    },
+    async renewLease(key, nodeId, ttlMs) {
+      assertNotShutdown();
+      const entry = leases.get(key);
+      if (entry === void 0 || entry.nodeId !== nodeId) {
+        return false;
+      }
+      if (!isLeaseValid(key)) {
+        leases.delete(key);
+        return false;
+      }
+      clearTimeout(entry.timer);
+      entry.timer = createLeaseTimer(key, ttlMs);
+      entry.expiresAt = Date.now() + ttlMs;
+      return true;
+    },
+    async releaseLease(key) {
+      assertNotShutdown();
+      clearLeaseEntry(key);
+    },
+    async get(key) {
+      assertNotShutdown();
+      const value = kvStore.get(key);
+      return value !== void 0 ? new Uint8Array(value) : null;
+    },
+    async compareAndSet(key, expected, value) {
+      assertNotShutdown();
+      const current = kvStore.get(key);
+      if (expected === null) {
+        if (current !== void 0) {
+          return false;
+        }
+        kvStore.set(key, new Uint8Array(value));
+        return true;
+      }
+      if (current === void 0) {
+        return false;
+      }
+      if (!bytesEqual(current, expected)) {
+        return false;
+      }
+      kvStore.set(key, new Uint8Array(value));
+      return true;
+    },
+    async getSchema(indexName) {
+      assertNotShutdown();
+      return schemas.get(indexName) ?? null;
+    },
+    async putSchema(indexName, schema) {
+      assertNotShutdown();
+      schemas.set(indexName, schema);
+      emitSchemaEvent({ type: "schema_created", indexName, schema });
+    },
+    async dropSchema(indexName) {
+      assertNotShutdown();
+      if (!schemas.delete(indexName)) {
+        return;
+      }
+      emitSchemaEvent({ type: "schema_dropped", indexName, schema: null });
+    },
+    async listSchemas() {
+      assertNotShutdown();
+      return Array.from(schemas.keys()).sort(compareCodePoints);
+    },
+    async watchSchemas(handler) {
+      assertNotShutdown();
+      schemaWatchers.add(handler);
+      return () => {
+        schemaWatchers.delete(handler);
+      };
+    },
+    async getLeaseHolder(key) {
+      assertNotShutdown();
+      if (!isLeaseValid(key)) {
+        clearLeaseEntry(key);
+        return null;
+      }
+      const entry = leases.get(key);
+      return entry?.nodeId ?? null;
+    },
+    async shutdown() {
+      if (isShutdown) {
+        return;
+      }
+      isShutdown = true;
+      for (const entry of leases.values()) {
+        clearTimeout(entry.timer);
+      }
+      leases.clear();
+      nodes.clear();
+      allocations.clear();
+      partitionStates.clear();
+      schemas.clear();
+      kvStore.clear();
+      nodeWatchers.clear();
+      allocationWatchers.clear();
+      schemaWatchers.clear();
+    }
+  };
+  return coordinator;
+}
+
+export { createInMemoryCoordinator };

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

@@ -0,0 +1,45 @@
+import { T as TransportConfig, N as NodeTransport } from '../../types-D5OwhtsQ.js';
+import { a as TlsConfig } from '../../types-BQDlIvfS.js';
+
+/**
+ * How the gRPC transport listens and dials.
+ *
+ * @public
+ */
+interface GrpcTransportConfig extends TransportConfig {
+    /** The transport listens on this host. */
+    host: string;
+    /** The transport listens on this port, and 0 asks the system for a free one. */
+    port: number;
+    /** Presenting this makes every connection mutually authenticated TLS. */
+    tls?: TlsConfig;
+}
+
+/**
+ * Builds the gRPC transport a cluster node reaches its peers through,
+ * implementing the `narsil.transport.v1.NodeTransport` service from the
+ * cross-language specification.
+ *
+ * Each call carries one MessagePack-serialised message in a protobuf
+ * envelope, so a node written in another language can join the same cluster
+ * through its own gRPC stack. The transport listens on `config.host` and
+ * `config.port`, and it dials a peer at the `host:port` address that peer
+ * registered with the coordinator. Passing `config.tls` makes every
+ * connection mutually authenticated: the server requires a client
+ * certificate and both sides verify against the configured authority.
+ *
+ * The `@grpc/grpc-js` package is an optional peer dependency, and calling
+ * this without it installed throws a `NarsilError` with the code
+ * `TRANSPORT_DEPENDENCY_MISSING`.
+ *
+ * @param nodeId - The node this transport belongs to, used in error reports.
+ * @param config - The listen address, the timeouts, and the TLS material.
+ * @returns The transport, with `getPort` for reading the bound port.
+ *
+ * @public
+ */
+declare function createGrpcTransport(nodeId: string, config?: Partial<GrpcTransportConfig>): Promise<NodeTransport & {
+    getPort(): number;
+}>;
+
+export { type GrpcTransportConfig, TlsConfig, createGrpcTransport };