@dxos/network-manager 0.4.10-main.fd4f2a3 → 0.4.10-next.71cec10

package/src/transport/memory-transport.ts

@@ -12,7 +12,7 @@ import { log, logInfo } from '@dxos/log';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap } from '@dxos/util';
 
-import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
+import { type Transport, type TransportFactory, type TransportOptions } from './transport';
 
 // TODO(burdon): Make configurable.
 // Delay (in milliseconds) for data being sent through in-memory connections to simulate network latency.
@@ -31,7 +31,7 @@ const createStreamDelay = (delay: number): NodeJS.ReadWriteStream => {
 };
 
 export const MemoryTransportFactory: TransportFactory = {
-  createTransport: (params) => new MemoryTransport(params),
+  createTransport: (options) => new MemoryTransport(options),
 };
 
 /**
@@ -41,10 +41,6 @@ export class MemoryTransport implements Transport {
   // 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();
-
   @logInfo
   private readonly _instanceId = PublicKey.random(); // TODO(burdon): Rename peerId? (Use local/remote labels in logs).
 
@@ -53,37 +49,46 @@ export class MemoryTransport implements Transport {
   private readonly _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
   private readonly _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
 
-  private _destroyed = false;
+  private _closed = false;
 
   @logInfo
   private _remoteInstanceId!: PublicKey;
 
   private _remoteConnection?: MemoryTransport;
 
-  constructor(private readonly options: TransportOptions) {
-    log('creating');
+  public readonly closed = new Event<void>();
+  public readonly connected = new Event<void>();
+  public readonly errors = new ErrorStream();
 
+  constructor(private readonly _options: TransportOptions) {
     invariant(!MemoryTransport._connections.has(this._instanceId), 'Duplicate memory connection');
     MemoryTransport._connections.set(this._instanceId, this);
+  }
+
+  get isOpen() {
+    // TODO(burdon): Open state?
+    return !this._closed;
+  }
+
+  async open() {
+    log('opening...');
 
     // 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');
-        void this.options.sendSignal({
-          payload: { transportId: this._instanceId.toHex() }
-        }).catch(err => {
-          if (!this._destroyed) {
-            this.errors.raise(err);
-          }
-        });
-    });
+    if (this._options.initiator) {
+      log('sending signal');
+      try {
+        await this._options.sendSignal({ payload: { transportId: this._instanceId.toHex() } });
+      } catch (err) {
+        if (!this._closed) {
+          this.errors.raise(toError(err));
+        }
+      }
     } else {
+      // Don't block the open method.
       this._remote
-        .wait({ timeout: this.options.timeout ?? 1000 })
+        .wait({ timeout: this._options.timeout ?? 1_000 })
         .then((remoteId) => {
-          if (this._destroyed) {
+          if (this._closed) {
             return;
           }
 
@@ -91,7 +96,7 @@ export class MemoryTransport implements Transport {
           this._remoteConnection = MemoryTransport._connections.get(this._remoteInstanceId);
           if (!this._remoteConnection) {
             // Remote connection was destroyed before we could connect.
-            this._destroyed = true;
+            this._closed = true;
             this.closed.emit();
             return;
           }
@@ -101,17 +106,17 @@ export class MemoryTransport implements Transport {
           this._remoteConnection._remoteInstanceId = this._instanceId;
 
           log('connected');
-          this.options.stream
+          this._options.stream
             .pipe(this._outgoingDelay)
-            .pipe(this._remoteConnection.options.stream)
+            .pipe(this._remoteConnection._options.stream)
             .pipe(this._incomingDelay)
-            .pipe(this.options.stream);
+            .pipe(this._options.stream);
 
           this.connected.emit();
           this._remoteConnection.connected.emit();
         })
         .catch((err) => {
-          if (this._destroyed) {
+          if (this._closed) {
             return;
           }
 
@@ -120,14 +125,13 @@ export class MemoryTransport implements Transport {
     }
   }
 
-  async destroy(): Promise<void> {
-    log('closing');
-    this._destroyed = true;
+  async close() {
+    log('closing...');
+    this._closed = true;
 
     MemoryTransport._connections.delete(this._instanceId);
     if (this._remoteConnection) {
-      log('closing');
-      this._remoteConnection._destroyed = true;
+      this._remoteConnection._closed = true;
       MemoryTransport._connections.delete(this._remoteInstanceId);
 
       // TODO(dmaretskyi): Hypercore streams do not seem to have the unpipe method.
@@ -138,27 +142,27 @@ export class MemoryTransport implements Transport {
       // code   .unpipe(this._incomingDelay)
       // code   .unpipe(this._stream);
 
-      this.options.stream.unpipe(this._incomingDelay);
-      this._incomingDelay.unpipe(this._remoteConnection.options.stream);
-      this._remoteConnection.options.stream.unpipe(this._outgoingDelay);
-      this._outgoingDelay.unpipe(this.options.stream);
-      this.options.stream.unpipe(this._outgoingDelay);
+      this._options.stream.unpipe(this._incomingDelay);
+      this._incomingDelay.unpipe(this._remoteConnection._options.stream);
+      this._remoteConnection._options.stream.unpipe(this._outgoingDelay);
+      this._outgoingDelay.unpipe(this._options.stream);
+      this._options.stream.unpipe(this._outgoingDelay);
 
       this._remoteConnection.closed.emit();
       this._remoteConnection._remoteConnection = undefined;
       this._remoteConnection = undefined;
-      log('closed');
     }
 
     this.closed.emit();
     log('closed');
   }
 
-  signal({ payload }: Signal) {
+  async onSignal({ payload }: Signal) {
     log('received signal', { payload });
     if (!payload?.transportId) {
       return;
     }
+
     // TODO(burdon): Check open?
     const transportId = payload.transportId as string;
     if (transportId) {
@@ -167,11 +171,11 @@ export class MemoryTransport implements Transport {
     }
   }
 
-  async getDetails(): Promise<string> {
+  async getDetails() {
     return this._instanceId.toHex();
   }
 
-  async getStats(): Promise<TransportStats> {
+  async getStats() {
     return {
       bytesSent: 0,
       bytesReceived: 0,
@@ -180,3 +184,6 @@ export class MemoryTransport implements Transport {
     };
   }
 }
+
+// TODO(burdon): Factor out.
+const toError = (err: any): Error => (err instanceof Error ? err : new Error(String(err)));

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

@@ -65,7 +65,8 @@ describe('SimplePeerTransportProxy', () => {
       sendSignal,
       bridgeService: rpcClient.rpc.BridgeService,
     });
-    afterTest(async () => await simplePeerTransportProxy.destroy());
+    await simplePeerTransportProxy.open();
+    afterTest(async () => await simplePeerTransportProxy.close());
 
     return { simplePeerService: rpcService, SimplePeerTransportProxy: simplePeerTransportProxy };
   };
@@ -75,7 +76,7 @@ describe('SimplePeerTransportProxy', () => {
     const { SimplePeerTransportProxy: connection } = await setupProxy();
 
     const wait = connection.closed.waitForCount(1);
-    await connection.destroy();
+    await connection.close();
     await wait;
   }).timeout(1_000);
 
@@ -85,7 +86,7 @@ describe('SimplePeerTransportProxy', () => {
       initiator: true,
       stream: stream1,
       sendSignal: async (signal) => {
-        connection2.signal(signal);
+        await connection2.onSignal(signal);
       },
     });
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
@@ -95,10 +96,11 @@ describe('SimplePeerTransportProxy', () => {
       initiator: false,
       stream: stream2,
       sendSignal: async (signal) => {
-        connection1.signal(signal);
+        await connection1.onSignal(signal);
       },
     });
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
     await TestStream.assertConnectivity(stream1, stream2);
   }).timeout(2_000);
 
@@ -147,13 +149,13 @@ describe('SimplePeerTransportProxy', () => {
         initiator: true,
         stream: stream1,
         sendSignal: async (signal) => {
-          proxy2.signal(signal);
+          await proxy2.onSignal(signal);
         },
         bridgeService: rpcClient.rpc.BridgeService,
       });
       afterTest(async () => {
         proxy1.errors.assertNoUnhandledErrors();
-        await proxy1.destroy();
+        await proxy1.close();
       });
 
       const stream2 = new TestStream();
@@ -161,15 +163,18 @@ describe('SimplePeerTransportProxy', () => {
         initiator: false,
         stream: stream2,
         sendSignal: async (signal) => {
-          proxy1.signal(signal);
+          await proxy1.onSignal(signal);
         },
         bridgeService: rpcClient.rpc.BridgeService,
       });
       afterTest(async () => {
         proxy2.errors.assertNoUnhandledErrors();
-        await proxy2.destroy();
+        await proxy2.close();
       });
 
+      await proxy1.open();
+      await proxy2.open();
+
       await TestStream.assertConnectivity(stream1, stream2);
     }).timeout(3_000);
   });

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

@@ -28,12 +28,8 @@ const RPC_TIMEOUT = 10_000;
 const RESP_MIN_THRESHOLD = 500;
 const TIMEOUT_THRESHOLD = 10;
 
-export type SimplePeerTransportProxyParams = {
-  initiator: boolean;
-  stream: NodeJS.ReadWriteStream;
+export type SimplePeerTransportProxyOptions = TransportOptions & {
   bridgeService: BridgeService;
-  // TODO(burdon): Rename onSignal.
-  sendSignal: (signal: Signal) => Promise<void>;
 };
 
 export class SimplePeerTransportProxy implements Transport {
@@ -48,11 +44,18 @@ export class SimplePeerTransportProxy implements Transport {
   private _closed = false;
   private _serviceStream!: Stream<BridgeEvent>;
 
-  constructor(private readonly _params: SimplePeerTransportProxyParams) {
-    this._serviceStream = this._params.bridgeService.open(
+  constructor(private readonly _options: SimplePeerTransportProxyOptions) {}
+
+  get isOpen() {
+    // TODO(burdon): Open state?
+    return !this._closed;
+  }
+
+  async open() {
+    this._serviceStream = this._options.bridgeService.open(
       {
         proxyId: this._proxyId,
-        initiator: this._params.initiator,
+        initiator: this._options.initiator,
       },
       { timeout: RPC_TIMEOUT },
     );
@@ -73,7 +76,7 @@ export class SimplePeerTransportProxy implements Transport {
         const proxyStream = new Writable({
           write: (chunk, _, callback) => {
             const then = performance.now();
-            this._params.bridgeService
+            this._options.bridgeService
               .sendData(
                 {
                   proxyId: this._proxyId,
@@ -111,12 +114,42 @@ export class SimplePeerTransportProxy implements Transport {
           log('proxystream error', { err });
         });
 
-        this._params.stream.pipe(proxyStream);
+        this._options.stream.pipe(proxyStream);
       },
       (error) => log.catch(error),
     );
   }
 
+  async close() {
+    await this._ctx.dispose();
+    if (this._closed) {
+      return;
+    }
+
+    await this._serviceStream.close();
+
+    try {
+      await this._options.bridgeService.close({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT });
+    } catch (err: any) {
+      log.catch(err);
+    }
+
+    this.closed.emit();
+    this._closed = true;
+  }
+
+  async onSignal(signal: Signal) {
+    this._options.bridgeService
+      .sendSignal(
+        {
+          proxyId: this._proxyId,
+          signal,
+        },
+        { timeout: RPC_TIMEOUT },
+      )
+      .catch((err) => this.errors.raise(decodeError(err)));
+  }
+
   private async _handleConnection(connectionEvent: BridgeEvent.ConnectionEvent): Promise<void> {
     if (connectionEvent.error) {
       this.errors.raise(decodeError(connectionEvent.error));
@@ -128,7 +161,7 @@ export class SimplePeerTransportProxy implements Transport {
         break;
       }
       case ConnectionState.CLOSED: {
-        await this.destroy();
+        await this.close();
         break;
       }
     }
@@ -136,53 +169,22 @@ export class SimplePeerTransportProxy implements Transport {
 
   private _handleData(dataEvent: BridgeEvent.DataEvent) {
     // NOTE: This must be a Buffer otherwise hypercore-protocol breaks.
-    this._params.stream.write(arrayToBuffer(dataEvent.payload));
+    this._options.stream.write(arrayToBuffer(dataEvent.payload));
   }
 
   private async _handleSignal(signalEvent: BridgeEvent.SignalEvent) {
-    await this._params.sendSignal(signalEvent.payload);
-  }
-
-  signal(signal: Signal): void {
-    this._params.bridgeService
-      .sendSignal(
-        {
-          proxyId: this._proxyId,
-          signal,
-        },
-        { timeout: RPC_TIMEOUT },
-      )
-      .catch((err) => this.errors.raise(decodeError(err)));
+    await this._options.sendSignal(signalEvent.payload);
   }
 
   async getDetails(): Promise<string> {
-    return (await this._params.bridgeService.getDetails({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT })).details;
+    return (await this._options.bridgeService.getDetails({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT })).details;
   }
 
   async getStats(): Promise<TransportStats> {
-    return (await this._params.bridgeService.getStats({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT }))
+    return (await this._options.bridgeService.getStats({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT }))
       .stats as TransportStats;
   }
 
-  // TODO(burdon): Move open from constructor.
-  async destroy(): Promise<void> {
-    await this._ctx.dispose();
-    if (this._closed) {
-      return;
-    }
-
-    await this._serviceStream.close();
-
-    try {
-      await this._params.bridgeService.close({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT });
-    } catch (err: any) {
-      log.catch(err);
-    }
-
-    this.closed.emit();
-    this._closed = true;
-  }
-
   /**
    * Called when underlying proxy service becomes unavailable.
    */
