@dxos/network-manager 0.6.13 → 0.6.14-main.69511f5

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

@@ -0,0 +1,176 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Duplex } from 'node:stream';
+import { describe, expect, test } from 'vitest';
+
+import { sleep } from '@dxos/async';
+
+import { type RtcPeerConnection } from './rtc-peer-connection';
+import { RtcTransportChannel } from './rtc-transport-channel';
+import { handleChannelErrors } from './test-utils';
+import { type TransportOptions } from '../transport';
+
+describe('RtcTransportChannel', () => {
+  test('transport error raised if channel creation fails', async () => {
+    const controller = createChannelController();
+    const { transport } = createTransport(controller.connection);
+    const transportErrors = handleChannelErrors(transport);
+    await transport.open();
+    controller.onChannelCreationFailed();
+    await transportErrors.expectErrorRaised();
+  });
+
+  test('channel closed if it was open after transport was closed', async () => {
+    const controller = createChannelController();
+    const { transport } = createTransport(controller.connection);
+    await transport.open();
+    await controller.onChannelCreated();
+    await transport.close();
+    controller.channel.onopen();
+    expect(controller.channel.wasClosed()).to.be.true;
+  });
+
+  test('channel open while transport is being closed', async () => {
+    for (const syncOpen of [false, true]) {
+      const controller = createChannelController();
+      const { transport } = createTransport(controller.connection);
+      await transport.open();
+      await controller.onChannelCreated();
+      void transport.close();
+      if (syncOpen) {
+        controller.channel.onopen();
+      } else {
+        setTimeout(() => controller.channel.onopen());
+      }
+      await sleep(10);
+      expect(controller.channel.wasClosed()).to.be.true;
+    }
+  });
+
+  test('channel close closes transport', async () => {
+    const controller = createChannelController();
+    const { transport } = createTransport(controller.connection);
+    const transportClosedEvent = handleClose(transport);
+    await transport.open();
+    await controller.onChannelCreated();
+    controller.channel.onopen();
+    await sleep(10);
+    await controller.channel.onclose();
+    expect(transport.isOpen).to.be.false;
+    await transportClosedEvent.expectWasEmitted();
+  });
+
+  test('channel closed if created after transport was closed', async () => {
+    const controller = createChannelController();
+    const { transport } = createTransport(controller.connection);
+    await transport.open();
+    await transport.close();
+    await controller.onChannelCreated();
+    controller.channel.onopen();
+    expect(controller.channel.wasClosed()).to.be.true;
+  });
+
+  test('message not delivered on a closed transport', async () => {
+    const controller = createChannelController();
+    const { deliveredMessages, transport } = createTransport(controller.connection);
+    await transport.open();
+    await controller.onChannelCreated();
+    controller.channel.onopen();
+    const message = 'hello';
+    await controller.channel.onMessage(message);
+    expect(deliveredMessages).toStrictEqual([message]);
+    await transport.close();
+    await controller.channel.onMessage(message + '1');
+    expect(deliveredMessages).toStrictEqual([message]);
+  });
+
+  test('message not sent on a closed transport', async () => {
+    const controller = createChannelController();
+    const { deliveredMessages, transport } = createTransport(controller.connection);
+    await transport.open();
+    await controller.onChannelCreated();
+    controller.channel.onopen();
+    const message = 'hello';
+    await controller.channel.onMessage(message);
+    expect(deliveredMessages).toStrictEqual([message]);
+    await transport.close();
+    await controller.channel.onMessage(message + '1');
+    expect(deliveredMessages).toStrictEqual([message]);
+  });
+
+  test('error raised if send fails', async () => {
+    const controller = createChannelController();
+    const { transport, stream } = createTransport(controller.connection);
+    await transport.open();
+    await controller.onChannelCreated();
+    const transportClosedEvent = handleChannelErrors(transport);
+    controller.channel.onopen();
+    controller.setFailSending(true);
+    stream.push('hello');
+    await transportClosedEvent.expectErrorRaised();
+  });
+
+  const createTransport = (connection: RtcPeerConnection) => {
+    const deliveredMessages: any[] = [];
+    const stream = new Duplex({
+      read: () => {},
+      write: (chunk: any, _: BufferEncoding, callback: (error?: Error | null) => void) => {
+        deliveredMessages.push(Buffer.from(chunk).toString());
+        callback();
+      },
+    });
+    const options = { topic: 'test', stream } as any as TransportOptions;
+    return { deliveredMessages, stream, transport: new RtcTransportChannel(connection, options) };
+  };
+
+  const handleClose = (channel: RtcTransportChannel) => {
+    let emitted = false;
+    channel.closed.on(() => (emitted = true));
+    return { expectWasEmitted: async () => expect(emitted).toBeTruthy() };
+  };
+
+  const createChannelController = () => {
+    // Lowercase methods will get overwritten internally.
+    let closed = false;
+    let failsSending = false;
+    const channel = {
+      onopen: () => {},
+      onclose: async () => {},
+      close: () => (closed = true),
+      send: () => {
+        if (failsSending) {
+          throw new Error('Expected');
+        }
+      },
+      wasClosed: () => closed,
+      onMessage: async (message: string) => {
+        (channel as any).onmessage({ data: message });
+        await sleep(5);
+      },
+    };
+    let onChannelCreated = async () => {};
+    let onChannelCreationFailed = () => {};
+    const createChannelPromise = new Promise((resolve, reject) => {
+      onChannelCreated = async () => {
+        resolve(channel);
+        await sleep(5);
+      };
+      onChannelCreationFailed = reject;
+    });
+    return {
+      onChannelCreated,
+      onChannelCreationFailed,
+      setFailSending: (fail: boolean) => {
+        failsSending = fail;
+      },
+      channel,
+      connection: {
+        createDataChannel: async (topic: string) => {
+          return createChannelPromise;
+        },
+      } as any as RtcPeerConnection,
+    };
+  };
+});

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

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

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