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

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

@@ -1,195 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Duplex } from 'node:stream';
-
-import { Event as AsyncEvent } from '@dxos/async';
-import { Resource } from '@dxos/context';
-import { ErrorStream } from '@dxos/debug';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { ConnectivityError } from '@dxos/protocols';
-import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
-
-import { type RtcPeerConnection } from './rtc-peer-connection';
-import { createRtcTransportStats, describeSelectedRemoteCandidate } from './rtc-transport-stats';
-import { type Transport, type TransportOptions, type TransportStats } from '../transport';
-
-// https://viblast.com/blog/2015/2/5/webrtc-data-channel-message-size
-const MAX_MESSAGE_SIZE = 64 * 1024;
-// The default Readable stream buffer size: https://nodejs.org/api/stream.html#implementing-a-readable-stream
-const MAX_BUFFERED_AMOUNT = 64 * 1024;
-
-/**
- * A WebRTC connection data channel.
- * Manages a WebRTC connection to a remote peer using an abstract signalling mechanism.
- */
-export class RtcTransportChannel extends Resource implements Transport {
-  public readonly closed = new AsyncEvent();
-  public readonly connected = new AsyncEvent();
-  public readonly errors = new ErrorStream();
-
-  private _channel: RTCDataChannel | undefined;
-  private _stream: Duplex | undefined;
-  private _streamDataFlushedCallback: PendingStreamFlushedCallback | null = null;
-  private _isChannelCreationInProgress = false;
-
-  constructor(
-    private readonly _connection: RtcPeerConnection,
-    private readonly _options: TransportOptions,
-  ) {
-    super();
-  }
-
-  public get isRtcChannelCreationInProgress() {
-    return this._isChannelCreationInProgress;
-  }
-
-  public onConnectionError(error: Error) {
-    if (this.isOpen) {
-      this.errors.raise(error);
-    }
-  }
-
-  protected override async _open() {
-    invariant(!this._isChannelCreationInProgress);
-    this._isChannelCreationInProgress = true;
-    this._connection
-      .createDataChannel(this._options.topic)
-      .then((channel) => {
-        if (this.isOpen) {
-          this._channel = channel;
-          this._initChannel(this._channel);
-        } else {
-          this._safeCloseChannel(channel);
-        }
-      })
-      .catch((err) => {
-        if (this.isOpen) {
-          this.errors.raise(new ConnectivityError(`Failed to create a channel: ${err?.message ?? 'unknown reason.'}`));
-        }
-      })
-      .finally(() => {
-        this._isChannelCreationInProgress = false;
-      });
-  }
-
-  protected override async _close() {
-    if (this._channel) {
-      this._safeCloseChannel(this._channel);
-      this._channel = undefined;
-      this._stream = undefined;
-    }
-    this.closed.emit();
-
-    log('closed');
-  }
-
-  private _initChannel(channel: RTCDataChannel) {
-    Object.assign<RTCDataChannel, Partial<RTCDataChannel>>(channel, {
-      onopen: () => {
-        if (!this.isOpen) {
-          log.warn('channel opened in a closed transport', { topic: this._options.topic });
-          this._safeCloseChannel(channel);
-          return;
-        }
-
-        log('onopen');
-        const duplex = new Duplex({
-          read: () => {},
-          write: (chunk, encoding, callback) => {
-            return this._handleChannelWrite(chunk, callback);
-          },
-        });
-        duplex.pipe(this._options.stream).pipe(duplex);
-        this._stream = duplex;
-        this.connected.emit();
-      },
-
-      onclose: async () => {
-        log('onclose');
-        await this.close();
-      },
-
-      onmessage: (event: MessageEvent) => {
-        if (!this._stream) {
-          log.warn('ignoring message on a closed channel');
-          return;
-        }
-
-        let data = event.data;
-        if (data instanceof ArrayBuffer) {
-          data = Buffer.from(data);
-        }
-        this._stream.push(data);
-      },
-
-      onerror: (event: Event & any) => {
-        if (this.isOpen) {
-          const err = event.error instanceof Error ? event.error : new Error(`Datachannel error: ${event.type}.`);
-          this.errors.raise(err);
-        }
-      },
-
-      onbufferedamountlow: () => {
-        const cb = this._streamDataFlushedCallback;
-        this._streamDataFlushedCallback = null;
-        cb?.();
-      },
-    });
-  }
-
-  private async _handleChannelWrite(chunk: any, callback: PendingStreamFlushedCallback) {
-    if (!this._channel) {
-      log.warn('writing to a channel after a connection was closed');
-      return;
-    }
-
-    if (chunk.length > MAX_MESSAGE_SIZE) {
-      const error = new Error(`Message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}.`);
-      this.errors.raise(error);
-      callback();
-      return;
-    }
-
-    try {
-      this._channel.send(chunk);
-    } catch (err: any) {
-      this.errors.raise(err);
-      callback();
-      return;
-    }
-
-    if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
-      if (this._streamDataFlushedCallback !== null) {
-        log.error('consumer trying to write before we are ready for more data');
-      }
-      this._streamDataFlushedCallback = callback;
-    } else {
-      callback();
-    }
-  }
-
-  private _safeCloseChannel(channel: RTCDataChannel) {
-    try {
-      channel.close();
-    } catch (error: any) {
-      log.catch(error);
-    }
-  }
-
-  public onSignal(signal: Signal): Promise<void> {
-    return this._connection.onSignal(signal);
-  }
-
-  async getDetails(): Promise<string> {
-    return describeSelectedRemoteCandidate(this._connection.currentConnection);
-  }
-
-  async getStats(): Promise<TransportStats> {
-    return createRtcTransportStats(this._connection.currentConnection, this._options.topic);
-  }
-}
-
-type PendingStreamFlushedCallback = () => void;

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

