@dxos/network-manager 2.33.9-dev.7d11f506 → 2.33.9-dev.9bbef4e2

package/src/swarm/swarm.test.ts

@@ -12,7 +12,7 @@ import { Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';
 import { afterTest } from '@dxos/testutils';
 
-import { Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalMessaging } from '../signal';
 import { MessageRouter } from '../signal/message-router';
 import { FullyConnectedTopology } from '../topology';
@@ -21,173 +21,214 @@ import { Swarm } from './swarm';
 
 const log = debug('dxos:network-manager:swarm:test');
 
-class MockSignalConnection implements SignalMessaging {
-  constructor (
-    readonly _swarm: () => Swarm,
-    readonly _delay = 10
-  ) {}
-
-  async offer (msg: Message) {
-    await sleep(this._delay);
-    return this._swarm().onOffer(msg);
+describe('Swarm', () => {
+  class MockSignalConnection implements SignalMessaging {
+    constructor (
+      readonly _swarm: () => Swarm,
+      readonly _delay = 10
+    ) {}
+
+    async offer (msg: SignalMessage) {
+      await sleep(this._delay);
+      return this._swarm().onOffer(msg);
+    }
+
+    async signal (msg: SignalMessage) {
+      await sleep(this._delay);
+      await this._swarm().onSignal(msg);
+    }
   }
 
-  async signal (msg: Message) {
-    await sleep(this._delay);
-    await this._swarm().onSignal(msg);
-  }
-}
-
-const setup = ({ router = false } = {}) => {
-  const topic = PublicKey.random();
-  const peerId1 = PublicKey.random();
-  const peerId2 = PublicKey.random();
-  // eslint-disable-next-line prefer-const
-  let swarm1: Swarm;
-  // eslint-disable-next-line prefer-const
-  let swarm2: Swarm;
-
-  const mr1: MessageRouter = new MessageRouter({
-    sendMessage: msg => mr2.receiveMessage(msg),
-    onSignal: msg => swarm1.onSignal(msg),
-    onOffer: msg => swarm1.onOffer(msg)
-  });
-
-  const mr2: MessageRouter = new MessageRouter({
-    sendMessage: msg => mr1.receiveMessage(msg),
-    onSignal: msg => swarm2.onSignal(msg),
-    onOffer: msg => swarm2.onOffer(msg)
-  });
-
-  const sm1: SignalMessaging = router ? mr1 : new MockSignalConnection(() => swarm2);
-
-  const sm2: SignalMessaging = router ? mr2 : new MockSignalConnection(() => swarm1);
-
-  swarm1 = new Swarm(
-    topic,
-    peerId1,
-    new FullyConnectedTopology(),
-    () => new Protocol(),
-    sm1,
-    () => {},
-    createWebRTCTransportFactory(),
-    undefined
-  );
-
-  swarm2 = new Swarm(
-    topic,
-    peerId2,
-    new FullyConnectedTopology(),
-    () => new Protocol(),
-    sm2,
-    () => {},
-    createWebRTCTransportFactory(),
-    undefined
-  );
-
-  afterTest(async () => {
+  const setup = ({ router = false } = {}) => {
+    const topic = PublicKey.random();
+    const peerId1 = PublicKey.random();
+    const peerId2 = PublicKey.random();
+    // eslint-disable-next-line prefer-const
+    let swarm1: Swarm;
+    // eslint-disable-next-line prefer-const
+    let swarm2: Swarm;
+
+    const mr1: MessageRouter = new MessageRouter({
+      sendMessage: msg => mr2.receiveMessage(msg),
+      onSignal: msg => swarm1.onSignal(msg),
+      onOffer: msg => swarm1.onOffer(msg)
+    });
+    afterTest(() => mr1.destroy());
+
+    const mr2: MessageRouter = new MessageRouter({
+      sendMessage: msg => mr1.receiveMessage(msg),
+      onSignal: msg => swarm2.onSignal(msg),
+      onOffer: msg => swarm2.onOffer(msg)
+    });
+    afterTest(() => mr2.destroy());
+
+    const sm1: SignalMessaging = router ? mr1 : new MockSignalConnection(() => swarm2);
+
+    const sm2: SignalMessaging = router ? mr2 : new MockSignalConnection(() => swarm1);
+
+    swarm1 = new Swarm(
+      topic,
+      peerId1,
+      new FullyConnectedTopology(),
+      () => new Protocol(),
+      sm1,
+      createWebRTCTransportFactory(),
+      undefined
+    );
+
+    swarm2 = new Swarm(
+      topic,
+      peerId2,
+      new FullyConnectedTopology(),
+      () => new Protocol(),
+      sm2,
+      createWebRTCTransportFactory(),
+      undefined
+    );
+
+    afterTest(async () => {
+      await swarm1.destroy();
+      await swarm2.destroy();
+    });
+
+    return { swarm1, swarm2, peerId1, peerId2 };
+  };
+
+  test('connects two peers in a swarm', async () => {
+    const { swarm1, swarm2, peerId1, peerId2 } = setup();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    const promise = Promise.all([
+      promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+      promiseTimeout(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);
+
+  test('two peers try to originate connections to each other simultaneously', async () => {
+    const { swarm1, swarm2, peerId1, peerId2 } = setup();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    swarm2.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    await Promise.all([
+      swarm1.connected.waitForCount(1),
+      swarm2.connected.waitForCount(1)
+    ]);
+  }).timeout(5_000);
+
+  test('second peer discovered after delay', async () => {
+    const { swarm1, swarm2, peerId1, peerId2 } = setup();
+
+    expect(swarm1.connections.length).toEqual(0);
+    expect(swarm2.connections.length).toEqual(0);
+
+    swarm1.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId2.asUint8Array(),
+        since: new Date()
+      }
+    });
+    await sleep(15);
+    swarm2.onSwarmEvent({
+      peerAvailable: {
+        peer: peerId1.asUint8Array(),
+        since: new Date()
+      }
+    });
+
+    await Promise.all([
+      swarm1.connected.waitForCount(1),
+      swarm1.connected.waitForCount(1)
+    ]);
+
+    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);
+
+  test('swarming with message router', async () => {
+    const { swarm1, swarm2, peerId2 } = setup({ router: true });
+
+    const promise = Promise.all([
+      promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+      promiseTimeout(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();
-  });
-
-  return { swarm1, swarm2, peerId1, peerId2 };
-};
-
-test('connects two peers in a swarm', async () => {
-  const { swarm1, swarm2, peerId2 } = setup();
-
-  expect(swarm1.connections.length).toEqual(0);
-  expect(swarm2.connections.length).toEqual(0);
-
-  const promise = Promise.all([
-    promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
-    promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
-  ]);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-
-  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);
-
-test('two peers try to originate connections to each other simultaneously', async () => {
-  const { swarm1, swarm2, peerId1, peerId2 } = setup();
-
-  expect(swarm1.connections.length).toEqual(0);
-  expect(swarm2.connections.length).toEqual(0);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-  swarm2.onPeerCandidatesChanged([peerId1]);
-
-  await Promise.all([
-    swarm1.connected.waitForCount(1),
-    swarm2.connected.waitForCount(1)
-  ]);
-}).timeout(5_000);
-
-test('second peer discovered after delay', async () => {
-  const { swarm1, swarm2, peerId1, peerId2 } = setup();
-
-  expect(swarm1.connections.length).toEqual(0);
-  expect(swarm2.connections.length).toEqual(0);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-  await sleep(15);
-  swarm2.onPeerCandidatesChanged([peerId1]);
-
-  await Promise.all([
-    swarm1.connected.waitForCount(1),
-    swarm1.connected.waitForCount(1)
-  ]);
-
-  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);
-
-test('swarming with message router', async () => {
-  const { swarm1, swarm2, peerId2 } = setup({ router: true });
-
-  const promise = Promise.all([
-    promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
-    promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
-  ]);
-
-  swarm1.onPeerCandidatesChanged([peerId2]);
-
-  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);
+  }).timeout(5_000);
+});

package/src/swarm/swarm.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
 import { discoveryKey } from '@dxos/crypto';
@@ -12,7 +12,8 @@ import { PublicKey } from '@dxos/protocols';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { ProtocolProvider } from '../network-manager';
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SwarmEvent } from '../proto/gen/dxos/mesh/signal';
+import { Answer, SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalMessaging } from '../signal';
 import { SwarmController, Topology } from '../topology';
 import { TransportFactory } from '../transport';
@@ -34,7 +35,6 @@ export class Swarm {
 
   private readonly _connections = new ComplexMap<PublicKey, Connection>(x => x.toHex());
   private readonly _discoveredPeers = new ComplexSet<PublicKey>(x => x.toHex());
-  private readonly _peerCandidatesUpdated = new Event();
 
   get connections () {
     return Array.from(this._connections.values());
@@ -64,7 +64,6 @@ export class Swarm {
     private _topology: Topology,
     private readonly _protocolProvider: ProtocolProvider,
     private readonly _signalMessaging: SignalMessaging,
-    private readonly _lookupPeers: (topic: PublicKey) => void,
     private readonly _transportFactory: TransportFactory,
     private readonly _label: string | undefined
   ) {
@@ -87,26 +86,33 @@ export class Swarm {
     return this._topic;
   }
 
-  onPeerCandidatesChanged (candidates: PublicKey[]) {
-    log(`New peers for ${this._topic} ${candidates}`);
-    this._discoveredPeers.clear();
-    for (const candidate of candidates) {
-      if (candidate.equals(this._ownPeerId)) {
-        continue;
+  onSwarmEvent (swarmEvent: SwarmEvent) {
+    log(`Swarm event ${JSON.stringify(swarmEvent)}`);
+    if (swarmEvent.peerAvailable) {
+      const peerId = PublicKey.from(swarmEvent.peerAvailable.peer);
+      log(`New peer for ${this._topic} ${peerId}`);
+      if (!peerId.equals(this._ownPeerId)) {
+        this._discoveredPeers.add(peerId);
       }
-      this._discoveredPeers.add(candidate);
+    } else if (swarmEvent.peerLeft) {
+      this._discoveredPeers.delete(PublicKey.from(swarmEvent.peerLeft.peer));
     }
-    this._peerCandidatesUpdated.emit();
     this._topology.update();
   }
 
-  async onOffer (message: Message): Promise<Answer> {
-    log(`Offer from ${message.id} topic=${this._topic}`);
+  async onOffer (message: SignalMessage): Promise<Answer> {
+    log(`Offer from ${JSON.stringify(message)}`);
     // Id of the peer offering us the connection.
     assert(message.id);
     const remoteId = message.id;
-    assert(message.remoteId?.equals(this._ownPeerId));
-    assert(message.topic?.equals(this._topic));
+    if (!message.remoteId?.equals(this._ownPeerId)) {
+      log(`Rejecting offer with incorrect peerId: ${message.remoteId}`);
+      return { accept: false };
+    }
+    if (!message.topic?.equals(this._topic)) {
+      log(`Rejecting offer with incorrect topic: ${message.topic}`);
+      return { accept: false };
+    }
 
     // Check if we are already trying to connect to that peer.
     if (this._connections.has(remoteId)) {
@@ -140,7 +146,7 @@ export class Swarm {
     return { accept };
   }
 
-  async onSignal (message: Message): Promise<void> {
+  async onSignal (message: SignalMessage): Promise<void> {
     log(`Signal ${this._topic} ${JSON.stringify(message)}`);
     assert(message.remoteId?.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.remoteId}`);
     assert(message.topic?.equals(this._topic));
@@ -186,9 +192,6 @@ export class Swarm {
           this.errors.raise(err);
         }
         this._topology.update();
-      },
-      lookup: () => {
-        this._lookupPeers(this._topic);
       }
     };
   }
@@ -201,6 +204,7 @@ export class Swarm {
 
     const sessionId = PublicKey.random();
 
+    log(`Initiate connection: topic=${this._topic} peerId=${remoteId} sessionId=${sessionId}`);
     const connection = this._createConnection(true, remoteId, sessionId);
     this._signalMessaging.offer({
       id: this._ownPeerId,
@@ -236,7 +240,7 @@ export class Swarm {
   }
 
   private _createConnection (initiator: boolean, remoteId: PublicKey, sessionId: PublicKey) {
-    log(`Create connection topic=${this._topic} remoteId=${remoteId} initiator=${initiator}`);
+    log(`Create connection topic=${this._topic} ownId=${this._ownPeerId} remoteId=${remoteId} initiator=${initiator}`);
     assert(!this._connections.has(remoteId), 'Peer already connected.');
 
     const connection = new Connection(
@@ -245,7 +249,7 @@ export class Swarm {
       remoteId,
       sessionId,
       initiator,
-      (msg: Message) => this._signalMessaging.signal(msg),
+      (msg: SignalMessage) => this._signalMessaging.signal(msg),
       this._protocolProvider({ channel: discoveryKey(this._topic), initiator }),
       this._transportFactory
     );

package/src/testing/test-protocol.ts

@@ -4,9 +4,9 @@
 
 // Test/mock Protocol implementation used in network-manager tests.
 
-import assert from 'assert';
 import debug from 'debug';
 import { EventEmitter } from 'events';
+import assert from 'node:assert';
 
 import { Extension, Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';

package/src/topology/fully-connected-topology.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 
 import { PublicKey } from '@dxos/protocols';
 
@@ -11,15 +11,9 @@ import { SwarmController, Topology } from './topology';
 export class FullyConnectedTopology implements Topology {
   private _controller?: SwarmController;
 
-  private _intervalId?: NodeJS.Timeout;
-
   init (controller: SwarmController): void {
     assert(!this._controller, 'Already initialized');
     this._controller = controller;
-
-    this._intervalId = setInterval(() => {
-      controller.lookup();
-    }, 10_000);
   }
 
   update (): void {
@@ -35,9 +29,7 @@ export class FullyConnectedTopology implements Topology {
   }
 
   async destroy (): Promise<void> {
-    if (this._intervalId !== undefined) {
-      clearInterval(this._intervalId);
-    }
+    // Nothing to do.
   }
 
   toString () {

package/src/topology/mmst-topology.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 import distance from 'xor-distance';
 
 import { PublicKey } from '@dxos/protocols';
@@ -36,8 +36,6 @@ export class MMSTTopology implements Topology {
 
   private _controller?: SwarmController;
 
-  private _lookupIntervalId?: NodeJS.Timeout;
-
   private _sampleCollected = false;
 
   constructor ({
@@ -53,10 +51,6 @@ export class MMSTTopology implements Topology {
   init (controller: SwarmController): void {
     assert(!this._controller, 'Already initialized');
     this._controller = controller;
-
-    this._lookupIntervalId = setInterval(() => {
-      controller.lookup();
-    }, 10_000);
   }
 
   update (): void {
@@ -79,9 +73,7 @@ export class MMSTTopology implements Topology {
   }
 
   async destroy (): Promise<void> {
-    if (this._lookupIntervalId !== undefined) {
-      clearInterval(this._lookupIntervalId);
-    }
+    // Nothing to do.
   }
 
   private _runAlgorithm () {

package/src/topology/star-topology.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { PublicKey } from '@dxos/protocols';
 
@@ -13,7 +13,6 @@ const log = debug('dxos:network-manager:topology:star');
 
 export class StarTopology implements Topology {
   private _controller?: SwarmController;
-  private _intervalId?: NodeJS.Timeout;
 
   constructor (
     private readonly _centralPeer: PublicKey
@@ -26,9 +25,6 @@ export class StarTopology implements Topology {
   init (controller: SwarmController): void {
     assert(!this._controller, 'Already initialized.');
     this._controller = controller;
-    this._intervalId = setInterval(() => {
-      controller.lookup();
-    }, 10_000);
   }
 
   update (): void {
@@ -62,8 +58,6 @@ export class StarTopology implements Topology {
   }
 
   async destroy (): Promise<void> {
-    if (this._intervalId !== undefined) {
-      clearInterval(this._intervalId);
-    }
+    // Nothing to do.
   }
 }

package/src/topology/topology.ts

@@ -19,13 +19,6 @@ export interface SwarmController {
    * Disconnect from a peer.
    */
   disconnect(peer: PublicKey): void;
-
-  /**
-   * Trigger a lookup of any other peers swarming on this topic.
-   *
-   * Updates will be propagated through `update` method.
-   */
-  lookup(): void;
 }
 
 export interface SwarmState {

package/src/transport/in-memory-transport.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 import { Transform } from 'stream';
 
 import { Event } from '@dxos/async';
@@ -11,7 +11,7 @@ import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/protocols';
 import { ComplexMap } from '@dxos/util';
 
-import { Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { Transport, TransportFactory } from './transport';
 
 const log = debug('dxos:network-manager:swarm:transport:in-memory-transport');
@@ -79,7 +79,7 @@ export class InMemoryTransport implements Transport {
     return this._sessionId;
   }
 
-  async signal (msg: Message) {
+  async signal (msg: SignalMessage) {
     // No-op.
   }