libp2p 2.9.0 → 2.10.0-8484de8a2

package/dist/src/upgrader.js

@@ -1,50 +1,15 @@
-import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, InvalidPeerIdError } from '@libp2p/interface';
+import { InvalidMultiaddrError, InvalidPeerIdError } from '@libp2p/interface';
 import * as mss from '@libp2p/multistream-select';
 import { peerIdFromString } from '@libp2p/peer-id';
-import { trackedMap } from '@libp2p/utils/tracked-map';
+import { trackedMap } from '@libp2p/utils';
+import { CODE_P2P } from '@multiformats/multiaddr';
 import { anySignal } from 'any-signal';
 import { setMaxListeners } from 'main-event';
 import { CustomProgressEvent } from 'progress-events';
 import { raceSignal } from 'race-signal';
-import { createConnection } from './connection/index.js';
-import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js';
+import { PROTOCOL_NEGOTIATION_TIMEOUT, INBOUND_UPGRADE_TIMEOUT, CONNECTION_CLOSE_TIMEOUT } from './connection-manager/constants.js';
+import { createConnection } from './connection.js';
 import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js';
-import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js';
-function findIncomingStreamLimit(protocol, registrar) {
-    try {
-        const { options } = registrar.getHandler(protocol);
-        return options.maxInboundStreams;
-    }
-    catch (err) {
-        if (err.name !== 'UnhandledProtocolError') {
-            throw err;
-        }
-    }
-    return DEFAULT_MAX_INBOUND_STREAMS;
-}
-function findOutgoingStreamLimit(protocol, registrar, options = {}) {
-    try {
-        const { options } = registrar.getHandler(protocol);
-        if (options.maxOutboundStreams != null) {
-            return options.maxOutboundStreams;
-        }
-    }
-    catch (err) {
-        if (err.name !== 'UnhandledProtocolError') {
-            throw err;
-        }
-    }
-    return options.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS;
-}
-function countStreams(protocol, direction, connection) {
-    let streamCount = 0;
-    connection.streams.forEach(stream => {
-        if (stream.direction === direction && stream.protocol === protocol) {
-            streamCount++;
-        }
-    });
-    return streamCount;
-}
 export class Upgrader {
     components;
     connectionEncrypters;
@@ -54,6 +19,7 @@ export class Upgrader {
     outboundStreamProtocolNegotiationTimeout;
     events;
     metrics;
+    connectionCloseTimeout;
     constructor(components, init) {
         this.components = components;
         this.connectionEncrypters = trackedMap({
@@ -73,6 +39,7 @@ export class Upgrader {
         this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? INBOUND_UPGRADE_TIMEOUT;
         this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT;
         this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT;
+        this.connectionCloseTimeout = init.connectionCloseTimeout ?? CONNECTION_CLOSE_TIMEOUT;
         this.events = components.events;
         this.metrics = {
             dials: components.metrics?.registerCounterGroup('libp2p_connection_manager_dials_total'),
@@ -100,9 +67,6 @@ export class Upgrader {
         setMaxListeners(Infinity, output);
         return output;
     }
-    /**
-     * Upgrades an inbound connection
-     */
     async upgradeInbound(maConn, opts) {
         let accepted = false;
         // always apply upgrade timeout for incoming upgrades
@@ -111,7 +75,7 @@ export class Upgrader {
             this.metrics.dials?.increment({
                 inbound: true
             });
-            accepted = await raceSignal(this.components.connectionManager.acceptIncomingConnection(maConn), signal);
+            accepted = this.components.connectionManager.acceptIncomingConnection(maConn);
             if (!accepted) {
                 throw new ConnectionDeniedError('Connection denied');
             }
@@ -137,15 +101,12 @@ export class Upgrader {
             }
         }
     }
-    /**
-     * Upgrades an outbound connection
-     */
     async upgradeOutbound(maConn, opts) {
         try {
             this.metrics.dials?.increment({
                 outbound: true
             });
-            const idStr = maConn.remoteAddr.getPeerId();
+            const idStr = maConn.remoteAddr.getComponents().findLast(c => c.code === CODE_P2P)?.value;
             let remotePeerId;
             if (idStr != null) {
                 remotePeerId = peerIdFromString(idStr);
@@ -169,49 +130,53 @@ export class Upgrader {
         }
     }
     async _performUpgrade(maConn, direction, opts) {
-        let encryptedConn;
+        let stream = maConn;
         let remotePeer;
-        let upgradedConn;
         let muxerFactory;
+        let muxer;
         let cryptoProtocol;
+        const id = `${(parseInt(String(Math.random() * 1e9))).toString(36)}${Date.now()}`;
+        maConn.log = maConn.log.newScope(`${direction}:${id}`);
         this.components.metrics?.trackMultiaddrConnection(maConn);
         maConn.log.trace('starting the %s connection upgrade', direction);
         // Protect
-        let protectedConn = maConn;
         if (opts?.skipProtection !== true) {
             const protector = this.components.connectionProtector;
             if (protector != null) {
                 maConn.log('protecting the %s connection', direction);
-                protectedConn = await protector.protect(maConn, opts);
+                stream = await protector.protect(stream, opts);
             }
         }
         try {
             // Encrypt the connection
-            encryptedConn = protectedConn;
-            if (opts?.skipEncryption !== true) {
+            if (isEncryptionSkipped(opts)) {
+                if (opts.remotePeer == null) {
+                    throw new InvalidMultiaddrError(`${direction} connection that skipped encryption must have a peer id`);
+                }
+                cryptoProtocol = 'native';
+                remotePeer = opts.remotePeer;
+            }
+            else {
+                const peerIdString = maConn.remoteAddr.getComponents().findLast(c => c.code === CODE_P2P)?.value;
+                let remotePeerFromMultiaddr;
+                if (peerIdString != null) {
+                    remotePeerFromMultiaddr = peerIdFromString(peerIdString);
+                }
                 opts?.onProgress?.(new CustomProgressEvent(`upgrader:encrypt-${direction}-connection`));
                 ({
-                    conn: encryptedConn,
+                    connection: stream,
                     remotePeer,
                     protocol: cryptoProtocol,
                     streamMuxer: muxerFactory
                 } = await (direction === 'inbound'
-                    ? this._encryptInbound(protectedConn, opts)
-                    : this._encryptOutbound(protectedConn, opts)));
-                const maConn = {
-                    ...protectedConn,
-                    ...encryptedConn
-                };
-                await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundEncryptedConnection' : 'denyOutboundEncryptedConnection', remotePeer, maConn);
-            }
-            else {
-                const idStr = maConn.remoteAddr.getPeerId();
-                if (idStr == null) {
-                    throw new InvalidMultiaddrError(`${direction} connection that skipped encryption must have a peer id`);
-                }
-                const remotePeerId = peerIdFromString(idStr);
-                cryptoProtocol = 'native';
-                remotePeer = remotePeerId;
+                    ? this._encryptInbound(stream, {
+                        ...opts,
+                        remotePeer: remotePeerFromMultiaddr
+                    })
+                    : this._encryptOutbound(stream, {
+                        ...opts,
+                        remotePeer: remotePeerFromMultiaddr
+                    })));
             }
             // this can happen if we dial a multiaddr without a peer id, we only find
             // out the identity of the remote after the connection is encrypted
@@ -220,287 +185,84 @@ export class Upgrader {
                 maConn.abort(err);
                 throw err;
             }
-            upgradedConn = encryptedConn;
+            // stream.pause()
+            await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundEncryptedConnection' : 'denyOutboundEncryptedConnection', remotePeer, maConn);
+            // stream.resume()
             if (opts?.muxerFactory != null) {
                 muxerFactory = opts.muxerFactory;
             }
             else if (muxerFactory == null && this.streamMuxers.size > 0) {
                 opts?.onProgress?.(new CustomProgressEvent(`upgrader:multiplex-${direction}-connection`));
                 // Multiplex the connection
-                const multiplexed = await (direction === 'inbound'
-                    ? this._multiplexInbound({
-                        ...protectedConn,
-                        ...encryptedConn
-                    }, this.streamMuxers, opts)
-                    : this._multiplexOutbound({
-                        ...protectedConn,
-                        ...encryptedConn
-                    }, this.streamMuxers, opts));
-                muxerFactory = multiplexed.muxerFactory;
-                upgradedConn = multiplexed.stream;
+                muxerFactory = await (direction === 'inbound'
+                    ? this._multiplexInbound(stream, this.streamMuxers, opts)
+                    : this._multiplexOutbound(stream, this.streamMuxers, opts));
             }
         }
         catch (err) {
-            maConn.log.error('failed to upgrade inbound connection %s %a - %e', direction === 'inbound' ? 'from' : 'to', maConn.remoteAddr, err);
+            maConn.log.error('failed to upgrade %s connection %s %a - %e', direction, direction === 'inbound' ? 'from' : 'to', maConn.remoteAddr, err);
             throw err;
         }
+        // create the connection muxer if one is configured
+        if (muxerFactory != null) {
+            maConn.log('create muxer %s', muxerFactory.protocol);
+            muxer = muxerFactory.createStreamMuxer(stream);
+        }
+        // stream.pause()
         await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundUpgradedConnection' : 'denyOutboundUpgradedConnection', remotePeer, maConn);
-        maConn.log('successfully upgraded %s connection', direction);
-        return this._createConnection({
+        const conn = this._createConnection({
+            id,
             cryptoProtocol,
             direction,
             maConn,
-            upgradedConn,
-            muxerFactory,
+            stream,
+            muxer,
             remotePeer,
-            limits: opts?.limits
+            limits: opts?.limits,
+            closeTimeout: this.connectionCloseTimeout
         });
+        conn.log('successfully upgraded connection');
+        // stream.resume()
+        return conn;
     }
     /**
      * A convenience method for generating a new `Connection`
      */
     _createConnection(opts) {
-        const { cryptoProtocol, direction, maConn, upgradedConn, remotePeer, muxerFactory, limits } = opts;
-        let muxer;
-        let newStream;
-        let connection; // eslint-disable-line prefer-const
-        if (muxerFactory != null) {
-            // Create the muxer
-            muxer = muxerFactory.createStreamMuxer({
-                direction,
-                // Run anytime a remote stream is created
-                onIncomingStream: muxedStream => {
-                    if (connection == null) {
-                        return;
-                    }
-                    const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout);
-                    setMaxListeners(Infinity, signal);
-                    void Promise.resolve()
-                        .then(async () => {
-                        const protocols = this.components.registrar.getProtocols();
-                        const { stream, protocol } = await mss.handle(muxedStream, protocols, {
-                            signal,
-                            log: muxedStream.log,
-                            yieldBytes: false
-                        });
-                        if (connection == null) {
-                            return;
-                        }
-                        connection.log('incoming stream opened on %s', protocol);
-                        const incomingLimit = findIncomingStreamLimit(protocol, this.components.registrar);
-                        const streamCount = countStreams(protocol, 'inbound', connection);
-                        if (streamCount === incomingLimit) {
-                            const err = new TooManyInboundProtocolStreamsError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`);
-                            muxedStream.abort(err);
-                            throw err;
-                        }
-                        // after the handshake the returned stream can have early data so override
-                        // the source/sink
-                        muxedStream.source = stream.source;
-                        muxedStream.sink = stream.sink;
-                        muxedStream.protocol = protocol;
-                        // allow closing the write end of a not-yet-negotiated stream
-                        if (stream.closeWrite != null) {
-                            muxedStream.closeWrite = stream.closeWrite;
-                        }
-                        // allow closing the read end of a not-yet-negotiated stream
-                        if (stream.closeRead != null) {
-                            muxedStream.closeRead = stream.closeRead;
-                        }
-                        // make sure we don't try to negotiate a stream we are closing
-                        if (stream.close != null) {
-                            muxedStream.close = stream.close;
-                        }
-                        // If a protocol stream has been successfully negotiated and is to be passed to the application,
-                        // the peer store should ensure that the peer is registered with that protocol
-                        await this.components.peerStore.merge(remotePeer, {
-                            protocols: [protocol]
-                        }, {
-                            signal
-                        });
-                        this.components.metrics?.trackProtocolStream(muxedStream, connection);
-                        this._onStream({ connection, stream: muxedStream, protocol });
-                    })
-                        .catch(async (err) => {
-                        connection.log.error('error handling incoming stream id %s - %e', muxedStream.id, err);
-                        if (muxedStream.timeline.close == null) {
-                            await muxedStream.close({
-                                signal
-                            })
-                                .catch(err => muxedStream.abort(err));
-                        }
-                    });
-                }
-            });
-            newStream = async (protocols, options = {}) => {
-                if (muxer == null) {
-                    throw new MuxerUnavailableError('Connection is not multiplexed');
-                }
-                connection.log.trace('starting new stream for protocols %s', protocols);
-                const muxedStream = await muxer.newStream();
-                connection.log.trace('started new stream %s for protocols %s', muxedStream.id, protocols);
-                try {
-                    if (options.signal == null) {
-                        muxedStream.log('no abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols);
-                        const signal = AbortSignal.timeout(this.outboundStreamProtocolNegotiationTimeout);
-                        setMaxListeners(Infinity, signal);
-                        options = {
-                            ...options,
-                            signal
-                        };
-                    }
-                    muxedStream.log.trace('selecting protocol from protocols %s', protocols);
-                    const { stream, protocol } = await mss.select(muxedStream, protocols, {
-                        ...options,
-                        log: muxedStream.log,
-                        yieldBytes: true
-                    });
-                    muxedStream.log.trace('selected protocol %s', protocol);
-                    const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.registrar, options);
-                    const streamCount = countStreams(protocol, 'outbound', connection);
-                    if (streamCount >= outgoingLimit) {
-                        const err = new TooManyOutboundProtocolStreamsError(`Too many outbound protocol streams for protocol "${protocol}" - ${streamCount}/${outgoingLimit}`);
-                        muxedStream.abort(err);
-                        throw err;
-                    }
-                    // If a protocol stream has been successfully negotiated and is to be passed to the application,
-                    // the peer store should ensure that the peer is registered with that protocol
-                    await this.components.peerStore.merge(remotePeer, {
-                        protocols: [protocol]
-                    });
-                    // after the handshake the returned stream can have early data so override
-                    // the source/sink
-                    muxedStream.source = stream.source;
-                    muxedStream.sink = stream.sink;
-                    muxedStream.protocol = protocol;
-                    // allow closing the write end of a not-yet-negotiated stream
-                    if (stream.closeWrite != null) {
-                        muxedStream.closeWrite = stream.closeWrite;
-                    }
-                    // allow closing the read end of a not-yet-negotiated stream
-                    if (stream.closeRead != null) {
-                        muxedStream.closeRead = stream.closeRead;
-                    }
-                    // make sure we don't try to negotiate a stream we are closing
-                    if (stream.close != null) {
-                        muxedStream.close = stream.close;
-                    }
-                    this.components.metrics?.trackProtocolStream(muxedStream, connection);
-                    return muxedStream;
-                }
-                catch (err) {
-                    connection.log.error('could not create new outbound stream on connection %s %a for protocols %s - %e', direction === 'inbound' ? 'from' : 'to', opts.maConn.remoteAddr, protocols, err);
-                    if (muxedStream.timeline.close == null) {
-                        muxedStream.abort(err);
-                    }
-                    throw err;
-                }
-            };
-            // Pipe all data through the muxer
-            void Promise.all([
-                muxer.sink(upgradedConn.source),
-                upgradedConn.sink(muxer.source)
-            ]).catch(err => {
-                connection.log.error('error piping data through muxer - %e', err);
-            });
-        }
-        const _timeline = maConn.timeline;
-        maConn.timeline = new Proxy(_timeline, {
-            set: (...args) => {
-                if (args[1] === 'close' && args[2] != null && _timeline.close == null) {
-                    // Wait for close to finish before notifying of the closure
-                    (async () => {
-                        try {
-                            if (connection.status === 'open') {
-                                await connection.close();
-                            }
-                        }
-                        catch (err) {
-                            connection.log.error('error closing connection after timeline close %e', err);
-                        }
-                        finally {
-                            this.events.safeDispatchEvent('connection:close', {
-                                detail: connection
-                            });
-                        }
-                    })().catch(err => {
-                        connection.log.error('error thrown while dispatching connection:close event %e', err);
-                    });
-                }
-                return Reflect.set(...args);
-            }
-        });
-        maConn.timeline.upgraded = Date.now();
-        const errConnectionNotMultiplexed = () => {
-            throw new MuxerUnavailableError('Connection is not multiplexed');
-        };
         // Create the connection
-        connection = createConnection({
-            remoteAddr: maConn.remoteAddr,
-            remotePeer,
-            status: 'open',
-            direction,
-            timeline: maConn.timeline,
-            multiplexer: muxer?.protocol,
-            encryption: cryptoProtocol,
-            limits,
-            logger: this.components.logger,
-            newStream: newStream ?? errConnectionNotMultiplexed,
-            getStreams: () => {
-                return muxer?.streams ?? [];
-            },
-            close: async (options) => {
-                // ensure remaining streams are closed gracefully
-                await muxer?.close(options);
-                // close the underlying transport
-                await maConn.close(options);
-            },
-            abort: (err) => {
-                maConn.abort(err);
-                // ensure remaining streams are aborted
-                muxer?.abort(err);
-            }
+        const connection = createConnection(this.components, {
+            ...opts,
+            outboundStreamProtocolNegotiationTimeout: this.outboundStreamProtocolNegotiationTimeout,
+            inboundStreamProtocolNegotiationTimeout: this.inboundStreamProtocolNegotiationTimeout
+        });
+        connection.addEventListener('close', () => {
+            this.events.safeDispatchEvent('connection:close', {
+                detail: connection
+            });
         });
         this.events.safeDispatchEvent('connection:open', {
             detail: connection
         });
-        // @ts-expect-error nah
-        connection.__maConnTimeline = _timeline;
         return connection;
     }
-    /**
-     * Routes incoming streams to the correct handler
-     */
-    _onStream(opts) {
-        const { connection, stream, protocol } = opts;
-        const { handler, options } = this.components.registrar.getHandler(protocol);
-        if (connection.limits != null && options.runOnLimitedConnection !== true) {
-            throw new LimitedConnectionError('Cannot open protocol stream on limited connection');
-        }
-        handler({ connection, stream });
-    }
     /**
      * Attempts to encrypt the incoming `connection` with the provided `cryptos`
      */
     async _encryptInbound(connection, options) {
         const protocols = Array.from(this.connectionEncrypters.keys());
         try {
-            const { stream, protocol } = await mss.handle(connection, protocols, {
-                ...options,
-                log: connection.log
-            });
+            const protocol = await mss.handle(connection, protocols, options);
             const encrypter = this.connectionEncrypters.get(protocol);
             if (encrypter == null) {
                 throw new EncryptionFailedError(`no crypto module found for ${protocol}`);
             }
-            connection.log('encrypting inbound connection to %a using %s', connection.remoteAddr, protocol);
+            connection.log('encrypting inbound connection using %s', protocol);
             return {
-                ...await encrypter.secureInbound(stream, options),
+                ...await encrypter.secureInbound(connection, options),
                 protocol
             };
         }
         catch (err) {
-            connection.log.error('encrypting inbound connection from %a failed', connection.remoteAddr, err);
             throw new EncryptionFailedError(err.message);
         }
     }
@@ -512,23 +274,18 @@ export class Upgrader {
         const protocols = Array.from(this.connectionEncrypters.keys());
         try {
             connection.log.trace('selecting encrypter from %s', protocols);
-            const { stream, protocol } = await mss.select(connection, protocols, {
-                ...options,
-                log: connection.log,
-                yieldBytes: true
-            });
+            const protocol = await mss.select(connection, protocols, options);
             const encrypter = this.connectionEncrypters.get(protocol);
             if (encrypter == null) {
                 throw new EncryptionFailedError(`no crypto module found for ${protocol}`);
             }
-            connection.log('encrypting outbound connection to %a using %s', connection.remoteAddr, protocol);
+            connection.log('encrypting outbound connection using %s', protocol);
             return {
-                ...await encrypter.secureOutbound(stream, options),
+                ...await encrypter.secureOutbound(connection, options),
                 protocol
             };
         }
         catch (err) {
-            connection.log.error('encrypting outbound connection to %a failed', connection.remoteAddr, err);
             throw new EncryptionFailedError(err.message);
         }
     }
@@ -536,22 +293,21 @@ export class Upgrader {
      * Selects one of the given muxers via multistream-select. That
      * muxer will be used for all future streams on the connection.
      */
-    async _multiplexOutbound(connection, muxers, options) {
+    async _multiplexOutbound(maConn, muxers, options) {
         const protocols = Array.from(muxers.keys());
-        connection.log('outbound selecting muxer %s', protocols);
+        maConn.log('outbound selecting muxer %s', protocols);
         try {
-            connection.log.trace('selecting stream muxer from %s', protocols);
-            const { stream, protocol } = await mss.select(connection, protocols, {
-                ...options,
-                log: connection.log,
-                yieldBytes: true
-            });
-            connection.log('selected %s as muxer protocol', protocol);
+            maConn.log.trace('selecting stream muxer from %s', protocols);
+            const protocol = await mss.select(maConn, protocols, options);
             const muxerFactory = muxers.get(protocol);
-            return { stream, muxerFactory };
+            if (muxerFactory == null) {
+                throw new MuxerUnavailableError(`No muxer configured for protocol "${protocol}"`);
+            }
+            maConn.log('selected %s as muxer protocol', protocol);
+            return muxerFactory;
         }
         catch (err) {
-            connection.log.error('error multiplexing outbound connection', err);
+            maConn.log.error('error multiplexing outbound connection', err);
             throw new MuxerUnavailableError(String(err));
         }
     }
@@ -559,20 +315,22 @@ export class Upgrader {
      * Registers support for one of the given muxers via multistream-select. The
      * selected muxer will be used for all future streams on the connection.
      */
-    async _multiplexInbound(connection, muxers, options) {
+    async _multiplexInbound(maConn, muxers, options) {
         const protocols = Array.from(muxers.keys());
-        connection.log('inbound handling muxers %s', protocols);
+        maConn.log('inbound handling muxers %s', protocols);
         try {
-            const { stream, protocol } = await mss.handle(connection, protocols, {
-                ...options,
-                log: connection.log
-            });
+            maConn.log.trace('selecting stream muxer from %s', protocols);
+            const protocol = await mss.handle(maConn, protocols, options);
             const muxerFactory = muxers.get(protocol);
-            return { stream, muxerFactory };
+            if (muxerFactory == null) {
+                throw new MuxerUnavailableError(`No muxer configured for protocol "${protocol}"`);
+            }
+            maConn.log('selected %s as muxer protocol', protocol);
+            return muxerFactory;
         }
         catch (err) {
-            connection.log.error('error multiplexing inbound connection', err);
-            throw new MuxerUnavailableError(String(err));
+            maConn.log.error('error multiplexing inbound connection', err);
+            throw err;
         }
     }
     getConnectionEncrypters() {
@@ -582,4 +340,7 @@ export class Upgrader {
         return this.streamMuxers;
     }
 }
+function isEncryptionSkipped(opts) {
+    return opts.skipEncryption === true;
+}
 //# sourceMappingURL=upgrader.js.map