@dxos/network-manager 0.1.41 → 0.1.45-next.45667d4

package/src/testing/test-builder.ts

@@ -3,7 +3,12 @@
 //
 
 import { PublicKey } from '@dxos/keys';
-import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from '@dxos/messaging';
+import {
+  MemorySignalManager,
+  MemorySignalManagerContext,
+  SignalManager,
+  WebsocketSignalManager,
+} from '@dxos/messaging';
 import { schema } from '@dxos/protocols';
 import { ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
 import { Runtime } from '@dxos/protocols/proto/dxos/config';
@@ -17,7 +22,7 @@ import {
   TransportFactory,
   WebRTCTransport,
   WebRTCTransportProxyFactory,
-  WebRTCTransportService
+  WebRTCTransportService,
 } from '../transport';
 import { TestWireProtocol } from './test-wire-protocol';
 
@@ -58,6 +63,11 @@ export class TestPeer {
 
   private readonly _swarms = new ComplexMap<PublicKey, TestSwarmConnection>(PublicKey.hash);
 
+  /**
+   * @internal
+   */
+  readonly _signalManager: SignalManager;
+
   /**
    * @internal
    */
@@ -67,6 +77,7 @@ export class TestPeer {
   private _service?: ProtoRpcPeer<any>;
 
   constructor(private readonly testBuilder: TestBuilder) {
+    this._signalManager = this.testBuilder.createSignalManager();
     this._networkManager = this.createNetworkManager();
   }
 
@@ -82,37 +93,37 @@ export class TestPeer {
         this._proxy = createProtoRpcPeer({
           port: proxyPort,
           requested: {
-            BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+            BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
           },
           noHandshake: true,
           encodingOptions: {
-            preserveAny: true
-          }
+            preserveAny: true,
+          },
         });
 
         this._service = createProtoRpcPeer({
           port: servicePort,
           exposed: {
-            BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+            BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
           },
           handlers: { BridgeService: new WebRTCTransportService() },
           noHandshake: true,
           encodingOptions: {
-            preserveAny: true
-          }
+            preserveAny: true,
+          },
         });
 
         transportFactory = new WebRTCTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
       } else {
         transportFactory = {
-          createTransport: (params) => new WebRTCTransport(params)
+          createTransport: (params) => new WebRTCTransport(params),
         };
       }
     }
 
     return new NetworkManager({
-      signalManager: this.testBuilder.createSignalManager(),
-      transportFactory
+      signalManager: this._signalManager,
+      transportFactory,
     });
   }
 
@@ -177,7 +188,7 @@ export class TestSwarmConnection {
       topic: this.topic,
       peerId: this.peer.peerId,
       protocolProvider: this.protocol.factory,
-      topology
+      topology,
     });
 
     return this;

package/src/testing/test-wire-protocol.ts

@@ -23,7 +23,7 @@ export class TestWireProtocol {
       onClose: async () => {
         this.connections.delete(teleport.remotePeerId);
         this.disconnected.emit(teleport.remotePeerId);
-      }
+      },
     });
     this.connections.set(teleport.remotePeerId, extension);
     teleport.addExtension('test', extension);
@@ -37,7 +37,7 @@ export class TestWireProtocol {
     log('waitForConnection', { peerId });
     await asyncTimeout(
       this.connected.waitFor((connectedId) => connectedId.equals(peerId)),
-      1_000
+      1_000,
     );
     return this.connections.get(peerId)!;
   }

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

@@ -107,7 +107,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
 
     await Promise.all([
       test1.swarm1a.protocol.testConnection(test1.peer2a.peerId),
-      test2.swarm1a.protocol.testConnection(test2.peer2a.peerId)
+      test2.swarm1a.protocol.testConnection(test2.peer2a.peerId),
     ]);
   }).tag('flaky');
 
@@ -125,7 +125,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     // Wait until both peers are disconnected.
     await Promise.all([
       swarm1.protocol.disconnected.waitForCondition(() => swarm1.protocol.connections.size === 0),
-      swarm2.protocol.disconnected.waitForCondition(() => swarm2.protocol.connections.size === 0)
+      swarm2.protocol.disconnected.waitForCondition(() => swarm2.protocol.connections.size === 0),
     ]);
 
     await exchangeMessages(swarm1, swarm2);
@@ -150,8 +150,8 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       .getSwarm(topic)
       ?.disconnected.waitFor((peerId) => peerId.equals(peer1.peerId));
 
