@peerbit/stream 5.2.1 → 5.2.2

package/src/index.ts

@@ -1,4 +1,5 @@
 import {
+	ConnectionClosedError,
 	MuxerClosedError,
 	StreamResetError,
 	TypedEventEmitter,
@@ -268,6 +269,7 @@ const DEFAULT_OUTBOUND_QUEUE_RESERVED_PRIORITY_BYTES = 1024 * 1024;
 const DEFAULT_PRUNE_CONNECTIONS_INTERVAL = 2e4;
 const DEFAULT_MIN_CONNECTIONS = 2;
 const DEFAULT_MAX_CONNECTIONS = 300;
+const MAX_RETIRED_PEER_STREAMS = 256;
 
 const DEFAULT_PRUNED_CONNNECTIONS_TIMEOUT = 30 * 1000;
 
@@ -387,6 +389,11 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	private outboundAbortController: AbortController;
 
 	private closed: boolean;
+	private closePromise?: Promise<void>;
+	/** Closing is irreversible, even while asynchronous cleanup is pending. */
+	public get isClosed(): boolean {
+		return this.closed;
+	}
 
 	public connId: string;
 
@@ -800,6 +807,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	 * Attach a raw inbound stream and setup a read stream
 	 */
 	attachInboundStream(stream: Stream): InboundStreamRecord {
+		this.assertOpenForAttachment(stream);
 		// Support multiple concurrent inbound streams with inactivity pruning.
 		// Enforce max inbound streams (drop least recently active)
 		if (this.inboundStreams.length >= PeerStreams.MAX_INBOUND_STREAMS) {
@@ -852,9 +860,10 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	}
 
 	private _scheduleInboundPrune() {
-		if (this._inboundPruneTimer) return; // already scheduled
+		if (this.closed || this._inboundPruneTimer) return;
 		this._inboundPruneTimer = setTimeout(() => {
 			this._inboundPruneTimer = undefined;
+			if (this.closed) return;
 			this._pruneInboundInactive();
 			if (this.inboundStreams.length > 1) {
 				// schedule again if still multiple
@@ -864,7 +873,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	}
 
 	private _pruneInboundInactive() {
-		if (this.inboundStreams.length <= 1) return;
+		if (this.closed || this.inboundStreams.length <= 1) return;
 		const now = Date.now();
 		// Keep at least one (the most recently active)
 		this.inboundStreams.sort((a, b) => b.lastActivity - a.lastActivity);
@@ -932,6 +941,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	 */
 
 	async attachOutboundStream(stream: Stream) {
+		this.assertOpenForAttachment(stream);
 		if (this.outboundStreams.some((candidate) => candidate.raw === stream)) {
 			return; // duplicate
 		}
@@ -943,6 +953,16 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 		this._scheduleOutboundPrune(true);
 	}
 
+	private assertOpenForAttachment(stream: Stream) {
+		if (!this.closed) return;
+		const error = new AbortError("Closed");
+		try {
+			stream.abort?.(error);
+		} catch {}
+		closeRawStreamBestEffort(stream);
+		throw error;
+	}
+
 	private pruneOutboundCandidates() {
 		try {
 			const candidates = this.outboundStreams;
@@ -1036,17 +1056,27 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 	/**
 	 * Closes the open connection to peer
 	 */
-	async close() {
-		if (this.closed) {
-			return;
-		}
+	close(): Promise<void> {
+		if (this.closePromise) return this.closePromise;
+		const closing = pDefer<void>();
+		// Publish the promise before callbacks can re-enter close().
+		this.closePromise = closing.promise;
 
 		this.closed = true;
+		// Cancel inbound maintenance before awaiting outbound shutdown.
+		if (this._inboundPruneTimer) {
+			clearTimeout(this._inboundPruneTimer);
+			this._inboundPruneTimer = undefined;
+		}
 		if (this._outboundPruneTimer) {
 			clearTimeout(this._outboundPruneTimer);
 			this._outboundPruneTimer = undefined;
 		}
+		void this.closeImpl().then(closing.resolve, closing.reject);
+		return this.closePromise;
+	}
 
+	private async closeImpl(): Promise<void> {
 		// End the outbound stream
 		if (this.outboundStreams.length) {
 			for (const c of this.outboundStreams) {
@@ -1060,29 +1090,29 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 			this.outboundAbortController.abort();
 		}
 
-			// End inbound streams
-			if (this.inboundStreams.length) {
-				for (const inbound of this.inboundStreams) {
+		// End inbound streams
+		if (this.inboundStreams.length) {
+			for (const inbound of this.inboundStreams) {
+				try {
+					inbound.abortController.abort();
+				} catch {
+					logger.error("Failed to abort inbound stream");
+				}
+				try {
+					// Best-effort shutdown: on some transports (notably websockets),
+					// awaiting a graceful close can hang indefinitely if the remote is
+					// concurrently stopping. Abort immediately and do not await close.
 					try {
-						inbound.abortController.abort();
+						inbound.raw.abort?.(new AbortError("Closed"));
 					} catch {
-						logger.error("Failed to abort inbound stream");
-					}
-					try {
-						// Best-effort shutdown: on some transports (notably websockets),
-						// awaiting a graceful close can hang indefinitely if the remote is
-						// concurrently stopping. Abort immediately and do not await close.
-						try {
-							inbound.raw.abort?.(new AbortError("Closed"));
-						} catch {
-							// ignore
-						}
-						closeRawStreamBestEffort(inbound.raw);
-					} catch {
-						logger.error("Failed to close inbound stream");
+						// ignore
 					}
+					closeRawStreamBestEffort(inbound.raw);
+				} catch {
+					logger.error("Failed to close inbound stream");
 				}
 			}
+		}
 
 		this.usedBandWidthTracker.stop();
 
@@ -1251,6 +1281,8 @@ export abstract class DirectStream<
 	 * Map of peer streams
 	 */
 	public peers: Map<string, PeerStreams>;
+	// Replacements must not orphan teardown that beforeStop still needs to drain.
+	private readonly retiredPeerStreams = new Set<PeerStreams>();
 	public peerKeyHashToPublicKey: Map<string, PublicSignKey>;
 	public routes: RoutesLike;
 	/**
@@ -1277,6 +1309,7 @@ export abstract class DirectStream<
 			private pruneToLimitsInFlight?: Promise<void>;
 			private _startInFlight?: Promise<void>;
 			private _stopInFlight?: Promise<void>;
+			private _networkStopPromise?: Promise<void>;
 			private routeMaxRetentionPeriod: number;
 	private routeCacheMaxFromEntries?: number;
 	private routeCacheMaxTargetsPerFrom?: number;
@@ -1557,10 +1590,11 @@ export abstract class DirectStream<
 
 		async start() {
 			// Do not queue a restart behind teardown; callers can retry after stop resolves.
-			if (this._stopInFlight) return;
+			if (this._stopInFlight || this.stopping) return;
 			if (this.started) return;
 			if (this._startInFlight) return this._startInFlight;
 			this.stopping = false;
+			this._networkStopPromise = undefined;
 			this._startInFlight = this._startImpl().finally(() => {
 				this._startInFlight = undefined;
 			});
@@ -1774,12 +1808,12 @@ export abstract class DirectStream<
 		}
 		if (this.connectionManagerOptions.pruner) {
 			const pruneConnectionsLoop = () => {
-				if (!this.connectionManagerOptions.pruner) {
+				if (this.stopping || !this.connectionManagerOptions.pruner) {
 					return;
 				}
 				this.pruneConnectionsTimeout = setTimeout(() => {
 					this.maybePruneConnections().finally(() => {
-						if (!this.started) {
+						if (this.stopping || !this.started) {
 							return;
 						}
 						pruneConnectionsLoop();
@@ -1790,12 +1824,24 @@ export abstract class DirectStream<
 		}
 	}
 
+	/**
+	 * Finish network teardown while libp2p still owns open transport connections.
+	 * Subclass resource cleanup remains in the normal stop phase.
+	 */
+	beforeStop(): Promise<void> {
+		if (this._networkStopPromise) return this._networkStopPromise;
+		if (!this.started && !this._startInFlight) return Promise.resolve();
+		return this.stopNetwork();
+	}
+
 	/**
 	 * Unregister the pubsub protocol and the streams with other peers will be closed.
 	 */
 	stop(): Promise<void> {
 		if (this._stopInFlight) return this._stopInFlight;
-		if (!this.started && !this._startInFlight) return Promise.resolve();
+		if (!this.started && !this._startInFlight && !this._networkStopPromise) {
+			return Promise.resolve();
+		}
 		this.stopping = true;
 		const starting = this._startInFlight;
 		this._stopInFlight = this._stopAfterStart(starting).finally(() => {
@@ -1817,9 +1863,10 @@ export abstract class DirectStream<
 
 		let stopFailed = false;
 		let stopFailure: unknown;
-		if (this.started) {
+		if (this.started || this._networkStopPromise) {
 			try {
-				await this._stopImpl();
+				if (this.started) await this._stopImpl();
+				else await this._networkStopPromise;
 			} catch (error) {
 				stopFailed = true;
 				stopFailure = error;
@@ -1836,9 +1883,23 @@ export abstract class DirectStream<
 		if (startFailed) throw startFailure;
 	}
 
-	private async _stopImpl(): Promise<void> {
-		const sharedState = this.sharedRoutingState;
-		const sharedKey = this.sharedRoutingKey;
+	private stopNetwork(): Promise<void> {
+		if (this._networkStopPromise) return this._networkStopPromise;
+		this.stopping = true;
+		this._networkStopPromise = this.stopNetworkAfterStart(
+			this._startInFlight,
+		).finally(() => {
+			// Startup can fail before marking the service started. In that case no
+			// normal stop is required to make a subsequent start possible.
+			if (!this.started && !this._stopInFlight) this.stopping = false;
+		});
+		return this._networkStopPromise;
+	}
+
+	private async stopNetworkAfterStart(starting?: Promise<void>): Promise<void> {
+		// A failed startup may still have installed handlers or opened streams.
+		// Its caller observes the startup error; teardown must still drain them.
+		await starting?.catch(() => {});
 
 		clearTimeout(this.pruneConnectionsTimeout);
 		try {
@@ -1873,20 +1934,34 @@ export abstract class DirectStream<
 			);
 		}
 
-		// reset and clear up
-		this.started = false;
-		this.outboundInflightQueue.end();
-		this.closeController.abort();
-
-		logger.trace("stopping");
-		for (const peerStreams of this.peers.values()) {
-			await peerStreams.close();
+		this.outboundInflightQueue?.end();
+		this.closeController?.abort();
+		for (const timer of this.healthChecks.values()) clearTimeout(timer);
+		this.healthChecks.clear();
+		// A stream open may settle after abort and still need to dispose its raw
+		// stream. Keep that work ahead of connection-manager shutdown as well.
+		await this._outboundPump;
+		this._outboundPump = undefined;
+
+		const closes = await Promise.allSettled(
+			[...this.peers.values(), ...this.retiredPeerStreams].map((peer) =>
+				peer.close(),
+			),
+		);
+		const failures = closes.flatMap((result) =>
+			result.status === "rejected" ? [result.reason] : [],
+		);
+		if (failures.length) {
+			throw new AggregateError(failures, "Peer stream teardown failed");
 		}
+	}
 
-		for (const [_k, v] of this.healthChecks) {
-			clearTimeout(v);
-		}
-		this.healthChecks.clear();
+	private async _stopImpl(): Promise<void> {
+		const sharedState = this.sharedRoutingState;
+		const sharedKey = this.sharedRoutingKey;
+		this.started = false;
+		logger.trace("stopping");
+		await this.stopNetwork();
 		this.prunedConnectionsCache?.clear();
 
 		this.queue.clear();
@@ -1939,7 +2014,8 @@ export abstract class DirectStream<
 	 */
 
 	protected async _onIncomingStream(stream: Stream, connection: Connection) {
-		if (!this.isStarted()) {
+		if (this.stopping || !this.isStarted()) {
+			closeRawStreamBestEffort(stream);
 			return;
 		}
 		const peerId = connection.remotePeer;
@@ -1951,21 +2027,24 @@ export abstract class DirectStream<
 		const publicKey = getPublicKeyFromPeerId(peerId);
 
 		if (this.prunedConnectionsCache?.has(publicKey.hashcode())) {
-			await connection.close();
+			// Reject immediately: graceful transport shutdown can race other
+			// incoming protocol negotiations that still need to reset their streams.
+			connection.abort(new AbortError("Connection was pruned"));
 			await this.components.peerStore.delete(peerId);
 			return;
 		}
 
-		const peer = this.addPeer(
-			peerId,
-			publicKey,
-			stream.protocol,
-			connection.id,
-		);
-
-		// handle inbound
-		const inboundRecord = peer.attachInboundStream(stream);
-		this.processMessages(peer.publicKey, inboundRecord, peer).catch(logError);
+		try {
+			const peer = this.addPeer(peerId, publicKey, stream.protocol, connection.id);
+			const inboundRecord = peer.attachInboundStream(stream);
+			this.processMessages(peer.publicKey, inboundRecord, peer).catch(logError);
+		} catch (error) {
+			try {
+				stream.abort(error as Error);
+			} catch {}
+			closeRawStreamBestEffort(stream);
+			throw error;
+		}
 
 		// try to create outbound stream
 		await this.outboundInflightQueue.push({ peerId, connection });
@@ -1992,7 +2071,7 @@ export abstract class DirectStream<
 		const peerKey = getPublicKeyFromPeerId(peerId);
 		while (tries <= 3) {
 			tries++;
-			if (!this.started) {
+			if (this.stopping || !this.started) {
 				return;
 			}
 
@@ -2018,7 +2097,7 @@ export abstract class DirectStream<
 					return;
 				}
 
-				if (!this.started) {
+				if (this.stopping || !this.started) {
 					// we closed before we could create the stream
 					stream.abort(new Error("Closed"));
 					return;
@@ -2026,6 +2105,12 @@ export abstract class DirectStream<
 				peer = this.addPeer(peerId, peerKey, stream.protocol!, connection.id); // TODO types
 				await peer.attachOutboundStream(stream);
 			} catch (error: any) {
+				if (stream) {
+					try {
+						stream.abort(error);
+					} catch {}
+					closeRawStreamBestEffort(stream);
+				}
 				if (error.code === "ERR_UNSUPPORTED_PROTOCOL") {
 					await delay(100);
 					continue; // Retry
@@ -2036,14 +2121,25 @@ export abstract class DirectStream<
 					continue; // Retry
 				}
 
+				if (connection.status !== "open") return;
 				if (
-					connection.status !== "open" ||
 					error?.message === "Muxer already closed" ||
-					error.code === "ERR_STREAM_RESET" ||
-					error instanceof StreamResetError ||
+					error instanceof ConnectionClosedError ||
 					error instanceof MuxerClosedError
 				) {
-					return; // fail silenty
+					// A closed muxer cannot open any protocol, even if the transport
+					// still reports open. Dispose it so a later dial can reconnect.
+					connection.abort(error);
+					return;
+				}
+				if (
+					error.code === "ERR_STREAM_RESET" ||
+					error instanceof StreamResetError
+				) {
+					// A single stream reset need not invalidate a healthy connection.
+					// Retry within the existing attempt/signal budget; a muxer-wide
+					// failure then surfaces on the next open instead of staying cached.
+					continue;
 				}
 
 				throw error;
@@ -2060,6 +2156,7 @@ export abstract class DirectStream<
 	 */
 	public async onPeerConnected(peerId: PeerId, connection: Connection) {
 		if (
+			this.stopping ||
 			!this.isStarted() ||
 			connection.limits ||
 			connection.status !== "open"
@@ -2069,7 +2166,7 @@ export abstract class DirectStream<
 		const peerKey = getPublicKeyFromPeerId(peerId);
 
 		if (this.prunedConnectionsCache?.has(peerKey.hashcode())) {
-			await connection.close();
+			connection.abort(new AbortError("Connection was pruned"));
 			await this.components.peerStore.delete(peerId);
 			return; // we recently pruned this connect, dont allow it to connect for a while
 		}
@@ -2088,6 +2185,8 @@ export abstract class DirectStream<
 		// PeerId could be me, if so, it means that I am disconnecting
 		const peerKey = getPublicKeyFromPeerId(peerId);
 		const peerKeyHash = peerKey.hashcode();
+		const currentPeer = this.peers.get(peerKeyHash);
+		if (!currentPeer || (conn && conn.id !== currentPeer.connId)) return;
 		const allConnections =
 			this.components.connectionManager.getConnections?.() ?? [];
 		const connections = allConnections.filter(
@@ -2110,8 +2209,13 @@ export abstract class DirectStream<
 			return;
 		}
 		if (!this.publicKey.equals(peerKey)) {
-			await this._removePeer(peerKey);
-			if (this.stopping || !this.started) {
+			const removed = await this._removePeer(peerKey);
+			if (
+				removed !== currentPeer ||
+				this.peers.has(peerKeyHash) ||
+				this.stopping ||
+				!this.started
+			) {
 				return;
 			}
 
@@ -2129,7 +2233,7 @@ export abstract class DirectStream<
 						mode: new SilentDelivery({ to: dependent, redundancy: 2 }),
 					}),
 				}).sign(this.sign);
-				if (this.stopping || !this.started) {
+				if (this.stopping || !this.started || this.peers.has(peerKeyHash)) {
 					return;
 				}
 				await this.publishMessageMaybe(
@@ -2252,17 +2356,27 @@ export abstract class DirectStream<
 			protocol: string,
 			connId: string,
 	): PeerStreams {
+		if (this.stopping) throw new AbortError("Closed");
 		const publicKeyHash = publicKey.hashcode();
 
 		this.clearHealthcheckTimer(publicKeyHash);
 
 		const existing = this.peers.get(publicKeyHash);
 
-		// If peer streams already exists, do nothing
-		if (existing != null) {
+		// Reuse only a live object; close has already made attachments impossible.
+		if (existing != null && !existing.isClosed) {
 			existing.connId = connId;
 			return existing;
 		}
+		if (existing) {
+			if (this.retiredPeerStreams.size >= MAX_RETIRED_PEER_STREAMS) {
+				throw new AbortError("Too many pending peer stream closes");
+			}
+			this.retiredPeerStreams.add(existing);
+			const forget = () => this.retiredPeerStreams.delete(existing);
+			// A failed close remains owned so beforeStop cannot report a clean drain.
+			void existing.close().then(forget, () => {});
+		}
 
 		// else create a new peer streams
 		const peerIdStr = peerId.toString();
@@ -2280,21 +2394,31 @@ export abstract class DirectStream<
 		});
 
 		this.peers.set(publicKeyHash, peerStreams);
-		this.updateSession(publicKey, -1);
+		// Object replacement is not evidence of a new authenticated peer session.
+		if (!existing) this.updateSession(publicKey, -1);
 
 		// Propagate per-peer stream readiness events to the parent emitter
-			const forwardOutbound = () =>
-				this.dispatchEvent(new CustomEvent("stream:outbound"));
-			const forwardInbound = () =>
-				this.dispatchEvent(new CustomEvent("stream:inbound"));
-			const forwardQueue = () => this.notifyTotalOutboundQueueWaiters();
+			const isCurrentPeer = () => this.peers.get(publicKeyHash) === peerStreams;
+			const forwardOutbound = () => {
+				if (isCurrentPeer()) this.dispatchEvent(new CustomEvent("stream:outbound"));
+			};
+			const forwardInbound = () => {
+				if (isCurrentPeer()) this.dispatchEvent(new CustomEvent("stream:inbound"));
+			};
+			const forwardQueue = () => {
+				if (isCurrentPeer()) this.notifyTotalOutboundQueueWaiters();
+			};
 			peerStreams.addEventListener("stream:outbound", forwardOutbound);
 			peerStreams.addEventListener("stream:inbound", forwardInbound);
 			peerStreams.addEventListener("queue:outbound", forwardQueue);
 
-			peerStreams.addEventListener("close", () => this._removePeer(publicKey), {
-				once: true,
-		});
+			peerStreams.addEventListener(
+				"close",
+				() => {
+					if (isCurrentPeer()) void this._removePeer(publicKey).catch(logError);
+				},
+				{ once: true },
+			);
 		peerStreams.addEventListener(
 				"close",
 				() => {
@@ -2312,7 +2436,7 @@ export abstract class DirectStream<
 				publicKey,
 				-1,
 				+new Date(),
-				-1,
+				existing ? this.routes.getSession(publicKeyHash) ?? -1 : -1,
 			);
 
 			// Enforce connection manager limits eagerly when new peers are added. Without this,
@@ -2327,7 +2451,9 @@ export abstract class DirectStream<
 	/**
 	 * Notifies the router that a peer has been disconnected
 	 */
-	protected async _removePeer(publicKey: PublicSignKey) {
+	protected async _removePeer(
+		publicKey: PublicSignKey,
+	): Promise<PeerStreams | undefined> {
 		const hash = publicKey.hashcode();
 		const peerStreams = this.peers.get(hash);
 		this.clearHealthcheckTimer(hash);
@@ -2338,6 +2464,7 @@ export abstract class DirectStream<
 
 		// close peer streams
 		await peerStreams.close();
+		if (this.peers.get(hash) !== peerStreams) return;
 
 		// delete peer streams
 		logger.trace("delete peer" + publicKey.toString());
@@ -2358,6 +2485,7 @@ export abstract class DirectStream<
 		let failed = false;
 		try {
 			for await (const data of record.iterable) {
+				if (this.peers.get(peerId.hashcode()) !== peerStreams) break;
 				const now = Date.now();
 				record.lastActivity = now;
 				record.bytesReceived += data.length || data.byteLength || 0;
@@ -2382,14 +2510,21 @@ export abstract class DirectStream<
 						err?.message,
 				);
 			}
-			this.onPeerDisconnected(peerStreams.peerId);
+			if (this.peers.get(peerId.hashcode()) === peerStreams) {
+				void this.onPeerDisconnected(peerStreams.peerId).catch(logError);
+			}
 		} finally {
 			const removed = peerStreams.detachInboundStream(
 				record,
 				new AbortError("Inbound stream reader ended"),
 				{ closeRaw: failed },
 			);
-			if (removed && !failed && !peerStreams.isReadable) {
+			if (
+				removed &&
+				!failed &&
+				!peerStreams.isReadable &&
+				this.peers.get(peerId.hashcode()) === peerStreams
+			) {
 				void this.onPeerDisconnected(peerStreams.peerId).catch(logError);
 			}
 		}
@@ -2612,7 +2747,7 @@ export abstract class DirectStream<
 		msg: Uint8ArrayList,
 		decodedMessage?: Message,
 	) {
-		if (!this.started) {
+		if (this.stopping || !this.started) {
 			return;
 		}
 
@@ -4034,6 +4169,7 @@ export abstract class DirectStream<
 		}
 
 	async pruneConnections(): Promise<void> {
+		if (this.stopping || !this.started) return;
 		// TODO sort by bandwidth
 		if (this.peers.size <= this.connectionManagerOptions.minConnections) {
 			return;
@@ -4051,6 +4187,7 @@ export abstract class DirectStream<
 			this.prunedConnectionsCache?.add(stream.publicKey.hashcode());
 
 			await this.onPeerDisconnected(stream.peerId);
+			if (this.stopping || !this.started) return;
 			return this.components.connectionManager.closeConnections(stream.peerId);
 		}