@dxos/network-manager 0.1.58-main.75cbd70 → 0.1.58-main.7858df5

package/src/tests/tcp-transport.test.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { randomBytes } from 'crypto';
+
+import { PublicKey } from '@dxos/keys';
+import { test } from '@dxos/test';
+import { range } from '@dxos/util';
+
+import { basicTestSuite } from './basic-test-suite';
+import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
+import { TestBuilder } from '../testing';
+import { FullyConnectedTopology } from '../topology';
+import { TransportKind } from '../transport';
+
+describe('Tcp transport', () => {
+  const testBuilder = new TestBuilder({
+    transport: TransportKind.TCP,
+  });
+
+  basicTestSuite(testBuilder);
+
+  test
+    .skip('load', async () => {
+      const NUM_PAIRS = 100;
+      const NUM_ROUNDS = 10_000;
+      const PACKET_SIZE = 1_000;
+
+      const pairs = await Promise.all(
+        range(NUM_PAIRS).map(async () => {
+          const peer1 = testBuilder.createPeer();
+          const peer2 = testBuilder.createPeer();
+          await openAndCloseAfterTest([peer1, peer2]);
+
+          const topic = PublicKey.random();
+          const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
+
+          return {
+            peer1,
+            peer2,
+            topic,
+            swarm1,
+            swarm2,
+          };
+        }),
+      );
+
+      const message = randomBytes(PACKET_SIZE / 2).toString('hex');
+
+      for (let i = 0; i < NUM_ROUNDS; i++) {
+        // console.log(`Round ${i}/${NUM_ROUNDS}`);
+        await Promise.all(
+          pairs.map(async ({ swarm1, swarm2 }) => {
+            await exchangeMessages(swarm1, swarm2, message);
+          }),
+        );
+      }
+
+      await Promise.all(
+        pairs.map(async ({ peer1, peer2, topic }) => {
+          await leaveSwarm([peer1, peer2], topic);
+        }),
+      );
+    })
+    .timeout(1_000_000);
+});

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

@@ -4,8 +4,8 @@
 
 import { describe } from '@dxos/test';
 
-import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
 import { basicTestSuite } from './basic-test-suite';
