@dxos/network-manager 0.1.57-main.e87098f → 0.1.57

package/src/transport/datachannel/rtc-peer-connection.test.ts

@@ -0,0 +1,112 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+// @dxos/test platform=nodejs
+
+import { expect } from 'chai';
+import nodeDataChannel from 'node-datachannel';
+
+import { Trigger, asyncTimeout } from '@dxos/async';
+import { log } from '@dxos/log';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { PeerConnection } from './rtc-peer-connection';
+
+describe('Node WebRTC libdatachannel implementation', () => {
+  test('Connect two datachannels', async () => {
+    const msg1to2 = 'Hello from Peer1';
+    const firstPeerReceived = new Trigger<string | Buffer>();
+    const msg2to1 = 'Hello from Peer2';
+    const secondPeerReceived = new Trigger<string | Buffer>();
+
+    let dc2: nodeDataChannel.DataChannel;
+    afterTest(() => dc2.close());
+
+    const peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
+    afterTest(() => peer1.close());
+
+    // Set Callbacks
+    peer1.onLocalDescription((sdp, type) => {
+      peer2.setRemoteDescription(sdp, type);
+    });
+    peer1.onLocalCandidate((candidate, mid) => {
+      peer2.addRemoteCandidate(candidate, mid);
+    });
+
+    const peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
+    afterTest(() => peer2.close());
+
+    // Set Callbacks
+    peer2.onLocalDescription((sdp, type) => {
+      peer1.setRemoteDescription(sdp, type);
+    });
+    peer2.onLocalCandidate((candidate, mid) => {
+      peer1.addRemoteCandidate(candidate, mid);
+    });
+    peer2.onDataChannel((dc) => {
+      dc2 = dc;
+      dc2.onMessage((msg) => secondPeerReceived.wake(msg));
+      dc2.sendMessage(msg2to1);
+    });
+
+    const dc1 = peer1.createDataChannel('test');
+    afterTest(() => dc1.close());
+
+    dc1.onOpen(() => dc1.sendMessage(msg1to2));
+
+    dc1.onMessage((msg) => firstPeerReceived.wake(msg));
+    dc1.onMessage((msg) => firstPeerReceived.wake(msg));
+    expect(await asyncTimeout(firstPeerReceived.wait(), 3000)).to.eq(msg2to1);
+    expect(await asyncTimeout(secondPeerReceived.wait(), 3000)).to.eq(msg1to2);
+  });
+
+  test('RTCPeerConnection', async () => {
+    const msg1to2 = 'Hello from Peer1';
+    const firstPeerReceived = new Trigger<string | Buffer>();
+    const msg2to1 = 'Hello from Peer2';
+    const secondPeerReceived = new Trigger<string | Buffer>();
+
+    const peer1 = new PeerConnection();
+    afterTest(() => peer1.close());
+
+    const peer2 = new PeerConnection();
+    afterTest(() => peer2.close());
+
+    peer1
+      .createOffer()
+      .then(async (offer) => {
+        await peer2.setRemoteDescription(offer);
+        const answer = await peer2.createAnswer();
+        await peer1.setRemoteDescription(answer);
+      })
+      .catch((err) => {
+        log.catch(err);
+      });
+
+    peer1.onicecandidate = async (env) => {
+      await peer2.addIceCandidate(env.candidate?.toJSON());
+    };
+    peer2.onicecandidate = async (env) => {
+      await peer1.addIceCandidate(env.candidate?.toJSON());
+    };
+    let dc2: RTCDataChannel;
+    peer2.ondatachannel = ({ channel }) => {
+      dc2 = channel;
+      dc2.onmessage = (msg) => {
+        secondPeerReceived.wake(msg.data);
+      };
+      dc2.send(msg2to1);
+    };
+
+    const dc1 = peer1.createDataChannel('test');
+    dc1.onmessage = (msg) => {
+      firstPeerReceived.wake(msg.data);
+    };
+
+    dc1.onopen = () => dc1.send(msg1to2);
+
+    expect((await asyncTimeout(firstPeerReceived.wait(), 3000)).toString()).to.eq(msg2to1);
+    expect((await asyncTimeout(secondPeerReceived.wait(), 3000)).toString()).to.eq(msg1to2);
+  });
+});

