@dxos/network-manager 0.1.13 → 0.1.16

package/src/network-manager.ts

@@ -7,7 +7,6 @@ import assert from 'node:assert';
 import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { Protocol } from '@dxos/mesh-protocol';
 import { Messenger, SignalManager } from '@dxos/messaging';
 import { ComplexMap } from '@dxos/util';
 
@@ -16,9 +15,11 @@ import { SignalConnection } from './signal';
 import { Swarm, SwarmMapper } from './swarm';
 import { Topology } from './topology';
 import { TransportFactory } from './transport';
+import { WireProtocolProvider } from './wire-protocol';
 
-export type ProtocolProvider = (opts: { channel: Buffer; initiator: boolean }) => Protocol;
-
+/**
+ * Represents a single connection to a remote peer.
+ */
 export type SwarmConnection = {
   close(): Promise<void>;
 };
@@ -38,7 +39,7 @@ export type SwarmOptions = {
   /**
    * Protocol to use for every connection.
    */
-  protocol: ProtocolProvider;
+  protocolProvider: WireProtocolProvider;
 
   /**
    * Requested topology. Must be a new instance for every swarm.
@@ -48,6 +49,7 @@ export type SwarmOptions = {
   /**
    * Presence plugin for network mapping, if exists.
    */
+  // TODO(dmaretskyi): Remove this dependency.
   presence?: any;
 
   /**
@@ -134,7 +136,14 @@ export class NetworkManager {
    * Join the swarm.
    */
   // TODO(burdon): Join/Open? Swarm abstraction?
-  async joinSwarm({ topic, peerId, topology, protocol, presence, label }: SwarmOptions): Promise<SwarmConnection> {
+  async joinSwarm({
+    topic,
+    peerId,
+    topology,
+    protocolProvider: protocol,
+    presence,
+    label
+  }: SwarmOptions): Promise<SwarmConnection> {
     assert(PublicKey.isPublicKey(topic));
     assert(PublicKey.isPublicKey(peerId));
     assert(topology);

package/src/protocol-factory.ts

@@ -9,14 +9,17 @@ import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { Extension, Protocol } from '@dxos/mesh-protocol';
 
-import { ProtocolProvider } from './network-manager';
-
 interface ProtocolFactoryOptions {
   plugins: any[];
   getTopics: () => Buffer[];
   session: Record<string, any>;
 }
 
+/**
+ * @deprecated Replaced by WireProtocolProvider.
+ */
+export type MeshProtocolProvider = (params: { channel: Buffer; initiator: boolean }) => Protocol;
+
 /**
  * Returns a function that takes a channel parameter, returns a Protocol object
  * with its context set to channel, plugins from plugins parameter and session
@@ -30,7 +33,7 @@ export const protocolFactory = ({
   session = {},
   plugins = [],
   getTopics
-}: ProtocolFactoryOptions): ProtocolProvider => {
+}: ProtocolFactoryOptions): MeshProtocolProvider => {
   assert(getTopics);
 
   // eslint-disable-next-line no-unused-vars
@@ -76,7 +79,7 @@ export const transportProtocolProvider = (
   rendezvousKey: Buffer,
   peerId: Buffer,
   protocolPlugin: any
-): ProtocolProvider => {
+): MeshProtocolProvider => {
   return protocolFactory({
     getTopics: () => [rendezvousKey],
     session: { peerId: PublicKey.stringify(peerId) },

package/src/signal/integration.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-// @dxos/mocha platform=nodejs
+// @dxos/test platform=nodejs
 
 import { expect } from 'earljs';
 import waitForExpect from 'wait-for-expect';
@@ -10,18 +10,19 @@ import waitForExpect from 'wait-for-expect';
 import { PublicKey } from '@dxos/keys';
 import { WebsocketSignalManager } from '@dxos/messaging';
 import { createTestBroker, TestBroker } from '@dxos/signal';
+import { afterAll, beforeAll, describe, test } from '@dxos/test';
 
 import { MessageRouter } from './message-router';
 import { SignalMessage } from './signal-messenger';
 
-describe('Signal Integration Test', function () {
+describe('Signal Integration Test', () => {
   let broker: TestBroker;
 
-  before(async function () {
+  beforeAll(async () => {
     broker = await createTestBroker();
   });
 
-  after(function () {
+  afterAll(() => {
     broker.stop();
   });
 
@@ -47,7 +48,7 @@ describe('Signal Integration Test', function () {
     };
   };
 
-  it('two peers connecting', async function () {
+  test('two peers connecting', async () => {
     const peer1 = PublicKey.random();
     const peer2 = PublicKey.random();
     const topic = PublicKey.random();
@@ -99,7 +100,7 @@ describe('Signal Integration Test', function () {
         recipient: peer2,
         sessionId: PublicKey.random(),
         data: {
-          signal: { json: JSON.stringify({ foo: 'bar' }) }
+          signal: { payload: { message: 'Hello world!' } }
         }
       };
       await peerNetworking1.messageRouter.signal(message);
@@ -116,7 +117,7 @@ describe('Signal Integration Test', function () {
         recipient: peer1,
         sessionId: PublicKey.random(),
         data: {
-          signal: { json: JSON.stringify({ foo: 'bar' }) }
+          signal: { payload: { foo: 'bar' } }
         }
       };
       await peerNetworking2.messageRouter.signal(message);

package/src/signal/message-router.test.ts

@@ -2,10 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-// @dxos/mocha platform=nodejs
+// @dxos/test platform=nodejs
 
 import { expect } from 'earljs';
-import { it, describe } from 'mocha';
 import waitForExpect from 'wait-for-expect';
 
 import { Awaited } from '@dxos/async';
@@ -13,25 +12,25 @@ import { PublicKey } from '@dxos/keys';
 import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
 import { Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { createTestBroker } from '@dxos/signal';
-import { afterTest } from '@dxos/testutils';
+import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
 
 import { MessageRouter } from './message-router';
 import { OfferMessage, SignalMessage } from './signal-messenger';
 
-describe('MessageRouter', function () {
+describe('MessageRouter', () => {
   let topic: PublicKey;
 
   let broker1: Awaited<ReturnType<typeof createTestBroker>>;
 
-  before(async function () {
+  beforeAll(async () => {
     broker1 = await createTestBroker();
   });
 
-  beforeEach(function () {
+  beforeEach(() => {
     topic = PublicKey.random();
   });
 
-  after(function () {
+  afterAll(() => {
     broker1.stop();
   });
 
@@ -72,7 +71,7 @@ describe('MessageRouter', function () {
     };
   };
 
-  it('signaling between 2 clients', async () => {
+  test('signaling between 2 clients', async () => {
     const received: SignalMessage[] = [];
     const signalMock1 = async (msg: SignalMessage) => {
       received.push(msg);
@@ -99,7 +98,7 @@ describe('MessageRouter', function () {
       recipient: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: JSON.stringify({ asd: 'asd' }) } }
+      data: { signal: { payload: { msg: 'Some info' } } }
     };
     await router2.signal(msg);
 
@@ -108,7 +107,7 @@ describe('MessageRouter', function () {
     }, 4_000);
   }).timeout(5_000);
 
-  it('offer/answer', async () => {
+  test('offer/answer', async () => {
     const {
       signalManager: signalManager1,
       router: router1,
@@ -138,7 +137,7 @@ describe('MessageRouter', function () {
     expect(answer.accept).toEqual(true);
   }).timeout(5_000);
 
-  it('signaling between 3 clients', async () => {
+  test('signaling between 3 clients', async () => {
     const received1: SignalMessage[] = [];
     const signalMock1 = async (msg: SignalMessage) => {
       received1.push(msg);
@@ -192,7 +191,7 @@ describe('MessageRouter', function () {
       recipient: peer3,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: '1to3' } }
+      data: { signal: { payload: { msg: '1to3' } } }
     };
     await router1.signal(msg1to3);
     await waitForExpect(() => {
@@ -205,7 +204,7 @@ describe('MessageRouter', function () {
       recipient: peer3,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: '2to3' } }
+      data: { signal: { payload: { msg: '2to3' } } }
     };
     await router2.signal(msg2to3);
     await waitForExpect(() => {
@@ -218,7 +217,7 @@ describe('MessageRouter', function () {
       recipient: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { signal: { json: '3to1' } }
+      data: { signal: { payload: { msg: '3to1' } } }
     };
     await router3.signal(msg3to1);
     await waitForExpect(() => {
@@ -226,7 +225,7 @@ describe('MessageRouter', function () {
     }, 4_000);
   }).timeout(5_000);
 
-  it('two offers', async () => {
+  test('two offers', async () => {
     const {
       signalManager: signalManager1,
       router: router1,

package/src/signal/message-router.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 
 import { Any } from '@dxos/codec-protobuf';
 import { PublicKey } from '@dxos/keys';

package/src/swarm/connection.ts

@@ -8,11 +8,11 @@ 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, SignalMessenger } from '../signal';
 import { Transport, TransportFactory } from '../transport';
+import { WireProtocol } from '../wire-protocol';
 
 /**
  * State machine for each connection.
@@ -25,25 +25,10 @@ export enum ConnectionState {
   INITIAL = 'INITIAL',
 
   /**
-   * Originating a connection.
-   */
-  INITIATING_CONNECTION = 'INITIATING_CONNECTION',
-
-  /**
-   * Waiting for a connection to be originated from the remote peer.
+   * Trying to establish connection.
    */
   CONNECTING = 'CONNECTING',
 
-  /**
-   * Peer rejected offer.
-   */
-  ACCEPTED = 'ACCEPTED',
-
-  /**
-   * Peer rejected offer.
-   */
-  REJECTED = 'REJECTED',
-
   /**
    * Connection is established.
    */
@@ -57,6 +42,7 @@ export enum ConnectionState {
 
 /**
  * Represents a connection to a remote peer.
+ * Owns a transport paired together with a wire-protocol.
  */
 export class Connection {
   private _state: ConnectionState = ConnectionState.INITIAL;
@@ -73,7 +59,7 @@ export class Connection {
     public readonly sessionId: PublicKey,
     public readonly initiator: boolean,
     private readonly _signalMessaging: SignalMessenger,
-    private readonly _protocol: Protocol,
+    private readonly _protocol: WireProtocol,
     private readonly _transportFactory: TransportFactory
   ) {}
 
@@ -89,48 +75,18 @@ export class Connection {
     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.openConnection();
-          } 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);
-      });
-  }
-
   /**
    * Create an underlying transport and prepares it for the connection.
    */
   // TODO(burdon): Make async?
   openConnection() {
     assert(this._state === ConnectionState.INITIAL, 'Invalid state.');
-    this._changeState(this.initiator ? ConnectionState.INITIATING_CONNECTION : ConnectionState.CONNECTING);
+    this._changeState(ConnectionState.CONNECTING);
+
+    // TODO(dmaretskyi): Initialize only after the transport has established connection.
+    this._protocol.initialize().catch((err) => {
+      this.errors.raise(err);
+    });
 
     assert(!this._transport);
     this._transport = this._transportFactory.createTransport({
@@ -176,7 +132,7 @@ export class Connection {
 
     try {
       // Gracefully close the stream flushing any unsent data packets.
-      await this._protocol.close();
+      await this._protocol.destroy();
     } catch (err: any) {
       log.catch(err);
     }

package/src/swarm/peer.ts

@@ -2,18 +2,24 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 
 import { synchronized } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { Protocol } from '@dxos/mesh-protocol';
+import { Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { SignalMessage, SignalMessenger } from '../signal';
+import { OfferMessage, SignalMessage, SignalMessenger } from '../signal';
 import { TransportFactory } from '../transport';
+import { WireProtocolProvider } from '../wire-protocol';
 import { Connection, ConnectionState } from './connection';
 
 interface PeerCallbacks {
+  /**
+   * Connection attempt initiated.
+   */
+  onInitiated: (connection: Connection) => void;
+
   /**
    * Connection opened.
    */
@@ -33,8 +39,17 @@ interface PeerCallbacks {
    * Peer rejected our offer to connect.
    */
   onRejected: () => void;
+
+  /**
+   * Returns true if the remote peer's offer should be accepted.
+   */
+  onOffer: (remoteId: PublicKey) => Promise<boolean>;
 }
 
+/**
+ * State of remote peer during the lifetime of a swarm connection.
+ * Can open and close multiple connections to the remote peer.
+ */
 export class Peer {
   public connection?: Connection;
 
@@ -43,25 +58,109 @@ export class Peer {
    */
   public advertizing = false;
 
+  public initiating = false;
+
   constructor(
     public readonly id: PublicKey,
     public readonly topic: PublicKey,
     public readonly localPeerId: PublicKey,
+    private readonly _signalMessaging: SignalMessenger,
+    private readonly _protocolProvider: WireProtocolProvider,
+    private readonly _transportFactory: TransportFactory,
     private readonly _callbacks: PeerCallbacks
   ) {}
 
+  /**
+   * Respond to remote offer.
+   */
+  async onOffer(message: OfferMessage): Promise<Answer> {
+    const remoteId = message.author;
+
+    // Check if we are already trying to connect to that peer.
+    if (this.connection || this.initiating) {
+      // Peer with the highest Id closes its connection, and accepts remote peer's offer.
+      if (remoteId.toHex() < this.localPeerId.toHex()) {
+        log.info("closing local connection and accepting remote peer's offer", {
+          id: this.id,
+          topic: this.topic,
+          peerId: this.localPeerId
+        });
+
+        if (this.connection) {
+          // Close our connection and accept remote peer's connection.
+          await this.closeConnection();
+        }
+      } else {
+        // Continue with our origination attempt, the remote peer will close it's connection and accept ours.
+        return { accept: false };
+      }
+    }
+
+    if (await this._callbacks.onOffer(remoteId)) {
+      if (!this.connection) {
+        // Connection might have been already established.
+        assert(message.sessionId);
+        const connection = this._createConnection(false, message.sessionId);
+        try {
+          connection.openConnection();
+        } catch (err: any) {
+          log.warn('connection error', { topic: this.topic, peerId: this.localPeerId, remoteId: this.id, err });
+          // Calls `onStateChange` with CLOSED state.
+          await this.closeConnection();
+        }
+
+        return { accept: true };
+      }
+    }
+    return { accept: false };
+  }
+
+  /**
+   * Initiate a connection to the remote peer.
+   */
+  async initiateConnection() {
+    assert(!this.initiating, 'Initiation in progress.');
+    assert(!this.connection, 'Already connected.');
+    const sessionId = PublicKey.random();
+    log('initiating...', { id: this.id, topic: this.topic, peerId: this.id, sessionId });
+    const connection = this._createConnection(true, sessionId);
+    this.initiating = true;
+
+    try {
+      const answer = await this._signalMessaging.offer({
+        author: this.localPeerId,
+        recipient: this.id,
+        sessionId,
+        topic: this.topic,
+        data: { offer: {} }
+      });
+      log('received', { answer, topic: this.topic, ownId: this.localPeerId, remoteId: this.id });
+      if (connection.state !== ConnectionState.INITIAL) {
+        log('ignoring response');
+        return;
+      }
+
+      if (!answer.accept) {
+        this._callbacks.onRejected();
+        return;
+      }
+      connection.openConnection();
+      this._callbacks.onAccepted();
+    } catch (err: any) {
+      log.warn('initiation error', { topic: this.topic, peerId: this.localPeerId, remoteId: this.id, err });
+      // Calls `onStateChange` with CLOSED state.
+      await this.closeConnection();
+      throw err;
+    } finally {
+      this.initiating = false;
+    }
+  }
+
   /**
    * 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
-  ) {
+  private _createConnection(initiator: boolean, sessionId: PublicKey) {
     log('creating connection', {
       topic: this.topic,
       peerId: this.localPeerId,
@@ -70,16 +169,19 @@ export class Peer {
       sessionId
     });
     assert(!this.connection, 'Already connected.');
+
     const connection = new Connection(
       this.topic,
       this.localPeerId,
       this.id,
       sessionId,
       initiator,
-      signalMessaging,
-      protocol,
-      transportFactory
+      this._signalMessaging,
+      // TODO(dmaretskyi): Init only when connection is established.
+      this._protocolProvider({ initiator, localPeerId: this.localPeerId, remotePeerId: this.id, topic: this.topic }),
+      this._transportFactory
     );
+    this._callbacks.onInitiated(connection);
     connection.stateChanged.on((state) => {
       switch (state) {
         case ConnectionState.CONNECTED: {
@@ -87,16 +189,6 @@ export class Peer {
           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).');
@@ -128,12 +220,9 @@ export class Peer {
     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);
-    }
+    // Triggers `onStateChange` callback which will clean up the connection.
+    // Won't throw.
+    await connection.close();
 
     log('closed', { peerId: this.id, sessionId: connection.sessionId });
   }

package/src/swarm/swarm.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-// @dxos/mocha platform=nodejs
+// @dxos/test platform=nodejs
 
 import { expect } from 'earljs';
 import waitForExpect from 'wait-for-expect';
@@ -11,18 +11,19 @@ import { sleep, asyncTimeout } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { MemorySignalManager, MemorySignalManagerContext, Messenger } from '@dxos/messaging';
-import { afterTest } from '@dxos/testutils';
+import { beforeEach, describe, test, afterTest } from '@dxos/test';
 
 import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { FullyConnectedTopology } from '../topology';
 import { createWebRTCTransportFactory } from '../transport';
+import { adaptProtocolProvider } from '../wire-protocol';
 import { Swarm } from './swarm';
 
-describe('Swarm', function () {
+describe('Swarm', () => {
   const context = new MemorySignalManagerContext();
   let signalManager: MemorySignalManager;
 
-  beforeEach(function () {
+  beforeEach(() => {
     signalManager = new MemorySignalManager(context);
     afterTest(() => signalManager.destroy());
   });
@@ -33,7 +34,7 @@ describe('Swarm', function () {
       topic,
       peerId,
       new FullyConnectedTopology(),
-      testProtocolProvider(topic.asBuffer(), peerId, plugin),
+      adaptProtocolProvider(testProtocolProvider(topic.asBuffer(), peerId, plugin)),
       new Messenger({ signalManager }),
       createWebRTCTransportFactory(),
       undefined
@@ -46,7 +47,7 @@ describe('Swarm', function () {
     return { swarm, plugin };
   };
 
-  it('connects two peers in a swarm', async function () {
+  test('connects two peers in a swarm', async () => {
     const topic = PublicKey.random();
     const peerId1 = PublicKey.random();
     const peerId2 = PublicKey.random();
@@ -95,7 +96,7 @@ describe('Swarm', function () {
     });
   }).timeout(5_000);
 
-  it('two peers try to originate connections to each other simultaneously', async function () {
+  test('two peers try to originate connections to each other simultaneously', async () => {
     const topic = PublicKey.random();
     const peerId1 = PublicKey.random();
     const peerId2 = PublicKey.random();
@@ -125,7 +126,7 @@ describe('Swarm', function () {
     await connectPromises;
   }).timeout(5_000);
 
-  it('second peer discovered after delay', async function () {
+  test('second peer discovered after delay', async () => {
     const topic = PublicKey.random();
     const peerId1 = PublicKey.random();
     const peerId2 = PublicKey.random();