@peerbit/stream 4.6.0 → 5.0.0-b712c6b

package/src/routes.ts

@@ -1,10 +1,15 @@
-import { AbortError, delay } from "@peerbit/time";
+import type { DirectStreamAckRouteHint } from "@peerbit/stream-interface";
 
 export const MAX_ROUTE_DISTANCE = Number.MAX_SAFE_INTEGER - 1;
 
+const DEFAULT_MAX_FROM_ENTRIES = 2048;
+const DEFAULT_MAX_TARGETS_PER_FROM = 10_000;
+const DEFAULT_MAX_RELAYS_PER_TARGET = 32;
+
 type RelayInfo = {
 	session: number;
 	hash: string;
+	updatedAt: number;
 	expireAt?: number;
 	distance: number;
 };
@@ -44,17 +49,103 @@ export class Routes {
 
 	signal?: AbortSignal;
 
+	private pendingCleanupByFrom: Map<string, Set<string>> = new Map();
+	private cleanupTimer?: ReturnType<typeof setTimeout>;
+	private maxFromEntries: number;
+	private maxTargetsPerFrom: number;
+	private maxRelaysPerTarget: number;
+
 	constructor(
 		readonly me: string,
-		options?: { routeMaxRetentionPeriod?: number; signal?: AbortSignal },
+		options?: {
+			routeMaxRetentionPeriod?: number;
+			signal?: AbortSignal;
+			maxFromEntries?: number;
+			maxTargetsPerFrom?: number;
+			maxRelaysPerTarget?: number;
+		},
 	) {
 		this.routeMaxRetentionPeriod =
 			options?.routeMaxRetentionPeriod ?? 10 * 1000;
 		this.signal = options?.signal;
+		this.maxFromEntries = Math.max(
+			1,
+			Math.floor(options?.maxFromEntries ?? DEFAULT_MAX_FROM_ENTRIES),
+		);
+		this.maxTargetsPerFrom = Math.max(
+			1,
+			Math.floor(options?.maxTargetsPerFrom ?? DEFAULT_MAX_TARGETS_PER_FROM),
+		);
+		this.maxRelaysPerTarget = Math.max(
+			1,
+			Math.floor(options?.maxRelaysPerTarget ?? DEFAULT_MAX_RELAYS_PER_TARGET),
+		);
 	}
 
 	clear() {
 		this.routes.clear();
+		this.pendingCleanupByFrom.clear();
+		if (this.cleanupTimer) clearTimeout(this.cleanupTimer);
+		this.cleanupTimer = undefined;
+	}
+
+	private requestCleanup(from: string, to: string) {
+		if (this.signal?.aborted) return;
+		let targets = this.pendingCleanupByFrom.get(from);
+		if (!targets) {
+			targets = new Set<string>();
+			this.pendingCleanupByFrom.set(from, targets);
+		}
+		targets.add(to);
+
+		// Coalesce cleanups into a single timer. The previous per-update timer approach
+		// scales poorly in large networks and can OOM in single-process simulations.
+		if (this.cleanupTimer) return;
+		this.cleanupTimer = setTimeout(() => {
+			this.cleanupTimer = undefined;
+			const pending = this.pendingCleanupByFrom;
+			this.pendingCleanupByFrom = new Map();
+			for (const [fromKey, tos] of pending) {
+				for (const toKey of tos) {
+					this.cleanup(fromKey, toKey);
+				}
+			}
+		}, this.routeMaxRetentionPeriod + 100);
+	}
+
+	private pruneFromMaps() {
+		if (this.routes.size <= this.maxFromEntries) return;
+
+		// Keep `me` pinned: local routes are used for pruning decisions and should be
+		// the last thing we evict under memory pressure.
+		while (this.routes.size > this.maxFromEntries) {
+			const oldest = this.routes.keys().next().value as string | undefined;
+			if (!oldest) return;
+			if (oldest === this.me) {
+				const selfMap = this.routes.get(oldest);
+				if (!selfMap) {
+					this.routes.delete(oldest);
+					continue;
+				}
+				// Move to the end (most recently used) and continue eviction.
+				this.routes.delete(oldest);
+				this.routes.set(oldest, selfMap);
+				continue;
+			}
+			this.routes.delete(oldest);
+		}
+	}
+
+	private pruneTargets(from: string, fromMap: Map<string, RouteInfo>) {
+		if (fromMap.size <= this.maxTargetsPerFrom) return;
+		while (fromMap.size > this.maxTargetsPerFrom) {
+			const oldestTarget = fromMap.keys().next().value as string | undefined;
+			if (!oldestTarget) break;
+			fromMap.delete(oldestTarget);
+		}
+		if (fromMap.size === 0) {
+			this.routes.delete(from);
+		}
 	}
 
 	private cleanup(from: string, to: string) {
@@ -73,6 +164,10 @@ export class Routes {
 					}
 				}
 
+				if (keepRoutes.length > this.maxRelaysPerTarget) {
+					keepRoutes.length = this.maxRelaysPerTarget;
+				}
+
 				if (keepRoutes.length > 0) {
 					map.list = keepRoutes;
 				} else {
@@ -96,6 +191,10 @@ export class Routes {
 		if (!fromMap) {
 			fromMap = new Map();
 			this.routes.set(from, fromMap);
+		} else {
+			// LRU-touch the `from` map.
+			this.routes.delete(from);
+			this.routes.set(from, fromMap);
 		}
 
 		let prev = fromMap.get(target);
@@ -106,6 +205,10 @@ export class Routes {
 		if (!prev) {
 			prev = { session, remoteSession, list: [] as RelayInfo[] };
 			fromMap.set(target, prev);
+		} else {
+			// LRU-touch the target entry.
+			fromMap.delete(target);
+			fromMap.set(target, prev);
 		}
 
 		const isRelayed = from !== this.me;
@@ -127,20 +230,6 @@ export class Routes {
 
 		prev.session = Math.max(session, prev.session);
 
-		const scheduleCleanup = () => {
-			return delay(this.routeMaxRetentionPeriod + 100, { signal: this.signal })
-				.then(() => {
-					this.cleanup(from, target);
-				})
-				.catch((e) => {
-					if (e instanceof AbortError) {
-						// skip
-						return;
-					}
-					throw e;
-				});
-		};
-
 		// Update routes and cleanup all old routes that are older than latest session - some threshold
 		if (isNewSession) {
 			// Mark previous routes as old
@@ -156,10 +245,10 @@ export class Routes {
 
 			// Initiate cleanup
 			if (distance !== -1 && foundNodeToExpire) {
-				scheduleCleanup();
+				this.requestCleanup(from, target);
 			}
 		} else if (isOldSession) {
-			scheduleCleanup();
+			this.requestCleanup(from, target);
 		}
 
 		// Modify list for new/update route
@@ -171,12 +260,24 @@ export class Routes {
 					if (route.distance > distance) {
 						route.distance = distance;
 						route.session = session;
+						route.updatedAt = +new Date();
 						route.expireAt = undefined; // remove expiry since we updated
 						sortRoutes(prev.list);
+						if (prev.list.length > this.maxRelaysPerTarget) {
+							prev.list.length = this.maxRelaysPerTarget;
+						}
+						this.pruneTargets(from, fromMap);
+						this.pruneFromMaps();
 						return isNewRemoteSession ? "restart" : "updated";
 					} else if (route.distance === distance) {
 						route.session = session;
+						route.updatedAt = +new Date();
 						route.expireAt = undefined; // remove expiry since we updated
+						if (prev.list.length > this.maxRelaysPerTarget) {
+							prev.list.length = this.maxRelaysPerTarget;
+						}
+						this.pruneTargets(from, fromMap);
+						this.pruneFromMaps();
 						return isNewRemoteSession ? "restart" : "updated";
 					}
 				}
@@ -194,13 +295,20 @@ export class Routes {
 				distance,
 				session,
 				hash: neighbour,
+				updatedAt: +new Date(),
 				expireAt: isOldSession
 					? +new Date() + this.routeMaxRetentionPeriod
 					: undefined,
 			});
 			sortRoutes(prev.list);
+			if (prev.list.length > this.maxRelaysPerTarget) {
+				prev.list.length = this.maxRelaysPerTarget;
+			}
 		}
 
+		this.pruneTargets(from, fromMap);
+		this.pruneFromMaps();
+
 		return exist ? (isNewRemoteSession ? "restart" : "updated") : "new";
 	}
 
@@ -262,6 +370,38 @@ export class Routes {
 		return this.routes.get(from)?.get(target);
 	}
 
+	getRouteHints(from: string, target: string): DirectStreamAckRouteHint[] {
+		const route = this.routes.get(from)?.get(target);
+		if (!route) {
+			return [];
+		}
+		const now = Date.now();
+		const out: DirectStreamAckRouteHint[] = [];
+		for (const next of route.list) {
+			if (next.expireAt != null && next.expireAt < now) {
+				continue;
+			}
+			out.push({
+				kind: "directstream-ack",
+				from,
+				target,
+				nextHop: next.hash,
+				distance: next.distance,
+				session: next.session,
+				updatedAt: next.updatedAt,
+				expiresAt: next.expireAt,
+			});
+		}
+		return out;
+	}
+
+	getBestRouteHint(
+		from: string,
+		target: string,
+	): DirectStreamAckRouteHint | undefined {
+		return this.getRouteHints(from, target)[0];
+	}
+
 	isReachable(from: string, target: string, maxDistance = MAX_ROUTE_DISTANCE) {
 		const remoteInfo = this.remoteInfo.get(target);
 		const routeInfo = this.routes.get(from)?.get(target);

package/src/wait-for-event.ts

@@ -19,6 +19,10 @@ export function waitForEvent<
 		timeout?: number;
 	},
 ): Promise<void> {
+	const traceEnabled =
+		(globalThis as any)?.process?.env?.PEERBIT_WAITFOREVENT_TRACE === "1";
+	const callsite = traceEnabled ? new Error("waitForEvent callsite").stack : undefined;
+
 	const deferred = pDefer<void>();
 	const abortFn = (e?: unknown) => {
 		if (e instanceof Error) {
@@ -39,15 +43,18 @@ export function waitForEvent<
 	const checkIsReady = (...args: any[]) => resolver(deferred);
 	let timeout: ReturnType<typeof setTimeout> | undefined = undefined;
 
-	deferred.promise.finally(() => {
-		for (const event of events) {
-			emitter.removeEventListener(event as any, checkIsReady as any);
-		}
-		timeout && clearTimeout(timeout);
-		options?.signals?.forEach((signal) =>
-			signal.removeEventListener("abort", abortFn),
-		);
-	});
+	void deferred.promise
+		.finally(() => {
+			for (const event of events) {
+				emitter.removeEventListener(event as any, checkIsReady as any);
+			}
+			timeout && clearTimeout(timeout);
+			options?.signals?.forEach((signal) =>
+				signal.removeEventListener("abort", abortFn),
+			);
+		})
+		// Avoid triggering an unhandled rejection from the `.finally()` return promise.
+		.catch(() => {});
 
 	const abortedSignal = options?.signals?.find((signal) => signal.aborted);
 	if (abortedSignal) {
@@ -65,7 +72,13 @@ export function waitForEvent<
 		emitter.addEventListener(event as any, checkIsReady as any);
 	}
 	timeout = setTimeout(
-		() => abortFn(new TimeoutError("Timeout waiting for event")),
+		() => {
+			const err = new TimeoutError("Timeout waiting for event");
+			if (callsite && err.stack) {
+				err.stack += `\n\n${callsite}`;
+			}
+			abortFn(err);
+		},
 		options?.timeout ?? 10 * 1000,
 	);
 	options?.signals?.forEach((signal) =>