@dxos/network-manager 0.6.12 → 0.6.13-main.09887cd

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

@@ -1,74 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import { TestStream } from '@dxos/async';
-import { PublicKey } from '@dxos/keys';
-import { afterTest, describe, test } from '@dxos/test';
-import { range } from '@dxos/util';
-
-import { MemoryTransport } from './memory-transport';
-
-// TODO(burdon): Flaky test.
-//  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 = async () => {
-  const topic = PublicKey.random();
-  const peer1Id = PublicKey.random();
-  const peer2Id = PublicKey.random();
-
-  const stream1 = new TestStream();
-  const connection1 = new MemoryTransport({
-    stream: stream1,
-    sendSignal: async (signal) => {
-      await connection2.onSignal(signal);
-    },
-    initiator: true,
-  });
-
-  afterTest(() => connection1.close());
-  afterTest(() => connection1.errors.assertNoUnhandledErrors());
-
-  const stream2 = new TestStream();
-  const connection2 = new MemoryTransport({
-    stream: stream2,
-    sendSignal: async (signal) => {
-      await connection1.onSignal(signal);
-    },
-    initiator: false,
-  });
-
-  afterTest(() => connection2.close());
-  afterTest(() => connection2.errors.assertNoUnhandledErrors());
-
-  await connection1.open();
-  await connection2.open();
-
-  return {
-    connection1,
-    connection2,
-    stream1,
-    stream2,
-    peer1Id,
-    peer2Id,
-    topic,
-  };
-};
-
-describe('MemoryTransport', () => {
-  test('establish connection and send data through with protocol', async () => {
-    const { stream1, stream2 } = await createPair();
-    await TestStream.assertConnectivity(stream1, stream2);
-  });
-
-  test('10 pairs of peers connecting at the same time', async () => {
-    await Promise.all(
-      range(10).map(async () => {
-        const { stream1, stream2 } = await createPair();
-        await TestStream.assertConnectivity(stream1, stream2);
-      }),
-    );
-  });
-});

package/src/transport/simplepeer-simple-peer.ts

@@ -1,26 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-// @dxos/test platform=nodejs
-
-import wrtc from '@koush/wrtc';
-import SimplePeerConstructor from 'simple-peer';
-
-import { sleep } from '@dxos/async';
-import { describe, test } from '@dxos/test';
-
-describe('Node WebRTC and simple-peer', () => {
-  // Simplest test that reproduces SIGABRT (mac) and SIGSEGV (linux) in wrtc.
-  test
-    .skip('open and close', async () => {
-      const peer = new SimplePeerConstructor({
-        initiator: true,
-        wrtc,
-      });
-
-      await sleep(1);
-      await peer.destroy();
-    })
-    .timeout(3_000);
-});

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

