@dxos/network-manager 2.33.9-dev.7d11f506 → 2.33.9-dev.9bbef4e2

package/src/signal/signal-manager-impl.ts

@@ -0,0 +1,166 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import debug from 'debug';
+import assert from 'node:assert';
+
+import { Event, synchronized } from '@dxos/async';
+import { PublicKey } from '@dxos/protocols';
+import { ComplexMap } from '@dxos/util';
+
+import { SwarmEvent } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
+import { SignalApi } from './signal-api';
+import { SignalClient } from './signal-client';
+import { SignalManager } from './signal-manager';
+
+const log = debug('dxos:network-manager:signal-manager-impl');
+
+export class SignalManagerImpl implements SignalManager {
+  private readonly _servers = new Map<string, SignalClient>();
+
+  /** Topics joined: topic => peerId */
+  private readonly _topicsJoined = new ComplexMap<PublicKey, PublicKey>(topic => topic.toHex());
+  /** host => topic => peerId */
+  private readonly _topicsJoinedPerSignal = new Map<string, ComplexMap<PublicKey, PublicKey>>();
+
+  private _reconciling?: boolean = false;
+  private _reconcileTimeoutId?: NodeJS.Timeout;
+  private _destroyed = false;
+
+  readonly statusChanged = new Event<SignalApi.Status[]>();
+  readonly commandTrace = new Event<SignalApi.CommandTrace>();
+  readonly swarmEvent = new Event<[topic: PublicKey, swarmEvent: SwarmEvent]>();
+  readonly onMessage = new Event<SignalMessage>();
+
+  constructor (
+    private readonly _hosts: string[]
+  ) {
+    log(`Created WebsocketSignalManager with signal servers: ${_hosts}`);
+    assert(_hosts.length === 1, 'Only a single signaling server connection is supported');
+    for (const host of this._hosts) {
+      const server = new SignalClient(
+        host,
+        async msg => this.onMessage.emit(msg)
+      );
+      // TODO(mykola): Add subscription group
+      server.swarmEvent.on(data => this.swarmEvent.emit(data));
+      server.statusChanged.on(() => this.statusChanged.emit(this.getStatus()));
+
+      this._servers.set(host, server);
+      server.commandTrace.on(trace => this.commandTrace.emit(trace));
+      this._topicsJoinedPerSignal.set(host, new ComplexMap(x => x.toHex()));
+    }
+  }
+
+  getStatus (): SignalApi.Status[] {
+    return Array.from(this._servers.values()).map(server => server.getStatus());
+  }
+
+  join (topic: PublicKey, peerId: PublicKey) {
+    assert(!this._topicsJoined.has(topic), `Topic ${topic} is already joined`);
+    log(`Join ${topic} ${peerId}`);
+    this._topicsJoined.set(topic, peerId);
+    this._scheduleReconcile();
+  }
+
+  leave (topic: PublicKey, peerId: PublicKey) {
+    assert(!!this._topicsJoined.has(topic), `Topic ${topic} was not joined`);
+    log(`Leave ${topic} ${peerId}`);
+    this._topicsJoined.delete(topic);
+    this._scheduleReconcile();
+  }
+
+  private _scheduleReconcile () {
+    if (this._destroyed) {
+      return;
+    }
+
+    if (!this._reconciling) {
+      this._reconciling = true;
+      this._reconcileJoinedTopics().then(
+        () => {
+          this._reconciling = false;
+        },
+        err => {
+          this._reconciling = false;
+          log(`Error while reconciling: ${err}`);
+          this._reconcileLater();
+        }
+      );
+    } else {
+      this._reconcileLater();
+    }
+  }
+
+  private _reconcileLater () {
+    if (this._destroyed) {
+      return;
+    }
+
+    if (!this._reconcileTimeoutId) {
+      this._reconcileTimeoutId = setTimeout(async () => this._scheduleReconcile(), 3000);
+    }
+  }
+
+  @synchronized
+  private async _reconcileJoinedTopics () {
+    // TODO(mykola): Handle reconnects to SS. Maybe move map of joined topics to signal-client.
+    log('Reconciling..');
+    for (const [host, server] of this._servers) {
+      const actualJoinedTopics = this._topicsJoinedPerSignal.get(host)!;
+
+      // Leave swarms
+      for (const [topic, actualPeerId] of actualJoinedTopics) {
+        try {
+          const desiredPeerId = this._topicsJoined.get(topic);
+          if (!desiredPeerId || !desiredPeerId.equals(actualPeerId)) {
+            await server.leave(topic, actualPeerId);
+            actualJoinedTopics.delete(topic);
+          }
+        } catch (err) {
+          log(`Error leaving swarm: ${err}`);
+          this._scheduleReconcile();
+        }
+      }
+
+      // Join swarms
+      for (const [topic, desiredPeerId] of this._topicsJoined) {
+        try {
+          const actualPeerId = actualJoinedTopics.get(topic);
+          if (!actualPeerId) {
+            await server.join(topic, desiredPeerId);
+            actualJoinedTopics.set(topic, desiredPeerId);
+          } else {
+            if (!actualPeerId.equals(desiredPeerId)) {
+              throw new Error(`Joined with peerId different from desired: ${JSON.stringify({ actualPeerId, desiredPeerId })}`);
+            }
+          }
+        } catch (err) {
+          log(`Error joining swarm: ${err}`);
+          this._scheduleReconcile();
+        }
+      }
+    }
+    log('Done reconciling..');
+    this._reconciling = false;
+  }
+
+  async message (msg: SignalMessage) {
+    log(`Signal ${msg.remoteId}`);
+    for (const server of this._servers.values()) {
+      server.signal(msg).catch(err => {
+        log(`Error signaling: ${err}`);
+      });
+    }
+  }
+
+  async destroy () {
+    this._destroyed = true;
+    if (this._reconcileTimeoutId) {
+      clearTimeout(this._reconcileTimeoutId);
+    }
+    await Promise.all(Array.from(this._servers.values()).map(server => server.close()));
+  }
+}

