@peerbit/stream 5.2.1 → 5.2.2

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import { MuxerClosedError, StreamResetError, TypedEventEmitter, UnsupportedProtocolError, } from "@libp2p/interface";
+import { ConnectionClosedError, MuxerClosedError, StreamResetError, TypedEventEmitter, UnsupportedProtocolError, } from "@libp2p/interface";
 import { multiaddr } from "@multiformats/multiaddr";
 import { Circuit } from "@multiformats/multiaddr-matcher";
 import { Cache } from "@peerbit/cache";
@@ -111,6 +111,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;
 const DEFAULT_CREATE_OUTBOUND_STREAM_TIMEOUT = 30_000;
 const PRIORITY_LANES = 4;
@@ -184,6 +185,11 @@ export class PeerStreams extends TypedEventEmitter {
     static MAX_INBOUND_STREAMS = 8; // sensible default to prevent flood
     outboundAbortController;
     closed;
+    closePromise;
+    /** Closing is irreversible, even while asynchronous cleanup is pending. */
+    get isClosed() {
+        return this.closed;
+    }
     connId;
     seekedOnce;
     usedBandWidthTracker;
@@ -535,6 +541,7 @@ export class PeerStreams extends TypedEventEmitter {
      * Attach a raw inbound stream and setup a read stream
      */
     attachInboundStream(stream) {
+        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) {
@@ -583,10 +590,12 @@ export class PeerStreams extends TypedEventEmitter {
         return record;
     }
     _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
@@ -595,7 +604,7 @@ export class PeerStreams extends TypedEventEmitter {
         }, PeerStreams.INBOUND_IDLE_MS);
     }
     _pruneInboundInactive() {
-        if (this.inboundStreams.length <= 1)
+        if (this.closed || this.inboundStreams.length <= 1)
             return;
         const now = Date.now();
         // Keep at least one (the most recently active)
@@ -660,6 +669,7 @@ export class PeerStreams extends TypedEventEmitter {
      * Attach a raw outbound stream and setup a write stream
      */
     async attachOutboundStream(stream) {
+        this.assertOpenForAttachment(stream);
         if (this.outboundStreams.some((candidate) => candidate.raw === stream)) {
             return; // duplicate
         }
@@ -670,6 +680,17 @@ export class PeerStreams extends TypedEventEmitter {
         }
         this._scheduleOutboundPrune(true);
     }
+    assertOpenForAttachment(stream) {
+        if (!this.closed)
+            return;
+        const error = new AbortError("Closed");
+        try {
+            stream.abort?.(error);
+        }
+        catch { }
+        closeRawStreamBestEffort(stream);
+        throw error;
+    }
     pruneOutboundCandidates() {
         try {
             const candidates = this.outboundStreams;
@@ -756,15 +777,26 @@ export class PeerStreams extends TypedEventEmitter {
     /**
      * Closes the open connection to peer
      */
-    async close() {
-        if (this.closed) {
-            return;
-        }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        const closing = pDefer();
+        // 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;
+    }
+    async closeImpl() {
         // End the outbound stream
         if (this.outboundStreams.length) {
             for (const c of this.outboundStreams) {
@@ -831,6 +863,8 @@ export class DirectStream extends TypedEventEmitter {
      * Map of peer streams
      */
     peers;
+    // Replacements must not orphan teardown that beforeStop still needs to drain.
+    retiredPeerStreams = new Set();
     peerKeyHashToPublicKey;
     routes;
     /**
@@ -856,6 +890,7 @@ export class DirectStream extends TypedEventEmitter {
     pruneToLimitsInFlight;
     _startInFlight;
     _stopInFlight;
+    _networkStopPromise;
     routeMaxRetentionPeriod;
     routeCacheMaxFromEntries;
     routeCacheMaxTargetsPerFrom;
@@ -1053,13 +1088,14 @@ export class DirectStream extends TypedEventEmitter {
     }
     async start() {
         // Do not queue a restart behind teardown; callers can retry after stop resolves.
-        if (this._stopInFlight)
+        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;
         });
@@ -1227,12 +1263,12 @@ export class DirectStream extends TypedEventEmitter {
         }
         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();
@@ -1242,14 +1278,26 @@ export class DirectStream extends TypedEventEmitter {
             pruneConnectionsLoop();
         }
     }
+    /**
+     * Finish network teardown while libp2p still owns open transport connections.
+     * Subclass resource cleanup remains in the normal stop phase.
+     */
+    beforeStop() {
+        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() {
         if (this._stopInFlight)
             return this._stopInFlight;
-        if (!this.started && !this._startInFlight)
+        if (!this.started && !this._startInFlight && !this._networkStopPromise) {
             return Promise.resolve();
+        }
         this.stopping = true;
         const starting = this._startInFlight;
         this._stopInFlight = this._stopAfterStart(starting).finally(() => {
@@ -1270,9 +1318,12 @@ export class DirectStream extends TypedEventEmitter {
         }
         let stopFailed = false;
         let stopFailure;
-        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;
@@ -1287,9 +1338,22 @@ export class DirectStream extends TypedEventEmitter {
         if (startFailed)
             throw startFailure;
     }
-    async _stopImpl() {
-        const sharedState = this.sharedRoutingState;
-        const sharedKey = this.sharedRoutingKey;
+    stopNetwork() {
+        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;
+    }
+    async stopNetworkAfterStart(starting) {
+        // 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 {
             if (this._peerConnectListener) {
@@ -1309,18 +1373,27 @@ export class DirectStream extends TypedEventEmitter {
         if (this._registrarTopologyIds != null) {
             await Promise.all(this._registrarTopologyIds.map((id) => this.components.registrar.unregister(id)));
         }
-        // reset and clear up
+        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");
+        }
+    }
+    async _stopImpl() {
+        const sharedState = this.sharedRoutingState;
+        const sharedKey = this.sharedRoutingKey;
         this.started = false;
-        this.outboundInflightQueue.end();
-        this.closeController.abort();
         logger.trace("stopping");
-        for (const peerStreams of this.peers.values()) {
-            await peerStreams.close();
-        }
-        for (const [_k, v] of this.healthChecks) {
-            clearTimeout(v);
-        }
-        this.healthChecks.clear();
+        await this.stopNetwork();
         this.prunedConnectionsCache?.clear();
         this.queue.clear();
         this.peers.clear();
@@ -1369,7 +1442,8 @@ export class DirectStream extends TypedEventEmitter {
      * On an inbound stream opened
      */
     async _onIncomingStream(stream, connection) {
-        if (!this.isStarted()) {
+        if (this.stopping || !this.isStarted()) {
+            closeRawStreamBestEffort(stream);
             return;
         }
         const peerId = connection.remotePeer;
@@ -1379,14 +1453,25 @@ export class DirectStream extends TypedEventEmitter {
         }
         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);
+            }
+            catch { }
+            closeRawStreamBestEffort(stream);
+            throw error;
+        }
         // try to create outbound stream
         await this.outboundInflightQueue.push({ peerId, connection });
     }
@@ -1404,7 +1489,7 @@ export class DirectStream extends TypedEventEmitter {
         const peerKey = getPublicKeyFromPeerId(peerId);
         while (tries <= 3) {
             tries++;
-            if (!this.started) {
+            if (this.stopping || !this.started) {
                 return;
             }
             try {
@@ -1428,7 +1513,7 @@ export class DirectStream extends TypedEventEmitter {
                     stream.abort(new Error("Stream was not multiplexed"));
                     return;
                 }
-                if (!this.started) {
+                if (this.stopping || !this.started) {
                     // we closed before we could create the stream
                     stream.abort(new Error("Closed"));
                     return;
@@ -1437,6 +1522,13 @@ export class DirectStream extends TypedEventEmitter {
                 await peer.attachOutboundStream(stream);
             }
             catch (error) {
+                if (stream) {
+                    try {
+                        stream.abort(error);
+                    }
+                    catch { }
+                    closeRawStreamBestEffort(stream);
+                }
                 if (error.code === "ERR_UNSUPPORTED_PROTOCOL") {
                     await delay(100);
                     continue; // Retry
@@ -1445,12 +1537,22 @@ export class DirectStream extends TypedEventEmitter {
                     await delay(100);
                     continue; // Retry
                 }
-                if (connection.status !== "open" ||
-                    error?.message === "Muxer already closed" ||
-                    error.code === "ERR_STREAM_RESET" ||
-                    error instanceof StreamResetError ||
+                if (connection.status !== "open")
+                    return;
+                if (error?.message === "Muxer already closed" ||
+                    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;
             }
@@ -1464,14 +1566,15 @@ export class DirectStream extends TypedEventEmitter {
      * Registrar notifies an established connection with protocol
      */
     async onPeerConnected(peerId, connection) {
-        if (!this.isStarted() ||
+        if (this.stopping ||
+            !this.isStarted() ||
             connection.limits ||
             connection.status !== "open") {
             return;
         }
         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
         }
@@ -1487,6 +1590,9 @@ export class DirectStream extends TypedEventEmitter {
         // 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((connection) => connection.remotePeer.toString() === peerId.toString());
         if (connections.length > 0) {
@@ -1505,8 +1611,11 @@ export class DirectStream extends TypedEventEmitter {
             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;
             }
             // tell dependent peers that there is a node that might have left
@@ -1521,7 +1630,7 @@ export class DirectStream extends TypedEventEmitter {
                         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(this.publicKey, goodbye);
@@ -1598,14 +1707,25 @@ export class DirectStream extends TypedEventEmitter {
      * Notifies the router that a peer has been connected
      */
     addPeer(peerId, publicKey, protocol, connId) {
+        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();
         logger.trace("new peer" + peerIdStr);
@@ -1620,24 +1740,37 @@ export class DirectStream extends TypedEventEmitter {
                 : undefined,
         });
         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", () => {
             peerStreams.removeEventListener("stream:outbound", forwardOutbound);
             peerStreams.removeEventListener("stream:inbound", forwardInbound);
             peerStreams.removeEventListener("queue:outbound", forwardQueue);
             this.notifyTotalOutboundQueueWaiters();
         }, { once: true });
-        this.addRouteConnection(this.publicKeyHash, publicKey.hashcode(), publicKey, -1, +new Date(), -1);
+        this.addRouteConnection(this.publicKeyHash, publicKey.hashcode(), publicKey, -1, +new Date(), existing ? this.routes.getSession(publicKeyHash) ?? -1 : -1);
         // Enforce connection manager limits eagerly when new peers are added. Without this,
         // join storms can create large temporary peer sets and OOM in single-process sims.
         if (this.peers.size > this.connectionManagerOptions.maxConnections) {
@@ -1657,6 +1790,8 @@ export class DirectStream extends TypedEventEmitter {
         }
         // close peer streams
         await peerStreams.close();
+        if (this.peers.get(hash) !== peerStreams)
+            return;
         // delete peer streams
         logger.trace("delete peer" + publicKey.toString());
         this.peers.delete(hash);
@@ -1670,6 +1805,8 @@ export class DirectStream extends TypedEventEmitter {
         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;
@@ -1691,11 +1828,16 @@ export class DirectStream extends TypedEventEmitter {
                     ". " +
                     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);
             }
         }
@@ -1869,7 +2011,7 @@ export class DirectStream extends TypedEventEmitter {
      * Handles a message from a peer
      */
     async processMessage(from, peerStream, msg, decodedMessage) {
-        if (!this.started) {
+        if (this.stopping || !this.started) {
             return;
         }
         // Ensure the message is valid before processing it
@@ -2892,6 +3034,8 @@ export class DirectStream extends TypedEventEmitter {
         return Promise.resolve();
     }
     async pruneConnections() {
+        if (this.stopping || !this.started)
+            return;
         // TODO sort by bandwidth
         if (this.peers.size <= this.connectionManagerOptions.minConnections) {
             return;
@@ -2906,6 +3050,8 @@ export class DirectStream extends TypedEventEmitter {
         const stream = this.peers.get(prunables[0]);
         this.prunedConnectionsCache?.add(stream.publicKey.hashcode());
         await this.onPeerDisconnected(stream.peerId);
+        if (this.stopping || !this.started)
+            return;
         return this.components.connectionManager.closeConnections(stream.peerId);
     }
     getTotalQueueAdmissionLimitBytes(priority) {