@dxos/network-manager 0.6.13 → 0.6.14-main.1366248

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

@@ -0,0 +1,264 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Writable } from 'node:stream';
+
+import { Event, scheduleTask } from '@dxos/async';
+import { type Stream } from '@dxos/codec-protobuf';
+import { Resource } 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, ConnectivityError, TimeoutError } from '@dxos/protocols';
+import { type BridgeEvent, type BridgeService, ConnectionState } 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 CLOSE_RPC_TIMEOUT = 3000;
+const RESP_MIN_THRESHOLD = 500;
+
+export type RtcTransportProxyOptions = TransportOptions & {
+  bridgeService: BridgeService;
+};
+
+export class RtcTransportProxy extends Resource implements Transport {
+  private readonly _proxyId = PublicKey.random();
+
+  readonly closed = new Event();
+  readonly connected = new Event();
+  readonly errors = new ErrorStream();
+
+  private _serviceStream: Stream<BridgeEvent> | undefined;
+
+  constructor(private readonly _options: RtcTransportProxyOptions) {
+    super();
+  }
+
+  protected override async _open() {
+    let stream: Stream<BridgeEvent>;
+    try {
+      stream = this._options.bridgeService.open(
+        {
+          proxyId: this._proxyId,
+          remotePeerKey: this._options.remotePeerKey,
+          ownPeerKey: this._options.ownPeerKey,
+          topic: this._options.topic,
+          initiator: this._options.initiator ?? false,
+        },
+        { timeout: RPC_TIMEOUT },
+      );
+    } catch (error: any) {
+      this.errors.raise(error);
+      return;
+    }
+
+    this._serviceStream = stream;
+
+    stream.waitUntilReady().then(
+      () => {
+        stream.subscribe(
+          async (event: BridgeEvent) => {
+            log('rtc transport proxy 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);
+            }
+          },
+          (err) => {
+            log('rtc bridge stream closed', { err });
+            if (err) {
+              this._raiseIfOpen(err);
+            } else {
+              void this.close();
+            }
+          },
+        );
+
+        const connectorStream = new Writable({
+          write: (chunk, _, callback) => {
+            const sendStartMs = Date.now();
+            this._options.bridgeService
+              .sendData({ proxyId: this._proxyId, payload: chunk }, { timeout: RPC_TIMEOUT })
+              .then(
+                () => {
+                  if (Date.now() - sendStartMs > RESP_MIN_THRESHOLD) {
+                    log('slow response, delaying callback');
+                    scheduleTask(this._ctx, () => callback(), RESP_MIN_THRESHOLD);
+                  } else {
+                    callback();
+                  }
+                },
+                (err: any) => {
+                  callback();
+                  this._raiseIfOpen(err);
+                },
+              );
+          },
+        });
+
+        connectorStream.on('error', (err) => {
+          this._raiseIfOpen(err);
+        });
+
+        this._options.stream.pipe(connectorStream);
+      },
+      (error) => {
+        if (error) {
+          this._raiseIfOpen(error);
+        } else {
+          void this.close();
+        }
+      },
+    );
+  }
+
+  protected override async _close() {
+    try {
+      await this._serviceStream?.close();
+      this._serviceStream = undefined;
+    } catch (err: any) {
+      log.catch(err);
+    }
+
+    try {
+      await this._options.bridgeService.close({ proxyId: this._proxyId }, { timeout: CLOSE_RPC_TIMEOUT });
+    } catch (err: any) {
+      log.catch(err);
+    }
+
+    this.closed.emit();
+  }
+
+  async onSignal(signal: Signal) {
+    this._options.bridgeService
+      .sendSignal({ proxyId: this._proxyId, signal }, { timeout: RPC_TIMEOUT })
+      .catch((err) => this._raiseIfOpen(decodeError(err)));
+  }
+
+  private async _handleConnection(connectionEvent: BridgeEvent.ConnectionEvent): Promise<void> {
+    if (connectionEvent.error) {
+      this.errors.raise(decodeError(connectionEvent.error));
+      return;
+    }
+
+    switch (connectionEvent.state) {
+      case ConnectionState.CONNECTED: {
+        this.connected.emit();
+        break;
+      }
+      case ConnectionState.CLOSED: {
+        await this.close();
+        break;
+      }
+    }
+  }
+
+  private _handleData(dataEvent: BridgeEvent.DataEvent) {
+    try {
+      // NOTE: This must be a Buffer otherwise hypercore-protocol breaks.
+      this._options.stream.write(arrayToBuffer(dataEvent.payload));
+    } catch (error: any) {
+      this._raiseIfOpen(error);
+    }
+  }
+
+  private async _handleSignal(signalEvent: BridgeEvent.SignalEvent) {
+    try {
+      await this._options.sendSignal(signalEvent.payload);
+    } catch (error) {
+      const type = signalEvent.payload.payload.data?.type;
+      if (type === 'offer' || type === 'answer') {
+        this._raiseIfOpen(new ConnectivityError(`Session establishment failed: ${type} couldn't be sent.`));
+      }
+    }
+  }
+
+  async getDetails(): Promise<string> {
+    try {
+      const response = await this._options.bridgeService.getDetails(
+        { proxyId: this._proxyId },
+        { timeout: RPC_TIMEOUT },
+      );
+      return response.details;
+    } catch (err) {
+      return 'bridge-svc unreachable';
+    }
+  }
+
+  async getStats(): Promise<TransportStats> {
+    try {
+      const response = await this._options.bridgeService.getStats({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT });
+      return response.stats as TransportStats;
+    } catch (err) {
+      return {
+        bytesSent: 0,
+        bytesReceived: 0,
+        packetsSent: 0,
+        packetsReceived: 0,
+        rawStats: 'bridge-svc unreachable',
+      };
+    }
+  }
+
+  private _raiseIfOpen(error: any) {
+    if (this.isOpen) {
+      this.errors.raise(error);
+    } else {
+      log.info('error swallowed because transport was closed', { message: error.message });
+    }
+  }
+
+  /**
+   * Called when underlying proxy service becomes unavailable.
+   */
+  forceClose() {
+    void this._serviceStream?.close();
+    this.closed.emit();
+  }
+}
+
+export class RtcTransportProxyFactory implements TransportFactory {
+  private _bridgeService: BridgeService | undefined;
+  private _connections = new Set<RtcTransportProxy>();
+
+  /**
+   * 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, 'RtcTransportProxyFactory is not ready to open connections');
+    const transport = new RtcTransportProxy({ ...options, bridgeService: this._bridgeService });
+    this._connections.add(transport);
+    transport.closed.on(() => this._connections.delete(transport));
+    return transport;
+  }
+}
+
+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('CONNECTIVITY_ERROR')) {
+    return new ConnectivityError(message);
+  } else {
+    return typeof err === 'string' ? new Error(err) : err;
+  }
+};

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

@@ -0,0 +1,192 @@
+//
+// 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 { createRtcTransportFactory } from './rtc-transport-factory';
+import { type IceProvider } from '../../signal';
+import { type Transport, type TransportFactory } from '../transport';
+
+type TransportState = {
+  proxyId: PublicKey;
+  transport: Transport;
+  connectorStream: Duplex;
+  writeProcessedCallbacks: (() => void)[];
+};
+
+export class RtcTransportService implements BridgeService {
+  private readonly _openTransports = new ComplexMap<PublicKey, TransportState>(PublicKey.hash);
+
+  constructor(
+    webrtcConfig?: RTCConfiguration,
+    iceProvider?: IceProvider,
+    private readonly _transportFactory: TransportFactory = createRtcTransportFactory(webrtcConfig, iceProvider),
+  ) {}
+
+  public hasOpenTransports() {
+    return this._openTransports.size > 0;
+  }
+
+  open(request: ConnectionRequest): Stream<BridgeEvent> {
+    const existingTransport = this._openTransports.get(request.proxyId);
+    if (existingTransport) {
+      log.error('requesting a new transport bridge for an existing proxy');
+      void this._safeCloseTransport(existingTransport);
+      this._openTransports.delete(request.proxyId);
+    }
+
+    return new Stream<BridgeEvent>(({ ready, next, close }) => {
+      const pushNewState = createStateUpdater(next);
+
+      const transportStream: Duplex = new Duplex({
+        read: () => {
+          const callbacks = [...transportState.writeProcessedCallbacks];
+          transportState.writeProcessedCallbacks.length = 0;
+          callbacks.forEach((cb) => cb());
+        },
+        write: function (chunk, _, callback) {
+          next({ data: { payload: chunk } });
+          callback();
+        },
+      });
+
+      const transport = this._transportFactory.createTransport({
+        initiator: request.initiator,
+        topic: request.topic,
+        ownPeerKey: request.ownPeerKey,
+        remotePeerKey: request.remotePeerKey,
+        stream: transportStream,
+        sendSignal: async (signal) => {
+          next({ signal: { payload: signal } });
+        },
+      });
+
+      const transportState: TransportState = {
+        proxyId: request.proxyId,
+        transport,
+        connectorStream: transportStream,
+        writeProcessedCallbacks: [],
+      };
+
+      pushNewState(ConnectionState.CONNECTING);
+
+      transport.connected.on(() => pushNewState(ConnectionState.CONNECTED));
+
+      transport.errors.handle(async (err) => {
+        pushNewState(ConnectionState.CLOSED, err);
+        void this._safeCloseTransport(transportState);
+        close(err);
+      });
+
+      transport.closed.on(async () => {
+        pushNewState(ConnectionState.CLOSED);
+        void this._safeCloseTransport(transportState);
+        close();
+      });
+
+      this._openTransports.set(request.proxyId, transportState);
+
+      transport.open().catch(async (err) => {
+        pushNewState(ConnectionState.CLOSED, err);
+        void this._safeCloseTransport(transportState);
+        close(err);
+      });
+
+      ready();
+    });
+  }
+
+  async sendSignal({ proxyId, signal }: SignalRequest): Promise<void> {
+    const transport = this._openTransports.get(proxyId);
+    invariant(transport);
+
+    await transport.transport.onSignal(signal);
+  }
+
+  async getDetails({ proxyId }: DetailsRequest): Promise<DetailsResponse> {
+    const transport = this._openTransports.get(proxyId);
+    invariant(transport);
+
+    return { details: await transport.transport.getDetails() };
+  }
+
+  async getStats({ proxyId }: StatsRequest): Promise<StatsResponse> {
+    const transport = this._openTransports.get(proxyId);
+    invariant(transport);
+
+    return { stats: await transport.transport.getStats() };
+  }
+
+  async sendData({ proxyId, payload }: DataRequest): Promise<void> {
+    const transport = this._openTransports.get(proxyId);
+    invariant(transport);
+
+    const bufferHasSpace = transport.connectorStream.push(payload);
+    if (!bufferHasSpace) {
+      await new Promise<void>((resolve) => {
+        transport.writeProcessedCallbacks.push(resolve);
+      });
+    }
+  }
+
+  async close({ proxyId }: CloseRequest) {
+    const transport = this._openTransports.get(proxyId);
+    if (!transport) {
+      return;
+    }
+
+    this._openTransports.delete(proxyId);
+    await this._safeCloseTransport(transport);
+  }
+
+  private async _safeCloseTransport(transport: TransportState) {
+    if (this._openTransports.get(transport.proxyId) === transport) {
+      this._openTransports.delete(transport.proxyId);
+    }
+
+    transport.writeProcessedCallbacks.forEach((cb) => cb());
+
+    try {
+      await transport.transport.close();
+    } catch (error: any) {
+      log.warn('transport close error', { message: error?.message });
+    }
+    try {
+      transport.connectorStream.end();
+    } catch (error: any) {
+      log.warn('connectorStream close error', { message: error?.message });
+    }
+    log('closed');
+  }
+}
+
+const createStateUpdater = (next: (event: BridgeEvent) => void) => {
+  return (state: ConnectionState, err?: Error) => {
+    next({
+      connection: {
+        state,
+        ...(err ? { error: err.message } : undefined),
+      },
+    });
+  };
+};

package/src/transport/webrtc/rtc-transport-stats.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type { TransportStats } from '../transport';
+
+export const describeSelectedRemoteCandidate = async (connection?: RTCPeerConnection): Promise<string> => {
+  const stats = connection && (await getRtcConnectionStats(connection));
+  const rc = stats?.remoteCandidate;
+  if (!rc) {
+    return 'unavailable';
+  }
+
+  if (rc.candidateType === 'relay') {
+    return `${rc.ip}:${rc.port} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
+  }
+
+  return `${rc.ip}:${rc.port} ${rc.candidateType}`;
+};
+
+export const createRtcTransportStats = async (
+  connection: RTCPeerConnection | undefined,
+  topic: string,
+): Promise<TransportStats> => {
+  const stats = connection && (await getRtcConnectionStats(connection, topic));
+  if (!stats) {
+    return {
+      bytesSent: 0,
+      bytesReceived: 0,
+      packetsSent: 0,
+      packetsReceived: 0,
+      rawStats: {},
+    };
+  }
+
+  return {
+    bytesSent: stats.dataChannel?.bytesSent,
+    bytesReceived: stats.dataChannel?.bytesReceived,
+    packetsSent: 0,
+    packetsReceived: 0,
+    rawStats: stats.raw,
+  };
+};
+
+const getRtcConnectionStats = async (connection: RTCPeerConnection, channelTopic?: string): Promise<any> => {
+  const stats = await connection.getStats();
+
+  const statsEntries: [string, any][] = Array.from((stats as any).entries());
+  const transport = statsEntries.find(([_, entry]) => entry.type === 'transport')?.[1];
+
+  const selectedCandidatePair =
+    transport && statsEntries.find(([entryId]) => entryId === transport.selectedCandidatePairId)?.[1];
+  const remoteCandidate =
+    selectedCandidatePair && statsEntries.find(([entryId]) => entryId === selectedCandidatePair.remoteCandidateId)?.[1];
+
+  const dataChannel =
+    channelTopic &&
+    statsEntries.find(([_, entry]) => entry.type === 'data-channel' && entry.label === channelTopic)?.[1];
+
+  return {
+    transport,
+    selectedCandidatePair,
+    dataChannel,
+    remoteCandidate,
+    raw: Object.fromEntries(stats as any),
+  };
+};