@dxos/network-manager 0.6.13 → 0.6.14-main.7bd9c89

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),
+  };
+};

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

@@ -0,0 +1,198 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { onTestFinished, describe, expect, test } from 'vitest';
+
+import { sleep, TestStream } from '@dxos/async';
+import { PublicKey } from '@dxos/keys';
+
+import { getRtcConnectionFactory } from './rtc-connection-factory';
+import { RtcPeerConnection } from './rtc-peer-connection';
+import { type RtcTransportChannel } from './rtc-transport-channel';
+import { chooseInitiatorPeer } from './utils';
+import { type TransportOptions } from '../transport';
+
+const connectionFactory = getRtcConnectionFactory();
+
+describe('RtcTransport', () => {
+  test('channel open and close', async () => {
+    const peer = await createConnection();
+    const channel = createChannel(peer);
+
+    await channel.open();
+    const wait = channel.closed.waitForCount(1);
+    await channel.close();
+    await wait;
+
+    expect(peer.connection.transportChannelCount).to.eq(0);
+    await expect.poll(() => channel.isRtcChannelCreationInProgress).toBeFalsy();
+  });
+
+  test('establish connection and send data through with protocol', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await initiatorChannel.open();
+    await anotherChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('initiator opens a channel before another peer', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await initiatorChannel.open();
+    await sleep(50);
+    await anotherChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('initiator opens a channel after another peer', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await anotherChannel.open();
+    await sleep(50);
+    await initiatorChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('signal delivery idempotency', async () => {
+    const { initiator, another } = await createConnectedPeers({ duplicateSignals: true });
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await anotherChannel.open();
+    await sleep(50);
+    await initiatorChannel.open();
+
+    await TestStream.assertConnectivity(initiator.stream, another.stream, { timeout: 1500 });
+  });
+
+  test('initiator closes before connectivity is established', async () => {
+    const { initiator, another } = await createConnectedPeers();
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await initiatorChannel.open();
+    await sleep(20);
+    await anotherChannel.open();
+    await initiatorChannel.close();
+
+    initiatorChannel.errors.assertNoUnhandledErrors();
+    anotherChannel.errors.assertNoUnhandledErrors();
+  });
+
+  test('initiator opens a channel after another peer closed it', async () => {
+    const { initiator, another } = await createConnectedPeers({ duplicateSignals: true });
+    const initiatorChannel = createChannel(initiator);
+    const anotherChannel = createChannel(another);
+
+    await anotherChannel.open();
+    await sleep(20);
+    await anotherChannel.close();
+    await initiatorChannel.open();
+    await initiatorChannel.close();
+
+    await expect.poll(() => anotherChannel.isRtcChannelCreationInProgress).toBeFalsy();
+    initiatorChannel.errors.assertNoUnhandledErrors();
+    anotherChannel.errors.assertNoUnhandledErrors();
+  });
+
+  const createConnectedPeers = async (options?: { duplicateSignals?: boolean }) => {
+    const peer1Signal = createSignalSender(options);
+    const peer2Signal = createSignalSender(options);
+
+    const peer1 = await createConnection({ sendSignal: peer1Signal.sendSignal }, peer2Signal.onChannelCreated);
+    const peer2 = await createConnection(
+      {
+        ownPeerKey: peer1.options.remotePeerKey,
+        remotePeerKey: peer1.options.ownPeerKey,
+        topic: peer1.options.topic,
+        sendSignal: peer2Signal.sendSignal,
+      },
+      peer1Signal.onChannelCreated,
+    );
+
+    return chooseInitiator(peer1, peer2);
+  };
+
+  const createSignalSender = (options?: { duplicateSignals?: boolean }) => {
+    const deliverSignal = (channel: RtcTransportChannel, signal: any) => {
+      void channel.onSignal(signal);
+      if (options?.duplicateSignals) {
+        void channel.onSignal(signal);
+      }
+    };
+    let remoteChannel: RtcTransportChannel | undefined;
+    const signalBuffer: any[] = [];
+    const sendSignal = async (signal: any) => {
+      await sleep(10);
+      if (remoteChannel) {
+        deliverSignal(remoteChannel, signal);
+      } else {
+        signalBuffer.push(signal);
+      }
+    };
+    const onChannelCreated = (channel: RtcTransportChannel): void => {
+      remoteChannel = channel;
+      for (const signal of signalBuffer) {
+        deliverSignal(channel, signal);
+      }
+    };
+    return { sendSignal, onChannelCreated };
+  };
+
+  const createConnection = async (
+    optionOverrides?: Partial<TransportOptions>,
+    onChannelCreated: (channel: RtcTransportChannel) => void = () => {},
+  ): Promise<TestSetup> => {
+    const stream = new TestStream();
+    const options: TransportOptions = {
+      initiator: false,
+      stream,
+      sendSignal: async () => {},
+      remotePeerKey: PublicKey.random().toHex(),
+      ownPeerKey: PublicKey.random().toHex(),
+      topic: PublicKey.random().toHex(),
+      ...optionOverrides,
+    };
+    const connection = new RtcPeerConnection(connectionFactory, options);
+    return { options, connection, stream, onChannelOpen: onChannelCreated };
+  };
+
+  const chooseInitiator = (peer1: TestSetup, peer2: TestSetup) => {
+    const [initiator, another] =
+      chooseInitiatorPeer(peer1.options.ownPeerKey, peer2.options.ownPeerKey) === peer1.options.ownPeerKey
+        ? [peer1, peer2]
+        : [peer2, peer1];
+    return { initiator, another };
+  };
+
+  const createChannel = (args: TestSetup) => {
+    const channel = args.connection.createTransportChannel(args.options);
+    const originalOpen = channel.open.bind(channel);
+    (channel as any).open = async () => {
+      await originalOpen();
+      args.onChannelOpen(channel);
+    };
+    onTestFinished(async () => {
+      await channel.close();
+    });
+    return channel;
+  };
+});
+
+type TestSetup = {
+  stream: TestStream;
+  connection: RtcPeerConnection;
+  options: TransportOptions;
+  onChannelOpen: (channel: RtcTransportChannel) => void;
+};

package/src/transport/webrtc/test-utils.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect } from 'vitest';
+
+import { sleep } from '@dxos/async';
+
+import { type Transport } from '../transport';
+
+export const handleChannelErrors = (channel: Transport) => {
+  let handled = false;
+  channel.errors.handle(() => (handled = true));
+  return {
+    expectErrorRaised: async () => {
+      if (!handled) {
+        await sleep(5);
+      }
+      expect(handled).toBeTruthy();
+    },
+  };
+};

package/src/transport/webrtc/utils.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const chooseInitiatorPeer = (peer1Key: string, peer2Key: string) => (peer1Key < peer2Key ? peer1Key : peer2Key);
+
+export const areSdpEqual = (sdp1: string, sdp2: string) => {
+  const sdp1Lines = deduplicatedSdpLines(sdp1);
+  const sdp2Lines = deduplicatedSdpLines(sdp2);
+  if (sdp1Lines.length !== sdp2Lines.length) {
+    return false;
+  }
+  return sdp1Lines.every((line, idx) => line === sdp2Lines[idx]);
+};
+
+/**
+ * For some reason libdatachannel duplicates some attributes after an sdp is set.
+ * So the following test might fail:
+ * conn.setRemoteDescription(sdp);
+ * expect(conn.remoteDescription.sdp).toEqual(sdp);
+ */
+const deduplicatedSdpLines = (sdp: string) => {
+  const deduplicatedLines: string[] = [];
+  const seenLines: string[] = [];
+  for (const line of sdp.split('\r\n')) {
+    if (line.startsWith('m')) {
+      seenLines.length = 0;
+    }
+    if (seenLines.includes(line)) {
+      continue;
+    }
+    seenLines.push(line);
+    deduplicatedLines.push(line);
+  }
+  return deduplicatedLines;
+};

package/src/typings.d.ts

@@ -3,5 +3,11 @@
 //
 
 declare module '@koush/wrtc';
-declare module 'nanomessage-rpc';
-declare module 'xor-distance';
+
+declare module '#node-datachannel' {
+  export * from 'node-datachannel';
+}
+
+declare module '#node-datachannel/polyfill' {
+  export * from 'node-datachannel/polyfill';
+}