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

package/src/swarm/connection.test.ts

@@ -8,7 +8,7 @@ import { log } from '@dxos/log';
 import { describe, test } from '@dxos/test';
 
 import { TestWireProtocol } from '../testing/test-wire-protocol';
-import { createWebRTCTransportFactory } from '../transport';
+import { createSimplePeerTransportFactory } from '../transport';
 import { Connection } from './connection';
 
 describe('Connection', () => {
@@ -37,7 +37,8 @@ describe('Connection', () => {
         remotePeerId: peerId2,
         topic,
       }),
-      createWebRTCTransportFactory(),
+      // TODO(nf): configure?
+      createSimplePeerTransportFactory(),
     );
 
     const protocol2 = new TestWireProtocol(peerId2);
@@ -58,11 +59,15 @@ describe('Connection', () => {
         },
       },
       protocol2.factory({ initiator: false, localPeerId: peerId2, remotePeerId: peerId1, topic }),
-      createWebRTCTransportFactory(),
+      // TODO(nf): configure?
+      createSimplePeerTransportFactory(),
     );
 
+    connection2.initiate();
     await connection2.openConnection();
     await sleep(100);
+
+    connection1.initiate();
     await connection1.openConnection();
     await Promise.all([
       protocol1.testConnection(peerId2, 'test message 1'),

package/src/swarm/connection.ts

@@ -43,6 +43,11 @@ interface ConnectionCallbacks {
  * State machine for each connection.
  */
 export enum ConnectionState {
+  /**
+   *  Connection is created, but not yet passed through the connection limiter.
+   */
+  CREATED = 'CREATED',
+
   /**
    * Initial state. Connection is registered but no attempt to connect to the remote peer has been performed.
    * Might mean that we are waiting for the answer signal from the remote peer.
@@ -77,7 +82,7 @@ export enum ConnectionState {
 export class Connection {
   private readonly _ctx = new Context();
 
-  private _state: ConnectionState = ConnectionState.INITIAL;
+  private _state: ConnectionState = ConnectionState.CREATED;
   private _transport: Transport | undefined;
   closeReason?: string;
 
@@ -144,7 +149,7 @@ export class Connection {
     this._changeState(ConnectionState.CONNECTING);
 
     // TODO(dmaretskyi): Initialize only after the transport has established connection.
-    this._protocol.initialize().catch((err) => {
+    this._protocol.open().catch((err) => {
       this.errors.raise(err);
     });
 
@@ -168,13 +173,21 @@ export class Connection {
 
     this._transport.closed.once(() => {
       this._transport = undefined;
-      this.close().catch((err) => this.errors.raise(err));
+      log('abort triggered by transport close');
+      this.abort().catch((err) => this.errors.raise(err));
     });
 
     this._transport.errors.handle((err) => {
+      log('transport error:', { err });
+      // TODO(nf): collect a list of errors?
       if (!this.closeReason) {
         this.closeReason = err?.message;
       }
+      if (err?.message.includes('OperationError')) {
+        log('aborting due to transport OperationError');
+        this.abort().catch((err) => this.errors.raise(err));
+      }
+
       if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {
         this.errors.raise(err);
       }
@@ -190,6 +203,41 @@ export class Connection {
     log.trace('dxos.mesh.connection.open-connection', trace.end({ id: this._instanceId }));
   }
 
+  @synchronized
+  // TODO(nf): make the caller responsible for recording the reason and determining flow control.
+  async abort(err?: Error) {
+    log('aborting...', { err });
+    if (!this.closeReason) {
+      this.closeReason = err?.message;
+    }
+    if (this._state === ConnectionState.CLOSED) {
+      log('abort ignored: already closed', this.closeReason);
+      return;
+    }
+    // TODO(nf): different state?
+    this._changeState(ConnectionState.CLOSING);
+
+    await this._ctx.dispose();
+
+    try {
+      // Forcefully close the stream flushing any unsent data packets.
+      log('aborting protocol... ', { proto: this._protocol });
+      await this._protocol.abort();
+    } catch (err: any) {
+      log.catch(err);
+    }
+
+    try {
+      // After the transport is closed streams are disconnected.
+      await this._transport?.destroy();
+    } catch (err: any) {
+      log.catch(err);
+    }
+
+    this._changeState(ConnectionState.CLOSED);
+    this._callbacks?.onClosed?.(err);
+  }
+
   @synchronized
   async close(err?: Error) {
     if (!this.closeReason) {
@@ -206,7 +254,7 @@ export class Connection {
 
     try {
       // Gracefully close the stream flushing any unsent data packets.
-      await this._protocol.destroy();
+      await this._protocol.close();
     } catch (err: any) {
       log.catch(err);
     }
@@ -255,7 +303,7 @@ export class Connection {
       }
 
       // If signal fails treat connection as failed
-      log.warn('Signal failed', { err });
+      log.warn('signal failed', { err });
       await this.close();
     }
   }
@@ -279,7 +327,7 @@ export class Connection {
         continue;
       }
 
-      if (this._state === ConnectionState.INITIAL) {
+      if ([ConnectionState.CREATED, ConnectionState.INITIAL].includes(this.state)) {
         log('buffered signal', { peerId: this.ownId, remoteId: this.remoteId, msg: msg.data });
         this._incomingSignalBuffer.push(signal);
       } else {
@@ -290,6 +338,10 @@ export class Connection {
     }
   }
 
+  initiate() {
+    this._changeState(ConnectionState.INITIAL);
+  }
+
   private _changeState(state: ConnectionState): void {
     log('stateChanged', { from: this._state, too: state, peerId: this.ownId });
     invariant(state !== this._state, 'Already in this state.');

package/src/swarm/peer.ts

@@ -113,6 +113,7 @@ export class Peer {
       // Peer with the highest Id closes its connection, and accepts remote peer's offer.
       if (remoteId.toHex() < this.localPeerId.toHex()) {
         // TODO(burdon): Too verbose.
+        // TODO(nf): gets stuck when remote connection is aborted (i.e. closed tab)
         log('close local connection', {
           localPeerId: this.id,
           topic: this.topic,
@@ -138,6 +139,8 @@ export class Peer {
 
         try {
           await this._connectionLimiter.connecting(message.sessionId);
+          connection.initiate();
+
           await connection.openConnection();
         } catch (err: any) {
           if (!(err instanceof CancelledError)) {
@@ -168,6 +171,7 @@ export class Peer {
 
     try {
       await this._connectionLimiter.connecting(sessionId);
+      connection.initiate();
 
       const answer = await this._signalMessaging.offer({
         author: this.localPeerId,

package/src/swarm/swarm.test.ts

@@ -12,7 +12,7 @@ import { ComplexSet } from '@dxos/util';
 
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
-import { createWebRTCTransportFactory } from '../transport';
+import { createSimplePeerTransportFactory } from '../transport';
 import { ConnectionState } from './connection';
 import { ConnectionLimiter } from './connection-limiter';
 import { Swarm } from './swarm';
@@ -48,7 +48,8 @@ describe('Swarm', () => {
       new FullyConnectedTopology(),
       protocol.factory,
       new Messenger({ signalManager }),
-      createWebRTCTransportFactory(),
+      // TODO(nf): configure?
+      createSimplePeerTransportFactory(),
       undefined,
       connectionLimiter,
       initiationDelay,

package/src/testing/test-builder.ts

@@ -3,6 +3,7 @@
 //
 
 import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
 import {
   MemorySignalManager,
   MemorySignalManagerContext,
@@ -20,9 +21,11 @@ import { FullyConnectedTopology } from '../topology';
 import {
   MemoryTransportFactory,
   TransportFactory,
-  WebRTCTransport,
-  WebRTCTransportProxyFactory,
-  WebRTCTransportService,
+  SimplePeerTransportProxyFactory,
+  SimplePeerTransportService,
+  createSimplePeerTransportFactory,
+  createLibDataChannelTransportFactory,
+  TransportKind,
 } from '../transport';
 import { TestWireProtocol, type TestTeleportExtensionFactory } from './test-wire-protocol';
 
@@ -35,6 +38,7 @@ export const TEST_SIGNAL_HOSTS: Runtime.Services.Signal[] = [
 export type TestBuilderOptions = {
   signalHosts?: Runtime.Services.Signal[];
   bridge?: boolean;
+  transport?: TransportKind;
 };
 
 /**
@@ -54,7 +58,7 @@ export class TestBuilder {
   }
 
   createPeer(peerId: PublicKey = PublicKey.random()) {
-    return new TestPeer(this, peerId);
+    return new TestPeer(this, peerId, this.options.transport);
   }
 }
 
@@ -77,49 +81,76 @@ export class TestPeer {
   private _proxy?: ProtoRpcPeer<any>;
   private _service?: ProtoRpcPeer<any>;
 
-  constructor(private readonly testBuilder: TestBuilder, public readonly peerId: PublicKey) {
+  constructor(
+    private readonly testBuilder: TestBuilder,
+    public readonly peerId: PublicKey,
+    public readonly transport?: TransportKind,
+  ) {
     this._signalManager = this.testBuilder.createSignalManager();
-    this._networkManager = this.createNetworkManager();
+    if (!transport) {
+      if (this.testBuilder.options.signalHosts) {
+        transport = TransportKind.SIMPLE_PEER;
+      } else {
+        transport = TransportKind.MEMORY;
+      }
+    }
+    this._networkManager = this.createNetworkManager(transport);
   }
 
   // TODO(burdon): Move to TestBuilder.
-  createNetworkManager() {
-    let transportFactory: TransportFactory = MemoryTransportFactory;
-
+  createNetworkManager(transport: TransportKind) {
+    let transportFactory: TransportFactory;
     if (this.testBuilder.options.signalHosts) {
-      if (this.testBuilder.options.bridge) {
-        // Simulates bridge to shared worker.
-        const [proxyPort, servicePort] = createLinkedPorts();
-
-        this._proxy = createProtoRpcPeer({
-          port: proxyPort,
-          requested: {
-            BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-          },
-          noHandshake: true,
-          encodingOptions: {
-            preserveAny: true,
-          },
-        });
-
-        this._service = createProtoRpcPeer({
-          port: servicePort,
-          exposed: {
-            BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
-          },
-          handlers: { BridgeService: new WebRTCTransportService() },
-          noHandshake: true,
-          encodingOptions: {
-            preserveAny: true,
-          },
-        });
-
-        transportFactory = new WebRTCTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
-      } else {
-        transportFactory = {
-          createTransport: (params) => new WebRTCTransport(params),
-        };
+      log.info(`using ${transport} transport with signal server.`);
+      switch (transport) {
+        case TransportKind.MEMORY:
+          throw new Error('Memory transport not supported with signal server.');
+        case TransportKind.SIMPLE_PEER:
+          transportFactory = createSimplePeerTransportFactory();
+          break;
+        case TransportKind.LIBDATACHANNEL:
+          transportFactory = createLibDataChannelTransportFactory();
+          break;
+        case TransportKind.SIMPLE_PEER_PROXY:
+          {
+            // Simulates bridge to shared worker.
+            const [proxyPort, servicePort] = createLinkedPorts();
+
+            this._proxy = createProtoRpcPeer({
+              port: proxyPort,
+              requested: {
+                BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
+              },
+              noHandshake: true,
+              encodingOptions: {
+                preserveAny: true,
+              },
+            });
+
+            this._service = createProtoRpcPeer({
+              port: servicePort,
+              exposed: {
+                BridgeService: schema.getService('dxos.mesh.bridge.BridgeService'),
+              },
+              handlers: { BridgeService: new SimplePeerTransportService() },
+              noHandshake: true,
+              encodingOptions: {
+                preserveAny: true,
+              },
+            });
+
+            transportFactory = new SimplePeerTransportProxyFactory().setBridgeService(this._proxy.rpc.BridgeService);
+          }
+          break;
+        default:
+          throw new Error(`Unsupported transport: ${transport}`);
+      }
+    } else {
+      if (transport !== TransportKind.MEMORY) {
+        log.warn(`specified transport ${transport} but no signalling configured, using memory transport instead`);
       }
+      log.info(`using ${transport} transport without signal server.`);
+      transportFactory = MemoryTransportFactory;
     }
 
     return new NetworkManager({

package/src/transport/datachannel/README.md

@@ -0,0 +1,2 @@
+Code in this directory was adopted from https://github.com/libp2p/js-libp2p/tree/master/packages/transport-webrtc/src/webrtc
+at of commit e664d14f

package/src/transport/datachannel/index.browser.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export const RTCPeerConnection = globalThis.RTCPeerConnection;
+export const RTCSessionDescription = globalThis.RTCSessionDescription;
+export const RTCIceCandidate = globalThis.RTCIceCandidate;
+export const cleanup = (): void => {};

package/src/transport/datachannel/index.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import node from 'node-datachannel';
+
+import { IceCandidate } from './rtc-ice-candidate';
+import { PeerConnection } from './rtc-peer-connection';
+import { SessionDescription } from './rtc-session-description';
+
+export { SessionDescription as RTCSessionDescription };
+export { IceCandidate as RTCIceCandidate };
+export { PeerConnection as RTCPeerConnection };
+
+export const cleanup = (): void => {
+  node.cleanup();
+};

package/src/transport/datachannel/rtc-data-channel.ts

@@ -0,0 +1,148 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import type node from 'node-datachannel';
+
+export class DataChannel extends EventTarget implements RTCDataChannel {
+  binaryType: BinaryType;
+
+  readonly maxPacketLifeTime: number | null;
+  readonly maxRetransmits: number | null;
+  readonly negotiated: boolean;
+  readonly ordered: boolean;
+
+  onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null;
+  onclose: ((this: RTCDataChannel, ev: Event) => any) | null;
+  onclosing: ((this: RTCDataChannel, ev: Event) => any) | null;
+  onerror: ((this: RTCDataChannel, ev: Event) => any) | null;
+  onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null;
+  onopen: ((this: RTCDataChannel, ev: Event) => any) | null;
+
+  #dataChannel: node.DataChannel;
+  #bufferedAmountLowThreshold: number;
+  #readyState: RTCDataChannelState;
+
+  constructor(dataChannel: node.DataChannel, dataChannelDict: RTCDataChannelInit = {}) {
+    super();
+
+    this.#dataChannel = dataChannel;
+    this.#readyState = 'connecting';
+    this.#bufferedAmountLowThreshold = 0;
+
+    this.binaryType = 'arraybuffer';
+
+    this.#dataChannel.onOpen(() => {
+      this.#readyState = 'open';
+      this.dispatchEvent(new Event('open'));
+    });
+    this.#dataChannel.onClosed(() => {
+      this.#readyState = 'closed';
+      this.dispatchEvent(new Event('close'));
+    });
+    this.#dataChannel.onError((msg) => {
+      this.#readyState = 'closed';
+      this.dispatchEvent(
+        new RTCErrorEvent('error', {
+          error: new RTCError(
+            {
+              errorDetail: 'data-channel-failure',
+            },
+            msg,
+          ),
+        }),
+      );
+    });
+    this.#dataChannel.onBufferedAmountLow(() => {
+      this.dispatchEvent(new Event('bufferedamountlow'));
+    });
+    this.#dataChannel.onMessage((data: string | Uint8Array) => {
+      if (typeof data === 'string') {
+        data = Buffer.from(data);
+      }
+
+      this.dispatchEvent(new MessageEvent('message', { data }));
+    });
+
+    // forward events to properties
+    this.addEventListener('message', (event) => {
+      this.onmessage?.(event as MessageEvent<ArrayBuffer>);
+    });
+    this.addEventListener('bufferedamountlow', (event) => {
+      this.onbufferedamountlow?.(event);
+    });
+    this.addEventListener('error', (event) => {
+      this.onerror?.(event);
+    });
+    this.addEventListener('close', (event) => {
+      this.onclose?.(event);
+    });
+    this.addEventListener('closing', (event) => {
+      this.onclosing?.(event);
+    });
+    this.addEventListener('open', (event) => {
+      this.onopen?.(event);
+    });
+
+    this.onbufferedamountlow = null;
+    this.onclose = null;
+    this.onclosing = null;
+    this.onerror = null;
+    this.onmessage = null;
+    this.onopen = null;
+
+    this.maxPacketLifeTime = dataChannelDict.maxPacketLifeTime ?? null;
+    this.maxRetransmits = dataChannelDict.maxRetransmits ?? null;
+    this.negotiated = dataChannelDict.negotiated ?? false;
+    this.ordered = dataChannelDict.ordered ?? true;
+  }
+
+  get id(): number {
+    return this.#dataChannel.getId();
+  }
+
+  get label(): string {
+    return this.#dataChannel.getLabel();
+  }
+
+  get protocol(): string {
+    return this.#dataChannel.getProtocol();
+  }
+
+  get bufferedAmount(): number {
+    return this.#dataChannel.bufferedAmount();
+  }
+
+  set bufferedAmountLowThreshold(threshold: number) {
+    this.#bufferedAmountLowThreshold = threshold;
+    this.#dataChannel.setBufferedAmountLowThreshold(threshold);
+  }
+
+  get bufferedAmountLowThreshold(): number {
+    return this.#bufferedAmountLowThreshold;
+  }
+
+  get readyState(): RTCDataChannelState {
+    return this.#readyState;
+  }
+
+  close(): void {
+    this.#readyState = 'closing';
+    this.dispatchEvent(new Event('closing'));
+
+    this.#dataChannel.close();
+  }
+
+  send(data: string): void;
+  send(data: Blob): void;
+  send(data: ArrayBuffer): void;
+  send(data: ArrayBufferView): void;
+  send(data: any): void {
+    // TODO: sending Blobs
+    if (typeof data === 'string') {
+      this.#dataChannel.sendMessage(data);
+    } else {
+      this.#dataChannel.sendMessageBinary(data);
+    }
+  }
+}

package/src/transport/datachannel/rtc-events.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export class PeerConnectionIceEvent extends Event implements RTCPeerConnectionIceEvent {
+  readonly candidate: RTCIceCandidate | null;
+
+  constructor(candidate: RTCIceCandidate) {
+    super('icecandidate');
+
+    this.candidate = candidate;
+  }
+}
+
+export class DataChannelEvent extends Event implements RTCDataChannelEvent {
+  readonly channel: RTCDataChannel;
+
+  constructor(channel: RTCDataChannel) {
+    super('datachannel');
+
+    this.channel = channel;
+  }
+}

package/src/transport/datachannel/rtc-ice-candidate.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+/**
+ * @see https://developer.mozilla.org/docs/Web/API/RTCIceCandidate
+ */
+export class IceCandidate implements RTCIceCandidate {
+  readonly address: string | null;
+  readonly candidate: string;
+  readonly component: RTCIceComponent | null;
+  readonly foundation: string | null;
+  readonly port: number | null;
+  readonly priority: number | null;
+  readonly protocol: RTCIceProtocol | null;
+  readonly relatedAddress: string | null;
+  readonly relatedPort: number | null;
+  readonly sdpMLineIndex: number | null;
+  readonly sdpMid: string | null;
+  readonly tcpType: RTCIceTcpCandidateType | null;
+  readonly type: RTCIceCandidateType | null;
+  readonly usernameFragment: string | null;
+
+  constructor(init: RTCIceCandidateInit) {
+    if (init.candidate == null) {
+      throw new DOMException('candidate must be specified');
+    }
+
+    this.candidate = init.candidate;
+    this.sdpMLineIndex = init.sdpMLineIndex ?? null;
+    this.sdpMid = init.sdpMid ?? null;
+    this.usernameFragment = init.usernameFragment ?? null;
+
+    this.address = null;
+    this.component = null;
+    this.foundation = null;
+    this.port = null;
+    this.priority = null;
+    this.protocol = null;
+    this.relatedAddress = null;
+    this.relatedPort = null;
+    this.tcpType = null;
+    this.type = null;
+  }
+
+  toJSON(): RTCIceCandidateInit {
+    return {
+      candidate: this.candidate,
+      sdpMLineIndex: this.sdpMLineIndex,
+      sdpMid: this.sdpMid,
+      usernameFragment: this.usernameFragment,
+    };
+  }
+}