+import { TEST_SIGNAL_HOSTS, TestBuilder } from '../testing';
 
 describe('WebRTC transport', () => {
   const testBuilder = new TestBuilder();

package/src/topology/star-topology.ts

@@ -11,10 +11,7 @@ import { SwarmController, Topology } from './topology';
 export class StarTopology implements Topology {
   private _controller?: SwarmController;
 
-  // prettier-ignore
-  constructor(
-    private readonly _centralPeer: PublicKey
-  ) {}
+  constructor(private readonly _centralPeer: PublicKey) {}
 
   toString() {
     return `StarTopology(${this._centralPeer.truncate()})`;

package/src/transport/simplepeer-transport-proxy.ts

@@ -11,6 +11,13 @@ import { ErrorStream } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
+import {
+  ConnectionResetError,
+  TimeoutError,
+  ProtocolError,
+  ConnectivityError,
+  UnknownProtocolError,
+} from '@dxos/protocols';
 import { ConnectionState, BridgeEvent, BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { arrayToBuffer } from '@dxos/util';
@@ -36,13 +43,10 @@ export class SimplePeerTransportProxy implements Transport {
   private _closed = false;
   private _serviceStream!: Stream<BridgeEvent>;
 
-  // prettier-ignore
-  constructor(
-    private readonly _params: SimplePeerTransportProxyParams
-  ) {
+  constructor(private readonly _params: SimplePeerTransportProxyParams) {
     this._serviceStream = this._params.bridgeService.open({
       proxyId: this._proxyId,
-      initiator: this._params.initiator
+      initiator: this._params.initiator,
     });
 
     this._serviceStream.waitUntilReady().then(
@@ -58,27 +62,31 @@ export class SimplePeerTransportProxy implements Transport {
           }
         });
 
-        this._params.stream.pipe(new Writable({
-          write: (chunk, _, callback) => {
-            this._params.bridgeService.sendData({
-              proxyId: this._proxyId,
-              payload: chunk
-            }).then(
-              () => callback(),
-              (err: any) => {
-                log.catch(err);
-              }
-            );
-          },
-        }));
+        this._params.stream.pipe(
+          new Writable({
+            write: (chunk, _, callback) => {
+              this._params.bridgeService
+                .sendData({
+                  proxyId: this._proxyId,
+                  payload: chunk,
+                })
+                .then(
+                  () => callback(),
+                  (err: any) => {
+                    log.catch(err);
+                  },
+                );
+            },
+          }),
+        );
       },
-      (error) => log.catch(error)
+      (error) => log.catch(error),
     );
   }
 
   private async _handleConnection(connectionEvent: BridgeEvent.ConnectionEvent): Promise<void> {
     if (connectionEvent.error) {
-      this.errors.raise(new Error(connectionEvent.error));
+      this.errors.raise(decodeError(connectionEvent.error));
     }
 
     switch (connectionEvent.state) {
@@ -108,7 +116,7 @@ export class SimplePeerTransportProxy implements Transport {
         proxyId: this._proxyId,
         signal,
       })
-      .catch((err) => this.errors.raise(err));
+      .catch((err) => this.errors.raise(decodeError(err)));
   }
 
   // TODO(burdon): Move open from constructor.
@@ -173,3 +181,22 @@ export class SimplePeerTransportProxyFactory implements TransportFactory {
     return transport;
   }
 }
+
+// TODO(nf): fix so Errors crossing RPC boundary preserve class
+const decodeError = (err: Error | string) => {
+  const message = typeof err === 'string' ? err : err.message;
+
+  if (message.includes('CONNECTION_RESET')) {
+    return new ConnectionResetError(message);
+  } else if (message.includes('TIMEOUT')) {
+    return new TimeoutError(message);
+  } else if (message.includes('PROTOCOL_ERROR')) {
+    return new ProtocolError(message);
+  } else if (message.includes('CONNECTIVITY_ERROR')) {
+    return new ConnectivityError(message);
+  } else if (message.includes('UNKNOWN_PROTOCOL_ERROR')) {
+    return new UnknownProtocolError(message);
+  } else {
+    return typeof err === 'string' ? new Error(err) : err;
+  }
+};

package/src/transport/simplepeer-transport-service.ts

@@ -30,10 +30,7 @@ type TransportState = {
 export class SimplePeerTransportService implements BridgeService {
   private readonly transports = new ComplexMap<PublicKey, TransportState>(PublicKey.hash);
 
-  // prettier-ignore
-  constructor(
-    private readonly _webrtcConfig?: any
-  ) { }
+  constructor(private readonly _webrtcConfig?: any) {}
 
   open(request: ConnectionRequest): Stream<BridgeEvent> {
     const rpcStream: Stream<BridgeEvent> = new Stream(({ ready, next, close }) => {

package/src/transport/simplepeer-transport.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-fallthrough */
 //
 // Copyright 2020 DXOS.org
 //
@@ -9,7 +10,7 @@ import { Event } from '@dxos/async';
 import { ErrorStream, raise } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { trace } from '@dxos/protocols';
+import { ConnectionResetError, ConnectivityError, ProtocolError, UnknownProtocolError, trace } from '@dxos/protocols';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 import { Transport, TransportFactory } from './transport';
@@ -63,11 +64,42 @@ export class SimplePeerTransport implements Transport {
     });
 
     this._peer.on('error', async (err) => {
-      this.errors.raise(err);
+      // https://developer.mozilla.org/en-US/docs/Web/API/RTCError
+      if (typeof RTCError !== 'undefined' && err instanceof RTCError) {
+        // Sent when connection is unexpectedly severed
+        if (err.errorDetail === 'sctp-failure') {
+          this.errors.raise(new ConnectionResetError('sctp-failure from RTCError', err));
+        } else {
+          this.errors.raise(new UnknownProtocolError('unknown RTCError', err));
+        }
+        // catch more generic simple-peer errors: https://github.com/feross/simple-peer/blob/master/README.md#error-codes
+      } else if ('code' in err) {
+        log.info('simple-peer error', err);
+        switch (err.code) {
+          case 'ERR_WEBRTC_SUPPORT':
+            this.errors.raise(new ProtocolError('WebRTC not supported', err));
+          case 'ERR_ICE_CONNECTION_FAILURE':
+          case 'ERR_DATA_CHANNEL':
+          case 'ERR_CONNECTION_FAILURE':
+          case 'ERR_SIGNALING':
+            this.errors.raise(new ConnectivityError('unknown communication failure', err));
+          case 'ERR_CREATE_OFFER':
+          case 'ERR_CREATE_ANSWER':
+          case 'ERR_SET_LOCAL_DESCRIPTION':
+          case 'ERR_SET_REMOTE_DESCRIPTION':
+          case 'ERR_ADD_ICE_CANDIDATE':
+            this.errors.raise(new UnknownProtocolError('unknown simple-peer library failure', err));
+          default:
+            this.errors.raise(new Error('unknown simple-peer error'));
+        }
+      } else {
+        log.info('unknown peer connection error', err);
+        this.errors.raise(err);
+      }
 
       // Try to gather additional information about the connection.
       try {
-        if (typeof (this._peer as any)?._pc.getStats === 'function') {
+        if (typeof (this._peer as any)?._pc?.getStats === 'function') {
           (this._peer as any)._pc.getStats().then((stats: any) => {
             log.warn('report after webrtc error', {
               config: this.params.webrtcConfig,
@@ -75,7 +107,9 @@ export class SimplePeerTransport implements Transport {
             });
           });
         }
-      } catch {} // TODO(burdon): Ignored?
+      } catch (err) {
+        log.catch(err);
+      }
 
       await this.destroy();
     });

package/src/transport/tcp-transport.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { AddressInfo, Socket, type Server } from 'node:net';
+
+import { Event } from '@dxos/async';
+import { ErrorStream } from '@dxos/debug';
+import { log } from '@dxos/log';
+import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
+
+import { Transport, TransportFactory, TransportOptions } from './transport';
+
+export const TcpTransportFactory: TransportFactory = {
+  createTransport: (params) => new TcpTransport(params),
+};
+
+/**
+ * Fake transport.
+ */
+export class TcpTransport implements Transport {
+  private _server?: Server = undefined;
+  private _socket?: Socket = undefined;
+
+  public readonly closed = new Event<void>();
+  public readonly connected = new Event<void>();
+  public readonly errors = new ErrorStream();
+
+  private _destroyed = false;
+
+  private _connected = false;
+
+  constructor(private readonly options: TransportOptions) {
+    log('creating');
+
+    // Initiator will send a signal, the receiver will receive the unique ID and connect the streams.
+    if (this.options.initiator) {
+      // prettier-ignore
+      setTimeout(async () => {
+        const { Server } = await import('node:net');
+        this._server = new Server(socket => {
+          log('new connection');
+          if (this._connected) {
+            socket.destroy();
+          }
+          this._handleSocket(socket);
+        });
+
+        this._server.on('listening', () => {
+          const { port } = this._server!.address() as AddressInfo;
+          log('listening', { port });
+          void this.options.sendSignal({
+            payload: { port }
+          }).catch(err => {
+            if (!this._destroyed) {
+              this.errors.raise(err);
+            }
+          });
+
+        });
+
+        this._server.on('error', err => {
+          this.errors.raise(err);
+        });
+
+        this._server.listen(0);
+      });
+    }
+  }
+
+  async destroy(): Promise<void> {
+    log('closing');
+    this._socket?.destroy();
+    this._server?.close();
+
+    this._destroyed = true;
+  }
+
+  signal({ payload }: Signal) {
+    log('received signal', { payload });
+    if (this.options.initiator || this._connected) {
+      return;
+    }
+
+    const socket = new Socket();
+    this._handleSocket(socket);
+    socket.connect({ port: payload.port, host: 'localhost' });
+  }
+
+  private _handleSocket(socket: Socket) {
+    log('handling socket', { remotePort: socket.remotePort, localPort: socket.localPort });
+    this._socket = socket;
+    this.connected.emit();
+    this.options.stream.pipe(this._socket!).pipe(this.options.stream);
+
+    this._socket.on('connect', () => {
+      log('connected to', { port: this._socket?.remotePort });
+      this._connected = true;
+    });
+    this._socket.on('error', (err) => {
+      this.errors.raise(err);
+    });
+    this._socket.on('close', () => {
+      this.closed.emit();
+    });
+  }
+}

package/src/transport/transport.ts

@@ -11,6 +11,7 @@ export enum TransportKind {
   LIBDATACHANNEL = 'LIBDATACHANNEL',
   SIMPLE_PEER_PROXY = 'SIMPLE_PEER_PROXY',
   MEMORY = 'MEMORY',
+  TCP = 'TCP',
 }
 
 /**