-    const peerLeft = peer2._networkManager.signalManager.swarmEvent.waitFor(
-      (event) => !!event.swarmEvent.peerLeft && peer1.peerId.equals(event.swarmEvent.peerLeft?.peer)
+    const peerLeft = peer2._signalManager.swarmEvent.waitFor(
+      (event) => !!event.swarmEvent.peerLeft && peer1.peerId.equals(event.swarmEvent.peerLeft?.peer),
     );
 
     await peer1.goOffline();
@@ -196,14 +196,14 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
               const swarm = peer.createSwarm(topic);
 
               swarmsAllPeersConnected.push(
-                swarm.protocol.connected.waitFor(() => swarm.protocol.connections.size === peersPerTopic - 1)
+                swarm.protocol.connected.waitFor(() => swarm.protocol.connections.size === peersPerTopic - 1),
               );
               await swarm.join();
-            })
+            }),
           );
-        })
+        }),
       ),
-      2_000
+      2_000,
     );
 
     await asyncTimeout(Promise.all(swarmsAllPeersConnected), 2_000);

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

@@ -37,9 +37,9 @@ describe('Memory transport', () => {
             peer2,
             topic,
             swarm1,
-            swarm2
+            swarm2,
           };
-        })
+        }),
       );
 
       const message = randomBytes(PACKET_SIZE / 2).toString('hex');
@@ -49,14 +49,14 @@ describe('Memory transport', () => {
         await Promise.all(
           pairs.map(async ({ swarm1, swarm2 }) => {
             await exchangeMessages(swarm1, swarm2, message);
-          })
+          }),
         );
       }
 
       await Promise.all(
         pairs.map(async ({ peer1, peer2, topic }) => {
           await leaveSwarm([peer1, peer2], topic);
-        })
+        }),
       );
     })
     .timeout(1_000_000);

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

@@ -51,7 +51,7 @@ export const propertyTestSuite = () => {
                 const context = {
                   peerId: peer.presence.peerId,
                   expectedPeerId: expectedPeerId.truncate(),
-                  connectedPeerIds: actuallyConnectedPeers.map((key: any) => key.toString('hex'))
+                  connectedPeerIds: actuallyConnectedPeers.map((key: any) => key.toString('hex')),
                 };
 
                 throw new Error(`Expected peer to be in the list of joined peers: ${context}`);
@@ -64,7 +64,7 @@ export const propertyTestSuite = () => {
       real.peers.forEach((peer) =>
         peer.networkManager.topics.forEach((topic) => {
           peer.networkManager.getSwarm(topic)!.errors.assertNoUnhandledErrors();
-        })
+        }),
       );
     };
 
@@ -124,7 +124,7 @@ export const propertyTestSuite = () => {
           peerId: this.peerId, // TODO(burdon): `this`?
           topic: model.topic,
           protocolProvider: todo(),
-          topology: new FullyConnectedTopology()
+          topology: new FullyConnectedTopology(),
           // presence
         });
 
@@ -160,7 +160,7 @@ export const propertyTestSuite = () => {
       peerId1.map((x) => new CreatePeerCommand(x)),
       peerId1.map((x) => new RemovePeerCommand(x)),
       peerId1.map((p) => new JoinTopicCommand(p)),
-      peerId1.map((p) => new LeaveTopicCommand(p))
+      peerId1.map((p) => new LeaveTopicCommand(p)),
     ];
 
     await fc.assert(
@@ -169,11 +169,11 @@ export const propertyTestSuite = () => {
           model: {
             topic: PublicKey.random(),
             peers: new ComplexSet(PublicKey.hash),
-            joinedPeers: new ComplexSet(PublicKey.hash)
+            joinedPeers: new ComplexSet(PublicKey.hash),
           },
           real: {
-            peers: new ComplexMap(PublicKey.hash)
-          }
+            peers: new ComplexMap(PublicKey.hash),
+          },
         });
 
         await fc.asyncModelRun(setup, cmds);
