@dxos/network-manager 0.1.17 → 0.1.18

package/src/transport/memory-transport.ts

@@ -8,7 +8,7 @@ import { Transform } from 'node:stream';
 import { Event, Trigger } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
+import { log, logInfo } from '@dxos/log';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap } from '@dxos/util';
 
@@ -45,29 +45,34 @@ export class MemoryTransport implements Transport {
   public readonly connected = new Event<void>();
   public readonly errors = new ErrorStream();
 
-  private readonly _id = PublicKey.random(); // TODO(burdon): Rename peerId? (Use local/remote labels in logs).
+  @logInfo
+  private readonly _instanceId = 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;
+
+  @logInfo
+  private _remoteInstanceId!: PublicKey;
+
   private _remoteConnection?: MemoryTransport;
 
   constructor(private readonly options: TransportOptions) {
-    log('creating', { id: this._id });
+    log('creating');
 
-    assert(!MemoryTransport._connections.has(this._id), 'Duplicate memory connection');
-    MemoryTransport._connections.set(this._id, this);
+    assert(!MemoryTransport._connections.has(this._instanceId), 'Duplicate memory connection');
+    MemoryTransport._connections.set(this._instanceId, 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 });
+        log('sending signal');
         void this.options.sendSignal({
-          payload: { transportId: this._id.toHex() }
+          payload: { transportId: this._instanceId.toHex() }
         });
     });
     } else {
@@ -78,8 +83,8 @@ export class MemoryTransport implements Transport {
             return;
           }
 
-          this._remoteId = remoteId;
-          this._remoteConnection = MemoryTransport._connections.get(this._remoteId);
+          this._remoteInstanceId = remoteId;
+          this._remoteConnection = MemoryTransport._connections.get(this._remoteInstanceId);
           if (!this._remoteConnection) {
             // Remote connection was destroyed before we could connect.
             this._destroyed = true;
@@ -87,11 +92,14 @@ export class MemoryTransport implements Transport {
             return;
           }
 
-          assert(!this._remoteConnection._remoteConnection, new Error(`Remote already connected: ${this._remoteId}`));
+          assert(
+            !this._remoteConnection._remoteConnection,
+            new Error(`Remote already connected: ${this._remoteInstanceId}`)
+          );
           this._remoteConnection._remoteConnection = this;
-          this._remoteConnection._remoteId = this._id;
+          this._remoteConnection._remoteInstanceId = this._instanceId;
 
-          log('connected', { id: this._id, remote: this._remoteId });
+          log('connected');
           this.options.stream
             .pipe(this._outgoingDelay)
             .pipe(this._remoteConnection.options.stream)
@@ -112,14 +120,14 @@ export class MemoryTransport implements Transport {
   }
 
   async destroy(): Promise<void> {
-    log('closing', { id: this._id });
+    log('closing');
     this._destroyed = true;
 
-    MemoryTransport._connections.delete(this._id);
+    MemoryTransport._connections.delete(this._instanceId);
     if (this._remoteConnection) {
-      log('closing', { id: this._remoteId });
+      log('closing');
       this._remoteConnection._destroyed = true;
-      MemoryTransport._connections.delete(this._remoteId);
+      MemoryTransport._connections.delete(this._remoteInstanceId);
 
       // TODO(dmaretskyi): Hypercore streams do not seem to have the unpipe method.
       //  NOTE(burdon): Using readable-stream.wrap() might help (see feed-store).
@@ -135,23 +143,23 @@ export class MemoryTransport implements Transport {
       this._remoteConnection.closed.emit();
       this._remoteConnection._remoteConnection = undefined;
       this._remoteConnection = undefined;
-      log('closed', { id: this._remoteId });
+      log('closed');
     }
 
     this.closed.emit();
-    log('closed', { id: this._id });
+    log('closed');
   }
 
-  signal(signal: Signal) {
-    const { payload: json } = signal;
-    if (json && json.transportId) {
-      // TODO(burdon): Check open?
-      const transportId = json.transportId as string;
-      if (transportId) {
-        const remoteId = PublicKey.fromHex(transportId);
-        log('received signal', { id: this._id, remoteId });
-        this._remote.wake(remoteId);
-      }
+  signal({ payload }: Signal) {
+    log('received signal', { payload });
+    if (!payload?.transportId) {
+      return;
+    }
+    // TODO(burdon): Check open?
+    const transportId = payload.transportId as string;
+    if (transportId) {
+      const remoteId = PublicKey.fromHex(transportId);
+      this._remote.wake(remoteId);
     }
   }
 }

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

@@ -5,27 +5,21 @@
 // @dxos/test platform=nodejs
 
 import expect from 'expect';
-import { Duplex } from 'stream';
-import waitForExpect from 'wait-for-expect';
 
-import { sleep } from '@dxos/async';
-import { discoveryKey } from '@dxos/crypto';
-import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
+import { sleep, TestStream } from '@dxos/async';
 import { schema } from '@dxos/protocols';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
-import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
+import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
-import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { WebRTCTransportProxy } from './webrtc-transport-proxy';
 import { WebRTCTransportService } from './webrtc-transport-service';
 
 describe('WebRTCTransportProxy', () => {
   const setupProxy = async ({
     initiator = true,
-    stream = new Duplex({ write: () => {}, read: () => {} }),
+    stream = new TestStream(),
     sendSignal = async () => {}
   }: {
     initiator?: boolean;
@@ -99,18 +93,10 @@ describe('WebRTCTransportProxy', () => {
     .retries(3);
 
   test('establish connection and send data through with protocol', async () => {
-    const topic = PublicKey.random();
-    const peer1Id = PublicKey.random();
-    const peer2Id = PublicKey.random();
-
-    const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-    const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+    const stream1 = new TestStream();
     const { webRTCTransportProxy: connection1 } = await setupProxy({
       initiator: true,
-      stream: protocolProvider1({
-        channel: discoveryKey(topic),
-        initiator: true
-      }).stream,
+      stream: stream1,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection2.signal(signal);
@@ -118,36 +104,17 @@ describe('WebRTCTransportProxy', () => {
     });
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
-    const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-    const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+    const stream2 = new TestStream();
     const { webRTCTransportProxy: connection2 } = await setupProxy({
       initiator: false,
-      stream: protocolProvider2({
-        channel: discoveryKey(topic),
-        initiator: false
-      }).stream,
+      stream: stream2,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection1.signal(signal);
       }
     });
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
-
-    const received: any[] = [];
-    const mockReceive = (p: Protocol, s: string) => {
-      received.push(p, s);
-      return undefined;
-    };
-    plugin1.on('receive', mockReceive);
-
-    plugin2.on('connect', async (protocol) => {
-      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-    });
-    await waitForExpect(() => {
-      expect(received.length).toBe(2);
-      expect(received[0]).toBeInstanceOf(Protocol);
-      expect(received[1]).toBe('{"message": "Hello"}');
-    });
+    await TestStream.assertConnectivity(stream1, stream2);
   })
     .timeout(2_000)
     .retries(3);
@@ -192,18 +159,10 @@ describe('WebRTCTransportProxy', () => {
     });
 
     test('establish connection and send data through with protocol', async () => {
-      const topic = PublicKey.random();
-      const peer1Id = PublicKey.random();
-      const peer2Id = PublicKey.random();
-
-      const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-      const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+      const stream1 = new TestStream();
       const proxy1 = new WebRTCTransportProxy({
         initiator: true,
-        stream: protocolProvider1({
-          channel: discoveryKey(topic),
-          initiator: true
-        }).stream,
+        stream: stream1,
         sendSignal: async (signal) => {
           await sleep(10);
           await proxy2.signal(signal);
@@ -212,14 +171,10 @@ describe('WebRTCTransportProxy', () => {
       });
       afterTest(() => proxy1.errors.assertNoUnhandledErrors());
 
-      const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-      const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+      const stream2 = new TestStream();
       const proxy2 = new WebRTCTransportProxy({
         initiator: false,
-        stream: protocolProvider2({
-          channel: discoveryKey(topic),
-          initiator: false
-        }).stream,
+        stream: stream2,
         sendSignal: async (signal) => {
           await sleep(10);
           await proxy1.signal(signal);
@@ -228,22 +183,7 @@ describe('WebRTCTransportProxy', () => {
       });
       afterTest(() => proxy2.errors.assertNoUnhandledErrors());
 
-      const received: any[] = [];
-      const mockReceive = (p: Protocol, s: string) => {
-        received.push(p, s);
-        return undefined;
-      };
-      plugin1.on('receive', mockReceive);
-
-      plugin2.on('connect', async (protocol) => {
-        await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-      });
-
-      await waitForExpect(() => {
-        expect(received.length).toBe(2);
-        expect(received[0]).toBeInstanceOf(Protocol);
-        expect(received[1]).toBe('{"message": "Hello"}');
-      });
+      await TestStream.assertConnectivity(stream1, stream2);
     })
       .timeout(5_000)
       .retries(3);

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

@@ -4,15 +4,10 @@
 
 import expect from 'expect';
 import { Duplex } from 'stream';
-import waitForExpect from 'wait-for-expect';
 
-import { sleep } from '@dxos/async';
-import { discoveryKey } from '@dxos/crypto';
-import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
-import { describe, test, afterTest } from '@dxos/test';
+import { sleep, TestStream } from '@dxos/async';
+import { afterTest, describe, test } from '@dxos/test';
 
-import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { WebRTCTransport } from './webrtc-transport';
 
 describe('WebRTCTransport', () => {
@@ -40,18 +35,10 @@ describe('WebRTCTransport', () => {
     .retries(3);
 
   test('establish connection and send data through with protocol', async () => {
-    const topic = PublicKey.random();
-    const peer1Id = PublicKey.random();
-    const peer2Id = PublicKey.random();
-
-    const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-    const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+    const stream1 = new TestStream();
     const connection1 = new WebRTCTransport({
       initiator: true,
-      stream: protocolProvider1({
-        channel: discoveryKey(topic),
-        initiator: true
-      }).stream,
+      stream: stream1,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection2.signal(signal);
@@ -60,14 +47,10 @@ describe('WebRTCTransport', () => {
     afterTest(() => connection1.destroy());
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
-    const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-    const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+    const stream2 = new TestStream();
     const connection2 = new WebRTCTransport({
       initiator: false,
-      stream: protocolProvider2({
-        channel: discoveryKey(topic),
-        initiator: false
-      }).stream,
+      stream: stream2,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection1.signal(signal);
@@ -76,21 +59,7 @@ describe('WebRTCTransport', () => {
     afterTest(() => connection2.destroy());
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
 
-    const received: any[] = [];
-    const mockReceive = (p: Protocol, s: string) => {
-      received.push(p, s);
-      return undefined;
-    };
-    plugin1.on('receive', mockReceive);
-    plugin2.on('connect', async (protocol) => {
-      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-    });
-
-    await waitForExpect(() => {
-      expect(received.length).toBe(2);
-      expect(received[0]).toBeInstanceOf(Protocol);
-      expect(received[1]).toBe('{"message": "Hello"}');
-    });
+    await TestStream.assertConnectivity(stream1, stream2);
   })
     .timeout(2_000)
     .retries(3);

package/src/wire-protocol.ts

@@ -4,13 +4,9 @@
 
 import { Duplex } from 'node:stream';
 
-import { discoveryKey } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
 import { Teleport } from '@dxos/teleport';
 
-import { MeshProtocolProvider } from './protocol-factory';
-
 export type WireProtocolParams = {
   initiator: boolean;
   localPeerId: PublicKey;
@@ -27,30 +23,10 @@ export type WireProtocolProvider = (params: WireProtocolParams) => WireProtocol;
 export interface WireProtocol {
   stream: Duplex;
 
-  /**
-   * @deprecated Only for devtools comapatibility.
-   */
-  protocol?: Protocol;
-
   initialize(): Promise<void>;
   destroy(): Promise<void>;
 }
 
-/**
- * @deprecated
- */
-export const adaptProtocolProvider =
-  (factory: MeshProtocolProvider): WireProtocolProvider =>
-  ({ initiator, localPeerId, remotePeerId, topic }) => {
-    const protocol = factory({ channel: discoveryKey(topic), initiator });
-    return {
-      initialize: () => protocol.open(),
-      destroy: () => protocol.close(),
-      stream: protocol.stream,
-      protocol
-    };
-  };
-
 /**
  * Create a wire-protocol provider backed by a teleport instance.
  * @param onConnection Called after teleport is initialized for the session. Protocol extensions could be attached here.