@peerbit/shared-log 13.2.24 → 13.2.25

package/src/sync/rateless-iblt.ts

@@ -25,6 +25,11 @@ import { SilentDelivery } from "@peerbit/stream-interface";
 import { type EntryWithRefs } from "../exchange-heads.js";
 import { TransportMessage } from "../message.js";
 import { type EntryReplicated } from "../ranges.js";
+import {
+	DispatchLifecycleRegistry,
+	isOwnershipGenerationActive,
+	isTrackedSessionActive,
+} from "./dispatch-lifecycle.js";
 import type {
 	HashSymbolRangeResolver,
 	RepairSession,
@@ -47,6 +52,10 @@ import {
 	SYNC_MESSAGE_PRIORITY,
 	SimpleSyncronizer,
 } from "./simple.js";
+import {
+	SyncPeerSlotRegistry,
+	type SyncPeerSlotRow,
+} from "./sync-peer-state.js";
 
 export const logger = loggerFn("peerbit:shared-log:rateless");
 
@@ -847,12 +856,19 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 	outgoingSyncProcesses: Map<string, OutgoingRatelessSyncProcess>;
 	private outgoingSyncProcessByTarget: Map<string, OutgoingRatelessSyncProcess>;
 	private ratelessDispatchLifecycleController: AbortController;
-	private ratelessDispatchTargets: Map<
-		string,
-		Set<RatelessDispatchTargetLifecycle>
+	private readonly ratelessDispatchRegistry: DispatchLifecycleRegistry<
+		RatelessDispatchLifecycle,
+		RatelessDispatchTargetLifecycle
 	>;
+
 	private activeRatelessResponseCount: number;
 	private activeRatelessResponseCountByPeer: Map<string, number>;
+	// Per-peer slot rows for active rateless responses (shared registry; see
+	// sync-peer-state.ts for the lifetime policy). Release closures capture
+	// the row: disconnect returns current-generation quota and logical
+	// ownership immediately, while the global physical permit remains charged
+	// until the shipment actually settles.
+	private readonly ratelessPeerSlotRows: SyncPeerSlotRegistry;
 	private ratelessClosed: boolean;
 
 	constructor(readonly properties: SynchronizerComponents<D>) {
@@ -862,9 +878,27 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 		this.outgoingSyncProcesses = new Map();
 		this.outgoingSyncProcessByTarget = new Map();
 		this.ratelessDispatchLifecycleController = new AbortController();
-		this.ratelessDispatchTargets = new Map();
+		this.ratelessDispatchRegistry = new DispatchLifecycleRegistry<
+			RatelessDispatchLifecycle,
+			RatelessDispatchTargetLifecycle
+		>({
+			isClosed: () => this.ratelessClosed,
+			currentOwnershipLifecycleController: () =>
+				this.ratelessDispatchLifecycleController,
+			hasRetainedWork: (lifecycle) =>
+				[...lifecycle.targets.values()].some(
+					(target) => target.retainedByProcess || target.responseLeases > 0,
+				),
+			// Target-activity strategy: set membership in the active-target
+			// registry (rateless target lifecycles carry no epochs).
+			isTargetCurrent: (targetLifecycle) =>
+				this.ratelessDispatchRegistry.activeTargets
+					.get(targetLifecycle.target)
+					?.has(targetLifecycle) === true,
+		});
 		this.activeRatelessResponseCount = 0;
 		this.activeRatelessResponseCountByPeer = new Map();
+		this.ratelessPeerSlotRows = new SyncPeerSlotRegistry();
 		this.ratelessClosed = false;
 		this.ingoingSyncProcesses = new Map();
 		this.incomingRatelessProcessAdmissions = new Set();
@@ -917,15 +951,16 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 	private isRatelessRepairSessionActive(
 		session: RatelessRepairSessionLifecycle,
 	): boolean {
-		return (
-			!this.ratelessClosed &&
-			!session.cancelled &&
-			!session.controller.signal.aborted &&
-			!session.ownershipLifecycleController.signal.aborted &&
-			session.ownershipLifecycleController ===
-				this.ratelessDispatchLifecycleController &&
-			this.ratelessRepairSessions.get(session.id) === session
-		);
+		return isTrackedSessionActive({
+			closed: this.ratelessClosed,
+			cancelled: session.cancelled,
+			sessionController: session.controller,
+			ownershipLifecycleController: session.ownershipLifecycleController,
+			currentOwnershipLifecycleController:
+				this.ratelessDispatchLifecycleController,
+			session,
+			registered: this.ratelessRepairSessions.get(session.id),
+		});
 	}
 
 	private cancelRatelessRepairSession(
@@ -1409,42 +1444,17 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			disposed: false,
 		} satisfies RatelessDispatchLifecycle;
 
-		for (const target of [...new Set(targets)]) {
-			const targetLifecycle: RatelessDispatchTargetLifecycle = {
-				lifecycle,
+		this.ratelessDispatchRegistry.register(
+			lifecycle,
+			targets,
+			(forLifecycle, target) => ({
+				lifecycle: forLifecycle,
 				target,
 				controller: new AbortController(),
 				retainedByProcess: false,
 				responseLeases: 0,
-			};
-			lifecycle.targets.set(target, targetLifecycle);
-			let activeForTarget = this.ratelessDispatchTargets.get(target);
-			if (!activeForTarget) {
-				activeForTarget = new Set();
-				this.ratelessDispatchTargets.set(target, activeForTarget);
-			}
-			activeForTarget.add(targetLifecycle);
-		}
-
-		ownershipLifecycleController.signal.addEventListener(
-			"abort",
-			lifecycle.onOwnerOrCallerAbort,
-			{ once: true },
+			}),
 		);
-		if (callerSignal && callerSignal !== ownershipLifecycleController.signal) {
-			callerSignal.addEventListener("abort", lifecycle.onOwnerOrCallerAbort, {
-				once: true,
-			});
-		}
-		if (
-			this.ratelessClosed ||
-			ownershipLifecycleController !==
-				this.ratelessDispatchLifecycleController ||
-			ownershipLifecycleController.signal.aborted ||
-			callerSignal?.aborted
-		) {
-			lifecycle.onOwnerOrCallerAbort();
-		}
 		return lifecycle;
 	}
 
@@ -1452,93 +1462,33 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 		targetLifecycle: RatelessDispatchTargetLifecycle,
 		reason?: unknown,
 	): void {
-		if (!targetLifecycle.controller.signal.aborted) {
-			targetLifecycle.controller.abort(reason);
-		}
-		this.maybeDisposeRatelessDispatchLifecycle(targetLifecycle.lifecycle);
+		this.ratelessDispatchRegistry.abortTarget(targetLifecycle, reason);
 	}
 
 	private abortRatelessDispatchLifecycle(
 		lifecycle: RatelessDispatchLifecycle,
 		reason?: unknown,
 	): void {
-		if (!lifecycle.controller.signal.aborted) {
-			lifecycle.controller.abort(reason);
-		}
-		for (const targetLifecycle of lifecycle.targets.values()) {
-			this.abortRatelessDispatchTarget(targetLifecycle, reason);
-		}
-		this.maybeDisposeRatelessDispatchLifecycle(lifecycle);
+		this.ratelessDispatchRegistry.abortLifecycle(lifecycle, reason);
 	}
 
 	private finishRatelessDispatchLifecycle(
 		lifecycle: RatelessDispatchLifecycle,
 	): void {
-		lifecycle.dispatchFinished = true;
-		this.maybeDisposeRatelessDispatchLifecycle(lifecycle);
+		this.ratelessDispatchRegistry.finish(lifecycle);
 	}
 
 	private maybeDisposeRatelessDispatchLifecycle(
 		lifecycle: RatelessDispatchLifecycle,
 	): void {
-		if (
-			lifecycle.disposed ||
-			!lifecycle.dispatchFinished ||
-			[...lifecycle.targets.values()].some(
-				(target) => target.retainedByProcess || target.responseLeases > 0,
-			)
-		) {
-			return;
-		}
-		lifecycle.disposed = true;
-		lifecycle.ownershipLifecycleController.signal.removeEventListener(
-			"abort",
-			lifecycle.onOwnerOrCallerAbort,
-		);
-		if (
-			lifecycle.callerSignal &&
-			lifecycle.callerSignal !== lifecycle.ownershipLifecycleController.signal
-		) {
-			lifecycle.callerSignal.removeEventListener(
-				"abort",
-				lifecycle.onOwnerOrCallerAbort,
-			);
-		}
-		for (const targetLifecycle of lifecycle.targets.values()) {
-			const activeForTarget = this.ratelessDispatchTargets.get(
-				targetLifecycle.target,
-			);
-			activeForTarget?.delete(targetLifecycle);
-			if (activeForTarget?.size === 0) {
-				this.ratelessDispatchTargets.delete(targetLifecycle.target);
-			}
-		}
+		this.ratelessDispatchRegistry.maybeDispose(lifecycle);
 	}
 
 	private isRatelessDispatchLifecycleActive(
 		lifecycle: RatelessDispatchLifecycle,
 		target?: string,
 	): boolean {
-		if (
-			this.ratelessClosed ||
-			lifecycle.disposed ||
-			lifecycle.ownershipLifecycleController !==
-				this.ratelessDispatchLifecycleController ||
-			lifecycle.ownershipLifecycleController.signal.aborted ||
-			lifecycle.callerSignal?.aborted ||
-			lifecycle.controller.signal.aborted
-		) {
-			return false;
-		}
-		if (target === undefined) {
-			return true;
-		}
-		const targetLifecycle = lifecycle.targets.get(target);
-		return (
-			targetLifecycle !== undefined &&
-			!targetLifecycle.controller.signal.aborted &&
-			this.ratelessDispatchTargets.get(target)?.has(targetLifecycle) === true
-		);
+		return this.ratelessDispatchRegistry.isLifecycleActive(lifecycle, target);
 	}
 
 	private getIncomingSyncProcessKey(sender: string, syncId: string): string {
@@ -1548,12 +1498,12 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 	private isIncomingSyncGenerationActive(
 		ownershipLifecycleController: AbortController,
 	): boolean {
-		return (
-			!this.ratelessClosed &&
-			ownershipLifecycleController ===
-				this.ratelessDispatchLifecycleController &&
-			!ownershipLifecycleController.signal.aborted
-		);
+		return isOwnershipGenerationActive({
+			closed: this.ratelessClosed,
+			ownershipLifecycleController,
+			currentOwnershipLifecycleController:
+				this.ratelessDispatchLifecycleController,
+		});
 	}
 
 	private isIncomingSyncProcessActive(
@@ -2309,41 +2259,77 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 
 		const targetLifecycle = process.targetLifecycle;
 		targetLifecycle.responseLeases += 1;
+		const slotRow = this.getOrCreateRatelessResponseSlotRow(target);
+		slotRow.active += 1;
 		this.activeRatelessResponseCount += 1;
 		this.activeRatelessResponseCountByPeer.set(
 			target,
 			(this.activeRatelessResponseCountByPeer.get(target) ?? 0) + 1,
 		);
-		let released = false;
+		let logicalReleased = false;
+		let physicalReleased = false;
+		const releaseLogical = () => {
+			if (logicalReleased) {
+				return;
+			}
+			logicalReleased = true;
+			slotRow.activeReleases.delete(releaseLogical);
+			targetLifecycle.responseLeases -= 1;
+			this.maybeDisposeRatelessDispatchLifecycle(targetLifecycle.lifecycle);
+		};
+		slotRow.activeReleases.add(releaseLogical);
 		return {
 			process,
 			authorized,
 			remaining,
 			signal: targetLifecycle.controller.signal,
 			release: (options) => {
-				if (released) {
+				if (physicalReleased) {
 					return;
 				}
-				released = true;
-				if (options?.rollback) {
-					for (const hash of authorized) {
-						process.consumedResponseHashes.delete(hash);
+				physicalReleased = true;
+				try {
+					releaseLogical();
+				} finally {
+					if (options?.rollback) {
+						for (const hash of authorized) {
+							process.consumedResponseHashes.delete(hash);
+						}
+					}
+					this.activeRatelessResponseCount -= 1;
+					slotRow.active -= 1;
+					if (slotRow.attached) {
+						const activeForPeer =
+							(this.activeRatelessResponseCountByPeer.get(target) ?? 1) - 1;
+						if (activeForPeer === 0) {
+							this.activeRatelessResponseCountByPeer.delete(target);
+						} else {
+							this.activeRatelessResponseCountByPeer.set(target, activeForPeer);
+						}
+						this.ratelessPeerSlotRows.maybeDropIdle(slotRow);
 					}
 				}
-				targetLifecycle.responseLeases -= 1;
-				this.activeRatelessResponseCount -= 1;
-				const activeForPeer =
-					(this.activeRatelessResponseCountByPeer.get(target) ?? 1) - 1;
-				if (activeForPeer === 0) {
-					this.activeRatelessResponseCountByPeer.delete(target);
-				} else {
-					this.activeRatelessResponseCountByPeer.set(target, activeForPeer);
-				}
-				this.maybeDisposeRatelessDispatchLifecycle(targetLifecycle.lifecycle);
 			},
 		};
 	}
 
+	private getOrCreateRatelessResponseSlotRow(peer: string): SyncPeerSlotRow {
+		return this.ratelessPeerSlotRows.ensure(peer);
+	}
+
+	private detachRatelessResponseSlotRow(peer: string): void {
+		const row = this.ratelessPeerSlotRows.detach(peer);
+		if (!row) {
+			return;
+		}
+		this.activeRatelessResponseCountByPeer.delete(peer);
+		// Release logical lifecycle ownership immediately. Each underlying
+		// shipment retains its global physical-work permit until its own finally.
+		for (const releaseLogical of [...row.activeReleases]) {
+			releaseLogical();
+		}
+	}
+
 	async onMessage(
 		message: TransportMessage,
 		context: RequestContext,
@@ -3240,13 +3226,17 @@ export class RatelessIBLTSynchronizer<D extends "u32" | "u64">
 			}
 		}
 		for (const targetLifecycle of [
-			...(this.ratelessDispatchTargets.get(target) ?? []),
+			...(this.ratelessDispatchRegistry.activeTargets.get(target) ?? []),
 		]) {
 			this.abortRatelessDispatchTarget(
 				targetLifecycle,
 				new Error("rateless sync target disconnected"),
 			);
 		}
+		// A response ship for this peer may never settle. Detach current-generation
+		// quota and logical ownership, but keep its global physical permit charged
+		// until settlement. open() likewise preserves physical accounting.
+		this.detachRatelessResponseSlotRow(target);
 		return this.simple.onPeerDisconnected(target);
 	}