@dxos/network-manager 0.1.58-next.3349da8 → 0.1.58-next.ffb4cc4

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

@@ -8,16 +8,16 @@ import { Event } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { Context } from '@dxos/context';
 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/errors';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
+} 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';
@@ -43,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(
@@ -65,21 +62,25 @@ 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),
     );
   }
 
@@ -185,15 +186,15 @@ export class SimplePeerTransportProxyFactory implements TransportFactory {
 const decodeError = (err: Error | string) => {
   const message = typeof err === 'string' ? err : err.message;
 
-  if (message.includes('ConnectionResetError')) {
+  if (message.includes('CONNECTION_RESET')) {
     return new ConnectionResetError(message);
-  } else if (message.includes('TimeoutError')) {
+  } else if (message.includes('TIMEOUT')) {
     return new TimeoutError(message);
-  } else if (message.includes('ProtocolError')) {
+  } else if (message.includes('PROTOCOL_ERROR')) {
     return new ProtocolError(message);
-  } else if (message.includes('ConnectivityError')) {
+  } else if (message.includes('CONNECTIVITY_ERROR')) {
     return new ConnectivityError(message);
-  } else if (message.includes('UnknownProtocolError')) {
+  } 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

@@ -25,15 +25,13 @@ type TransportState = {
   transport: SimplePeerTransport;
   stream: Duplex;
   writeCallbacks: (() => void)[];
+  state: 'OPEN' | 'CLOSED';
 };
 
 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 }) => {
@@ -99,6 +97,7 @@ export class SimplePeerTransportService implements BridgeService {
         transport,
         stream: duplex,
         writeCallbacks: [],
+        state: 'OPEN',
       };
 
       ready();
@@ -115,6 +114,9 @@ export class SimplePeerTransportService implements BridgeService {
   }
 
   async sendData({ proxyId, payload }: DataRequest): Promise<void> {
+    if (this.transports.get(proxyId)?.state !== 'OPEN') {
+      log.debug('transport is closed');
+    }
     invariant(this.transports.has(proxyId));
     const state = this.transports.get(proxyId)!;
     const bufferHasSpace = state.stream.push(payload);
@@ -128,7 +130,9 @@ export class SimplePeerTransportService implements BridgeService {
   async close({ proxyId }: CloseRequest) {
     await this.transports.get(proxyId)?.transport.destroy();
     await this.transports.get(proxyId)?.stream.end();
-    this.transports.delete(proxyId);
+    if (this.transports.get(proxyId)) {
+      this.transports.get(proxyId)!.state = 'CLOSED';
+    }
     log('Closed.');
   }
 }

package/src/transport/simplepeer-transport.ts

@@ -8,10 +8,9 @@ import invariant from 'tiny-invariant';
 
 import { Event } from '@dxos/async';
 import { ErrorStream, raise } from '@dxos/debug';
-import { ConnectionResetError, ConnectivityError, ProtocolError, UnknownProtocolError } from '@dxos/errors';
 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';
@@ -73,36 +72,39 @@ export class SimplePeerTransport implements Transport {
         } else {
           this.errors.raise(new UnknownProtocolError('unknown RTCError', err));
         }
-
-        // Safari specific? are all errors of code: "DATA_CHANNEL_ERROR" connection aborts?
-      } else if (err.name === 'InvalidStateError') {
-        this.errors.raise(new ConnectionResetError('safari WebRTC error', 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));
+            break;
           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));
+            break;
+          // errors due to library issues or improper API usage
           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));
+            break;
           default:
             this.errors.raise(new Error('unknown simple-peer error'));
+            break;
         }
       } 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,

package/src/transport/tcp-transport.browser.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { ErrorStream } from '@dxos/debug';
+
+import { Transport, TransportFactory } from './transport';
+
+// NOTE: Browser stub.
+
+export const TcpTransportFactory: TransportFactory = {
+  createTransport: () => new TcpTransport(),
+};
+
+export class TcpTransport implements Transport {
+  public readonly closed = new Event<void>();
+  public readonly connected = new Event<void>();
+  public readonly errors = new ErrorStream();
+
+  async destroy() {
+    throw new Error('Method not implemented.');
+  }
+
+  signal() {
+    throw new Error('Method not implemented.');
+  }
+}