@dxos/network-manager 2.33.9-dev.43c233c0 → 2.33.9-dev.46220a19

package/src/signal/websocket-rpc.ts

@@ -1,208 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-import debug from 'debug';
-import WebSocket from 'isomorphic-ws';
-import nanomessagerpc from 'nanomessage-rpc';
-import assert from 'node:assert';
-import { promisify } from 'util';
-
-import { Event, Trigger, sleep } from '@dxos/async';
-
-import { SignalApi } from './signal-api';
-
-const log = debug('dxos:network-manager:websocket-rpc');
-
-const RPC_TIMEOUT = 3_000;
-
-/**
- * A websocket connection paired with nanomessage-rpc endpoint.
- *
- * Provides lifecycle events and command trace.
- *
- * Does not automatically reconnect, if the connection is dropped client must recreate the class instance.
- */
-export class WebsocketRpc {
-  private readonly _connectTrigger = new Trigger();
-  private readonly _socket: WebSocket;
-  private readonly _rpc: any;
-  private _messageId = Date.now();
-
-  readonly commandTrace = new Event<SignalApi.CommandTrace>();
-  readonly connected = new Event();
-  readonly disconnected = new Event();
-  readonly error = new Event<Error>();
-
-  /**
-   * @param _host Signal server websocket URL.
-   */
-  constructor (
-    private readonly _host: string
-  ) {
-    this._socket = new WebSocket(this._host);
-    this._socket.onopen = async () => {
-      log(`Websocket connected ${this._host}`);
-      this._connectTrigger.wake();
-      try {
-        await this._rpc.open();
-        log(`RPC open ${this._host}`);
-        this.connected.emit();
-      } catch (err: any) {
-        this.error.emit(err);
-      }
-    };
-
-    this._socket.onclose = async () => {
-      log(`Disconnected ${this._host}`);
-      this.disconnected.emit();
-      try {
-        await this._rpc.close();
-      } catch (err: any) {
-        this.error.emit(err);
-      }
-    };
-
-    this._socket.onerror = e => {
-      log(`Signal socket error ${this._host} ${e.message}`);
-      this.error.emit(e.error ?? new Error(e.message));
-    };
-
-    this._rpc = nanomessagerpc({
-      send: async (data: Uint8Array) => {
-        await this._connectTrigger.wait();
-        assert(this._socket, 'No socket');
-        await promisify(this._socket.send.bind(this._socket) as any)(data);
-      },
-      subscribe: (next: (data: any) => void) => {
-        void this._connectTrigger.wait().then(() => {
-          assert(this._socket, 'No socket');
-          this._socket.onmessage = async e => {
-            try {
-              // `e.data` is Buffer in node, and Blob in chrome.
-              let data: Buffer;
-              if (Object.getPrototypeOf(e.data).constructor.name === 'Blob') {
-                data = Buffer.from(await (e.data as any).arrayBuffer());
-              } else {
-                data = e.data as any;
-              }
-              next(data);
-            } catch (err: any) {
-              this.error.emit(err);
-            }
-          };
-        });
-
-        return () => {
-          if (this._socket) {
-            this._socket.onmessage = () => {};
-          }
-        };
-      }
-    });
-    this._rpc.on('error', (error: Error) => this.error.emit(error));
-  }
-
-  async close () {
-    try {
-      await this._rpc.close();
-    } finally {
-      this._socket.close();
-    }
-  }
-
-  async call (method: string, payload: any): Promise<any> {
-    const start = Date.now();
-    try {
-      const response = await Promise.race([
-        (async () => {
-          await this._rpc.open();
-          await this._connectTrigger.wait();
-          return this._rpc.call(method, payload);
-        })(),
-        sleep(RPC_TIMEOUT).then(() => Promise.reject(new Error(`Signal RPC call timed out in ${RPC_TIMEOUT} ms`)))
-      ]);
-      this.commandTrace.emit({
-        messageId: `${this._host}-${this._messageId++}`,
-        host: this._host,
-        incoming: false,
-        time: Date.now() - start,
-        method,
-        payload,
-        response
-      });
-      log(`Signal RPC ${this._host}: ${method} ${JSON.stringify(payload)} ${JSON.stringify(response)}`);
-      return response;
-    } catch (err: any) {
-      log(`Signal RPC error ${this._host}: ${method} ${JSON.stringify(payload)} ${err.message}`);
-      this.commandTrace.emit({
-        messageId: `${this._host}-${this._messageId++}`,
-        host: this._host,
-        incoming: false,
-        time: Date.now() - start,
-        method,
-        payload,
-        error: err.message
-      });
-      throw err;
-    }
-  }
-
-  async emit (method: string, data: any) {
-    this.commandTrace.emit({
-      messageId: `${this._host}-${this._messageId++}`,
-      host: this._host,
-      incoming: false,
-      time: 0,
-      method,
-      payload: data
-    });
-    return this._rpc.emit('signal', data);
-  }
-
-  addHandler (method: string, handler: (data: any) => Promise<any>) {
-    this._rpc.actions({
-      [method]: async (data: any) => {
-        const begin = Date.now();
-        try {
-          const response = await handler(data);
-          this.commandTrace.emit({
-            messageId: `${this._host}-${this._messageId++}`,
-            host: this._host,
-            incoming: true,
-            time: Date.now() - begin,
-            method,
-            payload: data,
-            response
-          });
-          return response;
-        } catch (error: any) {
-          this.commandTrace.emit({
-            messageId: `${this._host}-${this._messageId++}`,
-            host: this._host,
-            incoming: true,
-            time: Date.now() - begin,
-            method,
-            payload: data,
-            error: error.message
-          });
-          throw error;
-        }
-      }
-    });
-  }
-
-  subscribe (method: string, handler: (data: any) => void) {
-    this._rpc.on(method, (data: any) => {
-      this.commandTrace.emit({
-        messageId: `${this._host}-${this._messageId++}`,
-        host: this._host,
-        incoming: true,
-        time: 0,
-        method,
-        payload: data
-      });
-      handler(data);
-    });
-  }
-}

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