package/src/signal/signal-manager.ts

@@ -5,18 +5,14 @@
 import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
 
-import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SwarmEvent } from '../proto/gen/dxos/mesh/signal';
+import { Answer, SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { SignalApi } from './signal-api';
 
 /**
  * Signal peer discovery interface.
  */
 export interface SignalConnection {
-  /**
-   * Find peers (triggers async event).
-   */
-  lookup (topic: PublicKey): void
-
   /**
    * Join topic on signal network, to be discoverable by other peers.
    */
@@ -35,20 +31,24 @@ export interface SignalMessaging {
   /**
    * Offer/answer RPC.
    */
-  offer (msg: Message): Promise<Answer>
+  offer (msg: SignalMessage): Promise<Answer>
 
   /**
-   * Send message to peer.
+   * Reliably send a signal to a peer.
    */
-  signal (msg: Message): Promise<void>
+  signal (msg: SignalMessage): Promise<void>
 }
 
-export interface SignalManager extends SignalConnection, SignalMessaging {
+export interface SignalManager extends SignalConnection {
   statusChanged: Event<SignalApi.Status[]>
   commandTrace: Event<SignalApi.CommandTrace>
-  peerCandidatesChanged: Event<[topic: PublicKey, candidates: PublicKey[]]>
-  onSignal: Event<Message>
+  swarmEvent: Event<[topic: PublicKey, swarmEvent: SwarmEvent]>
+  onMessage: Event<SignalMessage>
 
   getStatus (): SignalApi.Status[]
   destroy(): Promise<void>
+  /**
+   * Send message to peer.
+   */
+  message (msg: SignalMessage): Promise<void>
 }

package/src/signal/signal-rpc-client.test.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2022 DXOS.org
+//
+import { expect } from 'earljs';
+
+import { Any } from '@dxos/codec-protobuf';
+import { PublicKey } from '@dxos/protocols';
+import { createTestBroker, TestBroker } from '@dxos/signal';
+
+import { Message, SwarmEvent } from '../proto/gen/dxos/mesh/signal';
+import { SignalRPCClient } from './signal-rpc-client';
+
+describe('SignalRPCClient', () => {
+  let broker: TestBroker;
+
+  before(async () => {
+    broker = await createTestBroker();
+  });
+
+  after(() => {
+    broker.stop();
+  });
+
+  const setup = async () => {
+    const client = new SignalRPCClient(broker.url());
+    return client;
+  };
+
+  it('signal between 2 peers', async () => {
+    const client1 = await setup();
+    const client2 = await setup();
+
+    const peerId1 = PublicKey.random();
+    const peerId2 = PublicKey.random();
+
+    const stream1 = await client1.receiveMessages(peerId1);
+    const message: Any = {
+      'type_url': 'test',
+      value: Uint8Array.from([1, 2, 3])
+    };
+
+    await client2.sendMessage(peerId2, peerId1, message);
+
+    const received: Message = await new Promise(resolve => {
+      stream1.subscribe(message => {
+        resolve(message);
+      }, (error) => {
+        if (error) {
+          console.log(error);
+          throw error;
+        }
+      });
+    });
+    expect(received.author).toEqual(peerId2.asUint8Array());
+    stream1.close();
+  }).timeout(10000);
+
+  it('join', async () => {
+    const client1 = await setup();
+    const client2 = await setup();
+
+    const peerId1 = PublicKey.random();
+    const peerId2 = PublicKey.random();
+    const topic = PublicKey.random();
+
+    const stream1 = await client1.join(topic, peerId1);
+    const promise = new Promise<SwarmEvent>(resolve => {
+      stream1.subscribe((event: SwarmEvent) => {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+        if (peerId2.equals(event.peerAvailable?.peer!)) {
+          resolve(event);
+        }
+      }, (error) => {
+        if (error) {
+          console.log(error);
+          throw error;
+        }
+      });
+    });
+    const stream2 = await client2.join(topic, peerId2);
+
+    expect((await promise).peerAvailable?.peer).toEqual(peerId2.asBuffer());
+    stream1.close();
+    stream2.close();
+  }).timeout(10000);
+});

package/src/signal/signal-rpc-client.ts

@@ -0,0 +1,121 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import debug from 'debug';
+import WebSocket from 'isomorphic-ws';
+
+import { Trigger, Event } from '@dxos/async';
+import { Any, Stream } from '@dxos/codec-protobuf';
+import { PublicKey } from '@dxos/protocols';
+import { createBundledRpcClient, ProtoRpcClient } from '@dxos/rpc';
+
+import { schema } from '../proto/gen';
+import { Message, Signal } from '../proto/gen/dxos/mesh/signal';
+interface Services {
+  Signal: Signal
+}
+
+const log = debug('dxos:network-manager:signal-rpc-client');
+
+export class SignalRPCClient {
+  private readonly _socket: WebSocket
+  private readonly _rpc: ProtoRpcClient<Services>
+  private readonly _connectTrigger = new Trigger();
+
+  readonly connected = new Event();
+  readonly disconnected = new Event();
+  readonly error = new Event<Error>();
+
+  constructor (
+    private readonly _url: string
+  ) {
+    this._socket = new WebSocket(this._url);
+    this._socket.onopen = async () => {
+      try {
+        await this._rpc.open();
+        log(`RPC open ${this._url}`);
+        this.connected.emit();
+        this._connectTrigger.wake();
+      } catch (err: any) {
+        this.error.emit(err);
+      }
+    };
+
+    this._socket.onclose = async () => {
+      log(`Disconnected ${this._url}`);
+      this.disconnected.emit();
+      try {
+        await this._rpc.close();
+      } catch (err: any) {
+        this.error.emit(err);
+      }
+    };
+
+    this._socket.onerror = (e: WebSocket.ErrorEvent) => {
+      log(`Signal socket error ${this._url} ${e.message}`);
+      this.error.emit(e.error ?? new Error(e.message));
+    };
+
+    this._rpc = createBundledRpcClient(
+      {
+        Signal: schema.getService('dxos.mesh.signal.Signal')
+      },
+      {
+        noHandshake: true,
+        port: {
+          send: msg => {
+            this._socket.send(msg);
+          },
+          subscribe: cb => {
+            this._socket.onmessage = async (msg: WebSocket.MessageEvent) => {
+              if (typeof Blob !== 'undefined' && msg.data instanceof Blob) {
+                cb(Buffer.from(await msg.data.arrayBuffer()));
+              } else {
+                cb(msg.data as any);
+              }
+            };
+          }
+        }
+      }
+    );
+  }
+
+  async join (topic: PublicKey, peerId: PublicKey) {
+    log('join', topic, peerId);
+    await this._connectTrigger.wait();
+    const swarmStream = this._rpc.rpc.Signal.join({
+      swarm: topic.asUint8Array(),
+      peer: peerId.asUint8Array()
+    });
+    await swarmStream.waitUntilReady();
+    return swarmStream;
+  }
+
+  async receiveMessages (peerId: PublicKey): Promise<Stream<Message>> {
+    await this._connectTrigger.wait();
+    const messageStream = this._rpc.rpc.Signal.receiveMessages({
+      peer: peerId.asUint8Array()
+    });
+    await messageStream.waitUntilReady();
+    return messageStream;
+  }
+
+  async sendMessage (author: PublicKey, recipient: PublicKey, message: Any) {
+    log('sendMessage', author, recipient, message);
+    await this._connectTrigger.wait();
+    await this._rpc.rpc.Signal.sendMessage({
+      author: author.asUint8Array(),
+      recipient: recipient.asUint8Array(),
+      payload: message
+    });
+  }
+
+  async close () {
+    try {
+      await this._rpc.close();
+    } finally {
+      this._socket.close();
+    }
+  }
+}

package/src/swarm/connection.ts

@@ -2,15 +2,15 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event, synchronized } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';
 
-import { Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessage } from '../proto/gen/dxos/mesh/signalMessage';
 import { Transport, TransportFactory } from '../transport';
 
 const log = debug('dxos:network-manager:swarm:connection');
@@ -51,7 +51,7 @@ export enum ConnectionState {
 export class Connection {
   private _state: ConnectionState = ConnectionState.INITIAL;
   private _transport: Transport | undefined;
-  private _bufferedSignals: Message[] = [];
+  private _bufferedSignals: SignalMessage[] = [];
 
   readonly stateChanged = new Event<ConnectionState>();
   readonly errors = new ErrorStream();
@@ -62,7 +62,7 @@ export class Connection {
     public readonly remoteId: PublicKey,
     public readonly sessionId: PublicKey,
     public readonly initiator: boolean,
-    private readonly _sendSignal: (msg: Message) => Promise<void>,
+    private readonly _sendSignal: (msg: SignalMessage) => Promise<void>,
     private readonly _protocol: Protocol,
     private readonly _transportFactory: TransportFactory
   ) {}
@@ -116,16 +116,13 @@ export class Connection {
     this._bufferedSignals = [];
   }
 
-  async signal (msg: Message) {
+  async signal (msg: SignalMessage) {
     assert(msg.sessionId);
     if (!msg.sessionId.equals(this.sessionId)) {
       log('Dropping signal for incorrect session id.');
       return;
     }
-    assert(msg.data);
-    if (msg.data.offer && this._state === ConnectionState.INITIATING_CONNECTION) {
-      throw new Error('Invalid state: Cannot send offer to an initiating peer.');
-    }
+    assert(msg.data.signal);
     assert(msg.id?.equals(this.remoteId));
     assert(msg.remoteId?.equals(this.ownId));