@dxos/network-manager 0.1.8 → 0.1.10

package/src/swarm/peer.ts

@@ -0,0 +1,156 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import assert from 'assert';
+
+import { synchronized } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { Protocol } from '@dxos/mesh-protocol';
+
+import { SignalMessage, SignalMessenger } from '../signal';
+import { TransportFactory } from '../transport';
+import { Connection, ConnectionState } from './connection';
+
+interface PeerCallbacks {
+  /**
+   * Connection opened.
+   */
+  onConnected: () => void;
+
+  /**
+   * Connection closed.
+   */
+  onDisconnected: () => void;
+
+  /**
+   * Peer accepted our offer to connect.
+   */
+  onAccepted: () => void;
+
+  /**
+   * Peer rejected our offer to connect.
+   */
+  onRejected: () => void;
+}
+
+export class Peer {
+  public connection?: Connection;
+
+  /**
+   * Whether the peer is currently advertizing itself on the signal-network.
+   */
+  public advertizing = false;
+
+  constructor(
+    public readonly id: PublicKey,
+    public readonly topic: PublicKey,
+    public readonly localPeerId: PublicKey,
+    private readonly _callbacks: PeerCallbacks
+  ) {}
+
+  /**
+   * Create new connection.
+   * Either we're initiating a connection or creating one in response to an offer from the other peer.
+   */
+  createConnection(
+    // TODO(dmaretskyi): Move into constructor?
+    signalMessaging: SignalMessenger,
+    initiator: boolean,
+    sessionId: PublicKey,
+    protocol: Protocol,
+    transportFactory: TransportFactory
+  ) {
+    log('creating connection', {
+      topic: this.topic,
+      peerId: this.localPeerId,
+      remoteId: this.id,
+      initiator,
+      sessionId
+    });
+    assert(!this.connection, 'Already connected.');
+    const connection = new Connection(
+      this.topic,
+      this.localPeerId,
+      this.id,
+      sessionId,
+      initiator,
+      signalMessaging,
+      protocol,
+      transportFactory
+    );
+    connection.stateChanged.on((state) => {
+      switch (state) {
+        case ConnectionState.CONNECTED: {
+          this._callbacks.onConnected();
+          break;
+        }
+
+        case ConnectionState.REJECTED: {
+          this._callbacks.onRejected();
+          break;
+        }
+
+        case ConnectionState.ACCEPTED: {
+          this._callbacks.onAccepted();
+          break;
+        }
+
+        case ConnectionState.CLOSED: {
+          log('connection closed', { topic: this.topic, peerId: this.localPeerId, remoteId: this.id, initiator });
+          assert(this.connection === connection, 'Connection mismatch (race condition).');
+
+          this.connection = undefined;
+          this._callbacks.onDisconnected();
+          break;
+        }
+      }
+    });
+    connection.errors.handle((err) => {
+      log.warn('connection error', { topic: this.topic, peerId: this.localPeerId, remoteId: this.id, initiator, err });
+
+      // Calls `onStateChange` with CLOSED state.
+      void this.closeConnection().catch(() => {
+        log.catch(err);
+      });
+    });
+
+    this.connection = connection;
+
+    return connection;
+  }
+
+  async closeConnection() {
+    if (!this.connection) {
+      return;
+    }
+    const connection = this.connection;
+    log('closing...', { peerId: this.id, sessionId: connection.sessionId });
+
+    try {
+      // Triggers `onStateChange` callback which will clean up the connection.
+      await connection.close();
+    } catch (err) {
+      log.catch(err);
+    }
+
+    log('closed', { peerId: this.id, sessionId: connection.sessionId });
+  }
+
+  async onSignal(message: SignalMessage) {
+    if (!this.connection) {
+      log('dropping signal message for non-existent connection', { message });
+      return;
+    }
+    await this.connection.signal(message);
+  }
+
+  @synchronized
+  async destroy() {
+    log('Destroying peer', { peerId: this.id, topic: this.topic });
+
+    // Won't throw.
+    await this?.connection?.close();
+  }
+}

package/src/swarm/swarm-mapper.ts