package/src/transport/datachannel/rtc-peer-connection.ts

@@ -0,0 +1,347 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import node from 'node-datachannel';
+import defer, { type DeferredPromise } from 'p-defer';
+
+import { DataChannel } from './rtc-data-channel';
+import { DataChannelEvent, PeerConnectionIceEvent } from './rtc-events';
+import { IceCandidate } from './rtc-ice-candidate';
+import { SessionDescription } from './rtc-session-description';
+
+export class PeerConnection extends EventTarget implements RTCPeerConnection {
+  static async generateCertificate(keygenAlgorithm: AlgorithmIdentifier): Promise<RTCCertificate> {
+    throw new Error('Not implemented');
+  }
+
+  canTrickleIceCandidates: boolean | null;
+  sctp: RTCSctpTransport | null;
+
+  onconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+  ondatachannel: ((this: RTCPeerConnection, ev: RTCDataChannelEvent) => any) | null;
+  onicecandidate: ((this: RTCPeerConnection, ev: RTCPeerConnectionIceEvent) => any) | null;
+  onicecandidateerror: ((this: RTCPeerConnection, ev: Event) => any) | null;
+  oniceconnectionstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+  onicegatheringstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+  onnegotiationneeded: ((this: RTCPeerConnection, ev: Event) => any) | null;
+  onsignalingstatechange: ((this: RTCPeerConnection, ev: Event) => any) | null;
+  ontrack: ((this: RTCPeerConnection, ev: RTCTrackEvent) => any) | null;
+
+  #peerConnection: node.PeerConnection;
+  #config: RTCConfiguration;
+  #localOffer: DeferredPromise<RTCSessionDescriptionInit>;
+  #localAnswer: DeferredPromise<RTCSessionDescriptionInit>;
+  #dataChannels: Set<DataChannel>;
+
+  constructor(init: RTCConfiguration = {}) {
+    super();
+
+    this.#config = init;
+    this.#localOffer = defer();
+    this.#localAnswer = defer();
+    this.#dataChannels = new Set();
+
+    const iceServers = init.iceServers ?? [];
+
+    this.#peerConnection = new node.PeerConnection(`peer-${Math.random()}`, {
+      iceServers: iceServers
+        .map((server) => {
+          const urls = (Array.isArray(server.urls) ? server.urls : [server.urls]).map((str) => new URL(str));
+
+          return urls.map((url) => {
+            /** @type {import('../lib/index.js').IceServer} */
+            const iceServer = {
+              hostname: url.hostname,
+              port: parseInt(url.port, 10),
+              username: server.username,
+              password: server.credential,
+              // relayType - how to specify?
+            };
+
+            return iceServer;
+          });
+        })
+        .flat(),
+      iceTransportPolicy: init?.iceTransportPolicy,
+    });
+
+    this.#peerConnection.onStateChange(() => {
+      this.dispatchEvent(new Event('connectionstatechange'));
+    });
+    // https://github.com/murat-dogan/node-datachannel/pull/171
+    // this.#peerConnection.onSignalingStateChange(() => {
+    //  this.dispatchEvent(new Event('signalingstatechange'))
+    // })
+    this.#peerConnection.onGatheringStateChange(() => {
+      this.dispatchEvent(new Event('icegatheringstatechange'));
+    });
+    this.#peerConnection.onDataChannel((channel) => {
+      this.dispatchEvent(new DataChannelEvent(new DataChannel(channel)));
+    });
+
+    // forward events to properties
+    this.addEventListener('connectionstatechange', (event) => {
+      this.onconnectionstatechange?.(event);
+    });
+    this.addEventListener('signalingstatechange', (event) => {
+      this.onsignalingstatechange?.(event);
+    });
+    this.addEventListener('icegatheringstatechange', (event) => {
+      this.onicegatheringstatechange?.(event);
+    });
+    this.addEventListener('datachannel', (event) => {
+      this.ondatachannel?.(event as RTCDataChannelEvent);
+    });
+
+    this.#peerConnection.onLocalDescription((sdp, type) => {
+      if (type === 'offer') {
+        this.#localOffer.resolve({
+          sdp,
+          type,
+        });
+      }
+
+      if (type === 'answer') {
+        this.#localAnswer.resolve({
+          sdp,
+          type,
+        });
+      }
+    });
+
+    this.#peerConnection.onLocalCandidate((candidate, mid) => {
+      if (mid === 'unspec') {
+        this.#localAnswer.reject(new Error(`Invalid description type ${mid}`));
+        return;
+      }
+
+      const event = new PeerConnectionIceEvent(new IceCandidate({ candidate }));
+
+      this.onicecandidate?.(event);
+    });
+
+    this.canTrickleIceCandidates = null;
+    this.sctp = null;
+    this.onconnectionstatechange = null;
+    this.ondatachannel = null;
+    this.onicecandidate = null;
+    this.onicecandidateerror = null;
+    this.oniceconnectionstatechange = null;
+    this.onicegatheringstatechange = null;
+    this.onnegotiationneeded = null;
+    this.onsignalingstatechange = null;
+    this.ontrack = null;
+  }
+
+  get connectionState(): RTCPeerConnectionState {
+    return assertState(this.#peerConnection.state(), RTCPeerConnectionStates);
+  }
+
+  get iceConnectionState(): RTCIceConnectionState {
+    return assertState(this.#peerConnection.state(), RTCIceConnectionStates);
+  }
+
+  get iceGatheringState(): RTCIceGatheringState {
+    return assertState(this.#peerConnection.gatheringState(), RTCIceGatheringStates);
+  }
+
+  get signalingState(): RTCSignalingState {
+    return assertState(this.#peerConnection.signalingState(), RTCSignalingStates);
+  }
+
+  get currentLocalDescription(): RTCSessionDescription | null {
+    return toSessionDescription(this.#peerConnection.localDescription());
+  }
+
+  get localDescription(): RTCSessionDescription | null {
+    return toSessionDescription(this.#peerConnection.localDescription());
+  }
+
+  get pendingLocalDescription(): RTCSessionDescription | null {
+    return toSessionDescription(this.#peerConnection.localDescription());
+  }
+
+  get currentRemoteDescription(): RTCSessionDescription | null {
+    // not exposed by node-datachannel
+    console.log("node-datachannel doesn't expose currentRemoteDescription");
+    return toSessionDescription(null);
+  }
+
+  get pendingRemoteDescription(): RTCSessionDescription | null {
+    // not exposed by node-datachannel
+    console.log("node-datachannel doesn't expose pendingRemoteDescription");
+    return toSessionDescription(null);
+  }
+
+  get remoteDescription(): RTCSessionDescription | null {
+    // not exposed by node-datachannel
+    console.log("node-datachannel doesn't expose remoteDescription");
+    return toSessionDescription(null);
+  }
+
+  async addIceCandidate(candidate?: RTCIceCandidateInit): Promise<void> {
+    if (candidate == null || candidate.candidate == null) {
+      throw new Error('Candidate invalid');
+    }
+
+    this.#peerConnection.addRemoteCandidate(candidate.candidate, candidate.sdpMid ?? '0');
+  }
+
+  addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender {
+    throw new Error('addTrack Not implemented');
+  }
+
+  addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver {
+    throw new Error('addTransciever Not implemented');
+  }
+
+  close(): void {
+    // close all channels before shutting down
+    this.#dataChannels.forEach((channel) => {
+      channel.close();
+    });
+
+    this.#peerConnection.close();
+    this.#peerConnection.destroy();
+  }
+
+  createDataChannel(label: string, dataChannelDict: RTCDataChannelInit = {}): RTCDataChannel {
+    const channel = this.#peerConnection.createDataChannel(label, dataChannelDict);
+    const dataChannel = new DataChannel(channel, dataChannelDict);
+
+    // ensure we can close all channels when shutting down
+    this.#dataChannels.add(dataChannel);
+    dataChannel.addEventListener('close', () => {
+      this.#dataChannels.delete(dataChannel);
+    });
+
+    return dataChannel;
+  }
+
+  async createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
+  async createOffer(
+    successCallback: RTCSessionDescriptionCallback,
+    failureCallback: RTCPeerConnectionErrorCallback,
+    options?: RTCOfferOptions,
+  ): Promise<void>;
+
+  async createOffer(...args: any[]): Promise<any> {
+    return this.#localOffer.promise;
+  }
+
+  async createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit>;
+  async createAnswer(
+    successCallback: RTCSessionDescriptionCallback,
+    failureCallback: RTCPeerConnectionErrorCallback,
+  ): Promise<void>;
+
+  async createAnswer(...args: any[]): Promise<any> {
+    return this.#localAnswer.promise;
+  }
+
+  getConfiguration(): RTCConfiguration {
+    return this.#config;
+  }
+
+  getReceivers(): RTCRtpReceiver[] {
+    throw new Error('getReceivers Not implemented');
+  }
+
+  getSenders(): RTCRtpSender[] {
+    throw new Error('getSenders Not implemented');
+  }
+
+  async getStats(selector?: MediaStreamTrack | null): Promise<RTCStatsReport> {
+    throw new Error('getStats Not implemented');
+  }
+
+  getTransceivers(): RTCRtpTransceiver[] {
+    throw new Error('getTranscievers Not implemented');
+  }
+
+  removeTrack(sender: RTCRtpSender): void {
+    throw new Error('removeTrack Not implemented');
+  }
+
+  restartIce(): void {
+    throw new Error('restartIce Not implemented');
+  }
+
+  setConfiguration(configuration: RTCConfiguration = {}): void {
+    this.#config = configuration;
+  }
+
+  async setLocalDescription(description?: RTCLocalSessionDescriptionInit): Promise<void> {
+    if (description == null || description.type == null) {
+      throw new Error('Local description type must be set');
+    }
+
+    if (description.type !== 'offer') {
+      console.log(`node-datachannel: setLocalDescription: only offer is supported, not ${description.type}`);
+      // any other type causes libdatachannel to throw
+      return;
+    }
+
+    // @ts-expect-error types are wrong
+    this.#peerConnection.setLocalDescription(description.type);
+  }
+
+  async setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void> {
+    if (description.sdp == null) {
+      throw new Error('Remote SDP must be set');
+    }
+
+    // @ts-expect-error types are wrong
+    this.#peerConnection.setRemoteDescription(description.sdp, description.type);
+  }
+}
+
+export { PeerConnection as RTCPeerConnection };
+
+const assertState = <T>(state: any, states: T[]): T => {
+  if (state != null && !states.includes(state)) {
+    throw new Error(`Invalid value encountered - "${state}" must be one of ${states}`);
+  }
+
+  return state as T;
+};
+
+const toSessionDescription = (description: { sdp?: string; type: string } | null): RTCSessionDescription | null => {
+  if (description == null) {
+    return null;
+  }
+
+  return new SessionDescription({
+    sdp: description.sdp,
+    type: assertState(description.type, RTCSdpTypes),
+  });
+};
+
+const RTCPeerConnectionStates: RTCPeerConnectionState[] = [
+  'closed',
+  'connected',
+  'connecting',
+  'disconnected',
+  'failed',
+  'new',
+];
+const RTCSdpTypes: RTCSdpType[] = ['answer', 'offer', 'pranswer', 'rollback'];
+const RTCIceConnectionStates: RTCIceConnectionState[] = [
+  'checking',
+  'closed',
+  'completed',
+  'connected',
+  'disconnected',
+  'failed',
+  'new',
+];
+const RTCIceGatheringStates: RTCIceGatheringState[] = ['complete', 'gathering', 'new'];
+const RTCSignalingStates: RTCSignalingState[] = [
+  'closed',
+  'have-local-offer',
+  'have-local-pranswer',
+  'have-remote-offer',
+  'have-remote-pranswer',
+  'stable',
+];

package/src/transport/datachannel/rtc-session-description.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+/**
+ * @see https://developer.mozilla.org/docs/Web/API/RTCSessionDescription
+ */
+export class SessionDescription implements RTCSessionDescription {
+  readonly sdp: string;
+  readonly type: RTCSdpType;
+
+  constructor(init: RTCSessionDescriptionInit) {
+    this.sdp = init.sdp ?? '';
+    this.type = init.type;
+  }
+
+  toJSON(): RTCSessionDescriptionInit {
+    return {
+      sdp: this.sdp,
+      type: this.type,
+    };
+  }
+}

package/src/transport/index.ts

@@ -4,6 +4,8 @@
 
 export * from './memory-transport';
 export * from './transport';
-export * from './webrtc-transport';
-export * from './webrtc-transport-service';
-export * from './webrtc-transport-proxy';
+export * from './simplepeer-transport';
+export * from './simplepeer-transport-service';
+export * from './simplepeer-transport-proxy';
+export * from './datachannel';
+export * from './libdatachannel-transport';

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

@@ -0,0 +1,99 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Duplex } from 'stream';
+
+import { sleep, TestStream } from '@dxos/async';
+import { log } from '@dxos/log';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { LibDataChannelTransport } from './libdatachannel-transport';
+import { SimplePeerTransport } from './simplepeer-transport';
+
+describe('LibDataChannelTransport', () => {
+  test('open and close', async () => {
+    const connection = new LibDataChannelTransport({
+      initiator: true,
+      stream: new Duplex(),
+      sendSignal: async () => {},
+    });
+
+    const wait = connection.closed.waitForCount(1);
+    await connection.destroy();
+    await wait;
+  })
+    .onlyEnvironments('nodejs')
+    .timeout(1_000)
+    .retries(3);
+
+  test('establish connection and send data through with protocol', async () => {
+    const stream1 = new TestStream();
+    const connection1 = new LibDataChannelTransport({
+      initiator: true,
+      stream: stream1,
+      sendSignal: async (signal) => {
+        await sleep(10);
+        await connection2.signal(signal);
+      },
+    });
+    afterTest(() => connection1.destroy());
+    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+    const stream2 = new TestStream();
+    const connection2 = new LibDataChannelTransport({
+      initiator: false,
+      stream: stream2,
+      sendSignal: async (signal) => {
+        await sleep(10);
+        await connection1.signal(signal);
+      },
+    });
+    afterTest(() => connection2.destroy());
+    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+    await TestStream.assertConnectivity(stream1, stream2, { timeout: 2_000 });
+  })
+    .onlyEnvironments('nodejs')
+    .timeout(2_000)
+    .retries(3);
+
+  test('establish connection between LibDataChannel and SimplePeer', async () => {
+    const stream1 = new TestStream();
+    const connection1 = new LibDataChannelTransport({
+      initiator: true,
+      stream: stream1,
+      sendSignal: async (signal) => {
+        log.debug('signal', signal);
+
+        await sleep(10);
+        await connection2.signal(signal);
+      },
+    });
+    afterTest(() => connection1.destroy());
+    afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+    const stream2 = new TestStream();
+    const connection2 = new SimplePeerTransport({
+      initiator: false,
+      stream: stream2,
+      sendSignal: async (signal) => {
+        log.debug('signal', signal);
+
+        await sleep(10);
+        await connection1.signal(signal);
+      },
+    });
+    afterTest(() => connection2.destroy());
+    afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+    await TestStream.assertConnectivity(stream1, stream2, { timeout: 2_000 });
+  })
+    .onlyEnvironments('nodejs')
+    .timeout(2_000)
+    .retries(3);
+});