@peerbit/stream 4.0.10 → 4.1.0-81d59ee

package/src/index.ts

@@ -1,4 +1,9 @@
-import { TypedEventEmitter } from "@libp2p/interface";
+import {
+	MuxerClosedError,
+	StreamResetError,
+	TypedEventEmitter,
+	UnsupportedProtocolError,
+} from "@libp2p/interface";
 import type {
 	Connection,
 	Libp2pEvents,
@@ -37,6 +42,7 @@ import {
 	MultiAddrinfo,
 	NotStartedError,
 	type PriorityOptions,
+	type PublicKeyFromHashResolver,
 	SeekDelivery,
 	SilentDelivery,
 	type StreamEvents,
@@ -47,19 +53,20 @@ import {
 	deliveryModeHasReceiver,
 	getMsgId,
 } from "@peerbit/stream-interface";
-import { AbortError, TimeoutError, delay, waitFor } from "@peerbit/time";
+import { AbortError, TimeoutError, delay } from "@peerbit/time";
 import { abortableSource } from "abortable-iterator";
 import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { type Pushable, pushable } from "it-pushable";
 import type { Components } from "libp2p/components";
-import pDefer from "p-defer";
+import pDefer, { type DeferredPromise } from "p-defer";
 import Queue from "p-queue";
 import { Uint8ArrayList } from "uint8arraylist";
 import { logger } from "./logger.js";
 import { type PushableLanes, pushableLanes } from "./pushable-lanes.js";
 import { MAX_ROUTE_DISTANCE, Routes } from "./routes.js";
 import { BandwidthTracker } from "./stats.js";
+import { waitForEvent } from "./wait-for-event.js";
 
 export { logger };
 
@@ -88,6 +95,8 @@ export interface PeerStreamEvents {
 	"stream:inbound": CustomEvent<never>;
 	"stream:outbound": CustomEvent<never>;
 	close: CustomEvent<never>;
+	"peer:reachable": CustomEvent<PublicSignKey>;
+	"peer:unreachable": CustomEvent<PublicSignKey>;
 }
 
 const SEEK_DELIVERY_TIMEOUT = 10e3;
@@ -420,7 +429,7 @@ export abstract class DirectStream<
 		Events extends { [s: string]: any } = StreamEvents,
 	>
 	extends TypedEventEmitter<Events>
-	implements WaitForPeer
+	implements WaitForPeer, PublicKeyFromHashResolver
 {
 	public peerId: PeerId;
 	public publicKey: PublicSignKey;
@@ -579,12 +588,19 @@ export abstract class DirectStream<
 		this.outboundInflightQueue = pushable({ objectMode: true });
 		pipe(this.outboundInflightQueue, async (source) => {
 			for await (const { peerId, connection } of source) {
+				if (this.stopping || this.started === false) {
+					return;
+				}
 				await this.createOutboundStream(peerId, connection);
 			}
 		}).catch((e) => {
 			logger.error("outbound inflight queue error: " + e?.toString());
 		});
 
+		this.closeController.signal.addEventListener("abort", () => {
+			this.outboundInflightQueue.return();
+		});
+
 		this.routes = new Routes(this.publicKeyHash, {
 			routeMaxRetentionPeriod: this.routeMaxRetentionPeriod,
 			signal: this.closeController.signal,
@@ -776,11 +792,21 @@ export abstract class DirectStream<
 			}
 
 			try {
-				stream = await connection.newStream(this.multicodecs);
+				stream = await connection.newStream(this.multicodecs, {
+					// TODO this property seems necessary, together with waitFor isReadable when making sure two peers are conencted before talking.
+					// research whether we can do without this so we can push data without beeing able to send
+					negotiateFully: true,
+				});
 				if (stream.protocol == null) {
 					stream.abort(new Error("Stream was not multiplexed"));
 					return;
 				}
+
+				if (!this.started) {
+					// we closed before we could create the stream
+					stream.abort(new Error("Closed"));
+					return;
+				}
 				peer = this.addPeer(peerId, peerKey, stream.protocol!, connection.id); // TODO types
 				await peer.attachOutboundStream(stream);
 			} catch (error: any) {
@@ -789,10 +815,17 @@ export abstract class DirectStream<
 					continue; // Retry
 				}
 
+				if (error instanceof UnsupportedProtocolError) {
+					await delay(100);
+					continue; // Retry
+				}
+
 				if (
 					connection.status !== "open" ||
 					error?.message === "Muxer already closed" ||
-					error.code === "ERR_STREAM_RESET"
+					error.code === "ERR_STREAM_RESET" ||
+					error instanceof StreamResetError ||
+					error instanceof MuxerClosedError
 				) {
 					return; // fail silenty
 				}
@@ -1896,7 +1929,6 @@ export abstract class DirectStream<
 			}
 
 			sentOnce = true;
-
 			promises.push(id.waitForWrite(bytes, message.header.priority));
 		}
 		await Promise.all(promises);
@@ -1938,30 +1970,37 @@ export abstract class DirectStream<
 	}
 
 	async waitFor(
-		peer: PeerId | PublicSignKey,
+		peer: PeerId | PublicSignKey | string,
 		options?: { timeout?: number; signal?: AbortSignal; neighbour?: boolean },
 	) {
-		const hash = (
-			peer instanceof PublicSignKey ? peer : getPublicKeyFromPeerId(peer)
-		).hashcode();
-		try {
-			await waitFor(
-				() => {
-					if (options?.neighbour && !this.peers.has(hash)) {
-						return false;
-					}
+		const hash =
+			typeof peer === "string"
+				? peer
+				: (peer instanceof PublicSignKey
+						? peer
+						: getPublicKeyFromPeerId(peer)
+					).hashcode();
+		const checkIsReachable = (deferred: DeferredPromise<void>) => {
+			if (options?.neighbour && !this.peers.has(hash)) {
+				return;
+			}
 
-					if (!this.routes.isReachable(this.publicKeyHash, hash, 0)) {
-						return false;
-					}
+			if (!this.routes.isReachable(this.publicKeyHash, hash, 0)) {
+				return;
+			}
 
-					return true;
-				},
-				{
-					signal: options?.signal,
-					timeout: options?.timeout ?? 10 * 1000,
-				},
-			);
+			deferred.resolve();
+		};
+		const abortSignals = [this.closeController.signal];
+		if (options?.signal) {
+			abortSignals.push(options.signal);
+		}
+
+		try {
+			await waitForEvent(this, ["peer:reachable"], checkIsReachable, {
+				signals: abortSignals,
+				timeout: options?.timeout,
+			});
 		} catch (error) {
 			throw new Error(
 				"Stream to " +
@@ -1974,14 +2013,25 @@ export abstract class DirectStream<
 					this.routes.isReachable(this.publicKeyHash, hash, 0),
 			);
 		}
+
 		if (options?.neighbour) {
 			const stream = this.peers.get(hash)!;
 			try {
-				// Dontwait for readlable https://github.com/libp2p/js-libp2p/issues/2321
-				await waitFor(() => /* stream.isReadable && */ stream.isWritable, {
-					signal: options?.signal,
-					timeout: options?.timeout ?? 10 * 1000,
-				});
+				let checkIsWritable = (pDefer: DeferredPromise<void>) => {
+					// Dont wait for readlable https://github.com/libp2p/js-libp2p/issues/2321
+					if (stream.isReadable && stream.isWritable) {
+						pDefer.resolve();
+					}
+				};
+				await waitForEvent(
+					stream,
+					["stream:outbound", "stream:inbound"],
+					checkIsWritable,
+					{
+						signals: abortSignals,
+						timeout: options?.timeout,
+					},
+				);
 			} catch (error) {
 				throw new Error(
 					"Stream to " +
@@ -1995,6 +2045,10 @@ export abstract class DirectStream<
 		}
 	}
 
+	getPublicKey(hash: string): PublicSignKey | undefined {
+		return this.peerKeyHashToPublicKey.get(hash);
+	}
+
 	get pending(): boolean {
 		return this._ackCallbacks.size > 0;
 	}
@@ -2055,7 +2109,7 @@ export abstract class DirectStream<
 	}
 }
 
-export const waitForPeers = async (
+export const waitForReachable = async (
 	...libs: {
 		waitFor: (peer: PeerId | PublicSignKey) => Promise<void>;
 		peerId: PeerId;
@@ -2067,6 +2121,27 @@ export const waitForPeers = async (
 				continue;
 			}
 			await libs[i].waitFor(libs[j].peerId);
+			await libs[j].waitFor(libs[i].peerId);
+		}
+	}
+};
+
+export const waitForNeighbour = async (
+	...libs: {
+		waitFor: (
+			peer: PeerId | PublicSignKey,
+			options?: { neighbour?: boolean },
+		) => Promise<void>;
+		peerId: PeerId;
+	}[]
+) => {
+	for (let i = 0; i < libs.length; i++) {
+		for (let j = 0; j < libs.length; j++) {
+			if (i === j) {
+				continue;
+			}
+			await libs[i].waitFor(libs[j].peerId, { neighbour: true });
+			await libs[j].waitFor(libs[i].peerId, { neighbour: true });
 		}
 	}
 };

package/src/routes.ts

@@ -83,13 +83,17 @@ export class Routes {
 		let prev = fromMap.get(target);
 		const routeDidExist = prev;
 		const isNewSession = !prev || session > prev.session;
+		const isOldSession = prev && session < prev.session;
+
 		if (!prev) {
 			prev = { session, remoteSession, list: [] as RelayInfo[] };
 			fromMap.set(target, prev);
 		}
 
-		if (neighbour === target) {
-			if (from === this.me) {
+		const isRelayed = from !== this.me;
+		const targetIsNeighbour = neighbour === target;
+		if (targetIsNeighbour) {
+			if (!isRelayed) {
 				// force distance to neighbour as targets to always favor directly sending to them
 				// i.e. if target is our neighbour, always assume the shortest path to them is the direct path
 				distance = -1;
@@ -105,6 +109,20 @@ 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
@@ -120,18 +138,10 @@ export class Routes {
 
 			// Initiate cleanup
 			if (distance !== -1 && foundNodeToExpire) {
-				delay(this.routeMaxRetentionPeriod + 100, { signal: this.signal })
-					.then(() => {
-						this.cleanup(from, target);
-					})
-					.catch((e) => {
-						if (e instanceof AbortError) {
-							// skip
-							return;
-						}
-						throw e;
-					});
+				scheduleCleanup();
 			}
+		} else if (isOldSession) {
+			scheduleCleanup();
 		}
 
 		// Modify list for new/update route
@@ -139,16 +149,18 @@ export class Routes {
 		for (const route of prev.list) {
 			if (route.hash === neighbour) {
 				// if route is faster or just as fast, update existing route
-				if (route.distance > distance) {
-					route.distance = distance;
-					route.session = session;
-					route.expireAt = undefined; // remove expiry since we updated
-					prev.list.sort((a, b) => a.distance - b.distance);
-					return isNewRemoteSession ? "restart" : "updated";
-				} else if (route.distance === distance) {
-					route.session = session;
-					route.expireAt = undefined; // remove expiry since we updated
-					return isNewRemoteSession ? "restart" : "updated";
+				if (isNewSession) {
+					if (route.distance > distance) {
+						route.distance = distance;
+						route.session = session;
+						route.expireAt = undefined; // remove expiry since we updated
+						prev.list.sort((a, b) => a.distance - b.distance);
+						return isNewRemoteSession ? "restart" : "updated";
+					} else if (route.distance === distance) {
+						route.session = session;
+						route.expireAt = undefined; // remove expiry since we updated
+						return isNewRemoteSession ? "restart" : "updated";
+					}
 				}
 
 				exist = true;
@@ -157,8 +169,20 @@ export class Routes {
 			}
 		}
 
-		prev.list.push({ distance, session, hash: neighbour });
-		prev.list.sort((a, b) => a.distance - b.distance);
+		// if not exist add new route
+		// else if it exist then we only end up here if the distance is longer than prev, this means that we want to keep prev while adding the new route
+		if (!exist || isNewSession) {
+			prev.list.push({
+				distance,
+				session,
+				hash: neighbour,
+				expireAt: isOldSession
+					? +new Date() + this.routeMaxRetentionPeriod
+					: undefined,
+			});
+			prev.list.sort((a, b) => a.distance - b.distance);
+		}
+
 		return exist ? (isNewRemoteSession ? "restart" : "updated") : "new";
 	}
 
@@ -371,10 +395,11 @@ export class Routes {
 					continue; // don't send to me or backwards
 				}
 
+				// neighbours that are links from 'from' to 'to'
 				const neighbour = this.findNeighbor(from, to);
 				if (neighbour) {
 					let foundClosest = false;
-					let redundancyModified = redundancy;
+					let added = 0;
 					for (let i = 0; i < neighbour.list.length; i++) {
 						const { distance, session, expireAt } = neighbour.list[i];
 
@@ -384,7 +409,7 @@ export class Routes {
 							continue;
 						}
 
-						if (distance >= redundancyModified) {
+						if (distance >= redundancy) {
 							break; // because neighbour listis sorted
 						}
 
@@ -403,12 +428,15 @@ export class Routes {
 							session <= neighbour.session // (<) will never be the case, but we do add routes in the tests with later session timestamps
 						) {
 							foundClosest = true;
-
 							if (distance === -1) {
-								// remove 1 from the expected redunancy since we got a route with negative 1 distance
-								// if we do not do this, we would get 2 routes if redundancy = 1, {-1, 0}, while it should just be
-								// {-1} in this case
-								redundancyModified -= 1;
+								break; // dont send to more peers if we have the direct route
+							}
+						}
+
+						if (!expireAt) {
+							// only count non-expired routes or if we are relaying then also count expired routes
+							added++;
+							if (added >= redundancy) {
 								break;
 							}
 						}

package/src/wait-for-event.ts

@@ -0,0 +1,51 @@
+import type { TypedEventEmitter } from "@libp2p/interface";
+import pDefer, { type DeferredPromise } from "p-defer";
+
+export function waitForEvent<
+	Emitter extends TypedEventEmitter<Events>,
+	Events extends Record<string, any> = Emitter extends TypedEventEmitter<
+		infer E
+	>
+		? E
+		: never,
+	Event extends keyof Events = keyof Events,
+>(
+	emitter: Emitter,
+	events: Event[],
+	resolver: (deferred: DeferredPromise<void>) => void | Promise<void>,
+	options?: {
+		signals?: AbortSignal[];
+		timeout?: number;
+	},
+): Promise<void> {
+	const deferred = pDefer<void>();
+	const abortFn = () =>
+		deferred.reject(
+			new Error(
+				"Aborted waiting for event: " +
+					String(events.length > 1 ? events.join(", ") : events[0]),
+			),
+		);
+
+	const checkIsReady = (...args: any[]) => resolver(deferred);
+
+	deferred.promise.finally(() => {
+		for (const event of events) {
+			emitter.removeEventListener(event as any, checkIsReady);
+		}
+		clearTimeout(timeout);
+		options?.signals?.forEach((signal) =>
+			signal.removeEventListener("abort", abortFn),
+		);
+	});
+
+	for (const event of events) {
+		emitter.addEventListener(event as any, checkIsReady);
+	}
+	let timeout = setTimeout(abortFn, options?.timeout ?? 10 * 1000);
+	options?.signals?.forEach((signal) =>
+		signal.addEventListener("abort", abortFn),
+	);
+	(resolver as any)(deferred);
+	return deferred.promise;
+}