@dxos/network-manager 0.6.12-staging.e11e696 → 0.6.12

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

@@ -0,0 +1,246 @@
+//
+// 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

@@ -0,0 +1,160 @@
+//
+// 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.');
+  }
+}

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

@@ -0,0 +1,61 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Duplex } from 'stream';
+
+import { sleep, TestStream } from '@dxos/async';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { SimplePeerTransport } from './simplepeer-transport';
+
+describe('SimplePeerTransport', () => {
+  // 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 connection = new SimplePeerTransport({
+      initiator: true,
+      stream: new Duplex(),
+      sendSignal: async () => {},
+    });
+
+    await connection.open();
+    const wait = connection.closed.waitForCount(1);
+    await connection.close();
+    await wait;
+  })
+    .timeout(1_000)
+    .retries(3);
+
+  test('establish connection and send data through with protocol', async () => {
+    const stream1 = new TestStream();
+    const connection1 = new SimplePeerTransport({
+      initiator: true,
+      stream: stream1,
+      sendSignal: async (signal) => {
+        await sleep(10);
+        await connection2.onSignal(signal);
+      },
+    });
+    afterTest(() => connection1.close());
+    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+    const stream2 = new TestStream();
+    const connection2 = new SimplePeerTransport({
+      initiator: false,
+      stream: stream2,
+      sendSignal: async (signal) => {
+        await sleep(10);
+        await connection1.onSignal(signal);
+      },
+    });
+    afterTest(() => connection2.close());
+    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+    await connection1.open();
+    await connection2.open();
+
+    await TestStream.assertConnectivity(stream1, stream2);
+  })
+    .timeout(2_000)
+    .retries(3);
+});