@@ -1,181 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-// @dxos/test platform=nodejs
-
-import { TestStream } from '@dxos/async';
-import { schema } from '@dxos/protocols/proto';
-import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
-import { createLinkedPorts, createProtoRpcPeer, type ProtoRpcPeer } from '@dxos/rpc';
-import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
-
-import { SimplePeerTransportProxy } from './simplepeer-transport-proxy';
-import { SimplePeerTransportService } from './simplepeer-transport-service';
-
-describe('SimplePeerTransportProxy', () => {
-  const setupProxy = async ({
-    initiator = true,
-    stream = new TestStream(),
-    sendSignal = async () => {},
-  }: {
-    initiator?: boolean;
-    stream?: NodeJS.ReadWriteStream;
-    sendSignal?: (msg: Signal) => Promise<void>;
-  } = {}) => {
-    const [port1, port2] = createLinkedPorts();
-
-    // Starting BridgeService
-    const simplePeerTransportService: BridgeService = new SimplePeerTransportService();
-
-    // Starting BridgeService
-    const rpcService = createProtoRpcPeer({
-      requested: {},
-      exposed: {
-        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-      },
-      handlers: { BridgeService: simplePeerTransportService },
-      port: port1,
-      noHandshake: true,
-      encodingOptions: {
-        preserveAny: true,
-      },
-    });
-    await rpcService.open();
-    afterTest(() => rpcService.close());
-
-    // Starting RPC client
-    const rpcClient = createProtoRpcPeer({
-      requested: {
-        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-      },
-      port: port2,
-      noHandshake: true,
-      encodingOptions: {
-        preserveAny: true,
-      },
-    });
-    await rpcClient.open();
-    afterTest(() => rpcClient.close());
-
-    const simplePeerTransportProxy = new SimplePeerTransportProxy({
-      initiator,
-      stream,
-      sendSignal,
-      bridgeService: rpcClient.rpc.BridgeService,
-    });
-    await simplePeerTransportProxy.open();
-    afterTest(async () => await simplePeerTransportProxy.close());
-
-    return { simplePeerService: rpcService, SimplePeerTransportProxy: simplePeerTransportProxy };
-  };
-
-  // This doesn't clean up correctly and crashes with SIGSEGV / SIGABRT at the end. Probably an issue with wrtc package.
-  test('open and close', async () => {
-    const { SimplePeerTransportProxy: connection } = await setupProxy();
-
-    const wait = connection.closed.waitForCount(1);
-    await connection.close();
-    await wait;
-  }).timeout(1_000);
-
-  test('establish connection and send data through with protocol', async () => {
-    const stream1 = new TestStream();
-    const { SimplePeerTransportProxy: connection1 } = await setupProxy({
-      initiator: true,
-      stream: stream1,
-      sendSignal: async (signal) => {
-        await connection2.onSignal(signal);
-      },
-    });
-    afterTest(() => connection1.errors.assertNoUnhandledErrors());
-
-    const stream2 = new TestStream();
-    const { SimplePeerTransportProxy: connection2 } = await setupProxy({
-      initiator: false,
-      stream: stream2,
-      sendSignal: async (signal) => {
-        await connection1.onSignal(signal);
-      },
-    });
-    afterTest(() => connection2.errors.assertNoUnhandledErrors());
-
-    await TestStream.assertConnectivity(stream1, stream2);
-  }).timeout(2_000);
-
-  describe('Multiplexing', () => {
-    let service: any;
-    let rpcClient: ProtoRpcPeer<{ BridgeService: BridgeService }>;
-
-    beforeAll(async () => {
-      const [port1, port2] = createLinkedPorts();
-
-      const simplePeerTransportService: BridgeService = new SimplePeerTransportService();
-      service = createProtoRpcPeer({
-        exposed: {
-          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-        },
-        handlers: { BridgeService: simplePeerTransportService },
-        port: port1,
-        noHandshake: true,
-        encodingOptions: {
-          preserveAny: true,
-        },
-      });
-      await service.open();
-
-      rpcClient = createProtoRpcPeer({
-        requested: {
-          BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-        },
-        port: port2,
-        noHandshake: true,
-        encodingOptions: {
-          preserveAny: true,
-        },
-      });
-      await rpcClient.open();
-    });
-
-    afterAll(async () => {
-      await service?.close();
-      await rpcClient?.close();
-    });
-
-    test('establish connection and send data through with protocol', async () => {
-      const stream1 = new TestStream();
-      const proxy1 = new SimplePeerTransportProxy({
-        initiator: true,
-        stream: stream1,
-        sendSignal: async (signal) => {
-          await proxy2.onSignal(signal);
-        },
-        bridgeService: rpcClient.rpc.BridgeService,
-      });
-      afterTest(async () => {
-        proxy1.errors.assertNoUnhandledErrors();
-        await proxy1.close();
-      });
-
-      const stream2 = new TestStream();
-      const proxy2 = new SimplePeerTransportProxy({
-        initiator: false,
-        stream: stream2,
-        sendSignal: async (signal) => {
-          await proxy1.onSignal(signal);
-        },
-        bridgeService: rpcClient.rpc.BridgeService,
-      });
-      afterTest(async () => {
-        proxy2.errors.assertNoUnhandledErrors();
-        await proxy2.close();
-      });
-
-      await proxy1.open();
-      await proxy2.open();
-
-      await TestStream.assertConnectivity(stream1, stream2);
-    }).timeout(3_000);
-  });
-});

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