@@ -189,8 +189,8 @@ export const propertyTestSuite = () => {
               new LeaveTopicCommand(peerIds[0]),
               new LeaveTopicCommand(peerIds[1]),
               new RemovePeerCommand(peerIds[0]),
-              new RemovePeerCommand(peerIds[1])
-            ]
+              new RemovePeerCommand(peerIds[1]),
+            ],
           ],
           [
             [
@@ -199,8 +199,8 @@ export const propertyTestSuite = () => {
               new CreatePeerCommand(peerIds[1]),
               new RemovePeerCommand(peerIds[0]),
               new JoinTopicCommand(peerIds[1]),
-              new RemovePeerCommand(peerIds[1])
-            ]
+              new RemovePeerCommand(peerIds[1]),
+            ],
           ],
           [
             [
@@ -210,11 +210,11 @@ export const propertyTestSuite = () => {
               new CreatePeerCommand(peerIds[1]),
               new JoinTopicCommand(peerIds[1]),
               new CreatePeerCommand(peerIds[2]),
-              new JoinTopicCommand(peerIds[2])
-            ]
-          ]
-        ]
-      }
+              new JoinTopicCommand(peerIds[2]),
+            ],
+          ],
+        ],
+      },
     );
   });
 };

package/src/tests/utils.ts

@@ -31,7 +31,7 @@ export const joinSwarm = async (peers: TestPeer[], topic: PublicKey, topology?:
   const swarms = peers.map((peer) => peer.createSwarm(topic));
   await Promise.all(swarms.map((swarm) => swarm.join(topology?.())));
   await Promise.all(
-    swarms.map((swarm) => swarm.protocol.connected.waitForCondition(() => swarm.protocol.connections.size >= 0))
+    swarms.map((swarm) => swarm.protocol.connected.waitForCondition(() => swarm.protocol.connections.size >= 0)),
   );
   return swarms;
 };
@@ -43,7 +43,7 @@ export const leaveSwarm = async (peers: TestPeer[], topic: PublicKey) => {
   const swarms = peers.map((peer) => peer.getSwarm(topic));
   await Promise.all(swarms.map((swarm) => swarm.leave()));
   await Promise.all(
-    swarms.map((swarm) => swarm.protocol.connected.waitForCondition(() => swarm.protocol.connections.size === 0))
+    swarms.map((swarm) => swarm.protocol.connected.waitForCondition(() => swarm.protocol.connections.size === 0)),
   );
   return swarms;
 };

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

@@ -2,15 +2,29 @@
 // Copyright 2021 DXOS.org
 //
 
+import { describe } from '@dxos/test';
+
 import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
 import { basicTestSuite } from './basic-test-suite';
 
 describe('WebRTC transport', () => {
-  const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS });
+  const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);
 }).timeout(10_000);
 
 describe('WebRTC transport proxy', () => {
-  const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS, bridge: true });
+  const testBuilder = new TestBuilder({ bridge: true });
   basicTestSuite(testBuilder);
 }).timeout(10_000);
+
+describe.skip('test with signal server', () => {
+  describe('WebRTC transport', () => {
+    const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS });
+    basicTestSuite(testBuilder);
+  }).timeout(10_000);
+
+  describe('WebRTC transport proxy', () => {
+    const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS, bridge: true });
+    basicTestSuite(testBuilder);
+  }).timeout(10_000);
+});

package/src/topology/mmst-topology.ts

@@ -101,5 +101,5 @@ export class MMSTTopology implements Topology {
 
 const sortByXorDistance = (keys: PublicKey[], reference: PublicKey): PublicKey[] =>
   keys.sort((a, b) =>
-    distance.gt(distance(a.asBuffer(), reference.asBuffer()), distance(b.asBuffer(), reference.asBuffer()))
+    distance.gt(distance(a.asBuffer(), reference.asBuffer()), distance(b.asBuffer(), reference.asBuffer())),
   );

package/src/topology/star-topology.ts

@@ -56,7 +56,7 @@ export class StarTopology implements Topology {
     log('offer', {
       peer,
       isCentral: peer.equals(this._centralPeer),
-      isSelfCentral: ownPeerId.equals(this._centralPeer)
+      isSelfCentral: ownPeerId.equals(this._centralPeer),
     });
     return ownPeerId.equals(this._centralPeer) || peer.equals(this._centralPeer);
   }

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

@@ -25,7 +25,7 @@ const createPair = () => {
     sendSignal: async (signal) => {
       await connection2.signal(signal);
     },
-    initiator: true
+    initiator: true,
   });
 
   afterTest(() => connection1.destroy());
@@ -37,7 +37,7 @@ const createPair = () => {
     sendSignal: async (signal) => {
       await connection1.signal(signal);
     },
-    initiator: false
+    initiator: false,
   });
 
   afterTest(() => connection2.destroy());
