@dxos/network-manager 0.1.0

package/src/swarm/connection.ts

@@ -0,0 +1,206 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { Event, synchronized } from '@dxos/async';
+import { ErrorStream } from '@dxos/debug';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { Protocol } from '@dxos/mesh-protocol';
+import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
+
+import { SignalMessage, SignalMessaging } from '../signal';
+import { Transport, TransportFactory } from '../transport';
+
+/**
+ * State machine for each connection.
+ */
+export enum ConnectionState {
+  /**
+   * Initial state. Connection is registered but no attempt to connect to the remote peer has been performed.
+   * Might mean that we are waiting for the answer signal from the remote peer.
+   */
+  INITIAL = 'INITIAL',
+
+  /**
+   * Originating a connection.
+   */
+  INITIATING_CONNECTION = 'INITIATING_CONNECTION',
+
+  /**
+   * Waiting for a connection to be originated from the remote peer.
+   */
+  WAITING_FOR_CONNECTION = 'WAITING_FOR_CONNECTION',
+
+  /**
+   * Peer rejected offer.
+   */
+  ACCEPTED = 'ACCEPTED',
+
+  /**
+   * Peer rejected offer.
+   */
+  REJECTED = 'REJECTED',
+
+  /**
+   * Connection is established.
+   */
+  CONNECTED = 'CONNECTED',
+
+  /**
+   * Connection closed.
+   */
+  CLOSED = 'CLOSED'
+}
+
+/**
+ * Represents a connection to a remote peer.
+ */
+export class Connection {
+  private _state: ConnectionState = ConnectionState.INITIAL;
+  private _transport: Transport | undefined;
+  private _bufferedSignals: Signal[] = [];
+
+  readonly stateChanged = new Event<ConnectionState>();
+  readonly errors = new ErrorStream();
+
+  constructor(
+    public readonly topic: PublicKey,
+    public readonly ownId: PublicKey, // TODO(burdon): peerID?
+    public readonly remoteId: PublicKey,
+    public readonly sessionId: PublicKey,
+    public readonly initiator: boolean,
+    private readonly _signalMessaging: SignalMessaging,
+    private readonly _protocol: Protocol,
+    private readonly _transportFactory: TransportFactory
+  ) {}
+
+  get state() {
+    return this._state;
+  }
+
+  get transport() {
+    return this._transport;
+  }
+
+  get protocol() {
+    return this._protocol;
+  }
+
+  // TODO(burdon): Make async.
+  initiate() {
+    this._signalMessaging
+      .offer({
+        author: this.ownId,
+        recipient: this.remoteId,
+        sessionId: this.sessionId,
+        topic: this.topic,
+        data: { offer: {} }
+      })
+      .then((answer) => {
+        log('received', { answer, topic: this.topic, ownId: this.ownId, remoteId: this.remoteId });
+        if (this.state !== ConnectionState.INITIAL) {
+          log('ignoring response');
+          return;
+        }
+
+        if (answer.accept) {
+          try {
+            this.open();
+          } catch (err: any) {
+            this.errors.raise(err);
+          }
+        } else {
+          // If the peer rejected our connection remove it from the set of candidates.
+          this._changeState(ConnectionState.REJECTED);
+        }
+
+        this._changeState(ConnectionState.ACCEPTED);
+      })
+      .catch((err) => {
+        this.errors.raise(err);
+      });
+  }
+
+  // TODO(burdon): Make async?
+  open() {
+    assert(this._state === ConnectionState.INITIAL, 'Invalid state.');
+    this._changeState(this.initiator ? ConnectionState.INITIATING_CONNECTION : ConnectionState.WAITING_FOR_CONNECTION);
+
+    assert(!this._transport);
+    this._transport = this._transportFactory.create({
+      topic: this.topic,
+      ownId: this.ownId,
+      remoteId: this.remoteId,
+      sessionId: this.sessionId,
+      initiator: this.initiator,
+      stream: this._protocol.stream,
+      sendSignal: this._signalMessaging.signal.bind(this._signalMessaging)
+    });
+
+    this._transport.connected.once(() => {
+      this._changeState(ConnectionState.CONNECTED);
+    });
+
+    this._transport.closed.once(() => {
+      this._transport = undefined;
+      this.close().catch((err) => this.errors.raise(err));
+    });
+
+    this._transport.errors.pipeTo(this.errors);
+
+    // Replay signals that were received before transport was created.
+    for (const signal of this._bufferedSignals) {
+      void this._transport.signal(signal); // TODO(burdon): Remove async?
+    }
+
+    this._bufferedSignals = [];
+  }
+
+  @synchronized
+  async close() {
+    if (this._state === ConnectionState.CLOSED) {
+      return;
+    }
+
+    // TODO(dmaretskyi): CLOSING state.
+    log('closing', { peerId: this.ownId });
+
+    // This will try to gracefull close the stream flushing any unsent data packets.
+    await this._protocol.close();
+
+    // After the transport is closed streams are disconnected.
+    await this._transport?.close();
+
+    this._changeState(ConnectionState.CLOSED);
+    log('closed', { peerId: this.ownId });
+  }
+
+  async signal(msg: SignalMessage) {
+    assert(msg.sessionId);
+    if (!msg.sessionId.equals(this.sessionId)) {
+      log('dropping signal for incorrect session id');
+      return;
+    }
+    assert(msg.data.signal);
+    assert(msg.author?.equals(this.remoteId));
+    assert(msg.recipient?.equals(this.ownId));
+
+    if (this._state === ConnectionState.INITIAL) {
+      log('buffered signal', { peerId: this.ownId, remoteId: this.remoteId, msg: msg.data });
+      this._bufferedSignals.push(msg.data.signal);
+      return;
+    }
+
+    assert(this._transport, 'Connection not ready to accept signals.');
+    log('received signal', { peerId: this.ownId, remoteId: this.remoteId, msg: msg.data });
+    await this._transport.signal(msg.data.signal);
+  }
+
+  private _changeState(state: ConnectionState): void {
+    this._state = state;
+    this.stateChanged.emit(state);
+  }
+}