@@ -1,28 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { getRtcConnectionFactory } from './rtc-connection-factory';
-import { RtcPeerConnection } from './rtc-peer-connection';
-import type { IceProvider } from '../../signal';
-import type { TransportFactory } from '../transport';
-
-export const createRtcTransportFactory = (
-  webrtcConfig?: RTCConfiguration,
-  iceProvider?: IceProvider,
-): TransportFactory => {
-  const connectionFactory = getRtcConnectionFactory();
-  return {
-    createTransport: (options) => {
-      // TODO(yaroslav): sendSignal is scoped to a swarm, RtcConnections can be cached if it's scoped to a peer
-      const connection = new RtcPeerConnection(connectionFactory, {
-        ownPeerKey: options.ownPeerKey,
-        remotePeerKey: options.remotePeerKey,
-        sendSignal: options.sendSignal,
-        webrtcConfig,
-        iceProvider,
-      });
-      return connection.createTransportChannel(options);
-    },
-  };
-};

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

@@ -1,413 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-import { Duplex } from 'stream';
-import { onTestFinished, describe, test, expect } from 'vitest';
-
-import { Event as AsyncEvent, TestStream, Trigger, sleep } from '@dxos/async';
-import { ErrorStream } from '@dxos/debug';
-import { PublicKey } from '@dxos/keys';
-import { schema } from '@dxos/protocols/proto';
-import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { createLinkedPorts, createProtoRpcPeer, type RpcPort } from '@dxos/rpc';
-
-import { RtcTransportProxy } from './rtc-transport-proxy';
-import { RtcTransportService } from './rtc-transport-service';
-import { handleChannelErrors } from './test-utils';
-import { type Transport, type TransportFactory, type TransportOptions, type TransportStats } from '../transport';
-
-describe('RtcPeerTransportProxy', () => {
-  test('open and close', async () => {
-    const { proxy } = await setupProxy();
-    await proxy.open();
-    const wait = proxy.closed.waitForCount(1);
-    expect(proxy.isOpen).toBeTruthy();
-    await proxy.close();
-    await wait;
-  });
-
-  test('transport open failure closes proxy', async () => {
-    const mockTransport = createMockTransport({
-      open: async () => {
-        await sleep(20);
-        throw new Error();
-      },
-    });
-    const peer = await setupProxy({}, mockTransport.factory);
-    const errors = handleChannelErrors(peer.proxy);
-    await peer.proxy.open();
-    await sleep(20);
-    expect(peer.proxy.isOpen).toBeFalsy();
-    await errors.expectErrorRaised();
-  });
-
-  test('transport error before connected closes proxy', async () => {
-    const mockTransport = createMockTransport();
-    const peer = await setupProxy({}, mockTransport.factory);
-    const errors = handleChannelErrors(peer.proxy);
-    await peer.proxy.open();
-    mockTransport.transport.errors.raise(new Error());
-    await sleep(20);
-    expect(peer.proxy.isOpen).toBeFalsy();
-    await errors.expectErrorRaised();
-  });
-
-  test('transport close closes proxy', async () => {
-    const mockTransport = createMockTransport();
-    const peer = await setupProxy({}, mockTransport.factory);
-    await peer.proxy.open();
-    expect(peer.proxy.isOpen).toBeTruthy();
-    await connectAndWaitProxy(peer, mockTransport);
-    await closeAndWaitProxy(peer, mockTransport);
-    expect(peer.proxy.isOpen).toBeFalsy();
-  });
-
-  test('transport connected after proxy is closed is ignored', async () => {
-    const mockTransport = createMockTransport();
-    const peer = await setupProxy({}, mockTransport.factory);
-    await peer.proxy.open();
-    expect(peer.proxy.isOpen).toBeTruthy();
-    await peer.proxy.close();
-
-    let connected = false;
-    peer.proxy.connected.on(() => {
-      connected = true;
-    });
-    mockTransport.transport.connected.emit();
-    await sleep(20);
-
-    expect(connected).toBeFalsy();
-    peer.proxy.errors.assertNoUnhandledErrors();
-  });
-
-  test('transport error after connection passed to proxy raises an error', async () => {
-    const mockTransport = createMockTransport();
-    const peer = await setupProxy({}, mockTransport.factory);
-    const errors = handleChannelErrors(peer.proxy);
-    await peer.proxy.open();
-    await connectAndWaitProxy(peer, mockTransport);
-    mockTransport.transport.errors.raise(new Error());
-    await sleep(20);
-    expect(peer.proxy.isOpen).toBeFalsy();
-    await errors.expectErrorRaised();
-  });
-
-  test('transport error raised after close is ignored', async () => {
-    const mockTransport = createMockTransport();
-    const peer = await setupProxy({}, mockTransport.factory);
-    await peer.proxy.open();
-    await connectAndWaitProxy(peer, mockTransport);
-    await sleep(20);
-    await closeAndWaitProxy(peer, mockTransport);
-    mockTransport.transport.errors.raise(new Error());
-    await sleep(20);
-    expect(peer.proxy.isOpen).toBeFalsy();
-    peer.proxy.errors.assertNoUnhandledErrors();
-  });
-
-  test('ice candidate signal failure tolerated', async () => {
-    const mockTransport = createMockTransport();
-    const failed = new Trigger();
-    const peer = await setupProxy(
-      {
-        sendSignal: () => {
-          failed.wake();
-          throw new Error();
-        },
-      },
-      mockTransport.factory,
-    );
-    await peer.proxy.open();
-    await connectAndWaitProxy(peer, mockTransport);
-    await mockTransport.sendSignalFromTransport({ payload: { data: { type: 'candidate' } } });
-    await failed.wait();
-
-    await sleep(20);
-    expect(peer.proxy.isOpen).toBeTruthy();
-    peer.proxy.errors.assertNoUnhandledErrors();
-  });
-
-  test('error raised when fails to send an offer/answer', async () => {
-    for (const type of ['offer', 'answer']) {
-      const mockTransport = createMockTransport();
-      const failed = new Trigger();
-      const peer = await setupProxy(
-        {
-          sendSignal: () => {
-            failed.wake();
-            throw new Error();
-          },
-        },
-        mockTransport.factory,
-      );
-      await peer.proxy.open();
-      const errors = handleChannelErrors(peer.proxy);
-      await connectAndWaitProxy(peer, mockTransport);
-      await mockTransport.sendSignalFromTransport({ payload: { data: { type } } });
-      await failed.wait();
-
-      await sleep(20);
-      await errors.expectErrorRaised();
-    }
-  });
-
-  test('error raised when transport fails to handle a signal', async () => {
-    const failed = new Trigger();
-    const mockTransport = createMockTransport({
-      onSignal: async (): Promise<void> => {
-        await sleep(20);
-        failed.wake();
-        throw new Error();
-      },
-    });
-    const peer = await setupProxy({}, mockTransport.factory);
-    await peer.proxy.open();
-    const errors = handleChannelErrors(peer.proxy);
-    await connectAndWaitProxy(peer, mockTransport);
-    await peer.proxy.onSignal({ payload: { data: { type: 'offer' } } });
-    await failed.wait();
-
-    await sleep(20);
-    await errors.expectErrorRaised();
-  });
-
-  test('transport close error tolerated', async () => {
-    const failed = new Trigger();
-    const mockTransport = createMockTransport({
-      close: async () => {
-        await sleep(20);
-        failed.wake();
-        throw new Error();
-      },
-    });
-    const peer = await setupProxy({}, mockTransport.factory);
-    await peer.proxy.open();
-    await connectAndWaitProxy(peer, mockTransport);
-    await sleep(20);
-    await peer.proxy.close();
-    await failed.wait();
-
-    peer.proxy.errors.assertNoUnhandledErrors();
-  });
-
-  test('transport data push after proxy close is ignored', async () => {
-    const mockTransport = createMockTransport();
-    const peer = await setupProxy({}, mockTransport.factory);
-    await peer.proxy.open();
-    const messageParts = [Buffer.from('hello,'), Buffer.from('world!')];
-    await connectAndWaitProxy(peer, mockTransport);
-    mockTransport.stream.push(messageParts[0]);
-    mockTransport.stream.push(messageParts[1]);
-    await sleep(20);
-    await peer.stream.assertReceivedAsync(Buffer.concat(messageParts));
-    await peer.proxy.close();
-    await sleep(20);
-    mockTransport.stream.push(Buffer.from('!!!'));
-    await sleep(20);
-
-    await peer.stream.assertReceivedAsync(Buffer.concat(messageParts));
-    peer.proxy.errors.assertNoUnhandledErrors();
-  });
-
-  describe('RtcPeerConnection', () => {
-    test('establish connection and send data through with protocol', async () => {
-      const peer1 = await setupProxy({
-        sendSignal: async (signal) => {
-          await peer2.proxy.onSignal(signal);
-        },
-      });
-      await peer1.proxy.open();
-      assertNoErrorsAfterTest(peer1);
-
-      const peer2 = await setupProxy({
-        ownPeerKey: peer1.options.remotePeerKey,
-        remotePeerKey: peer1.options.ownPeerKey,
-        topic: peer1.options.topic,
-        sendSignal: async (signal) => {
-          await peer1.proxy.onSignal(signal);
-        },
-      });
-      await peer2.proxy.open();
-      assertNoErrorsAfterTest(peer2);
-
-      await TestStream.assertConnectivity(peer1.stream, peer2.stream, { timeout: 1500 });
-    });
-
-    test('establish connection and send data through with protocol with multiplexing', async () => {
-      const [port1, port2] = createLinkedPorts();
-      await createService(port1);
-      const rpcClient = await createClient(port2);
-
-      const proxy1 = await createProxy(rpcClient, {
-        sendSignal: async (signal) => {
-          await proxy2.proxy.onSignal(signal);
-        },
-      });
-      assertNoErrorsAfterTest(proxy1);
-
-      const proxy2 = await createProxy(rpcClient, {
-        ownPeerKey: proxy1.options.remotePeerKey,
-        remotePeerKey: proxy1.options.ownPeerKey,
-        topic: proxy1.options.topic,
-        sendSignal: async (signal) => {
-          await proxy1.proxy.onSignal(signal);
-        },
-      });
-      assertNoErrorsAfterTest(proxy2);
-
-      await proxy1.proxy.open();
-      await proxy2.proxy.open();
-
-      await TestStream.assertConnectivity(proxy1.stream, proxy2.stream, { timeout: 1500 });
-    });
-  });
-
-  const setupProxy = async (overrides?: Partial<TransportOptions>, transportFactory?: TransportFactory) => {
-    const [port1, port2] = createLinkedPorts();
-    const service = await createService(port1, transportFactory);
-    const rpcClient = await createClient(port2);
-    return { service, ...(await createProxy(rpcClient, overrides)) };
-  };
-
-  const createProxy = async (
-    client: { rpc: { BridgeService: BridgeService } },
-    overrides?: Partial<TransportOptions>,
-  ) => {
-    const stream = (overrides?.stream as TestStream) ?? new TestStream();
-    const options = createTransportOptions({ stream, ...overrides });
-    const proxy = new RtcTransportProxy({ ...options, bridgeService: client.rpc.BridgeService });
-    onTestFinished(async () => {
-      await proxy.close();
-    });
-    return { proxy, options, stream };
-  };
-
-  const createService = async (port: RpcPort, transportFactory?: TransportFactory) => {
-    const rtcTransportService = new RtcTransportService(undefined, undefined, transportFactory);
-    const service = createProtoRpcPeer({
-      requested: {},
-      exposed: {
-        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-      },
-      handlers: { BridgeService: rtcTransportService },
-      port,
-      noHandshake: true,
-      encodingOptions: {
-        preserveAny: true,
-      },
-    });
-    await service.open();
-    onTestFinished(async () => {
-      expect(rtcTransportService.hasOpenTransports()).toBeFalsy();
-      await service.close();
-    });
-    return service;
-  };
-
-  const createClient = async (port: RpcPort) => {
-    const rpcClient = createProtoRpcPeer({
-      requested: {
-        BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-      },
-      port,
-      noHandshake: true,
-      encodingOptions: {
-        preserveAny: true,
-      },
-    });
-    await rpcClient.open();
-    onTestFinished(async () => {
-      await rpcClient.close();
-    });
-    return rpcClient;
-  };
-
-  const assertNoErrorsAfterTest = (args: { proxy: Transport }) => {
-    onTestFinished(() => {
-      args.proxy.errors.assertNoUnhandledErrors();
-    });
-  };
-
-  const closeAndWaitProxy = (peer: { proxy: RtcTransportProxy }, mockTransport: { transport: MockTransport }) => {
-    const waitForConnected = peer.proxy.closed.waitForCount(1);
-    mockTransport.transport.closed.emit();
-    return waitForConnected;
-  };
-
-  const connectAndWaitProxy = (peer: { proxy: RtcTransportProxy }, mockTransport: { transport: MockTransport }) => {
-    const waitForConnected = peer.proxy.connected.waitForCount(1);
-    mockTransport.transport.connected.emit();
-    return waitForConnected;
-  };
-});
-
-const createTransportOptions = (options: Partial<TransportOptions>): TransportOptions => {
-  return {
-    initiator: false,
-    stream: new Duplex(),
-    sendSignal: async () => {},
-    remotePeerKey: PublicKey.random().toHex(),
-    ownPeerKey: PublicKey.random().toHex(),
-    topic: PublicKey.random().toHex(),
-    ...options,
-  };
-};
-
-const createMockTransport = (delegate?: Partial<Transport>) => {
-  const transport = new MockTransport(delegate);
-  const receivedMessages: string[] = [];
-  const stream = new Duplex({
-    read: () => {},
-    write: (chunk: any, _: BufferEncoding, callback: () => void) => {
-      receivedMessages.push(Buffer.from(chunk).toString());
-      callback();
-    },
-  });
-  let sendSignal: any | undefined;
-  return {
-    receivedMessages,
-    transport,
-    stream,
-    sendSignalFromTransport: async (signal: any) => {
-      sendSignal(signal);
-    },
-    factory: {
-      createTransport: (options: TransportOptions): Transport => {
-        sendSignal = options.sendSignal;
-        stream.pipe(options.stream).pipe(stream);
-        return transport;
-      },
-    },
-  };
-};
-
-class MockTransport implements Transport {
-  public readonly closed = new AsyncEvent();
-  public readonly connected = new AsyncEvent();
-  public readonly errors = new ErrorStream();
-
-  constructor(private readonly _delegate: Partial<Transport> = {}) {}
-
-  public async open(): Promise<this> {
-    await this._delegate.open?.();
-    return this;
-  }
-
-  public async close(): Promise<this> {
-    await this._delegate.close?.();
-    return this;
-  }
-
-  public async onSignal(signal: any): Promise<void> {
-    return this._delegate.onSignal?.(signal);
-  }
-
-  public async getStats(): Promise<TransportStats> {
-    return {} as any;
-  }
-
-  public async getDetails(): Promise<string> {
-    return '';
-  }
-}