@dxos/network-manager 0.1.8 → 0.1.10

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

@@ -0,0 +1,221 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import * as fc from 'fast-check';
+import { ModelRunSetup } from 'fast-check';
+import waitForExpect from 'wait-for-expect';
+
+import { PublicKey } from '@dxos/keys';
+import { PresencePlugin } from '@dxos/protocol-plugin-presence';
+import { afterTest } from '@dxos/testutils';
+import { range, ComplexMap, ComplexSet } from '@dxos/util';
+
+import { NetworkManager } from '../network-manager';
+import { createProtocolFactory } from '../protocol-factory';
+import { FullyConnectedTopology } from '../topology';
+
+/**
+ * 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 () {
+    /**
+     * The simplified model of the system.
+     */
+    interface Model {
+      topic: PublicKey;
+      peers: ComplexSet<PublicKey>;
+      joinedPeers: ComplexSet<PublicKey>;
+    }
+
+    /**
+     * The real system being tested.
+     */
+    interface Real {
+      peers: ComplexMap<PublicKey, { networkManager: NetworkManager; presence?: PresencePlugin }>;
+    }
+
+    const assertState = async (model: Model, real: Real) => {
+      await waitForExpect(() => {
+        for (const peer of real.peers.values()) {
+          if (peer.presence) {
+            for (const expectedPeerId of model.joinedPeers) {
+              if (expectedPeerId.equals(peer.presence.peerId)) {
+                continue;
+              }
+
+              const actuallyConnectedPeers = peer.presence!.peers;
+              if (!actuallyConnectedPeers.some((peer) => PublicKey.equals(expectedPeerId, peer))) {
+                // TODO(burdon): More concise error.
+                const context = {
+                  peerId: peer.presence.peerId,
+                  expectedPeerId: expectedPeerId.truncate(),
+                  connectedPeerIds: actuallyConnectedPeers.map((key) => key.toString('hex'))
+                };
+
+                throw new Error(`Expected peer to be in the list of joined peers: ${context}`);
+              }
+            }
+          }
+        }
+      }, 5_000);
+
+      real.peers.forEach((peer) =>
+        peer.networkManager.topics.forEach((topic) => {
+          peer.networkManager.getSwarm(topic)!.errors.assertNoUnhandledErrors();
+        })
+      );
+    };
+
+    class CreatePeerCommand implements fc.AsyncCommand<Model, Real> {
+      constructor(readonly peerId: PublicKey) {}
+
+      check = (model: Model) => !model.peers.has(this.peerId);
+      async run(model: Model, real: Real) {
+        // TODO(burdon): ???
+        throw new Error('Not implemented.');
+        // model.peers.add(this.peerId);
+        // const networkManager = testBuilder.createNetworkManager();
+        // afterTest(() => networkManager.close());
+
+        // real.peers.set(this.peerId, {
+        //   networkManager
+        // });
+
+        // await assertState(model, real);
+      }
+
+      toString = () => `CreatePeer(${this.peerId})`;
+    }
+
+    class RemovePeerCommand implements fc.AsyncCommand<Model, Real> {
+      constructor(readonly peerId: PublicKey) {}
+
+      check = (model: Model) => model.peers.has(this.peerId);
+      async run(model: Model, real: Real) {
+        model.peers.delete(this.peerId);
+        model.joinedPeers.delete(this.peerId);
+
+        const peer = real.peers.get(this.peerId);
+        await peer!.networkManager.close();
+        real.peers.delete(this.peerId);
+
+        await assertState(model, real);
+      }
+
+      toString = () => `RemovePeer(${this.peerId})`;
+    }
+
+    class JoinTopicCommand implements fc.AsyncCommand<Model, Real> {
+      constructor(readonly peerId: PublicKey) {}
+
+      check = (model: Model) => model.peers.has(this.peerId) && !model.joinedPeers.has(this.peerId);
+      async run(model: Model, real: Real) {
+        model.joinedPeers.add(this.peerId);
+
+        const peer = real.peers.get(this.peerId)!;
+
+        const presence = new PresencePlugin(this.peerId.asBuffer());
+        afterTest(() => presence.stop());
+        const protocol = createProtocolFactory(model.topic, this.peerId, [presence]);
+
+        await peer.networkManager.joinSwarm({
+          peerId: this.peerId, // TODO(burdon): `this`?
+          topic: model.topic,
+          protocol,
+          topology: new FullyConnectedTopology(),
+          presence
+        });
+
+        peer.presence = presence;
+
+        await assertState(model, real);
+      }
+
+      toString = () => `JoinTopic(peerId=${this.peerId})`;
+    }
+
+    class LeaveTopicCommand implements fc.AsyncCommand<Model, Real> {
+      constructor(readonly peerId: PublicKey) {}
+
+      check = (model: Model) => model.peers.has(this.peerId) && model.joinedPeers.has(this.peerId);
+      async run(model: Model, real: Real) {
+        model.joinedPeers.delete(this.peerId);
+
+        const peer = real.peers.get(this.peerId)!;
+        await peer.networkManager.leaveSwarm(model.topic);
+        peer.presence = undefined;
+
+        await assertState(model, real);
+      }
+
+      toString = () => `LeaveTopic(peerId=${this.peerId})`;
+    }
+
+    const peerIds = range(10).map(() => PublicKey.random());
+    const peerId1 = fc.constantFrom(...peerIds);
+
+    const allCommands = [
+      peerId1.map((x) => new CreatePeerCommand(x)),
+      peerId1.map((x) => new RemovePeerCommand(x)),
+      peerId1.map((p) => new JoinTopicCommand(p)),
+      peerId1.map((p) => new LeaveTopicCommand(p))
+    ];
+
+    await fc.assert(
+      fc.asyncProperty(fc.commands(allCommands, { maxCommands: 30 }), async (cmds) => {
+        const setup: ModelRunSetup<Model, Real> = () => ({
+          model: {
+            topic: PublicKey.random(),
+            peers: new ComplexSet(PublicKey.hash),
+            joinedPeers: new ComplexSet(PublicKey.hash)
+          },
+          real: {
+            peers: new ComplexMap(PublicKey.hash)
+          }
+        });
+
+        await fc.asyncModelRun(setup, cmds);
+      }),
+      {
+        examples: [
+          [
+            [
+              new CreatePeerCommand(peerIds[0]),
+              new CreatePeerCommand(peerIds[1]),
+              new JoinTopicCommand(peerIds[0]),
+              new JoinTopicCommand(peerIds[1]),
+              new LeaveTopicCommand(peerIds[0]),
+              new LeaveTopicCommand(peerIds[1]),
+              new RemovePeerCommand(peerIds[0]),
+              new RemovePeerCommand(peerIds[1])
+            ]
+          ],
+          [
+            [
+              new CreatePeerCommand(peerIds[0]),
+              new JoinTopicCommand(peerIds[0]),
+              new CreatePeerCommand(peerIds[1]),
+              new RemovePeerCommand(peerIds[0]),
+              new JoinTopicCommand(peerIds[1]),
+              new RemovePeerCommand(peerIds[1])
+            ]
+          ],
+          [
+            [
+              new CreatePeerCommand(peerIds[0]),
+              new JoinTopicCommand(peerIds[0]),
+              new RemovePeerCommand(peerIds[0]),
+              new CreatePeerCommand(peerIds[1]),
+              new JoinTopicCommand(peerIds[1]),
+              new CreatePeerCommand(peerIds[2]),
+              new JoinTopicCommand(peerIds[2])
+            ]
+          ]
+        ]
+      }
+    );
+  });
+};