package/src/swarm/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+export * from './connection';
+export * from './swarm';
+export * from './swarm-mapper';

package/src/swarm/swarm-mapper.ts

@@ -0,0 +1,120 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Event, EventSubscriptions } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { PresencePlugin } from '@dxos/protocol-plugin-presence';
+import { ComplexMap } from '@dxos/util';
+
+import { ConnectionState } from './connection';
+import { Swarm } from './swarm';
+
+/**
+ * State of the connection to the remote peer with additional info derived from network mapping.
+ */
+export type PeerState = ConnectionState | 'INDIRECTLY_CONNECTED' | 'ME';
+
+/**
+ * Information about remote peer, directly or indirectly connected.
+ */
+export interface PeerInfo {
+  id: PublicKey;
+  state: PeerState;
+  connections: PublicKey[];
+}
+
+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);
+
+  get peers(): PeerInfo[] {
+    return Array.from(this._peers.values());
+  }
+
+  readonly mapUpdated = new Event<PeerInfo[]>();
+
+  // prettier-ignore
+  constructor(
+    private readonly _swarm: Swarm,
+    private readonly _presence: PresencePlugin | undefined
+  ) {
+    this._subscriptions.add(
+      _swarm.connectionAdded.on((connection) => {
+        this._update();
+        this._connectionSubscriptions.set(
+          connection.remoteId,
+          connection.stateChanged.on(() => {
+            this._update();
+          })
+        );
+      })
+    );
+    this._subscriptions.add(
+      _swarm.connectionRemoved.on((connection) => {
+        this._connectionSubscriptions.get(connection.remoteId)?.();
+        this._connectionSubscriptions.delete(connection.remoteId);
+        this._update();
+      })
+    );
+    if (_presence) {
+      const cb = () => {
+        this._update();
+      };
+      this._subscriptions.add(_presence.graphUpdated.on(cb));
+    }
+    this._update();
+  }
+
+  private _update() {
+    this._peers.clear();
+    this._peers.set(this._swarm.ownPeerId, {
+      id: this._swarm.ownPeerId,
+      state: 'ME',
+      connections: []
+    });
+    for (const connection of this._swarm.connections) {
+      this._peers.set(connection.remoteId, {
+        id: connection.remoteId,
+        state: connection.state,
+        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);
+        // Ignore connections to self, they are already handled.
+        if (!from.equals(this._swarm.ownPeerId) && !to.equals(this._swarm.ownPeerId)) {
+          this._peers.get(from)!.connections.push(to);
+        }
+      });
+    }
+    log('graph changed', {
+      directConnections: this._swarm.connections.length,
+      totalPeersInSwarm: this._peers.size
+    });
+    this.mapUpdated.emit(Array.from(this._peers.values()));
+  }
+
+  destroy() {
+    Array.from(this._connectionSubscriptions.values()).forEach((cb) => cb());
+    this._subscriptions.clear();
+  }
+}