@@ -214,7 +216,6 @@ export class SimplePeerTransportProxyFactory implements TransportFactory {
 
   createTransport(options: TransportOptions): Transport {
     invariant(this._bridgeService, 'SimplePeerTransportProxyFactory is not ready to open connections');
-
     const transport = new SimplePeerTransportProxy({
       ...options,
       bridgeService: this._bridgeService,
@@ -222,7 +223,6 @@ export class SimplePeerTransportProxyFactory implements TransportFactory {
 
     this._connections.add(transport);
     transport.closed.on(() => this._connections.delete(transport));
-
     return transport;
   }
 }
@@ -230,7 +230,6 @@ export class SimplePeerTransportProxyFactory implements TransportFactory {
 // TODO(nf): fix so Errors crossing RPC boundary preserve class
 const decodeError = (err: Error | string) => {
   const message = typeof err === 'string' ? err : err.message;
-
   if (message.includes('CONNECTION_RESET')) {
     return new ConnectionResetError(message);
   } else if (message.includes('TIMEOUT')) {

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

@@ -64,6 +64,9 @@ export class SimplePeerTransportService implements BridgeService {
         },
       });
 
+      // TODO(burdon): Async.
+      void transport.open();
+
       next({
         connection: {
           state: ConnectionState.CONNECTING,
@@ -114,7 +117,7 @@ export class SimplePeerTransportService implements BridgeService {
 
   async sendSignal({ proxyId, signal }: SignalRequest): Promise<void> {
     invariant(this.transports.has(proxyId));
-    await this.transports.get(proxyId)!.transport.signal(signal);
+    await this.transports.get(proxyId)!.transport.onSignal(signal);
   }
 
   async getDetails({ proxyId }: DetailsRequest): Promise<DetailsResponse> {
@@ -142,7 +145,7 @@ export class SimplePeerTransportService implements BridgeService {
   }
 
   async close({ proxyId }: CloseRequest) {
-    await this.transports.get(proxyId)?.transport.destroy();
+    await this.transports.get(proxyId)?.transport.close();
     await this.transports.get(proxyId)?.stream.end();
     if (this.transports.get(proxyId)) {
       this.transports.get(proxyId)!.state = 'CLOSED';

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

@@ -18,8 +18,9 @@ describe('SimplePeerTransport', () => {
       sendSignal: async () => {},
     });
 
+    await connection.open();
     const wait = connection.closed.waitForCount(1);
-    await connection.destroy();
+    await connection.close();
     await wait;
   })
     .timeout(1_000)
@@ -32,10 +33,10 @@ describe('SimplePeerTransport', () => {
       stream: stream1,
       sendSignal: async (signal) => {
         await sleep(10);
-        await connection2.signal(signal);
+        await connection2.onSignal(signal);
       },
     });
-    afterTest(() => connection1.destroy());
+    afterTest(() => connection1.close());
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
     const stream2 = new TestStream();
@@ -44,12 +45,15 @@ describe('SimplePeerTransport', () => {
       stream: stream2,
       sendSignal: async (signal) => {
         await sleep(10);
-        await connection1.signal(signal);
+        await connection1.onSignal(signal);
       },
     });
-    afterTest(() => connection2.destroy());
+    afterTest(() => connection2.close());
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
 
+    await connection1.open();
+    await connection2.open();
+
     await TestStream.assertConnectivity(stream1, stream2);
   })
     .timeout(2_000)

package/src/transport/simplepeer-transport.ts

@@ -13,16 +13,17 @@ import { log } from '@dxos/log';
 import { ConnectionResetError, ConnectivityError, ProtocolError, UnknownProtocolError, trace } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { type Transport, type TransportFactory, type TransportStats } from './transport';
+import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
 import { wrtc } from './webrtc';
 
-export type SimplePeerTransportParams = {
-  initiator: boolean;
-  stream: NodeJS.ReadWriteStream;
+export type SimplePeerTransportParams = TransportOptions & {
   webrtcConfig?: any;
-  sendSignal: (signal: Signal) => Promise<void>;
 };
 
+export const createSimplePeerTransportFactory = (webrtcConfig?: any): TransportFactory => ({
+  createTransport: (options) => new SimplePeerTransport({ ...options, webrtcConfig }),
+});
+
 /**
  * Implements Transport for WebRTC. Uses simple-peer under the hood.
  */
@@ -37,34 +38,39 @@ export class SimplePeerTransport implements Transport {
 
   private readonly _instanceId = PublicKey.random().toHex();
 
+  get isOpen() {
+    // TODO(burdon): Open state?
+    return this._piped && !this._closed;
+  }
+
   /**
    * @params opts.config formatted as per https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection
    */
-  constructor(private readonly params: SimplePeerTransportParams) {
+  constructor(private readonly _params: SimplePeerTransportParams) {
     log.trace('dxos.mesh.webrtc-transport.constructor', trace.begin({ id: this._instanceId }));
-    log('created connection', params);
+    log('created connection', _params);
     this._peer = new SimplePeerConstructor({
       channelName: 'dxos.mesh.transport',
-      initiator: this.params.initiator,
+      initiator: this._params.initiator,
       wrtc: SimplePeerConstructor.WEBRTC_SUPPORT ? undefined : wrtc ?? raise(new Error('wrtc not available')),
-      config: this.params.webrtcConfig,
+      config: this._params.webrtcConfig,
     });
 
     this._peer.on('signal', async (data) => {
       log('signal', data);
-      await this.params.sendSignal({ payload: { data } });
+      await this._params.sendSignal({ payload: { data } });
     });
 
     this._peer.on('connect', () => {
       log('connected');
-      this.params.stream.pipe(this._peer!).pipe(this.params.stream);
+      this._params.stream.pipe(this._peer!).pipe(this._params.stream);
       this._piped = true;
       this.connected.emit();
     });
 
     this._peer.on('close', async () => {
       log('closed');
-      await this.destroy();
+      await this.close();
     });
 
     this._peer.on('error', async (err) => {
@@ -114,7 +120,7 @@ export class SimplePeerTransport implements Transport {
         if (typeof (this._peer as any)?._pc?.getStats === 'function') {
           (this._peer as any)._pc.getStats().then((stats: any) => {
             log.info('report after webrtc error', {
-              config: this.params.webrtcConfig,
+              config: this._params.webrtcConfig,
               stats: Object.fromEntries((stats as any).entries()),
             });
           });
@@ -123,7 +129,7 @@ export class SimplePeerTransport implements Transport {
         log.catch(err);
       }
 
-      await this.destroy();
+      await this.close();
     });
 
     log.trace('dxos.mesh.webrtc-transport.constructor', trace.end({ id: this._instanceId }));
@@ -188,7 +194,9 @@ export class SimplePeerTransport implements Transport {
     return `${rc.ip}:${rc.port}/${rc.protocol} ${rc.candidateType}`;
   }
 
-  async destroy() {
+  async open() {}
+
+  async close() {
     log('closing...');
     if (this._closed) {
       return;
@@ -200,7 +208,7 @@ export class SimplePeerTransport implements Transport {
     log('closed');
   }
 
-  signal(signal: Signal) {
+  async onSignal(signal: Signal) {
     if (this._closed) {
       return; // Ignore signals after close.
     }
@@ -212,15 +220,7 @@ export class SimplePeerTransport implements Transport {
   private _disconnectStreams() {
     // TODO(rzadp): Find a way of unpiping this?
     if (this._piped) {
-      this.params.stream.unpipe?.(this._peer)?.unpipe?.(this.params.stream);
+      this._params.stream.unpipe?.(this._peer)?.unpipe?.(this._params.stream);
     }
   }
 }
-
-export const createSimplePeerTransportFactory = (webrtcConfig?: any): TransportFactory => ({
-  createTransport: (params) =>
-    new SimplePeerTransport({
-      ...params,
-      webrtcConfig,
-    }),
-});

package/src/transport/tcp-transport.browser.ts

@@ -7,22 +7,27 @@ import { ErrorStream } from '@dxos/debug';
 
 import { type Transport, type TransportFactory, type TransportStats } from './transport';
 
-// NOTE: Browser stub.
-
 export const TcpTransportFactory: TransportFactory = {
   createTransport: () => new TcpTransport(),
 };
 
+/**
+ * NOTE: Browser stub.
+ */
 export class TcpTransport implements Transport {
   public readonly closed = new Event<void>();
   public readonly connected = new Event<void>();
   public readonly errors = new ErrorStream();
 
-  async destroy() {
-    throw new Error('Method not implemented.');
+  get isOpen() {
+    return true;
   }
 
-  signal() {
+  async open() {}
+
+  async close() {}
+
+  async onSignal() {
     throw new Error('Method not implemented.');
   }