package/src/tests/utils.ts

@@ -0,0 +1,85 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { latch, Trigger } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+import { afterTest } from '@dxos/testutils';
+import { Provider } from '@dxos/util';
+
+import { TestPeer, TestSwarmConnection } from '../testing';
+import { Topology } from '../topology';
+
+//
+// NOTE: Don't move to testing directory since not exportable outside of package.
+//
+
+/**
+ * Open peers and close after tests complete.
+ */
+export const openAndCloseAfterTest = async (peers: TestPeer[]) => {
+  await Promise.all(peers.map((peer) => peer.open()));
+  afterTest(async () => {
+    await Promise.all(peers.map((peer) => peer.close()));
+  });
+};
+
+/**
+ * Join and cleanly leave swarm.
+ */
+export const joinSwarm = async (peers: TestPeer[], topic: PublicKey, topology?: Provider<Topology>) => {
+  const [connected, connect] = latch({ count: peers.length });
+  const swarms = peers.map((peer) => {
+    const swarm = peer.createSwarm(topic);
+    swarm.plugin.once('connect', connect);
+    return swarm;
+  });
+
+  await Promise.all(swarms.map((swarm) => swarm.join(topology?.())));
+  await connected();
+  return swarms;
+};
+
+/**
+ * Cleanly leave swarm.
+ */
+export const leaveSwarm = async (peers: TestPeer[], topic: PublicKey) => {
+  const [disconnected, disconnect] = latch({ count: peers.length });
+  const swarms = peers.map((peer) => {
+    const swarm = peer.getSwarm(topic);
+    swarm.plugin.once('disconnect', disconnect);
+    return swarm;
+  });
+
+  await Promise.all(swarms.map((swarm) => swarm.leave()));
+  await disconnected();
+  return swarms;
+};
+
+/**
+ * Exchange messages between peers.
+ */
+// TODO(burdon): Based on plugin instance.
+// TODO(burdon): Configure to send more messages.
+export const exchangeMessages = async (swarm1: TestSwarmConnection, swarm2: TestSwarmConnection) => {
+  {
+    const peer2Received = new Trigger<any>();
+    swarm2.plugin.on('receive', (peer, message) => peer2Received.wake(message));
+
+    // TODO(burdon): Message encoding?
+    await swarm1.plugin.send(swarm2.peer.peerId.asBuffer(), JSON.stringify({ message: 'ping' }));
+    const { message } = JSON.parse(await peer2Received.wait());
+    expect(message).to.eq('ping');
+  }
+
+  {
+    const peer1Received = new Trigger<any>();
+    swarm1.plugin.on('receive', (peer, message) => peer1Received.wake(message));
+
+    await swarm2.plugin.send(swarm1.peer.peerId.asBuffer(), JSON.stringify({ message: 'pong' }));
+    const { message } = JSON.parse(await peer1Received.wait());
+    expect(message).to.eq('pong');
+  }
+};

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

