@dxos/network-manager 0.1.13 → 0.1.16

package/src/swarm/swarm.ts

@@ -4,21 +4,21 @@
 
 import assert from 'node:assert';
 
-import { Event, sleep } from '@dxos/async';
-import { discoveryKey } from '@dxos/crypto';
+import { Event, scheduleTask, sleep } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
+import { log, logInfo } 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, isNotNullOrUndefined } from '@dxos/util';
 
-import { ProtocolProvider } from '../network-manager';
 import { MessageRouter, OfferMessage, SignalMessage } from '../signal';
 import { SwarmController, Topology } from '../topology';
 import { TransportFactory } from '../transport';
 import { Topic } from '../types';
+import { WireProtocolProvider } from '../wire-protocol';
 import { Connection } from './connection';
 import { Peer } from './peer';
 
@@ -37,12 +37,13 @@ export class Swarm {
 
   private readonly _swarmMessenger: MessageRouter;
 
-  private _destroyed = false;
+  private _ctx = new Context();
 
   /**
    * Unique id of the swarm, local to the current peer, generated when swarm is joined.
    */
-  readonly id = PublicKey.random();
+  @logInfo
+  readonly instanceId = PublicKey.random();
 
   /**
    * New connection to a peer is started.
@@ -71,12 +72,12 @@ export class Swarm {
     private readonly _topic: PublicKey,
     private readonly _ownPeerId: PublicKey,
     private _topology: Topology,
-    private readonly _protocolProvider: ProtocolProvider,
+    private readonly _protocolProvider: WireProtocolProvider,
     private readonly _messenger: Messenger,
     private readonly _transportFactory: TransportFactory,
     private readonly _label: string | undefined
   ) {
-    log('creating swarm', { id: this.id, topic: this._topic, peerId: _ownPeerId });
+    log('creating swarm', { peerId: _ownPeerId });
     _topology.init(this._getSwarmController());
 
     this._swarmMessenger = new MessageRouter({
@@ -101,6 +102,7 @@ export class Swarm {
       .filter(isNotNullOrUndefined);
   }
 
+  @logInfo
   get ownPeerId() {
     return this._ownPeerId;
   }
@@ -112,16 +114,18 @@ export class Swarm {
     return this._label;
   }
 
+  @logInfo
   get topic(): Topic {
     return this._topic;
   }
 
   // TODO(burdon): async open?
   async destroy() {
-    log('destroying', { id: this.id, topic: this._topic });
-    this._destroyed = true;
+    log('destroying...');
+    await this._ctx.dispose();
     await this._topology.destroy();
-    await Promise.all(Array.from(this._peers.keys()).map((key) => this._closeConnection(key)));
+    await Promise.all(Array.from(this._peers.keys()).map((key) => this._destroyPeer(key)));
+    log('destroyed');
   }
 
   async setTopology(topology: Topology) {
@@ -129,8 +133,6 @@ export class Swarm {
       return;
     }
     log('setting topology', {
-      id: this.id,
-      topic: this._topic,
       previous: getClassName(this._topology),
       topology: getClassName(topology)
     });
@@ -144,29 +146,43 @@ export class Swarm {
   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);
+      peer = new Peer(
+        peerId,
+        this._topic,
+        this._ownPeerId,
+        this._swarmMessenger,
+        this._protocolProvider,
+        this._transportFactory,
+        {
+          onInitiated: (connection) => {
+            this.connectionAdded.emit(connection);
+          },
+          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();
+          },
+          onOffer: (remoteId) => {
+            return this._topology.onOffer(remoteId);
           }
-
-          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);
     }
 
@@ -180,15 +196,15 @@ export class Swarm {
   }
 
   onSwarmEvent(swarmEvent: 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 });
+    log('swarm event', { swarmEvent }); // TODO(burdon): Stringify.
+    if (this._ctx.disposed) {
+      log.warn('ignored for destroyed swarm');
       return;
     }
 
     if (swarmEvent.peerAvailable) {
       const peerId = PublicKey.from(swarmEvent.peerAvailable.peer);
-      log('new peer', { id: this.id, topic: this._topic, peerId });
+      log('new peer', { peerId });
       if (!peerId.equals(this._ownPeerId)) {
         const peer = this._getOrCreatePeer(peerId);
         peer.advertizing = true;
@@ -207,69 +223,33 @@ export class Swarm {
   }
 
   async onOffer(message: OfferMessage): Promise<Answer> {
-    log('offer', { id: this.id, topic: this._topic, message });
-    if (this._destroyed) {
-      log.warn('ignored for destroyed swarm', { peerId: this.id, topic: this._topic });
+    log('offer', { message });
+    if (this._ctx.disposed) {
+      log.info('ignored for destroyed swarm');
       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', { id: this.id, topic: this._topic, message });
+      log('rejecting offer with incorrect peerId', { message });
       return { accept: false };
     }
     if (!message.topic?.equals(this._topic)) {
-      log('rejecting offer with incorrect topic', { id: this.id, topic: this._topic, message });
+      log('rejecting offer with incorrect topic', { message });
       return { accept: false };
     }
 
-    const peer = this._getOrCreatePeer(remoteId);
-
-    // Check if we are already trying to connect to that peer.
-    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
-        });
-        // Close our connection and accept remote peer's connection.
-        await this._closeConnection(remoteId).catch((err) => {
-          this.errors.raise(err);
-        });
-      } else {
-        // Continue with our origination attempt, the remote peer will close it's connection and accept ours.
-        return { accept: true };
-      }
-    }
-
-    let accept = false;
-    if (await this._topology.onOffer(remoteId)) {
-      if (!peer.connection) {
-        // Connection might have been already established.
-        assert(message.sessionId);
-        const connection = this._createConnection(false, message.author, message.sessionId);
-        try {
-          connection.openConnection();
-        } catch (err: any) {
-          this.errors.raise(err);
-        }
-
-        accept = true;
-      }
-    }
-
+    const peer = this._getOrCreatePeer(message.author);
+    const answer = await peer.onOffer(message);
     this._topology.update();
-    return { accept };
+    return answer;
   }
 
   async onSignal(message: SignalMessage): Promise<void> {
-    log('signal', { id: this.id, topic: this._topic, message });
-    if (this._destroyed) {
-      log.warn('ignored for destroyed swarm', { peerId: this.id, topic: this._topic });
+    log('signal', { message });
+    if (this._ctx.disposed) {
+      log.info('ignored for destroyed swarm');
       return;
     }
     assert(
@@ -294,14 +274,30 @@ export class Swarm {
           .filter((peer) => !peer.connection && peer.advertizing)
           .map((peer) => peer.id)
       }),
-      connect: (peer) => this._initiateConnection(peer),
+      connect: (peer) => {
+        if (this._ctx.disposed) {
+          return;
+        }
+
+        // Run in a separate non-blocking task.
+        scheduleTask(this._ctx, async () => {
+          try {
+            await this._initiateConnection(peer);
+          } catch (err: any) {
+            log.warn('initiation error', err);
+          }
+        });
+      },
       disconnect: async (peer) => {
-        try {
-          await this._closeConnection(peer);
-        } catch (err: any) {
-          this.errors.raise(err);
+        if (this._ctx.disposed) {
+          return;
         }
-        this._topology.update();
+
+        // Run in a separate non-blocking task.
+        scheduleTask(this._ctx, async () => {
+          await this._closeConnection(peer);
+          this._topology.update();
+        });
       }
     };
   }
@@ -313,39 +309,24 @@ export class Swarm {
     // 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.
     if (remoteId.toHex() < this._ownPeerId.toHex()) {
+      log('initiation delay', { remoteId });
       await sleep(INITIATION_DELAY);
     }
-
-    if (this._peers.get(remoteId)?.connection) {
-      // Do nothing if peer is already connected.
+    if (this._ctx.disposed) {
       return;
     }
 
-    const sessionId = PublicKey.random();
-
-    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', { id: this.id, topic: this._topic });
-  }
-
-  /**
-   * Synchronously create a connection, which must be initialized.
-   */
-  private _createConnection(initiator: boolean, remoteId: PublicKey, sessionId: PublicKey): Connection {
     const peer = this._getOrCreatePeer(remoteId);
 
-    const connection = peer.createConnection(
-      this._swarmMessenger,
-      initiator,
-      sessionId,
-      this._protocolProvider({ channel: discoveryKey(this._topic), initiator }),
-      this._transportFactory
-    );
+    if (peer.connection) {
+      // Do nothing if peer is already connected.
+      return;
+    }
 
-    this.connectionAdded.emit(connection);
-    return connection;
+    log('initiating connection...', { remoteId });
+    await peer.initiateConnection();
+    this._topology.update();
+    log('initiated', { remoteId });
   }
 
   private async _closeConnection(peerId: PublicKey) {

package/src/testing/test-builder.ts

@@ -17,6 +17,7 @@ import {
   WebRTCTransportProxyFactory,
   WebRTCTransportService
 } from '../transport';
+import { adaptProtocolProvider } from '../wire-protocol';
 import { TestProtocolPlugin, testProtocolProvider } from './test-protocol';
 
 // Signal server will be started by the setup script.
@@ -165,7 +166,9 @@ export class TestSwarmConnection {
     await this.peer._networkManager.joinSwarm({
       topic: this.topic,
       peerId: this.peer.peerId,
-      protocol: testProtocolProvider(this.topic.asBuffer(), this.peer.peerId, this.plugin),
+      protocolProvider: adaptProtocolProvider(
+        testProtocolProvider(this.topic.asBuffer(), this.peer.peerId, this.plugin)
+      ),
       topology
     });
 

package/src/testing/test-protocol.ts

@@ -4,8 +4,8 @@
 
 // Test/mock Protocol implementation used in network-manager tests.
 
-import { EventEmitter } from 'events';
 import assert from 'node:assert';
+import { EventEmitter } from 'node:events';
 
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';

package/src/tests/basic-test-suite.ts

@@ -9,6 +9,7 @@ import { latch } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { Protocol } from '@dxos/mesh-protocol';
+import { test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { TestBuilder } from '../testing';
@@ -25,7 +26,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     return;
   }
 
-  it('joins swarm, sends messages, and cleanly exits', async () => {
+  test('joins swarm, sends messages, and cleanly exits', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -37,7 +38,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
   });
 
   // TODO(burdon): Test with more peers (configure and test messaging).
-  it('joins swarm with star topology', async () => {
+  test('joins swarm with star topology', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -49,7 +50,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
   });
 
   // TODO(burdon): Fails when trying to reconnect to same topic.
-  it('joins swarm multiple times', async () => {
+  test('joins swarm multiple times', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -75,7 +76,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     }
   });
 
-  it.skip('joins multiple swarms', async () => {
+  test.skip('joins multiple swarms', async () => {
     // TODO(burdon): N peers.
     // TODO(burdon): Merge with test below.
     const peer1 = testBuilder.createPeer();
@@ -90,7 +91,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
   // TODO(burdon): Fails with WebRTC.
   // TODO(burdon): This just tests multiple swarms (not peers in the same swarm)?
   //  Generalize for n swarms and factor into other tests; configure message activity.
-  it.skip('joins multiple swarms concurrently', async () => {
+  test.skip('joins multiple swarms concurrently', async () => {
     const createSwarm = async (messages: any[], label: string) => {
       const topicA = PublicKey.random();
       const peer1a = testBuilder.createPeer();
@@ -125,7 +126,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
 
   // TODO(burdon): Fails with WebRTC.
   // TODO(burdon): Factor out components of test.
-  it.skip('many peers and connections', async () => {
+  test.skip('many peers and connections', async () => {
     const numTopics = 5;
     const peersPerTopic = 5;
 

package/src/tests/memory-transport.test.ts

@@ -5,7 +5,7 @@
 import { TestBuilder } from '../testing';
 import { basicTestSuite } from './basic-test-suite';
 
-describe('Memory transport', function () {
+describe('Memory transport', () => {
   const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);
 });

package/src/tests/presence.test.ts

@@ -8,12 +8,13 @@ import waitForExpect from 'wait-for-expect';
 import { PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext, MemorySignalManager } from '@dxos/messaging';
 import { PresencePlugin } from '@dxos/protocol-plugin-presence';
-import { afterTest } from '@dxos/testutils';
+import { describe, test, afterTest } from '@dxos/test';
 
 import { NetworkManager } from '../network-manager';
 import { createProtocolFactory } from '../protocol-factory';
 import { FullyConnectedTopology } from '../topology';
 import { MemoryTransportFactory } from '../transport';
+import { adaptProtocolProvider } from '../wire-protocol';
 
 const signalContext = new MemorySignalManagerContext();
 
@@ -32,7 +33,7 @@ const createPeer = async (topic: PublicKey) => {
 
   await networkManager.joinSwarm({
     peerId,
-    protocol: createProtocolFactory(topic, peerId, [presencePlugin]),
+    protocolProvider: adaptProtocolProvider(createProtocolFactory(topic, peerId, [presencePlugin])),
     topic,
     topology: new FullyConnectedTopology()
   });
@@ -40,8 +41,8 @@ const createPeer = async (topic: PublicKey) => {
   return { peerId, presence: presencePlugin, networkManager };
 };
 
-describe('Presence', function () {
-  it('detects connected peers', async function () {
+describe('Presence', () => {
+  test('detects connected peers', async () => {
     // TODO(burdon): Configure plugins.
     // const testBuilder = new TestBuilder();
     // const peer1 = testBuilder.createPeer();

package/src/tests/property-test-suite.ts

@@ -8,19 +8,20 @@ import waitForExpect from 'wait-for-expect';
 
 import { PublicKey } from '@dxos/keys';
 import { PresencePlugin } from '@dxos/protocol-plugin-presence';
-import { afterTest } from '@dxos/testutils';
+import { afterTest, test } from '@dxos/test';
 import { range, ComplexMap, ComplexSet } from '@dxos/util';
 
 import { NetworkManager } from '../network-manager';
 import { createProtocolFactory } from '../protocol-factory';
 import { FullyConnectedTopology } from '../topology';
+import { adaptProtocolProvider } from '../wire-protocol';
 
 /**
  * Performs random actions in the real system and compares its state with a simplified model.
  */
 // TODO(dmaretskyi): Run this with actual webrtc and signal servers.
 export const propertyTestSuite = () => {
-  it.skip('property-based tests', async function () {
+  test.skip('property-based tests', async function () {
     /**
      * The simplified model of the system.
      */
@@ -124,7 +125,7 @@ export const propertyTestSuite = () => {
         await peer.networkManager.joinSwarm({
           peerId: this.peerId, // TODO(burdon): `this`?
           topic: model.topic,
-          protocol,
+          protocolProvider: adaptProtocolProvider(protocol),
           topology: new FullyConnectedTopology(),
           presence
         });

package/src/tests/utils.ts

@@ -6,7 +6,7 @@ import { expect } from 'chai';
 
 import { latch, Trigger } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { afterTest } from '@dxos/testutils';
+import { afterTest } from '@dxos/test';
 import { Provider } from '@dxos/util';
 
 import { TestPeer, TestSwarmConnection } from '../testing';

package/src/tests/webrtc-transport.test.ts

@@ -5,12 +5,12 @@
 import { TEST_SIGNAL_URL, TestBuilder } from '../testing';
 import { basicTestSuite } from './basic-test-suite';
 
-describe('WebRTC transport', function () {
+describe('WebRTC transport', () => {
   const testBuilder = new TestBuilder({ signalHosts: [TEST_SIGNAL_URL] });
   basicTestSuite(testBuilder);
 }).timeout(10_000);
 
-describe('WebRTC transport proxy', function () {
+describe('WebRTC transport proxy', () => {
   const testBuilder = new TestBuilder({ signalHosts: [TEST_SIGNAL_URL], bridge: true });
   basicTestSuite(testBuilder);
 }).timeout(10_000);

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

@@ -8,7 +8,7 @@ import waitForExpect from 'wait-for-expect';
 import { discoveryKey } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
 import { Protocol } from '@dxos/mesh-protocol';
-import { afterTest } from '@dxos/testutils';
+import { describe, test, afterTest } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { TestProtocolPlugin, testProtocolProvider } from '../testing';
@@ -61,8 +61,8 @@ const createPair = () => {
   };
 };
 
-describe('MemoryTransport', function () {
-  it('establish connection and send data through with protocol', async function () {
+describe('MemoryTransport', () => {
+  test('establish connection and send data through with protocol', async () => {
     const { plugin1, plugin2, peer1Id } = createPair();
 
     const received: any[] = [];
@@ -83,7 +83,7 @@ describe('MemoryTransport', function () {
     });
   });
 
-  it.skip('10 pairs of peers connecting at the same time', async function () {
+  test.skip('10 pairs of peers connecting at the same time', async () => {
     await Promise.all(
       range(10).map(async () => {
         const { plugin1, plugin2, peer1Id } = createPair();

package/src/transport/memory-transport.ts

@@ -3,7 +3,7 @@
 //
 
 import assert from 'node:assert';
-import { Transform } from 'stream';
+import { Transform } from 'node:stream';
 
 import { Event, Trigger } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
@@ -67,7 +67,7 @@ export class MemoryTransport implements Transport {
       setTimeout(async () => {
         log('sending signal', { transportId: this._id });
         void this.options.sendSignal({
-          json: JSON.stringify({ transportId: this._id.toHex() })
+          payload: { transportId: this._id.toHex() }
         });
     });
     } else {
@@ -143,10 +143,10 @@ export class MemoryTransport implements Transport {
   }
 
   signal(signal: Signal) {
-    const { json } = signal;
-    if (json) {
+    const { payload: json } = signal;
+    if (json && json.transportId) {
       // TODO(burdon): Check open?
-      const { transportId } = JSON.parse(json);
+      const transportId = json.transportId as string;
       if (transportId) {
         const remoteId = PublicKey.fromHex(transportId);
         log('received signal', { id: this._id, remoteId });

package/src/transport/webrtc-simple-peer.test.ts

@@ -2,23 +2,26 @@
 // Copyright 2020 DXOS.org
 //
 
-// @dxos/mocha platform=nodejs
+// @dxos/test platform=nodejs
 
 import wrtc from '@koush/wrtc';
 import SimplePeerConstructor from 'simple-peer';
 
 import { sleep } from '@dxos/async';
+import { describe, test } from '@dxos/test';
 
-describe('Node WebRTC and simple-peer', function () {
+describe('Node WebRTC and simple-peer', () => {
   // Simplest test that reproduces SIGABRT (mac) and SIGSEGV (linux) in wrtc.
-  it.skip('open and close', async function () {
-    const peer = new SimplePeerConstructor({
-      initiator: true,
-      wrtc
-    });
+  test
+    .skip('open and close', async () => {
+      const peer = new SimplePeerConstructor({
+        initiator: true,
+        wrtc
+      });
 
-    await sleep(1);
+      await sleep(1);
 
-    await peer.destroy();
-  }).timeout(3_000);
+      await peer.destroy();
+    })
+    .timeout(3_000);
 });