@@ -1,246 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { Writable } from 'node:stream';
-
-import { Event, scheduleTask } from '@dxos/async';
-import { type Stream } from '@dxos/codec-protobuf';
-import { Context } from '@dxos/context';
-import { ErrorStream } from '@dxos/debug';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import {
-  ConnectionResetError,
-  TimeoutError,
-  ProtocolError,
-  ConnectivityError,
-  UnknownProtocolError,
-} from '@dxos/protocols';
-import { ConnectionState, type BridgeEvent, type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
-import { arrayToBuffer } from '@dxos/util';
-
-import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from './transport';
-
-const RPC_TIMEOUT = 10_000;
-const RESP_MIN_THRESHOLD = 500;
-const TIMEOUT_THRESHOLD = 10;
-
-export type SimplePeerTransportProxyOptions = TransportOptions & {
-  bridgeService: BridgeService;
-};
-
-export class SimplePeerTransportProxy implements Transport {
-  private readonly _proxyId = PublicKey.random();
-  private readonly _ctx = new Context();
-  private _timeoutCount = 0;
-
-  readonly closed = new Event();
-  readonly connected = new Event();
-  readonly errors = new ErrorStream();
-
-  private _closed = false;
-  private _serviceStream!: Stream<BridgeEvent>;
-
-  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._options.initiator,
-      },
-      { timeout: RPC_TIMEOUT },
-    );
-
-    this._serviceStream.waitUntilReady().then(
-      () => {
-        this._serviceStream.subscribe(async (event: BridgeEvent) => {
-          log('SimplePeerTransportProxy: event', event);
-          if (event.connection) {
-            await this._handleConnection(event.connection);
-          } else if (event.data) {
-            this._handleData(event.data);
-          } else if (event.signal) {
-            await this._handleSignal(event.signal);
-          }
-        });
-
-        const proxyStream = new Writable({
-          write: (chunk, _, callback) => {
-            const then = performance.now();
-            this._options.bridgeService
-              .sendData(
-                {
-                  proxyId: this._proxyId,
-                  payload: chunk,
-                },
-                { timeout: RPC_TIMEOUT },
-              )
-              .then(
-                () => {
-                  if (performance.now() - then > RESP_MIN_THRESHOLD) {
-                    log('slow response, delaying callback');
-                    scheduleTask(this._ctx, () => callback(), RESP_MIN_THRESHOLD);
-                  } else {
-                    callback();
-                  }
-                  this._timeoutCount = 0;
-                },
-                (err: any) => {
-                  if (err instanceof TimeoutError || err.constructor.name === 'TimeoutError') {
-                    if (this._timeoutCount++ > TIMEOUT_THRESHOLD) {
-                      throw new TimeoutError(`too many timeouts (${this._timeoutCount} > ${TIMEOUT_THRESHOLD}`);
-                    } else {
-                      log('timeout error, but still invoking callback');
-                      callback();
-                    }
-                  } else {
-                    log.catch(err);
-                  }
-                },
-              );
-          },
-        });
-
-        proxyStream.on('error', (err) => {
-          log('proxystream error', { err });
-        });
-
-        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));
-    }
-
-    switch (connectionEvent.state) {
-      case ConnectionState.CONNECTED: {
-        this.connected.emit();
-        break;
-      }
-      case ConnectionState.CLOSED: {
-        await this.close();
-        break;
-      }
-    }
-  }
-
-  private _handleData(dataEvent: BridgeEvent.DataEvent) {
-    // NOTE: This must be a Buffer otherwise hypercore-protocol breaks.
-    this._options.stream.write(arrayToBuffer(dataEvent.payload));
-  }
-
-  private async _handleSignal(signalEvent: BridgeEvent.SignalEvent) {
-    await this._options.sendSignal(signalEvent.payload);
-  }
-
-  async getDetails(): Promise<string> {
-    return (await this._options.bridgeService.getDetails({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT })).details;
-  }
-
-  async getStats(): Promise<TransportStats> {
-    return (await this._options.bridgeService.getStats({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT }))
-      .stats as TransportStats;
-  }
-
-  /**
-   * Called when underlying proxy service becomes unavailable.
-   */
-  // TODO(burdon): Option on close method.
-  forceClose() {
-    void this._serviceStream.close();
-    this.closed.emit();
-    this._closed = true;
-  }
-}
-
-// TODO(burdon): Why is this named Proxy?
-export class SimplePeerTransportProxyFactory implements TransportFactory {
-  private _bridgeService: BridgeService | undefined;
-  private _connections = new Set<SimplePeerTransportProxy>();
-
-  /**
-   * Sets the current BridgeService to be used to open connections.
-   * Calling this method will close any existing connections.
-   */
-  setBridgeService(bridgeService: BridgeService | undefined): this {
-    this._bridgeService = bridgeService;
-    for (const connection of this._connections) {
-      connection.forceClose();
-    }
-
-    return this;
-  }
-
-  createTransport(options: TransportOptions): Transport {
-    invariant(this._bridgeService, 'SimplePeerTransportProxyFactory is not ready to open connections');
-    const transport = new SimplePeerTransportProxy({
-      ...options,
-      bridgeService: this._bridgeService,
-    });
-
-    this._connections.add(transport);
-    transport.closed.on(() => this._connections.delete(transport));
-    return transport;
-  }
-}
-
-// 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')) {
-    return new TimeoutError(message);
-  } else if (message.includes('PROTOCOL_ERROR')) {
-    return new ProtocolError(message);
-  } else if (message.includes('CONNECTIVITY_ERROR')) {
-    return new ConnectivityError(message);
-  } else if (message.includes('UNKNOWN_PROTOCOL_ERROR')) {
-    return new UnknownProtocolError(message);
-  } else {
-    return typeof err === 'string' ? new Error(err) : err;
-  }
-};

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

