@optimystic/db-p2p 0.1.1 → 0.1.3

package/src/cluster/service.ts

@@ -1,17 +1,13 @@
 import { pipe } from 'it-pipe';
 import { decode as lpDecode, encode as lpEncode } from 'it-length-prefixed';
-import type { Startable, Logger, IncomingStreamData } from '@libp2p/interface';
+import type { Startable, Logger, Stream, Connection, StreamHandler } from '@libp2p/interface';
 import type { ICluster, ClusterRecord } from '@optimystic/db-core';
-import { computeResponsibility } from '../routing/responsibility.js'
-import { peersEqual } from '../peer-utils.js'
-import { buildKnownPeers } from '../routing/libp2p-known-peers.js'
-import { encodePeers } from '../repo/redirect.js'
 import type { Uint8ArrayList } from 'uint8arraylist';
 
 interface BaseComponents {
 	logger: { forComponent: (name: string) => Logger },
 	registrar: {
-		handle: (protocol: string, handler: (data: IncomingStreamData) => void, options: any) => Promise<void>,
+		handle: (protocol: string, handler: StreamHandler, options: any) => Promise<void>,
 		unhandle: (protocol: string) => Promise<void>
 	}
 }
@@ -26,10 +22,19 @@ export interface ClusterServiceInit {
 	maxInboundStreams?: number,
 	maxOutboundStreams?: number,
 	logPrefix?: string,
-  kBucketSize?: number,
-  configuredClusterSize?: number,
-  allowClusterDownsize?: boolean,
-  clusterSizeTolerance?: number,
+	kBucketSize?: number,
+	configuredClusterSize?: number,
+	allowClusterDownsize?: boolean,
+	clusterSizeTolerance?: number,
+	/**
+	 * Responsibility K - the replica set size for determining cluster membership.
+	 * This is distinct from kBucketSize (DHT routing) and configuredClusterSize (consensus quorum).
+	 * When set, this determines how many peers (by XOR distance) are considered
+	 * responsible for a key. If this node is not in the top responsibilityK peers,
+	 * it will redirect requests to closer peers.
+	 * Default: 1 (only the closest peer handles requests)
+	 */
+	responsibilityK?: number,
 }
 
 export function clusterService(init: ClusterServiceInit = {}): (components: ClusterServiceComponents) => ClusterService {
@@ -47,10 +52,12 @@ export class ClusterService implements Startable {
 	private readonly cluster: ICluster;
 	private readonly components: ClusterServiceComponents;
 	private running: boolean;
-  private readonly k: number;
-  private readonly configuredClusterSize: number;
-  private readonly allowDownsize: boolean;
-  private readonly sizeTolerance: number;
+	private readonly k: number;
+	private readonly configuredClusterSize: number;
+	private readonly allowDownsize: boolean;
+	private readonly sizeTolerance: number;
+	/** Responsibility K - how many peers are responsible for a key (for redirect decisions) */
+	private readonly responsibilityK: number;
 
 	constructor(components: ClusterServiceComponents, init: ClusterServiceInit = {}) {
 		this.components = components;
@@ -60,10 +67,11 @@ export class ClusterService implements Startable {
 		this.log = components.logger.forComponent(init.logPrefix ?? 'db-p2p:cluster');
 		this.cluster = components.cluster;
 		this.running = false;
-    this.k = init.kBucketSize ?? 10;
-    this.configuredClusterSize = init.configuredClusterSize ?? 10;
-    this.allowDownsize = init.allowClusterDownsize ?? true;
-    this.sizeTolerance = init.clusterSizeTolerance ?? 0.5;
+		this.k = init.kBucketSize ?? 10;
+		this.configuredClusterSize = init.configuredClusterSize ?? 10;
+		this.allowDownsize = init.allowClusterDownsize ?? true;
+		this.sizeTolerance = init.clusterSizeTolerance ?? 0.5;
+		this.responsibilityK = init.responsibilityK ?? 1;
 	}
 
 	readonly [Symbol.toStringTag] = '@libp2p/cluster';
@@ -90,8 +98,7 @@ export class ClusterService implements Startable {
 		this.running = false;
 	}
 
-	private handleIncomingStream(data: IncomingStreamData): void {
-		const { stream, connection } = data;
+	private handleIncomingStream(stream: Stream, connection: Connection): void {
 		const peerId = connection.remotePeer;
 
 		const processStream = async function* (this: ClusterService, source: AsyncIterable<Uint8ArrayList>) {
@@ -141,16 +148,22 @@ export class ClusterService implements Startable {
 			}
 		};
 
-		Promise.resolve().then(async () => {
-			await pipe(
-				stream,
-				(source) => lpDecode(source),
-				processStream.bind(this),
-				(source) => lpEncode(source),
-				stream
-			);
-		}).catch((err: Error) => {
-			this.log.error('error handling cluster protocol message from %p - %e', peerId, err);
-		});
+		void (async () => {
+			try {
+				const responses = pipe(
+					stream,
+					(source) => lpDecode(source),
+					processStream.bind(this),
+					(source) => lpEncode(source)
+				);
+				for await (const chunk of responses) {
+					stream.send(chunk);
+				}
+				await stream.close();
+			} catch (err) {
+				this.log.error('error handling cluster protocol message from %p - %e', peerId, err);
+				stream.abort(err instanceof Error ? err : new Error(String(err)));
+			}
+		})();
 	}
 }

package/src/index.ts

@@ -7,10 +7,10 @@ export * from "./repo/cluster-coordinator.js";
 export * from "./repo/coordinator-repo.js";
 export * from "./repo/service.js";
 export * from "./storage/block-storage.js";
-export * from "./storage/file-storage.js";
 export * from "./storage/memory-storage.js";
 export * from "./storage/i-block-storage.js";
 export * from "./storage/i-raw-storage.js";
+export * from "./storage/struct.js";
 export * from "./storage/storage-repo.js";
 export * from "./storage/restoration-coordinator-v2.js";
 export * from "./storage/ring-selector.js";