package/src/swarm/swarm.test.ts

@@ -0,0 +1,192 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+// @dxos/mocha platform=nodejs
+
+import { expect, mockFn } from 'earljs';
+import waitForExpect from 'wait-for-expect';
+
+import { sleep, asyncTimeout } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { Protocol } from '@dxos/mesh-protocol';
+import { MemorySignalManager, MemorySignalManagerContext, Messenger } from '@dxos/messaging';
+import { afterTest } from '@dxos/testutils';
+
+import { FullyConnectedTopology } from '../topology';
+import { createWebRTCTransportFactory, WebRTCTransport } from '../transport';
+import { Swarm } from './swarm';
+
+describe('Swarm', function () {
+  const context = new MemorySignalManagerContext();
+
+  const setupSwarm = () => {
+    const topic = PublicKey.random();
+    const peerId1 = PublicKey.random();
+    const peerId2 = PublicKey.random();
+
+    const swarm1 = new Swarm(
+      topic,
+      peerId1,
+      new FullyConnectedTopology(),
+      () => new Protocol(),
+      new Messenger({ signalManager: new MemorySignalManager(context) }),
+      createWebRTCTransportFactory(),
+      undefined
+    );
+
+    const swarm2 = new Swarm(
+      topic,
+      peerId2,
+      new FullyConnectedTopology(),
+      () => new Protocol(),
+      new Messenger({ signalManager: new MemorySignalManager(context) }),
+      createWebRTCTransportFactory(),
+      undefined
+    );
+
+    afterTest(async () => {
+      await swarm1.destroy();
+      await swarm2.destroy();
+    });
+
+    return { swarm1, swarm2, peerId1, peerId2 };
+  };
+
+  it('connects two peers in a swarm', async function () {
+    const { swarm1, swarm2, peerId1, peerId2 } = setupSwarm();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    const promise = Promise.all([
+      asyncTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+      asyncTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
+    ]);
+
+    // Behavior of the Signal Server.
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    log('Candidates changed');
+    await promise;
+    log('Swarms connected');
+
+    const swarm1Connection = swarm1.connections[0];
+    const swarm2Connection = swarm2.connections[0];
+    const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+    (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+    const data = Buffer.from('1234');
+    (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith([data]);
+    });
+  }).timeout(5_000);
+
+  it('two peers try to originate connections to each other simultaneously', async function () {
+    const { swarm1, swarm2, peerId1, peerId2 } = setupSwarm();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    const connectPromises = Promise.all([swarm1.connected.waitForCount(1), swarm2.connected.waitForCount(1)]);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    swarm2.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    await connectPromises;
+  }).timeout(5_000);
+
+  it('second peer discovered after delay', async function () {
+    const { swarm1, swarm2, peerId1, peerId2 } = setupSwarm();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    const connectPromises = Promise.all([swarm1.connected.waitForCount(1), swarm2.connected.waitForCount(1)]);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+    await sleep(15);
+    swarm2.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    await connectPromises;
+
+    const swarm1Connection = swarm1.connections[0];
+    const swarm2Connection = swarm2.connections[0];
+    const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+    (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+    const data = Buffer.from('1234');
+    (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith([data]);
+    });
+  }).timeout(10_000);
+
+  it('swarming with message router', async function () {
+    const { swarm1, swarm2, peerId2 } = setupSwarm();
+
+    const promise = Promise.all([
+      asyncTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+      asyncTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
+    ]);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    log('Candidates changed');
+    await promise;
+    log('Swarms connected');
+
+    const swarm1Connection = swarm1.connections[0];
+    const swarm2Connection = swarm2.connections[0];
+    const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+    (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+    const data = Buffer.from('1234');
+    (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+    await waitForExpect(() => {
+      expect(onData).toHaveBeenCalledWith([data]);
+    });
+    await swarm1.destroy();
+    await swarm2.destroy();
+  }).timeout(5_000);
+});