@@ -50,7 +50,7 @@ const createPair = () => {
     stream2,
     peer1Id,
     peer2Id,
-    topic
+    topic,
   };
 };
 
@@ -65,7 +65,7 @@ describe('MemoryTransport', () => {
       range(10).map(async () => {
         const { stream1, stream2 } = createPair();
         await TestStream.assertConnectivity(stream1, stream2);
-      })
+      }),
     );
   });
 });

package/src/transport/memory-transport.ts

@@ -26,12 +26,12 @@ const createStreamDelay = (delay: number): NodeJS.ReadWriteStream => {
     objectMode: true,
     transform: (chunk, _, cb) => {
       setTimeout(() => cb(null, chunk), delay); // TODO(burdon): Randomize.
-    }
+    },
   });
 };
 
 export const MemoryTransportFactory: TransportFactory = {
-  createTransport: (params) => new MemoryTransport(params)
+  createTransport: (params) => new MemoryTransport(params),
 };
 
 /**
@@ -98,7 +98,7 @@ export class MemoryTransport implements Transport {
 
           assert(
             !this._remoteConnection._remoteConnection,
-            new Error(`Remote already connected: ${this._remoteInstanceId}`)
+            new Error(`Remote already connected: ${this._remoteInstanceId}`),
           );
           this._remoteConnection._remoteConnection = this;
           this._remoteConnection._remoteInstanceId = this._instanceId;

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

@@ -16,7 +16,7 @@ describe('Node WebRTC and simple-peer', () => {
     .skip('open and close', async () => {
       const peer = new SimplePeerConstructor({
         initiator: true,
-        wrtc
+        wrtc,
       });
 
       await sleep(1);

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

@@ -20,7 +20,7 @@ describe('WebRTCTransportProxy', () => {
   const setupProxy = async ({
     initiator = true,
     stream = new TestStream(),
-    sendSignal = async () => {}
+    sendSignal = async () => {},
   }: {
     initiator?: boolean;
     stream?: NodeJS.ReadWriteStream;
@@ -35,14 +35,14 @@ describe('WebRTCTransportProxy', () => {
     const rpcService = createProtoRpcPeer({
       requested: {},
       exposed: {
-        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
       },
       handlers: { BridgeService: webRTCTransportService },
       port: port1,
       noHandshake: true,
       encodingOptions: {
-        preserveAny: true
-      }
+        preserveAny: true,
+      },
     });
     await rpcService.open();
     afterTest(() => rpcService.close());
@@ -50,13 +50,13 @@ describe('WebRTCTransportProxy', () => {
     // Starting RPC client
     const rpcClient = createProtoRpcPeer({
       requested: {
-        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
       },
       port: port2,
       noHandshake: true,
       encodingOptions: {
-        preserveAny: true
-      }
+        preserveAny: true,
+      },
     });
     await rpcClient.open();
     afterTest(() => rpcClient.close());
@@ -65,7 +65,7 @@ describe('WebRTCTransportProxy', () => {
       initiator,
       stream,
       sendSignal,
-      bridgeService: rpcClient.rpc.BridgeService
+      bridgeService: rpcClient.rpc.BridgeService,
     });
     afterTest(async () => await webRTCTransportProxy.destroy());
 
@@ -100,7 +100,7 @@ describe('WebRTCTransportProxy', () => {
       sendSignal: async (signal) => {
         await sleep(10);
         await connection2.signal(signal);
-      }
+      },
     });
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
@@ -111,7 +111,7 @@ describe('WebRTCTransportProxy', () => {
       sendSignal: async (signal) => {
         await sleep(10);
         await connection1.signal(signal);
-      }
+      },
     });
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
     await TestStream.assertConnectivity(stream1, stream2);
@@ -129,26 +129,26 @@ describe('WebRTCTransportProxy', () => {
       const webRTCTransportService: BridgeService = new WebRTCTransportService();
       service = createProtoRpcPeer({
         exposed: {
-          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
         },
         handlers: { BridgeService: webRTCTransportService },
         port: port1,
         noHandshake: true,
         encodingOptions: {
-          preserveAny: true
-        }
+          preserveAny: true,
+        },
       });
       await service.open();
 
       rpcClient = createProtoRpcPeer({
         requested: {
-          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService')
+          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
         },
         port: port2,
         noHandshake: true,
         encodingOptions: {
-          preserveAny: true
-        }
+          preserveAny: true,
+        },
       });
       await rpcClient.open();
     });
@@ -167,7 +167,7 @@ describe('WebRTCTransportProxy', () => {
           await sleep(10);
           await proxy2.signal(signal);
         },
-        bridgeService: rpcClient.rpc.BridgeService
+        bridgeService: rpcClient.rpc.BridgeService,
       });
       afterTest(() => proxy1.errors.assertNoUnhandledErrors());
 
@@ -179,7 +179,7 @@ describe('WebRTCTransportProxy', () => {
           await sleep(10);
           await proxy1.signal(signal);
         },
-        bridgeService: rpcClient.rpc.BridgeService
+        bridgeService: rpcClient.rpc.BridgeService,
       });
       afterTest(() => proxy2.errors.assertNoUnhandledErrors());
 

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

@@ -103,7 +103,7 @@ export class WebRTCTransportProxy implements Transport {
     this._params.bridgeService
       .sendSignal({
         proxyId: this._proxyId,
-        signal
+        signal,
       })
       .catch((err) => this.errors.raise(err));
   }
@@ -161,7 +161,7 @@ export class WebRTCTransportProxyFactory implements TransportFactory {
 
     const transport = new WebRTCTransportProxy({
       ...options,
-      bridgeService: this._bridgeService
+      bridgeService: this._bridgeService,
     });
 
     this._connections.add(transport);

package/src/transport/webrtc-transport-service.ts

@@ -15,7 +15,7 @@ import {
   DataRequest,
   BridgeEvent,
   ConnectionState,
-  CloseRequest
+  CloseRequest,
 } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { ComplexMap } from '@dxos/util';
 
@@ -23,7 +23,7 @@ import { WebRTCTransport } from './webrtc-transport';
 
 export class WebRTCTransportService implements BridgeService {
   private readonly transports = new ComplexMap<PublicKey, { transport: WebRTCTransport; stream: Duplex }>(
-    PublicKey.hash
+    PublicKey.hash,
   );
 
   // prettier-ignore
@@ -38,7 +38,7 @@ export class WebRTCTransportService implements BridgeService {
         write: function (chunk, _, callback) {
           next({ data: { payload: chunk } });
           callback();
-        }
+        },
       });
 
       const transport = new WebRTCTransport({
@@ -47,22 +47,22 @@ export class WebRTCTransportService implements BridgeService {
         webrtcConfig: this._webrtcConfig,
         sendSignal: async (signal) => {
           next({
-            signal: { payload: signal }
+            signal: { payload: signal },
           });
-        }
+        },
       });
 
       next({
         connection: {
-          state: ConnectionState.CONNECTING
-        }
+          state: ConnectionState.CONNECTING,
+        },
       });
 
       transport.connected.on(() => {
         next({
           connection: {
-            state: ConnectionState.CONNECTED
-          }
+            state: ConnectionState.CONNECTED,
+          },
         });
       });
 
@@ -70,8 +70,8 @@ export class WebRTCTransportService implements BridgeService {
         next({
           connection: {
             state: ConnectionState.CLOSED,
-            error: err.toString()
-          }
+            error: err.toString(),
+          },
         });
         close(err);
       });
@@ -79,8 +79,8 @@ export class WebRTCTransportService implements BridgeService {
       transport.closed.on(() => {
         next({
           connection: {
-            state: ConnectionState.CLOSED
-          }
+            state: ConnectionState.CLOSED,
+          },
         });
         close();
       });

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

@@ -16,7 +16,7 @@ describe('WebRTCTransport', () => {
     const connection = new WebRTCTransport({
       initiator: true,
       stream: new Duplex(),
-      sendSignal: async () => {}
+      sendSignal: async () => {},
     });
 
     let callsCounter = 0;
@@ -42,7 +42,7 @@ describe('WebRTCTransport', () => {
       sendSignal: async (signal) => {
         await sleep(10);
         await connection2.signal(signal);
-      }
+      },
     });
     afterTest(() => connection1.destroy());
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
@@ -54,7 +54,7 @@ describe('WebRTCTransport', () => {
       sendSignal: async (signal) => {
         await sleep(10);
         await connection1.signal(signal);
-      }
+      },
     });
     afterTest(() => connection2.destroy());
     afterTest(() => connection2.errors.assertNoUnhandledErrors());