@@ -30,15 +30,14 @@ type Unsubscribe = () => void;
 export class SwarmMapper {
   private readonly _subscriptions = new EventSubscriptions();
   private readonly _connectionSubscriptions = new ComplexMap<PublicKey, Unsubscribe>(PublicKey.hash);
-
   private readonly _peers = new ComplexMap<PublicKey, PeerInfo>(PublicKey.hash);
 
+  readonly mapUpdated = new Event<PeerInfo[]>();
+
   get peers(): PeerInfo[] {
     return Array.from(this._peers.values());
   }
 
-  readonly mapUpdated = new Event<PeerInfo[]>();
-
   // prettier-ignore
   constructor(
     private readonly _swarm: Swarm,
@@ -55,29 +54,35 @@ export class SwarmMapper {
         );
       })
     );
+
     this._subscriptions.add(
-      _swarm.connectionRemoved.on((connection) => {
-        this._connectionSubscriptions.get(connection.remoteId)?.();
-        this._connectionSubscriptions.delete(connection.remoteId);
+      _swarm.disconnected.on((peerId) => {
+        this._connectionSubscriptions.get(peerId)?.();
+        this._connectionSubscriptions.delete(peerId);
         this._update();
       })
     );
+
     if (_presence) {
-      const cb = () => {
+      this._subscriptions.add(_presence.graphUpdated.on(() => {
         this._update();
-      };
-      this._subscriptions.add(_presence.graphUpdated.on(cb));
+      }));
     }
+
+    // TODO(burdon): Do not call from constructor.
     this._update();
   }
 
   private _update() {
+    log('updating swarm');
+
     this._peers.clear();
     this._peers.set(this._swarm.ownPeerId, {
       id: this._swarm.ownPeerId,
-      state: 'ME',
+      state: 'ME', // TODO(burdon): Enum (rename "local").
       connections: []
     });
+
     for (const connection of this._swarm.connections) {
       this._peers.set(connection.remoteId, {
         id: connection.remoteId,
@@ -85,18 +90,21 @@ export class SwarmMapper {
         connections: [this._swarm.ownPeerId]
       });
     }
+
     if (this._presence) {
       this._presence.graph.forEachNode((node: any) => {
         const id = PublicKey.fromHex(node.id);
         if (this._peers.has(id)) {
           return;
         }
+
         this._peers.set(id, {
           id,
           state: 'INDIRECTLY_CONNECTED',
           connections: []
         });
       });
+
       this._presence.graph.forEachLink((link: any) => {
         const from = PublicKey.from(link.fromId);
         const to = PublicKey.from(link.toId);
@@ -106,13 +114,16 @@ export class SwarmMapper {
         }
       });
     }
+
     log('graph changed', {
       directConnections: this._swarm.connections.length,
       totalPeersInSwarm: this._peers.size
     });
+
     this.mapUpdated.emit(Array.from(this._peers.values()));
   }
 
+  // TODO(burdon): Async open/close.
   destroy() {
     Array.from(this._connectionSubscriptions.values()).forEach((cb) => cb());
     this._subscriptions.clear();

package/src/swarm/swarm.ts

@@ -12,15 +12,15 @@ import { log } from '@dxos/log';
 import { Messenger } from '@dxos/messaging';
 import { SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
 import { Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
-import { ComplexMap, ComplexSet } from '@dxos/util';
+import { ComplexMap, isNotNullOrUndefined } from '@dxos/util';
 
 import { ProtocolProvider } from '../network-manager';
-import { MessageRouter } from '../signal';
-import { OfferMessage, SignalMessage } from '../signal/signal-messaging';
+import { MessageRouter, OfferMessage, SignalMessage } from '../signal';
 import { SwarmController, Topology } from '../topology';
 import { TransportFactory } from '../transport';
 import { Topic } from '../types';
-import { Connection, ConnectionState } from './connection';
+import { Connection } from './connection';
+import { Peer } from './peer';
 
 const INITIATION_DELAY = 100;
 
@@ -33,10 +33,12 @@ const getClassName = (obj: any) => Object.getPrototypeOf(obj).constructor.name;
  * Routes signal events and maintains swarm topology.
  */
 export class Swarm {
-  private readonly _connections = new ComplexMap<PublicKey, Connection>(PublicKey.hash);
-  private readonly _discoveredPeers = new ComplexSet<PublicKey>(PublicKey.hash);
+  private readonly _peers = new ComplexMap<PublicKey, Peer>(PublicKey.hash);
+
   private readonly _swarmMessenger: MessageRouter;
 
+  private _destroyed = false;
+
   /**
    * Unique id of the swarm, local to the current peer, generated when swarm is joined.
    */
@@ -44,21 +46,26 @@ export class Swarm {
 
   /**
    * New connection to a peer is started.
+   * @internal
    */
   readonly connectionAdded = new Event<Connection>();
 
   /**
    * Connection to a peer is dropped.
+   * @internal
    */
-  readonly connectionRemoved = new Event<Connection>();
+  readonly disconnected = new Event<PublicKey>();
 
   /**
    * Connection is established to a new peer.
+   * @internal
    */
   readonly connected = new Event<PublicKey>();
 
   readonly errors = new ErrorStream();
 
+  // TODO(burdon): Swarm => Peer.create/destroy =< Connection.open/close
+
   // TODO(burdon): Split up properties.
   constructor(
     private readonly _topic: PublicKey,
@@ -69,7 +76,7 @@ export class Swarm {
     private readonly _transportFactory: TransportFactory,
     private readonly _label: string | undefined
   ) {
-    log('creating swarm', { topic: this._topic, peerId: _ownPeerId });
+    log('creating swarm', { id: this.id, topic: this._topic, peerId: _ownPeerId });
     _topology.init(this._getSwarmController());
 
     this._swarmMessenger = new MessageRouter({
@@ -89,7 +96,9 @@ export class Swarm {
   }
 
   get connections() {
-    return Array.from(this._connections.values());
+    return Array.from(this._peers.values())
+      .map((peer) => peer.connection)
+      .filter(isNotNullOrUndefined);
   }
 
   get ownPeerId() {
@@ -107,40 +116,123 @@ export class Swarm {
     return this._topic;
   }
 
+  // TODO(burdon): async open?
+  async destroy() {
+    log('destroying', { id: this.id, topic: this._topic });
+    this._destroyed = true;
+    await this._topology.destroy();
+    await Promise.all(Array.from(this._peers.keys()).map((key) => this._closeConnection(key)));
+  }
+
+  async setTopology(topology: Topology) {
+    if (topology === this._topology) {
+      return;
+    }
+    log('setting topology', {
+      id: this.id,
+      topic: this._topic,
+      previous: getClassName(this._topology),
+      topology: getClassName(topology)
+    });
+
+    await this._topology.destroy();
+    this._topology = topology;
+    this._topology.init(this._getSwarmController());
+    this._topology.update();
+  }
+
+  private _getOrCreatePeer(peerId: PublicKey): Peer {
+    let peer = this._peers.get(peerId);
+    if (!peer) {
+      peer = new Peer(peerId, this._topic, this._ownPeerId, {
+        onConnected: () => {
+          this.connected.emit(peerId);
+        },
+        onDisconnected: async () => {
+          if (!peer!.advertizing) {
+            await this._destroyPeer(peer!.id);
+          }
+
+          this.disconnected.emit(peerId);
+          this._topology.update();
+        },
+        onRejected: () => {
+          // If the peer rejected our connection remove it from the set of candidates.
+          // TODO(dmaretskyi): Set flag instead.
+          if (this._peers.has(peerId)) {
+            void this._destroyPeer(peerId);
+          }
+        },
+        onAccepted: () => {
+          this._topology.update();
+        }
+      });
+      this._peers.set(peerId, peer);
+    }
+
+    return peer;
+  }
+
+  private async _destroyPeer(peerId: PublicKey) {
+    assert(this._peers.has(peerId));
+    await this._peers.get(peerId)!.destroy();
+    this._peers.delete(peerId);
+  }
+
   onSwarmEvent(swarmEvent: SwarmEvent) {
-    log('swarm event', { topic: this._topic, swarmEvent });
+    log('swarm event', { id: this.id, topic: this._topic, swarmEvent }); // TODO(burdon): Stringify.
+    if (this._destroyed) {
+      log.warn('ignored for destroyed swarm', { peerId: this.id, topic: this._topic });
+      return;
+    }
+
     if (swarmEvent.peerAvailable) {
       const peerId = PublicKey.from(swarmEvent.peerAvailable.peer);
-      log('new peer', { topic: this._topic, peerId });
+      log('new peer', { id: this.id, topic: this._topic, peerId });
       if (!peerId.equals(this._ownPeerId)) {
-        this._discoveredPeers.add(peerId);
+        const peer = this._getOrCreatePeer(peerId);
+        peer.advertizing = true;
       }
     } else if (swarmEvent.peerLeft) {
-      this._discoveredPeers.delete(PublicKey.from(swarmEvent.peerLeft.peer));
+      const peer = this._peers.get(PublicKey.from(swarmEvent.peerLeft.peer));
+      if (peer) {
+        peer.advertizing = false;
+        if (!peer.connection) {
+          void this._destroyPeer(peer.id);
+        }
+      }
     }
 
     this._topology.update();
   }
 
   async onOffer(message: OfferMessage): Promise<Answer> {
-    log('offer', { topic: this._topic, message });
+    log('offer', { id: this.id, topic: this._topic, message });
+    if (this._destroyed) {
+      log.warn('ignored for destroyed swarm', { peerId: this.id, topic: this._topic });
+      return { accept: false };
+    }
+
     // Id of the peer offering us the connection.
     assert(message.author);
     const remoteId = message.author;
     if (!message.recipient?.equals(this._ownPeerId)) {
-      log('rejecting offer with incorrect peerId', { topic: this._topic, message });
+      log('rejecting offer with incorrect peerId', { id: this.id, topic: this._topic, message });
       return { accept: false };
     }
     if (!message.topic?.equals(this._topic)) {
-      log('rejecting offer with incorrect topic', { topic: this._topic, message });
+      log('rejecting offer with incorrect topic', { id: this.id, topic: this._topic, message });
       return { accept: false };
     }
 
+    const peer = this._getOrCreatePeer(remoteId);
+
     // Check if we are already trying to connect to that peer.
-    if (this._connections.has(remoteId)) {
-      // Peer with the highest Id closes it's connection, and accepts remote peer's offer.
+    if (peer.connection) {
+      // Peer with the highest Id closes its connection, and accepts remote peer's offer.
       if (remoteId.toHex() < this._ownPeerId.toHex()) {
         log("closing local connection and accepting remote peer's offer", {
+          id: this.id,
           topic: this._topic,
           peerId: this._ownPeerId
         });
@@ -156,12 +248,12 @@ export class Swarm {
 
     let accept = false;
     if (await this._topology.onOffer(remoteId)) {
-      if (!this._connections.has(remoteId)) {
+      if (!peer.connection) {
         // Connection might have been already established.
         assert(message.sessionId);
         const connection = this._createConnection(false, message.author, message.sessionId);
         try {
-          connection.open();
+          connection.openConnection();
         } catch (err: any) {
           this.errors.raise(err);
         }
@@ -175,49 +267,32 @@ export class Swarm {
   }
 
   async onSignal(message: SignalMessage): Promise<void> {
-    log('signal', { topic: this._topic, message });
+    log('signal', { id: this.id, topic: this._topic, message });
+    if (this._destroyed) {
+      log.warn('ignored for destroyed swarm', { peerId: this.id, topic: this._topic });
+      return;
+    }
     assert(
       message.recipient?.equals(this._ownPeerId),
       `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`
     );
     assert(message.topic?.equals(this._topic));
     assert(message.author);
-    const connection = this._connections.get(message.author);
-    if (!connection) {
-      log('dropping signal message for non-existent connection', { topic: this._topic, message });
-      return;
-    }
 
-    await connection.signal(message);
-  }
-
-  async setTopology(topology: Topology) {
-    if (topology === this._topology) {
-      return;
-    }
-    log('setting topology', {
-      topic: this._topic,
-      previous: getClassName(this._topology),
-      topology: getClassName(topology)
-    });
-    await this._topology.destroy();
-    this._topology = topology;
-    this._topology.init(this._getSwarmController());
-    this._topology.update();
-  }
-
-  async destroy() {
-    log('destroying', { topic: this._topic });
-    await this._topology.destroy();
-    await Promise.all(Array.from(this._connections.keys()).map((key) => this._closeConnection(key)));
+    const peer = this._getOrCreatePeer(message.author);
+    await peer.onSignal(message);
   }
 
   private _getSwarmController(): SwarmController {
     return {
       getState: () => ({
         ownPeerId: this._ownPeerId,
-        connected: Array.from(this._connections.keys()),
-        candidates: Array.from(this._discoveredPeers.keys()).filter((key) => !this._connections.has(key))
+        connected: Array.from(this._peers.values())
+          .filter((peer) => peer.connection)
+          .map((peer) => peer.id),
+        candidates: Array.from(this._peers.values())
+          .filter((peer) => !peer.connection && peer.advertizing)
+          .map((peer) => peer.id)
       }),
       connect: (peer) => this._initiateConnection(peer),
       disconnect: async (peer) => {
@@ -231,7 +306,9 @@ export class Swarm {
     };
   }
 
-  // TODO(burdon): Make async.
+  /**
+   * Creates a connection then sends message over signal network.
+   */
   private async _initiateConnection(remoteId: PublicKey) {
     // It is likely that the other peer will also try to connect to us at the same time.
     // If our peerId is higher, we will wait for a bit so that other peer has a chance to connect first.
@@ -239,90 +316,44 @@ export class Swarm {
       await sleep(INITIATION_DELAY);
     }
 
-    if (this._connections.has(remoteId)) {
+    if (this._peers.get(remoteId)?.connection) {
       // Do nothing if peer is already connected.
       return;
     }
 
     const sessionId = PublicKey.random();
 
-    log('initiating...', { topic: this._topic, peerId: remoteId, sessionId });
+    log('initiating...', { id: this.id, topic: this._topic, peerId: remoteId, sessionId });
     const connection = this._createConnection(true, remoteId, sessionId);
     connection.initiate();
     this._topology.update();
-    log('initiated', { topic: this._topic });
+    log('initiated', { id: this.id, topic: this._topic });
   }
 
-  // TODO(burdon): Make async.
-  private _createConnection(initiator: boolean, remoteId: PublicKey, sessionId: PublicKey) {
-    log('creating connection', { topic: this._topic, peerId: this._ownPeerId, remoteId, initiator });
-    assert(!this._connections.has(remoteId), 'Peer already connected.');
+  /**
+   * Synchronously create a connection, which must be initialized.
+   */
+  private _createConnection(initiator: boolean, remoteId: PublicKey, sessionId: PublicKey): Connection {
+    const peer = this._getOrCreatePeer(remoteId);
 
-    const connection = new Connection(
-      this._topic,
-      this._ownPeerId,
-      remoteId,
-      sessionId,
-      initiator,
+    const connection = peer.createConnection(
       this._swarmMessenger,
+      initiator,
+      sessionId,
       this._protocolProvider({ channel: discoveryKey(this._topic), initiator }),
       this._transportFactory
     );
 
-    this._connections.set(remoteId, connection);
     this.connectionAdded.emit(connection);
-
-    connection.errors.handle((err) => {
-      // TODO(burdon): Change to warn? Why does this fail during tests?
-      log('connection failed', { topic: this._topic, peerId: this._ownPeerId, remoteId, initiator, err });
-      this._closeConnection(remoteId).catch((err) => this.errors.raise(err));
-    });
-
-    connection.stateChanged.on((state) => {
-      switch (state) {
-        case ConnectionState.CONNECTED: {
-          this.connected.emit(remoteId);
-          break;
-        }
-
-        case ConnectionState.REJECTED: {
-          // If the peer rejected our connection remove it from the set of candidates.
-          this._discoveredPeers.delete(remoteId);
-          break;
-        }
-
-        case ConnectionState.ACCEPTED: {
-          this._topology.update();
-          break;
-        }
-
-        case ConnectionState.CLOSED: {
-          log('connection closed', { topic: this._topic, peerId: this._ownPeerId, remoteId, initiator });
-          // Connection might have been already closed or replace by a different one.
-          // Only remove the connection if it has the same session id.
-          if (this._connections.get(remoteId)?.sessionId.equals(sessionId)) {
-            this._connections.delete(remoteId);
-            this.connectionRemoved.emit(connection);
-            this._topology.update();
-          }
-          break;
-        }
-      }
-    });
-
     return connection;
   }
 
-  // TODO(burdon): Make async.
   private async _closeConnection(peerId: PublicKey) {
-    log('closing...', { topic: this._topic, peerId });
-    const connection = this._connections.get(peerId);
-    if (!connection) {
+    const peer = this._peers.get(peerId);
+    if (!peer) {
       return;
     }
 
-    this._connections.delete(peerId);
-    await connection.close();
-    log('closed', { topic: this._topic });
+    await peer.closeConnection();
   }
 }