libp2p 0.36.2 → 0.37.0-5934b13

package/dist/src/connection-manager/index.d.ts

@@ -1,193 +1,159 @@
-export = ConnectionManager;
-/**
- * @typedef {import('../')} Libp2p
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- */
-/**
- * @typedef {Object} ConnectionManagerOptions
- * @property {number} [maxConnections = Infinity] - The maximum number of connections allowed.
- * @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning.
- * @property {number} [maxData = Infinity] - The max data (in and out), per average interval to allow.
- * @property {number} [maxSentData = Infinity] - The max outgoing data, per average interval to allow.
- * @property {number} [maxReceivedData = Infinity] - The max incoming data, per average interval to allow.
- * @property {number} [maxEventLoopDelay = Infinity] - The upper limit the event loop can take to run.
- * @property {number} [pollInterval = 2000] - How often, in milliseconds, metrics and latency should be checked.
- * @property {number} [movingAverageInterval = 60000] - How often, in milliseconds, to compute averages.
- * @property {number} [defaultPeerValue = 1] - The value of the peer.
- * @property {boolean} [autoDial = true] - Should preemptively guarantee connections are above the low watermark.
- * @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark.
- */
-/**
- *
- * @fires ConnectionManager#peer:connect Emitted when a new peer is connected.
- * @fires ConnectionManager#peer:disconnect Emitted when a peer is disconnected.
- */
-declare class ConnectionManager extends EventEmitter {
+import { SummaryObject } from './latency-monitor.js';
+import type { AbortOptions } from '@libp2p/interfaces';
+import { EventEmitter } from '@libp2p/interfaces/events';
+import type { Startable } from '@libp2p/interfaces/startable';
+import { PeerId } from '@libp2p/interfaces/peer-id';
+import type { Connection } from '@libp2p/interfaces/connection';
+import type { ConnectionManager } from '@libp2p/interfaces/connection-manager';
+import { Components, Initializable } from '@libp2p/interfaces/components';
+import { Dialer } from './dialer/index.js';
+import type { AddressSorter } from '@libp2p/interfaces/peer-store';
+import type { Resolver } from '@multiformats/multiaddr';
+export interface ConnectionManagerInit {
     /**
-     * Responsible for managing known connections.
-     *
-     * @class
-     * @param {Libp2p} libp2p
-     * @param {ConnectionManagerOptions} options
+     * The maximum number of connections to keep open
      */
-    constructor(libp2p: Libp2p, options?: ConnectionManagerOptions);
-    _libp2p: import("../");
-    _peerId: string;
-    _options: any;
+    maxConnections: number;
     /**
-     * Map of peer identifiers to their peer value for pruning connections.
-     *
-     * @type {Map<string, number>}
+     * The minimum number of connections to keep open
      */
-    _peerValues: Map<string, number>;
+    minConnections: number;
     /**
-     * Map of connections per peer
-     *
-     * @type {Map<string, Connection[]>}
+     * The max data (in and out), per average interval to allow
      */
-    connections: Map<string, Connection[]>;
-    _started: boolean;
-    _timer: any;
+    maxData?: number;
     /**
-     * Checks the libp2p metrics to determine if any values have exceeded
-     * the configured maximums.
-     *
-     * @private
+     * The max outgoing data, per average interval to allow
      */
-    private _checkMetrics;
-    _latencyMonitor: LatencyMonitor;
+    maxSentData?: number;
     /**
-     * Get current number of open connections.
+     * The max incoming data, per average interval to allow
      */
-    get size(): number;
+    maxReceivedData?: number;
     /**
-     * Starts the Connection Manager. If Metrics are not enabled on libp2p
-     * only event loop and connection limits will be monitored.
+     * The upper limit the event loop can take to run
      */
-    start(): void;
+    maxEventLoopDelay?: number;
     /**
-     * If the event loop is slow, maybe close a connection
-     *
-     * @private
-     * @param {*} summary - The LatencyMonitor summary
+     * How often, in milliseconds, metrics and latency should be checked
      */
-    private _onLatencyMeasure;
+    pollInterval?: number;
     /**
-     * Stops the Connection Manager
-     *
-     * @async
+     * How often, in milliseconds, to compute averages
      */
-    stop(): Promise<void>;
+    movingAverageInterval?: number;
     /**
-     * Cleans up the connections
-     *
-     * @async
+     * The value of the peer
      */
-    _close(): Promise<void>;
+    defaultPeerValue?: number;
     /**
-     * Sets the value of the given peer. Peers with lower values
-     * will be disconnected first.
-     *
-     * @param {PeerId} peerId
-     * @param {number} value - A number between 0 and 1
-     * @returns {void}
+     * If true, try to connect to all discovered peers up to the connection manager limit
      */
-    setPeerValue(peerId: PeerId, value: number): void;
+    autoDial?: boolean;
     /**
-     * Tracks the incoming connection and check the connection limit
-     *
-     * @param {Connection} connection
+     * How long to wait between attempting to keep our number of concurrent connections
+     * above minConnections
      */
-    onConnect(connection: Connection): Promise<void>;
+    autoDialInterval: number;
     /**
-     * Removes the connection from tracking
-     *
-     * @param {Connection} connection
-     * @returns {void}
+     * Sort the known addresses of a peer before trying to dial
      */
-    onDisconnect(connection: Connection): void;
+    addressSorter?: AddressSorter;
     /**
-     * Get a connection with a peer.
-     *
-     * @param {PeerId} peerId
-     * @returns {Connection|null}
+     * Number of max concurrent dials
      */
-    get(peerId: PeerId): Connection | null;
+    maxParallelDials?: number;
     /**
-     * Get all open connections with a peer.
-     *
-     * @param {PeerId} peerId
-     * @returns {Connection[]}
+     * Number of max addresses to dial for a given peer
      */
-    getAll(peerId: PeerId): Connection[];
+    maxAddrsToDial?: number;
     /**
-     * If the `value` of `name` has exceeded its limit, maybe close a connection
-     *
-     * @private
-     * @param {string} name - The name of the field to check limits for
-     * @param {number} value - The current value of the field
+     * How long a dial attempt is allowed to take
      */
-    private _checkMaxLimit;
+    dialTimeout?: number;
     /**
-     * If we have more connections than our maximum, close a connection
-     * to the lowest valued peer.
-     *
-     * @private
+     * Number of max concurrent dials per peer
      */
-    private _maybeDisconnectOne;
+    maxDialsPerPeer?: number;
+    /**
+     * Multiaddr resolvers to use when dialing
+     */
+    resolvers?: Record<string, Resolver>;
 }
-declare namespace ConnectionManager {
-    export { Libp2p, Connection, ConnectionManagerOptions };
+export interface ConnectionManagerEvents {
+    'peer:connect': CustomEvent<PeerId>;
+    'peer:disconnect': CustomEvent<PeerId>;
 }
-import { EventEmitter } from "events";
-type Connection = import("libp2p-interfaces/src/connection/connection");
-import LatencyMonitor = require("./latency-monitor");
-import PeerId = require("peer-id");
-type Libp2p = import('../');
-type ConnectionManagerOptions = {
+/**
+ * Responsible for managing known connections.
+ */
+export declare class DefaultConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Startable, Initializable {
+    readonly dialer: Dialer;
+    private components;
+    private readonly opts;
+    private readonly peerValues;
+    private readonly connections;
+    private started;
+    private timer?;
+    private readonly latencyMonitor;
+    constructor(init: ConnectionManagerInit);
+    init(components: Components): void;
+    isStarted(): boolean;
     /**
-     * - The maximum number of connections allowed.
+     * Starts the Connection Manager. If Metrics are not enabled on libp2p
+     * only event loop and connection limits will be monitored.
      */
-    maxConnections?: number | undefined;
+    start(): Promise<void>;
+    afterStart(): Promise<void>;
+    beforeStop(): Promise<void>;
     /**
-     * - The minimum number of connections to avoid pruning.
+     * Stops the Connection Manager
      */
-    minConnections?: number | undefined;
+    stop(): Promise<void>;
     /**
-     * - The max data (in and out), per average interval to allow.
+     * Cleans up the connections
      */
-    maxData?: number | undefined;
+    _close(): Promise<void>;
     /**
-     * - The max outgoing data, per average interval to allow.
+     * Sets the value of the given peer. Peers with lower values
+     * will be disconnected first.
      */
-    maxSentData?: number | undefined;
+    setPeerValue(peerId: PeerId, value: number): void;
     /**
-     * - The max incoming data, per average interval to allow.
+     * Checks the libp2p metrics to determine if any values have exceeded
+     * the configured maximums.
+     *
+     * @private
      */
-    maxReceivedData?: number | undefined;
+    _checkMetrics(): Promise<void>;
+    onConnect(evt: CustomEvent<Connection>): void;
     /**
-     * - The upper limit the event loop can take to run.
+     * Tracks the incoming connection and check the connection limit
      */
-    maxEventLoopDelay?: number | undefined;
+    _onConnect(evt: CustomEvent<Connection>): Promise<void>;
     /**
-     * - How often, in milliseconds, metrics and latency should be checked.
+     * Removes the connection from tracking
      */
-    pollInterval?: number | undefined;
+    onDisconnect(evt: CustomEvent<Connection>): void;
+    getConnections(peerId?: PeerId): Connection[];
+    openConnection(peerId: PeerId, options?: AbortOptions): Promise<Connection>;
+    closeConnections(peerId: PeerId): Promise<void>;
     /**
-     * - How often, in milliseconds, to compute averages.
+     * Get all open connections with a peer
      */
-    movingAverageInterval?: number | undefined;
+    getAll(peerId: PeerId): Connection[];
     /**
-     * - The value of the peer.
+     * If the event loop is slow, maybe close a connection
      */
-    defaultPeerValue?: number | undefined;
+    _onLatencyMeasure(evt: CustomEvent<SummaryObject>): void;
     /**
-     * - Should preemptively guarantee connections are above the low watermark.
+     * If the `value` of `name` has exceeded its limit, maybe close a connection
      */
-    autoDial?: boolean | undefined;
+    _checkMaxLimit(name: keyof ConnectionManagerInit, value: number): Promise<void>;
     /**
-     * - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark.
+     * If we have more connections than our maximum, close a connection
+     * to the lowest valued peer.
      */
-    autoDialInterval?: number | undefined;
-};
+    _maybeDisconnectOne(): Promise<void>;
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/src/connection-manager/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.js"],"names":[],"mappings":";AAsCA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,oBAHW,MAAM,YACN,wBAAwB,EAgDlC;IA3CC,uBAAqB;IACrB,gBAA0C;IAE1C,cAAqF;IAOrF;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAM3B;IAEF;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,UAAU,EAAE,CAAC,CAMjC;IAEF,kBAAqB;IACrB,YAAkB;IAuFpB;;;;;OAKG;IACH,sBAiBC;IA3GC,gCAGE;IAMJ;;OAEG;IACH,mBAGC;IAED;;;OAGG;IACH,cAYC;IA2KD;;;;;OAKG;IACH,0BAKC;IApLD;;;;OAIG;IACH,sBASC;IAED;;;;OAIG;IACH,wBAWC;IAED;;;;;;;OAOG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAOhB;IA2BD;;;;OAIG;IACH,sBAFW,UAAU,iBA4BpB;IAED;;;;;OAKG;IACH,yBAHW,UAAU,GACR,IAAI,CAqBhB;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAQ3B;IAED;;;;;OAKG;IACH,eAHW,MAAM,GACJ,UAAU,EAAE,CAexB;IAeD;;;;;;OAMG;IACH,uBAOC;IAED;;;;;OAKG;IACH,4BAqBC;CACF;;;;;;;;cA5UY,OAAO,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.ts"],"names":[],"mappings":"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"}

package/dist/src/connection-manager/index.js

@@ -0,0 +1,339 @@
+import { logger } from '@libp2p/logger';
+import errCode from 'err-code';
+import mergeOptions from 'merge-options';
+import { LatencyMonitor } from './latency-monitor.js';
+// @ts-expect-error retimer does not have types
+import retimer from 'retimer';
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events';
+import { trackedMap } from '@libp2p/tracked-map';
+import { codes } from '../errors.js';
+import { isPeerId } from '@libp2p/interfaces/peer-id';
+import { setMaxListeners } from 'events';
+import { Components } from '@libp2p/interfaces/components';
+import * as STATUS from '@libp2p/interfaces/connection/status';
+import { Dialer } from './dialer/index.js';
+const log = logger('libp2p:connection-manager');
+const defaultOptions = {
+    maxConnections: Infinity,
+    minConnections: 0,
+    maxData: Infinity,
+    maxSentData: Infinity,
+    maxReceivedData: Infinity,
+    maxEventLoopDelay: Infinity,
+    pollInterval: 2000,
+    autoDialInterval: 10000,
+    movingAverageInterval: 60000,
+    defaultPeerValue: 1
+};
+const METRICS_COMPONENT = 'connection-manager';
+const METRICS_PEER_CONNECTIONS = 'peer-connections';
+const METRICS_PEER_VALUES = 'peer-values';
+/**
+ * Responsible for managing known connections.
+ */
+export class DefaultConnectionManager extends EventEmitter {
+    constructor(init) {
+        super();
+        this.components = new Components();
+        this.opts = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, init);
+        if (this.opts.maxConnections < this.opts.minConnections) {
+            throw errCode(new Error('Connection Manager maxConnections must be greater than minConnections'), codes.ERR_INVALID_PARAMETERS);
+        }
+        log('options: %o', this.opts);
+        /**
+         * Map of peer identifiers to their peer value for pruning connections.
+         *
+         * @type {Map<string, number>}
+         */
+        this.peerValues = trackedMap({
+            component: METRICS_COMPONENT,
+            metric: METRICS_PEER_VALUES,
+            metrics: this.components.getMetrics()
+        });
+        /**
+         * Map of connections per peer
+         */
+        this.connections = trackedMap({
+            component: METRICS_COMPONENT,
+            metric: METRICS_PEER_CONNECTIONS,
+            metrics: this.components.getMetrics()
+        });
+        this.started = false;
+        this._checkMetrics = this._checkMetrics.bind(this);
+        this.latencyMonitor = new LatencyMonitor({
+            latencyCheckIntervalMs: init.pollInterval,
+            dataEmitIntervalMs: init.pollInterval
+        });
+        try {
+            // This emitter gets listened to a lot
+            setMaxListeners?.(Infinity, this);
+        }
+        catch { }
+        this.dialer = new Dialer(this.opts);
+        this.onConnect = this.onConnect.bind(this);
+        this.onDisconnect = this.onDisconnect.bind(this);
+    }
+    init(components) {
+        this.components = components;
+        this.dialer.init(components);
+    }
+    isStarted() {
+        return this.started;
+    }
+    /**
+     * Starts the Connection Manager. If Metrics are not enabled on libp2p
+     * only event loop and connection limits will be monitored.
+     */
+    async start() {
+        if (this.components.getMetrics() != null) {
+            this.timer = this.timer ?? retimer(this._checkMetrics, this.opts.pollInterval);
+        }
+        // latency monitor
+        this.latencyMonitor.start();
+        this._onLatencyMeasure = this._onLatencyMeasure.bind(this);
+        this.latencyMonitor.addEventListener('data', this._onLatencyMeasure);
+        await this.dialer.start();
+        this.started = true;
+        log('started');
+    }
+    async afterStart() {
+        this.components.getUpgrader().addEventListener('connection', this.onConnect);
+        this.components.getUpgrader().addEventListener('connectionEnd', this.onDisconnect);
+    }
+    async beforeStop() {
+        this.components.getUpgrader().removeEventListener('connection', this.onConnect);
+        this.components.getUpgrader().removeEventListener('connectionEnd', this.onDisconnect);
+    }
+    /**
+     * Stops the Connection Manager
+     */
+    async stop() {
+        this.timer?.clear();
+        this.latencyMonitor.removeEventListener('data', this._onLatencyMeasure);
+        this.latencyMonitor.stop();
+        await this.dialer.stop();
+        this.started = false;
+        await this._close();
+        log('stopped');
+    }
+    /**
+     * Cleans up the connections
+     */
+    async _close() {
+        // Close all connections we're tracking
+        const tasks = [];
+        for (const connectionList of this.connections.values()) {
+            for (const connection of connectionList) {
+                tasks.push((async () => {
+                    try {
+                        await connection.close();
+                    }
+                    catch (err) {
+                        log.error(err);
+                    }
+                })());
+            }
+        }
+        log('closing %d connections', tasks.length);
+        await Promise.all(tasks);
+        this.connections.clear();
+    }
+    /**
+     * Sets the value of the given peer. Peers with lower values
+     * will be disconnected first.
+     */
+    setPeerValue(peerId, value) {
+        if (value < 0 || value > 1) {
+            throw new Error('value should be a number between 0 and 1');
+        }
+        this.peerValues.set(peerId.toString(), value);
+    }
+    /**
+     * Checks the libp2p metrics to determine if any values have exceeded
+     * the configured maximums.
+     *
+     * @private
+     */
+    async _checkMetrics() {
+        const metrics = this.components.getMetrics();
+        if (metrics != null) {
+            try {
+                const movingAverages = metrics.getGlobal().getMovingAverages();
+                const received = movingAverages.dataReceived[this.opts.movingAverageInterval].movingAverage;
+                await this._checkMaxLimit('maxReceivedData', received);
+                const sent = movingAverages.dataSent[this.opts.movingAverageInterval].movingAverage;
+                await this._checkMaxLimit('maxSentData', sent);
+                const total = received + sent;
+                await this._checkMaxLimit('maxData', total);
+                log.trace('metrics update', total);
+            }
+            finally {
+                this.timer = retimer(this._checkMetrics, this.opts.pollInterval);
+            }
+        }
+    }
+    onConnect(evt) {
+        void this._onConnect(evt).catch(err => {
+            log.error(err);
+        });
+    }
+    /**
+     * Tracks the incoming connection and check the connection limit
+     */
+    async _onConnect(evt) {
+        const { detail: connection } = evt;
+        if (!this.started) {
+            // This can happen when we are in the process of shutting down the node
+            await connection.close();
+            return;
+        }
+        const peerId = connection.remotePeer;
+        const peerIdStr = peerId.toString();
+        const storedConns = this.connections.get(peerIdStr);
+        if (storedConns != null) {
+            storedConns.push(connection);
+        }
+        else {
+            this.connections.set(peerIdStr, [connection]);
+        }
+        if (peerId.publicKey != null) {
+            await this.components.getPeerStore().keyBook.set(peerId, peerId.publicKey);
+        }
+        if (!this.peerValues.has(peerIdStr)) {
+            this.peerValues.set(peerIdStr, this.opts.defaultPeerValue);
+        }
+        await this._checkMaxLimit('maxConnections', this.getConnections().length);
+        this.dispatchEvent(new CustomEvent('peer:connect', { detail: connection }));
+    }
+    /**
+     * Removes the connection from tracking
+     */
+    onDisconnect(evt) {
+        const { detail: connection } = evt;
+        if (!this.started) {
+            // This can happen when we are in the process of shutting down the node
+            return;
+        }
+        const peerId = connection.remotePeer.toString();
+        let storedConn = this.connections.get(peerId);
+        if (storedConn != null && storedConn.length > 1) {
+            storedConn = storedConn.filter((conn) => conn.id !== connection.id);
+            this.connections.set(peerId, storedConn);
+        }
+        else if (storedConn != null) {
+            this.connections.delete(peerId);
+            this.peerValues.delete(connection.remotePeer.toString());
+            this.dispatchEvent(new CustomEvent('peer:disconnect', { detail: connection }));
+            this.components.getMetrics()?.onPeerDisconnected(connection.remotePeer);
+        }
+    }
+    getConnections(peerId) {
+        if (peerId != null) {
+            return this.connections.get(peerId.toString()) ?? [];
+        }
+        let conns = [];
+        for (const c of this.connections.values()) {
+            conns = conns.concat(c);
+        }
+        return conns;
+    }
+    async openConnection(peerId, options) {
+        log('dial to %p', peerId);
+        const existingConnections = this.getConnections(peerId);
+        if (existingConnections.length > 0) {
+            log('had an existing connection to %p', peerId);
+            return existingConnections[0];
+        }
+        const connection = await this.dialer.dial(peerId, options);
+        let peerConnections = this.connections.get(peerId.toString());
+        if (peerConnections == null) {
+            peerConnections = [];
+            this.connections.set(peerId.toString(), peerConnections);
+        }
+        // we get notified of connections via the Upgrader emitting "connection"
+        // events, double check we aren't already tracking this connection before
+        // storing it
+        let trackedConnection = false;
+        for (const conn of peerConnections) {
+            if (conn.id === connection.id) {
+                trackedConnection = true;
+            }
+        }
+        if (!trackedConnection) {
+            peerConnections.push(connection);
+        }
+        return connection;
+    }
+    async closeConnections(peerId) {
+        const connections = this.connections.get(peerId.toString()) ?? [];
+        await Promise.all(connections.map(async (connection) => {
+            return await connection.close();
+        }));
+    }
+    /**
+     * Get all open connections with a peer
+     */
+    getAll(peerId) {
+        if (!isPeerId(peerId)) {
+            throw errCode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS);
+        }
+        const id = peerId.toString();
+        const connections = this.connections.get(id);
+        // Return all open connections
+        if (connections != null) {
+            return connections.filter(connection => connection.stat.status === STATUS.OPEN);
+        }
+        return [];
+    }
+    /**
+     * If the event loop is slow, maybe close a connection
+     */
+    _onLatencyMeasure(evt) {
+        const { detail: summary } = evt;
+        this._checkMaxLimit('maxEventLoopDelay', summary.avgMs)
+            .catch(err => {
+            log.error(err);
+        });
+    }
+    /**
+     * If the `value` of `name` has exceeded its limit, maybe close a connection
+     */
+    async _checkMaxLimit(name, value) {
+        const limit = this.opts[name];
+        log.trace('checking limit of %s. current value: %d of %d', name, value, limit);
+        if (value > limit) {
+            log('%s: limit exceeded: %p, %d', this.components.getPeerId(), name, value);
+            await this._maybeDisconnectOne();
+        }
+    }
+    /**
+     * If we have more connections than our maximum, close a connection
+     * to the lowest valued peer.
+     */
+    async _maybeDisconnectOne() {
+        if (this.opts.minConnections < this.connections.size) {
+            const peerValues = Array.from(new Map([...this.peerValues.entries()].sort((a, b) => a[1] - b[1])));
+            log('%p: sorted peer values: %j', this.components.getPeerId(), peerValues);
+            const disconnectPeer = peerValues[0];
+            if (disconnectPeer != null) {
+                const peerId = disconnectPeer[0];
+                log('%p: lowest value peer is %s', this.components.getPeerId(), peerId);
+                log('%p: closing a connection to %j', this.components.getPeerId(), peerId);
+                for (const connections of this.connections.values()) {
+                    if (connections[0].remotePeer.toString() === peerId) {
+                        void connections[0].close()
+                            .catch(err => {
+                            log.error(err);
+                        });
+                        // TODO: should not need to invoke this manually
+                        this.onDisconnect(new CustomEvent('connectionEnd', {
+                            detail: connections[0]
+                        }));
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=index.js.map