@@ -1,160 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { Duplex } from 'node:stream';
-
-import { Stream } from '@dxos/codec-protobuf';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import {
-  type BridgeService,
-  type ConnectionRequest,
-  type SignalRequest,
-  type DataRequest,
-  type BridgeEvent,
-  ConnectionState,
-  type CloseRequest,
-  type DetailsRequest,
-  type DetailsResponse,
-  type StatsRequest,
-  type StatsResponse,
-} from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { ComplexMap } from '@dxos/util';
-
-import { SimplePeerTransport } from './simplepeer-transport';
-import { type IceProvider } from '../signal';
-
-type TransportState = {
-  transport: SimplePeerTransport;
-  stream: Duplex;
-  writeCallbacks: (() => void)[];
-  state: 'OPEN' | 'CLOSED';
-};
-
-export class SimplePeerTransportService implements BridgeService {
-  private readonly transports = new ComplexMap<PublicKey, TransportState>(PublicKey.hash);
-
-  constructor(
-    private readonly _webrtcConfig?: RTCConfiguration,
-    private readonly _iceProvider?: IceProvider,
-  ) {}
-
-  open(request: ConnectionRequest): Stream<BridgeEvent> {
-    const rpcStream: Stream<BridgeEvent> = new Stream(({ ready, next, close }) => {
-      const duplex: Duplex = new Duplex({
-        read: () => {
-          const callbacks = [...transportState.writeCallbacks];
-          transportState.writeCallbacks.length = 0;
-          for (const cb of callbacks) {
-            cb();
-          }
-        },
-        write: function (chunk, _, callback) {
-          next({ data: { payload: chunk } });
-          callback();
-        },
-      });
-
-      const transport = new SimplePeerTransport({
-        initiator: request.initiator,
-        stream: duplex,
-        webrtcConfig: this._webrtcConfig,
-        sendSignal: async (signal) => {
-          next({
-            signal: { payload: signal },
-          });
-        },
-        iceProvider: this._iceProvider,
-      });
-
-      // TODO(burdon): Async.
-      void transport.open();
-
-      next({
-        connection: {
-          state: ConnectionState.CONNECTING,
-        },
-      });
-
-      transport.connected.on(() => {
-        next({
-          connection: {
-            state: ConnectionState.CONNECTED,
-          },
-        });
-      });
-
-      transport.errors.handle((err) => {
-        next({
-          connection: {
-            state: ConnectionState.CLOSED,
-            error: err.toString(),
-          },
-        });
-        close(err);
-      });
-
-      transport.closed.on(() => {
-        next({
-          connection: {
-            state: ConnectionState.CLOSED,
-          },
-        });
-        close();
-      });
-
-      const transportState: TransportState = {
-        transport,
-        stream: duplex,
-        writeCallbacks: [],
-        state: 'OPEN',
-      };
-
-      ready();
-
-      this.transports.set(request.proxyId, transportState);
-    });
-
-    return rpcStream;
-  }
-
-  async sendSignal({ proxyId, signal }: SignalRequest): Promise<void> {
-    invariant(this.transports.has(proxyId));
-    await this.transports.get(proxyId)!.transport.onSignal(signal);
-  }
-
-  async getDetails({ proxyId }: DetailsRequest): Promise<DetailsResponse> {
-    invariant(this.transports.has(proxyId));
-    return { details: await this.transports.get(proxyId)!.transport.getDetails() };
-  }
-
-  async getStats({ proxyId }: StatsRequest): Promise<StatsResponse> {
-    invariant(this.transports.has(proxyId));
-    return { stats: await this.transports.get(proxyId)!.transport.getStats() };
-  }
-
-  async sendData({ proxyId, payload }: DataRequest): Promise<void> {
-    if (this.transports.get(proxyId)?.state !== 'OPEN') {
-      log.debug('transport is closed');
-    }
-    invariant(this.transports.has(proxyId));
-    const state = this.transports.get(proxyId)!;
-    const bufferHasSpace = state.stream.push(payload);
-    if (!bufferHasSpace) {
-      await new Promise<void>((resolve) => {
-        state.writeCallbacks.push(resolve);
-      });
-    }
-  }
-
-  async close({ proxyId }: CloseRequest) {
-    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';
-    }
-    log('Closed.');
-  }
-}