@@ -1,158 +0,0 @@
-//
-// 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 { Answer, Message } from '../proto/gen/dxos/mesh/signal';
-import { SignalApi } from './signal-api';
-import { SignalClient } from './signal-client';
-import { SignalManager } from './signal-manager';
-
-const log = debug('dxos:network-manager:websocket-signal-manager');
-
-export class WebsocketSignalManager implements SignalManager {
-  private readonly _servers = new Map<string, SignalClient>();
-
-  /** Topics joined: topic => peerId */
-  private readonly _topicsJoined = new ComplexMap<PublicKey, PublicKey>(topic => topic.toHex());
-  private readonly _topicsJoinedPerSignal = new Map<string, ComplexMap<PublicKey, PublicKey>>();
-
-  private _reconcileTimeoutId?: NodeJS.Timeout;
-
-  readonly statusChanged = new Event<SignalApi.Status[]>();
-  readonly commandTrace = new Event<SignalApi.CommandTrace>();
-  readonly peerCandidatesChanged = new Event<[topic: PublicKey, candidates: PublicKey[]]>()
-  readonly onSignal = new Event<Message>();
-
-  constructor (
-    private readonly _hosts: string[],
-    private readonly _onOffer: (message: Message) => Promise<Answer>
-  ) {
-    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._onOffer(msg),
-        async msg => this.onSignal.emit(msg)
-      );
-
-      this._servers.set(host, server);
-      server.statusChanged.on(() => this.statusChanged.emit(this.getStatus()));
-      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) {
-    log(`Join ${topic} ${peerId}`);
-    this._topicsJoined.set(topic, peerId);
-    void this._reconcileJoinedTopics();
-  }
-
-  leave (topic: PublicKey, peerId: PublicKey) {
-    log(`Leave ${topic} ${peerId}`);
-    this._topicsJoined.delete(topic);
-    void this._reconcileJoinedTopics();
-  }
-
-  @synchronized
-  private async _reconcileJoinedTopics () {
-    log('Reconciling joined topics');
-    const promises: Promise<void>[] = [];
-    for (const [host, server] of this._servers.entries()) {
-      for (const [topic, peerId] of this._topicsJoined.entries()) {
-        if (!this._topicsJoinedPerSignal.get(host)!.has(topic)) {
-          log(`Join ${topic} as ${peerId} on ${host}`);
-          promises.push(server.join(topic, peerId).then(
-            peers => {
-              log(`Joined successfully ${host}`);
-              this._topicsJoinedPerSignal.get(host)!.set(topic, peerId);
-
-              log(`Peer candidates changed ${topic} ${peers}`);
-              // TODO(marik-d): Deduplicate peers.
-              this.peerCandidatesChanged.emit([topic, peers]);
-            },
-            err => {
-              log(`Join error ${host} ${err.message}`);
-              this._topicsJoinedPerSignal.get(host)!.delete(topic);
-              this._reconcile();
-            }
-          ));
-        }
-
-        for (const [topic, peerId] of this._topicsJoinedPerSignal.get(host)!.entries()) {
-          if (!this._topicsJoined.has(topic)) {
-            log(`Leave ${topic} as ${peerId} on ${host}`);
-            promises.push(server.leave(topic, peerId).then(
-              () => {
-                log(`Left successfully ${host}`);
-                this._topicsJoinedPerSignal.get(host)!.delete(topic);
-              },
-              err => {
-                log(`Leave error ${host} ${err.message}`);
-                this._reconcile();
-              }
-            ));
-          }
-        }
-      }
-    }
-    await Promise.all(promises);
-  }
-
-  private _reconcile () {
-    if (this._reconcileTimeoutId !== undefined) {
-      return;
-    }
-    log('Will reconcile in 3 seconds');
-    this._reconcileTimeoutId = setTimeout(async () => {
-      this._reconcileTimeoutId = undefined;
-      await this._reconcileJoinedTopics();
-    }, 3_000);
-  }
-
-  lookup (topic: PublicKey) {
-    log(`Lookup ${topic}`);
-    for (const server of this._servers.values()) {
-      server.lookup(topic).then(
-        peers => {
-          log(`Peer candidates changed ${topic} ${peers}`);
-          // TODO(marik-d): Deduplicate peers.
-          this.peerCandidatesChanged.emit([topic, peers]);
-        },
-        () => {
-          // Error will already be reported in devtools. No need to do anything here.
-        }
-      );
-    }
-  }
-
-  offer (msg: Message) {
-    log(`Offer ${msg.remoteId}`);
-    // TODO(marik-d): Broadcast to all signal servers.
-    return Array.from(this._servers.values())[0].offer(msg);
-  }
-
-  async signal (msg: Message) {
-    log(`Signal ${msg.remoteId}`);
-    for (const server of this._servers.values()) {
-      void server.signal(msg);
-      // TODO(marik-d): Error handling.
-    }
-  }
-
-  async destroy () {
-    await Promise.all(Array.from(this._servers.values()).map(server => server.close()));
-  }
-}