@@ -0,0 +1,16 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { TEST_SIGNAL_URL, TestBuilder } from '../testing';
+import { basicTestSuite } from './basic-test-suite';
+
+describe('WebRTC transport', function () {
+  const testBuilder = new TestBuilder({ signalHosts: [TEST_SIGNAL_URL] });
+  basicTestSuite(testBuilder);
+}).timeout(10_000);
+
+describe('WebRTC transport proxy', function () {
+  const testBuilder = new TestBuilder({ signalHosts: [TEST_SIGNAL_URL], bridge: true });
+  basicTestSuite(testBuilder);
+}).timeout(10_000);

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

@@ -11,6 +11,10 @@ import { SwarmController, Topology } from './topology';
 export class FullyConnectedTopology implements Topology {
   private _controller?: SwarmController;
 
+  toString() {
+    return 'FullyConnectedTopology';
+  }
+
   init(controller: SwarmController): void {
     assert(!this._controller, 'Already initialized');
     this._controller = controller;
@@ -20,6 +24,7 @@ export class FullyConnectedTopology implements Topology {
     assert(this._controller, 'Not initialized');
     const { candidates: discovered } = this._controller.getState();
     for (const peer of discovered) {
+      // TODO(burdon): Back-off.
       this._controller.connect(peer);
     }
   }
@@ -31,8 +36,4 @@ export class FullyConnectedTopology implements Topology {
   async destroy(): Promise<void> {
     // Nothing to do.
   }
-
-  toString() {
-    return 'FullyConnectedTopology';
-  }
 }

package/src/topology/topology.ts

@@ -41,10 +41,7 @@ export interface SwarmState {
 export interface Topology {
   /**
    * Called when swarm is created.
-   *
    * May be used to bind the swarm controller and initialize any asynchronous actions.
-   *
-   * @param controller
    */
   init(controller: SwarmController): void;
 
@@ -55,14 +52,12 @@ export interface Topology {
 
   /**
    * Called when remote peer offers a connection.
-   *
    * @returns true - to accept the connection, false - to reject.
    */
   onOffer(peer: PublicKey): Promise<boolean>;
 
   /**
    * Called when swarm is destroyed or topology is changed.
-   *
    * Any error thrown here will be a critical error for the swarm.
    */
   destroy(): Promise<void>;

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

@@ -18,6 +18,7 @@ import { MemoryTransport } from './memory-transport';
 //  Cannot log after tests are done. Did you forget to wait for something async in your test?
 //  Attempted to log "Ignoring unsupported ICE candidate.".
 
+// TODO(burdon): Move to TestBuilder.
 const createPair = () => {
   const topic = PublicKey.random();
   const peer1Id = PublicKey.random();
@@ -33,7 +34,7 @@ const createPair = () => {
     initiator: true
   });
 
-  afterTest(() => connection1.close());
+  afterTest(() => connection1.destroy());
   afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
   const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
@@ -46,7 +47,7 @@ const createPair = () => {
     initiator: false
   });
 
-  afterTest(() => connection2.close());
+  afterTest(() => connection2.destroy());
   afterTest(() => connection2.errors.assertNoUnhandledErrors());
 
   return {

package/src/transport/memory-transport.ts

@@ -14,91 +14,111 @@ import { ComplexMap } from '@dxos/util';
 
 import { Transport, TransportFactory, TransportOptions } from './transport';
 
+// TODO(burdon): Make configurable.
 // Delay (in milliseconds) for data being sent through in-memory connections to simulate network latency.
 const MEMORY_TRANSPORT_DELAY = 1;
 
 /**
  * Creates a binary stream that delays data being sent through the stream by the specified amount of time.
  */
-const createStreamDelay = (delay: number): NodeJS.ReadWriteStream =>
-  new Transform({
+const createStreamDelay = (delay: number): NodeJS.ReadWriteStream => {
+  return new Transform({
     objectMode: true,
     transform: (chunk, _, cb) => {
       setTimeout(() => cb(null, chunk), delay); // TODO(burdon): Randomize.
     }
   });
+};
+
+export const MemoryTransportFactory: TransportFactory = {
+  createTransport: (params) => new MemoryTransport(params)
+};
 
 /**
  * Fake transport.
  */
-// TODO(burdon): Remove static variables.
 export class MemoryTransport implements Transport {
-  // TODO(burdon): Remove global properties.
+  // TODO(burdon): Remove static properties (inject context into constructor).
   private static readonly _connections = new ComplexMap<PublicKey, MemoryTransport>(PublicKey.hash);
 
   public readonly closed = new Event<void>();
   public readonly connected = new Event<void>();
   public readonly errors = new ErrorStream();
 
-  private readonly _ownId = PublicKey.random();
-  private _remoteId!: PublicKey;
+  private readonly _id = PublicKey.random(); // TODO(burdon): Rename peerId? (Use local/remote labels in logs).
   private readonly _remote = new Trigger<PublicKey>();
 
   private readonly _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
   private readonly _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
 
+  private _destroyed = false;
+  private _remoteId!: PublicKey;
   private _remoteConnection?: MemoryTransport;
 
-  constructor(private readonly params: TransportOptions) {
-    log('creating', this._ownId);
-
-    if (this.params.initiator) {
-      setTimeout(async () => this.params.sendSignal({ json: JSON.stringify({ transportId: this._ownId.toHex() }) }));
-    }
-
-    assert(!MemoryTransport._connections.has(this._ownId), 'Duplicate memory connection');
-    MemoryTransport._connections.set(this._ownId, this);
-
-    this._remote.wait().then(
-      (remoteId) => {
-        this._remoteId = remoteId;
-        this._remoteConnection = MemoryTransport._connections.get(this._remoteId);
-        if (this._remoteConnection) {
+  constructor(private readonly options: TransportOptions) {
+    log('creating', { id: this._id });
+
+    assert(!MemoryTransport._connections.has(this._id), 'Duplicate memory connection');
+    MemoryTransport._connections.set(this._id, this);
+
+    // Initiator will send a signal, the receiver will receive the unique ID and connect the streams.
+    if (this.options.initiator) {
+      // prettier-ignore
+      setTimeout(async () => {
+        log('sending signal', { transportId: this._id });
+        void this.options.sendSignal({
+          json: JSON.stringify({ transportId: this._id.toHex() })
+        });
+    });
+    } else {
+      this._remote
+        .wait({ timeout: this.options.timeout ?? 1000 })
+        .then((remoteId) => {
+          if (this._destroyed) {
+            return;
+          }
+
+          this._remoteId = remoteId;
+          this._remoteConnection = MemoryTransport._connections.get(this._remoteId);
+          if (!this._remoteConnection) {
+            // Remote connection was destroyed before we could connect.
+            this._destroyed = true;
+            this.closed.emit();
+            return;
+          }
+
+          assert(!this._remoteConnection._remoteConnection, new Error(`Remote already connected: ${this._remoteId}`));
           this._remoteConnection._remoteConnection = this;
-          this._remoteConnection._remoteId = this._ownId;
+          this._remoteConnection._remoteId = this._id;
 
-          log('connected', { ownId: this._ownId, remoteId: this._remoteId });
-          this.params.stream
+          log('connected', { id: this._id, remote: this._remoteId });
+          this.options.stream
             .pipe(this._outgoingDelay)
-            .pipe(this._remoteConnection.params.stream)
+            .pipe(this._remoteConnection.options.stream)
             .pipe(this._incomingDelay)
-            .pipe(this.params.stream);
+            .pipe(this.options.stream);
 
           this.connected.emit();
           this._remoteConnection.connected.emit();
-        }
-      },
-      async (err) => {
-        log.catch(err);
-      }
-    );
-  }
-
-  async signal(signal: Signal) {
-    const { json } = signal;
-    if (json) {
-      const { transportId } = JSON.parse(json);
-      if (transportId) {
-        this._remote.wake(PublicKey.from(transportId));
-      }
+        })
+        .catch((err) => {
+          if (this._destroyed) {
+            return;
+          }
+
+          this.errors.raise(err);
+        });
     }
   }
 
-  async close(): Promise<void> {
-    log('closing', this._ownId);
+  async destroy(): Promise<void> {
+    log('closing', { id: this._id });
+    this._destroyed = true;
 
-    MemoryTransport._connections.delete(this._ownId);
+    MemoryTransport._connections.delete(this._id);
     if (this._remoteConnection) {
+      log('closing', { id: this._remoteId });
+      this._remoteConnection._destroyed = true;
       MemoryTransport._connections.delete(this._remoteId);
 
       // TODO(dmaretskyi): Hypercore streams do not seem to have the unpipe method.
@@ -115,13 +135,23 @@ export class MemoryTransport implements Transport {
       this._remoteConnection.closed.emit();
       this._remoteConnection._remoteConnection = undefined;
       this._remoteConnection = undefined;
+      log('closed', { id: this._remoteId });
     }
 
     this.closed.emit();
-    log('closed');
+    log('closed', { id: this._id });
   }
-}
 
-export const MemoryTransportFactory: TransportFactory = {
-  create: (params) => new MemoryTransport(params)
-};
+  signal(signal: Signal) {
+    const { json } = signal;
+    if (json) {
+      // TODO(burdon): Check open?
+      const { transportId } = JSON.parse(json);
+      if (transportId) {
+        const remoteId = PublicKey.fromHex(transportId);
+        log('received signal', { id: this._id, remoteId });
+        this._remote.wake(remoteId);
+      }
+    }
+  }
+}

package/src/transport/transport.ts

@@ -13,8 +13,9 @@ export interface Transport {
   closed: Event;
   connected: Event;
   errors: ErrorStream;
-  signal(signal: Signal): Promise<void>; // TODO(burdon): Remove async?
-  close(): Promise<void>;
+
+  destroy(): Promise<void>;
+  signal(signal: Signal): void;
 }
 
 export type TransportOptions = {
@@ -32,8 +33,13 @@ export type TransportOptions = {
    * Send a signal message to remote peer.
    */
   sendSignal: (signal: Signal) => Promise<void>; // TODO(burdon): Remove async?
+
+  timeout?: number;
 };
 
+/**
+ *
+ */
 export interface TransportFactory {
-  create(options: TransportOptions): Transport;
+  createTransport(options: TransportOptions): Transport;
 }

package/src/transport/{wrtc-simple-peer.test.ts → webrtc-simple-peer.test.ts}

@@ -9,7 +9,7 @@ import SimplePeerConstructor from 'simple-peer';
 
 import { sleep } from '@dxos/async';
 
-describe('node wrtc and simple-peer', function () {
+describe('Node WebRTC and simple-peer', function () {
   // Simplest test that reproduces SIGABRT (mac) and SIGSEGV (linux) in wrtc.
   it.skip('open and close', async function () {
     const peer = new SimplePeerConstructor({

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

@@ -73,7 +73,7 @@ describe('WebRTCTransportProxy', function () {
       sendSignal,
       bridgeService: rpcClient.rpc.BridgeService
     });
-    afterTest(async () => await webRTCTransportProxy.close());
+    afterTest(async () => await webRTCTransportProxy.destroy());
 
     return { webRTCService: rpcService, webRTCTransportProxy };
   };
@@ -89,7 +89,7 @@ describe('WebRTCTransportProxy', function () {
     connection.closed.once(closedCb);
 
     await sleep(10); // Let simple-peer process events.
-    await connection.close();
+    await connection.destroy();
 
     await sleep(1); // Process events.