@dxos/network-manager 0.6.14-staging.e15392e → 0.7.0

package/src/swarm/connection.ts

@@ -234,10 +234,10 @@ export class Connection {
       // TODO(nf): fix ErrorStream so instanceof works here
       if (err instanceof ConnectionResetError) {
         log.info('aborting due to transport ConnectionResetError');
-        this.abort().catch((err) => this.errors.raise(err));
+        this.abort(err).catch((err) => this.errors.raise(err));
       } else if (err instanceof ConnectivityError) {
         log.info('aborting due to transport ConnectivityError');
-        this.abort().catch((err) => this.errors.raise(err));
+        this.abort(err).catch((err) => this.errors.raise(err));
       }
 
       if (this._state !== ConnectionState.CLOSED && this._state !== ConnectionState.CLOSING) {

package/src/swarm/peer.ts

@@ -285,7 +285,8 @@ export class Peer {
           });
         },
         onClosed: (err) => {
-          log('connection closed', { topic: this.topic, peerId: this.localInfo, remoteId: this.remoteInfo, initiator });
+          const logMeta = { topic: this.topic, peerId: this.localInfo, remoteId: this.remoteInfo, initiator };
+          log('connection closed', logMeta);
 
           // Make sure none of the connections are stuck in the limiter.
           this._connectionLimiter.doneConnecting(sessionId);
@@ -310,11 +311,13 @@ export class Peer {
               this.availableToConnect = false;
               this._availableAfter = increaseInterval(this._availableAfter);
             }
+
             this._callbacks.onDisconnected();
 
             scheduleTask(
               this._connectionCtx!,
               () => {
+                log('peer became available', logMeta);
                 this.availableToConnect = true;
                 this._callbacks.onPeerAvailable();
               },

package/src/swarm/swarm.ts

@@ -189,8 +189,10 @@ export class Swarm {
       const peer = this._peers.get(swarmEvent.peerLeft.peer);
       if (peer) {
         peer.advertizing = false;
-        if (peer.connection?.state !== ConnectionState.CONNECTED) {
-          // Destroy peer only if there is no p2p-connection established
+        // Destroy peer only if there is no p2p-connection established. Otherwise, let peers go through
+        // the graceful shutdown protocol.
+        if (this._isConnectionEstablishmentInProgress(peer)) {
+          log(`destroying peer, state: ${peer.connection?.state}`);
           void this._destroyPeer(swarmEvent.peerLeft.peer, 'peer left').catch((err) => log.catch(err));
         }
       } else {
@@ -277,6 +279,7 @@ export class Swarm {
           },
           onDisconnected: async () => {
             if (this._isUnregistered(peer)) {
+              log.verbose('ignored onDisconnected for unregistered peer');
               return;
             }
             if (!peer!.advertizing) {
@@ -312,6 +315,7 @@ export class Swarm {
   }
 
   private async _destroyPeer(peerInfo: PeerInfo, reason?: string) {
+    log('destroy peer', { peerKey: peerInfo.peerKey, reason });
     const peer = this._peers.get(peerInfo);
     invariant(peer);
     this._peers.delete(peerInfo);
@@ -399,6 +403,15 @@ export class Swarm {
     await peer.closeConnection();
   }
 
+  private _isConnectionEstablishmentInProgress(peer: Peer) {
+    if (!peer.connection) {
+      return true;
+    }
+    return [ConnectionState.INITIAL, ConnectionState.CREATED, ConnectionState.CONNECTING].includes(
+      peer.connection.state,
+    );
+  }
+
   private _isUnregistered(peer?: Peer): boolean {
     return !peer || this._peers.get(peer.remoteInfo) !== peer;
   }

package/src/testing/test-builder.ts

@@ -84,6 +84,7 @@ export class TestPeer {
   ) {
     this._signalManager = this.testBuilder.createSignalManager();
     this._networkManager = this.createNetworkManager(this.transport);
+    this._networkManager.setPeerInfo({ identityKey: peerId.toHex(), peerKey: peerId.toHex() });
   }
 
   // TODO(burdon): Move to TestBuilder.

package/src/testing/test-wire-protocol.ts

@@ -33,11 +33,13 @@ export class TestWireProtocol {
 
   readonly factory = createTeleportProtocolFactory(async (teleport) => {
     log('create', { remotePeerId: teleport.remotePeerId });
+    const handleDisconnect = () => {
+      this.connections.delete(teleport.remotePeerId);
+      this.disconnected.emit(teleport.remotePeerId);
+    };
     const extension = new TestExtension({
-      onClose: async () => {
-        this.connections.delete(teleport.remotePeerId);
-        this.disconnected.emit(teleport.remotePeerId);
-      },
+      onClose: async () => handleDisconnect(),
+      onAbort: async () => handleDisconnect(),
     });
     this.connections.set(teleport.remotePeerId, extension);
     teleport.addExtension('test', extension);

package/src/tests/basic-test-suite.ts

@@ -23,7 +23,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     return;
   }
 
-  test.skip('joins swarm, sends messages, and cleanly exits', async () => {
+  test('joins swarm, sends messages, and cleanly exits', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -35,7 +35,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
   });
 
   // TODO(burdon): Test with more peers (configure and test messaging).
-  test.skip('joins swarm with star topology', async () => {
+  test('joins swarm with star topology', async () => {
     const peer1 = testBuilder.createPeer();
     onTestFinished(() => peer1.close());
     const peer2 = testBuilder.createPeer();
@@ -49,7 +49,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
   });
 
   // TODO(burdon): Fails when trying to reconnect to same topic.
-  test.skip('joins swarm multiple times', async () => {
+  test('joins swarm multiple times', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -75,7 +75,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     }
   });
 
-  test.skip('joins multiple swarms', async () => {
+  test('joins multiple swarms', async () => {
     // TODO(burdon): N peers.
     // TODO(burdon): Merge with test below.
     const peer1 = testBuilder.createPeer();
@@ -87,7 +87,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     expect(topics).to.have.length(numSwarms);
   });
 
-  test.skip('joins multiple swarms concurrently', async () => {
+  test('joins multiple swarms concurrently', async () => {
     const createSwarm = async () => {
       const topicA = PublicKey.random();
       const peer1a = testBuilder.createPeer();
@@ -109,7 +109,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     ]);
   });
 
-  test.skip('peers reconnect after and error in connection', async () => {
+  test('peers reconnect after and error in connection', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -118,20 +118,20 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
     await exchangeMessages(swarm1, swarm2);
 
-    void swarm1.protocol.connections.get(swarm2.peer.peerId)!.closeConnection(new Error('test error'));
+    const disconnectedKeys = new Set();
+    swarm1.protocol.disconnected.on((peerInfo) => disconnectedKeys.add(peerInfo.toHex()));
+    swarm2.protocol.disconnected.on((peerInfo) => disconnectedKeys.add(peerInfo.toHex()));
 
+    void swarm1.protocol.connections.get(swarm2.peer.peerId)!.closeConnection(new Error('test error'));
     // Wait until both peers are disconnected.
-    await Promise.all([
-      swarm1.protocol.disconnected.waitForCondition(() => swarm1.protocol.connections.size === 0),
-      swarm2.protocol.disconnected.waitForCondition(() => swarm2.protocol.connections.size === 0),
-    ]);
+    await expect.poll(() => disconnectedKeys.size).toEqual(2);
 
     await exchangeMessages(swarm1, swarm2);
 
     await leaveSwarm([peer1, peer2], topic);
   });
 
-  test.skip('going offline and back online', { timeout: 2_000 }, async () => {
+  test('going offline and back online', { timeout: 2_000 }, async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -180,7 +180,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
   });
 
   // TODO(mykola): Fails with large amount of peers ~10.
-  test.skip('many peers and connections', async () => {
+  test('many peers and connections', async () => {
     const numTopics = 2;
     const peersPerTopic = 3;
     const swarmsAllPeersConnected: Promise<any>[] = [];

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

@@ -17,7 +17,7 @@ describe('WebRTC transport proxy', { timeout: 10_000 }, () => {
   basicTestSuite(testBuilder);
 });
 
-describe('test with signal server', () => {
+describe.skip('test with signal server', () => {
   describe('WebRTC transport', { timeout: 10_000 }, () => {
     const testBuilder = new TestBuilder({ signalHosts: TEST_SIGNAL_HOSTS });
     basicTestSuite(testBuilder);

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

@@ -26,8 +26,18 @@ export type RtcPeerChannelFactoryOptions = {
   // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/RTCPeerConnection#iceservers
   webrtcConfig?: RTCConfiguration;
   iceProvider?: IceProvider;
+
+  /**
+   * TODO: remove after the new rtc code rollout. Used for staging interop with older version running in prod.
+   */
+  legacyInitiator?: boolean;
 };
 
+/**
+ * TODO: remove after the new rtc code rollout. Used for staging interop with older version running in prod.
+ */
+const isLegacyInteropEnabled = () => Boolean((globalThis as any)?.DEVICE_INVITE_INTEROP);
+
 /**
  * A factory for rtc Transport implementations for a particular peer.
  * Contains WebRTC connection establishment logic.
@@ -59,7 +69,9 @@ export class RtcPeerConnection {
     private readonly _factory: RtcConnectionFactory,
     private readonly _options: RtcPeerChannelFactoryOptions,
   ) {
-    this._initiator = chooseInitiatorPeer(_options.ownPeerKey, _options.remotePeerKey) === _options.ownPeerKey;
+    this._initiator = isLegacyInteropEnabled()
+      ? Boolean(this._options.legacyInitiator)
+      : chooseInitiatorPeer(_options.ownPeerKey, _options.remotePeerKey) === _options.ownPeerKey;
   }
 
   public get transportChannelCount() {
@@ -71,25 +83,27 @@ export class RtcPeerConnection {
   }
 
   public async createDataChannel(topic: string): Promise<RTCDataChannel> {
+    const channelKey = isLegacyInteropEnabled() ? 'dxos.mesh.transport' : topic;
+
     const connection = await this._openConnection();
-    if (!this._transportChannels.has(topic)) {
+    if (isLegacyInteropEnabled() ? this._transportChannels.size === 0 : !this._transportChannels.has(channelKey)) {
       if (!this._transportChannels.size) {
         this._lockAndCloseConnection();
       }
       throw new Error('Transport closed while connection was being open');
     }
     if (this._initiator) {
-      const channel = connection.createDataChannel(topic);
-      this._dataChannels.set(topic, channel);
+      const channel = connection.createDataChannel(channelKey);
+      this._dataChannels.set(channelKey, channel);
       return channel;
     } else {
-      const existingChannel = this._dataChannels.get(topic);
+      const existingChannel = this._dataChannels.get(channelKey);
       if (existingChannel) {
         return existingChannel;
       }
       log('waiting for initiator-peer to open a data channel');
       return new Promise((resolve, reject) => {
-        this._channelCreatedCallbacks.set(topic, { resolve, reject });
+        this._channelCreatedCallbacks.set(channelKey, { resolve, reject });
       });
     }
   }
@@ -327,7 +341,7 @@ export class RtcPeerConnection {
         break;
     }
 
-    log('signal processed');
+    log('signal processed', { type: data.type });
   }
 
   private async _processIceCandidate(connection: RTCPeerConnection, candidate: RTCIceCandidate) {

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

@@ -67,7 +67,13 @@ export class RtcTransportChannel extends Resource implements Transport {
       })
       .catch((err) => {
         if (this.isOpen) {
-          this.errors.raise(new ConnectivityError(`Failed to create a channel: ${err?.message ?? 'unknown reason.'}`));
+          const error =
+            err instanceof Error
+              ? err
+              : new ConnectivityError(`Failed to create a channel: ${JSON.stringify(err?.message)}`);
+          this.errors.raise(error);
+        } else {
+          log.verbose('connection establishment failed after transport was closed', { err });
         }
       })
       .finally(() => {

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

@@ -19,6 +19,7 @@ export const createRtcTransportFactory = (
         ownPeerKey: options.ownPeerKey,
         remotePeerKey: options.remotePeerKey,
         sendSignal: options.sendSignal,
+        legacyInitiator: options.initiator,
         webrtcConfig,
         iceProvider,
       });

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

@@ -88,8 +88,6 @@ export class RtcTransportService implements BridgeService {
         writeProcessedCallbacks: [],
       };
 
-      pushNewState(ConnectionState.CONNECTING);
-
       transport.connected.on(() => pushNewState(ConnectionState.CONNECTED));
 
       transport.errors.handle(async (err) => {
@@ -113,6 +111,10 @@ export class RtcTransportService implements BridgeService {
       });
 
       ready();
+
+      log('stream ready');
+
+      pushNewState(ConnectionState.CONNECTING);
     });
   }
 

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

@@ -126,12 +126,20 @@ describe('RtcTransport', () => {
 
   const createSignalSender = (options?: { duplicateSignals?: boolean }) => {
     const deliverSignal = (channel: RtcTransportChannel, signal: any) => {
+      // There's a race in libdatachannel between ice candidate gathering, connectivity checks and dtls connection
+      // establishment, which seems to be 100% reproducible when there are only host candidates.
+      // When there are no iceServers the first pair attempt starts too fast and gets interrupted by an arriving
+      // remote candidate. Dtls has a retry backoff which starts with 1 second delay, so all tests finish in 1s+.
+      if (signal.payload.data.type === 'candidate' && !isInitiator) {
+        return;
+      }
       void channel.onSignal(signal);
       if (options?.duplicateSignals) {
         void channel.onSignal(signal);
       }
     };
     let remoteChannel: RtcTransportChannel | undefined;
+    let isInitiator = false;
     const signalBuffer: any[] = [];
     const sendSignal = async (signal: any) => {
       await sleep(10);
@@ -141,7 +149,8 @@ describe('RtcTransport', () => {
         signalBuffer.push(signal);
       }
     };
-    const onChannelCreated = (channel: RtcTransportChannel): void => {
+    const onChannelCreated = (channel: RtcTransportChannel, initiator: boolean) => {
+      isInitiator = initiator;
       remoteChannel = channel;
       for (const signal of signalBuffer) {
         deliverSignal(channel, signal);
@@ -152,20 +161,23 @@ describe('RtcTransport', () => {
 
   const createConnection = async (
     optionOverrides?: Partial<TransportOptions>,
-    onChannelCreated: (channel: RtcTransportChannel) => void = () => {},
+    onChannelCreated: (channel: RtcTransportChannel, initiator: boolean) => void = () => {},
   ): Promise<TestSetup> => {
+    const remotePeerKey = optionOverrides?.remotePeerKey ?? PublicKey.random().toHex();
+    const ownPeerKey = optionOverrides?.ownPeerKey ?? PublicKey.random().toHex();
+    const initiator = chooseInitiatorPeer(remotePeerKey, ownPeerKey) === ownPeerKey;
     const stream = new TestStream();
     const options: TransportOptions = {
-      initiator: false,
+      initiator,
       stream,
       sendSignal: async () => {},
-      remotePeerKey: PublicKey.random().toHex(),
-      ownPeerKey: PublicKey.random().toHex(),
+      remotePeerKey,
+      ownPeerKey,
       topic: PublicKey.random().toHex(),
       ...optionOverrides,
     };
     const connection = new RtcPeerConnection(connectionFactory, options);
-    return { options, connection, stream, onChannelOpen: onChannelCreated };
+    return { options, connection, stream, onChannelOpen: (channel) => onChannelCreated(channel, initiator) };
   };
 
   const chooseInitiator = (peer1: TestSetup, peer2: TestSetup) => {