@dxos/messaging 0.10.0 → 0.11.0

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

@@ -1,227 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import WebSocket from 'isomorphic-ws';
-
-import { TimeoutError, Trigger, scheduleTaskInterval } from '@dxos/async';
-import { type Any, type Stream } from '@dxos/codec-protobuf';
-import { Context } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { schema } from '@dxos/protocols/proto';
-import { type Signal, type Message as SignalMessage } from '@dxos/protocols/proto/dxos/mesh/signal';
-import { type ProtoRpcPeer, createProtoRpcPeer } from '@dxos/rpc';
-
-import { SignalRpcClientMonitor } from './signal-rpc-client-monitor';
-
-const SIGNAL_KEEPALIVE_INTERVAL = 10000;
-
-interface Services {
-  Signal: Signal;
-}
-
-export type SignalCallbacks = {
-  onConnected?: () => void;
-
-  /**
-   * Called on disconnect.
-   * In case of error, `onError` will be called first and then `onDisconnected`.
-   */
-  onDisconnected?: () => void;
-
-  onError?: (error: Error) => void;
-  getMetadata?: () => any;
-};
-
-export type SignalRPCClientProps = {
-  url: string;
-  callbacks?: SignalCallbacks;
-};
-
-/**
- * Signal RPC client.
- * TODO(mykola): Delete.
- * @deprecated
- */
-export class SignalRPCClient {
-  private readonly _socket: WebSocket;
-  private readonly _rpc: ProtoRpcPeer<Services>;
-  private readonly _connectTrigger = new Trigger();
-
-  private _keepaliveCtx?: Context;
-
-  private _closed = false;
-
-  private readonly _url: string;
-  private readonly _callbacks: SignalCallbacks;
-  private readonly _closeComplete = new Trigger();
-
-  private readonly _monitor = new SignalRpcClientMonitor();
-
-  constructor({ url, callbacks = {} }: SignalRPCClientProps) {
-    log('creating signal rpc client', { url });
-    this._url = url;
-    this._callbacks = callbacks;
-    this._socket = new WebSocket(this._url);
-
-    this._rpc = createProtoRpcPeer({
-      requested: {
-        Signal: schema.getService('dxos.mesh.signal.Signal'),
-      },
-      noHandshake: true,
-      port: {
-        send: (msg) => {
-          if (this._closed) {
-            // Do not send messages after close.
-            return;
-          }
-          try {
-            this._socket!.send(msg);
-          } catch (err) {
-            log.warn('send error', err);
-          }
-        },
-        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);
-            }
-          };
-        },
-      },
-      encodingOptions: {
-        preserveAny: true,
-      },
-    });
-
-    this._socket.onopen = async () => {
-      try {
-        await this._rpc!.open();
-        if (this._closed) {
-          await this._safeCloseRpc();
-          return;
-        }
-        log(`RPC open ${this._url}`);
-        this._callbacks.onConnected?.();
-        this._connectTrigger.wake();
-        this._keepaliveCtx = new Context();
-        scheduleTaskInterval(
-          this._keepaliveCtx,
-          async () => {
-            // TODO(nf): use RFC6455 ping/pong once implemented in the browser?
-            // TODO(nf): check for pong response from server (once implemented)
-            // Current implementation of signal server ignores all text data messages, and does not send a response.
-            // However this is enough to detect breakages in the connection as TCP will reset the connection if ACKs are not received.
-            this._socket?.send('__ping__');
-          },
-          SIGNAL_KEEPALIVE_INTERVAL,
-        );
-      } catch (err: any) {
-        this._callbacks.onError?.(err);
-        this._socket.close();
-        this._closed = true;
-      }
-    };
-
-    this._socket.onclose = async () => {
-      log(`Disconnected ${this._url}`);
-      this._callbacks.onDisconnected?.();
-      this._closeComplete.wake();
-      await this.close();
-    };
-
-    this._socket.onerror = async (event: WebSocket.ErrorEvent) => {
-      if (this._closed) {
-        this._socket.close();
-        return;
-      }
-      this._closed = true;
-
-      this._callbacks.onError?.(event.error ?? new Error(event.message));
-      await this._safeCloseRpc();
-
-      log.warn(`Socket ${event.type ?? 'unknown'} error`, { message: event.message, url: this._url });
-    };
-
-    log('created signal rpc client', { url });
-  }
-
-  async close(): Promise<void> {
-    if (this._closed) {
-      return;
-    }
-    this._closed = true;
-
-    await this._keepaliveCtx?.dispose();
-    try {
-      await this._safeCloseRpc();
-
-      if (this._socket.readyState === WebSocket.OPEN || this._socket.readyState === WebSocket.CONNECTING) {
-        // close() only starts the closing handshake.
-        this._socket.close();
-      }
-
-      await this._closeComplete.wait({ timeout: 1_000 });
-    } catch (err) {
-      const failureReason = err instanceof TimeoutError ? 'timeout' : (err?.constructor?.name ?? 'unknown');
-      this._monitor.recordClientCloseFailure({ failureReason });
-    }
-  }
-
-  async join({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }) {
-    log('join', { topic, peerId, metadata: this._callbacks?.getMetadata?.() });
-    invariant(!this._closed, 'SignalRPCClient is closed');
-    await this._connectTrigger.wait();
-    const swarmStream = this._rpc.rpc.Signal.join({
-      swarm: topic.asUint8Array(),
-      peer: peerId.asUint8Array(),
-      metadata: this._callbacks?.getMetadata?.(),
-    });
-    await swarmStream.waitUntilReady();
-    return swarmStream;
-  }
-
-  async receiveMessages(peerId: PublicKey): Promise<Stream<SignalMessage>> {
-    log('receiveMessages', { peerId });
-    invariant(!this._closed, 'SignalRPCClient is closed');
-    await this._connectTrigger.wait();
-    const messageStream = this._rpc.rpc.Signal.receiveMessages({
-      peer: peerId.asUint8Array(),
-    });
-    await messageStream.waitUntilReady();
-    return messageStream;
-  }
-
-  async sendMessage({
-    author,
-    recipient,
-    payload,
-  }: {
-    author: PublicKey;
-    recipient: PublicKey;
-    payload: Any;
-  }): Promise<void> {
-    log('sendMessage', { author, recipient, payload, metadata: this._callbacks?.getMetadata?.() });
-    invariant(!this._closed, 'SignalRPCClient is closed');
-    await this._connectTrigger.wait();
-    await this._rpc.rpc.Signal.sendMessage({
-      author: author.asUint8Array(),
-      recipient: recipient.asUint8Array(),
-      payload,
-      metadata: this._callbacks?.getMetadata?.(),
-    });
-  }
-
-  private async _safeCloseRpc(): Promise<void> {
-    try {
-      this._connectTrigger.reset();
-      await this._rpc.close();
-    } catch (err) {
-      log.catch(err);
-    }
-  }
-}

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

@@ -1,20 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { trace } from '@dxos/tracing';
-
-export class WebsocketSignalManagerMonitor {
-  public recordRateLimitExceeded(): void {
-    trace.metrics.increment('dxos.mesh.signal.signal-manager.rate-limit-hit', 1);
-  }
-
-  public recordServerFailure(params: { serverName: string; willRestart: boolean }): void {
-    trace.metrics.increment('dxos.mesh.signal.signal-manager.server-failure', 1, {
-      tags: {
-        server: params.serverName,
-        restarted: params.willRestart,
-      },
-    });
-  }
-}

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

@@ -1,112 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { afterAll, beforeAll, describe, test } from 'vitest';
-
-import { asyncTimeout, sleep } from '@dxos/async';
-import { Context } from '@dxos/context';
-import { PublicKey } from '@dxos/keys';
-import { type SignalServerRunner, runTestSignalServer } from '@dxos/signal';
-import { openAndClose } from '@dxos/test-utils';
-
-import { createMessage, expectPeerAvailable, expectReceivedMessage } from '../testing';
-import { WebsocketSignalManager } from './websocket-signal-manager';
-
-describe.skip('WebSocketSignalManager', () => {
-  let broker1: SignalServerRunner;
-  let broker2: SignalServerRunner;
-
-  beforeAll(async () => {
-    broker1 = await runTestSignalServer({ port: 5001 });
-    broker2 = await runTestSignalServer({ port: 5002 });
-  });
-
-  afterAll(() => {
-    void broker1.stop();
-    void broker2.stop();
-  });
-
-  test('join swarm with two brokers', { timeout: 1_000 }, async () => {
-    const client1 = new WebsocketSignalManager([{ server: broker1.url() }, { server: broker2.url() }]);
-    const client2 = new WebsocketSignalManager([{ server: broker1.url() }]);
-    const client3 = new WebsocketSignalManager([{ server: broker2.url() }]);
-    await openAndClose(client1, client2, client3);
-
-    const [topic, peer1, peer2, peer3] = PublicKey.randomSequence();
-
-    const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
-    const joined13 = expectPeerAvailable(client1, topic, { peerKey: peer3.toHex() });
-    const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
-    const joined31 = expectPeerAvailable(client3, topic, { peerKey: peer1.toHex() });
-
-    await client1.join(Context.default(), { topic, peer: { peerKey: peer1.toHex() } });
-    await client2.join(Context.default(), { topic, peer: { peerKey: peer2.toHex() } });
-    await client3.join(Context.default(), { topic, peer: { peerKey: peer3.toHex() } });
-
-    await Promise.all([joined12, joined13, joined21, joined31]);
-  });
-
-  test('join single swarm with doubled brokers', { timeout: 1_000 }, async () => {
-    const client1 = new WebsocketSignalManager([{ server: broker1.url() }, { server: broker2.url() }]);
-    const client2 = new WebsocketSignalManager([{ server: broker1.url() }, { server: broker2.url() }]);
-    await openAndClose(client1, client2);
-
-    const [topic, peer1, peer2] = PublicKey.randomSequence();
-
-    const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
-    const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
-
-    await client1.join(Context.default(), { topic, peer: { peerKey: peer1.toHex() } });
-    await client2.join(Context.default(), { topic, peer: { peerKey: peer2.toHex() } });
-
-    await asyncTimeout(Promise.all([joined12, joined21]), 1_000);
-
-    const message = createMessage({ peerKey: peer1.toHex() }, { peerKey: peer2.toHex() });
-
-    const received = expectReceivedMessage(client2.onMessage, message);
-    await client2.subscribeMessages({ peerKey: peer2.toHex() });
-    await sleep(50);
-    await client1.sendMessage(Context.default(), message);
-
-    await asyncTimeout(received, 1_000);
-  });
-
-  test('works with one broken server', { timeout: 1_000 }, async () => {
-    const client1 = new WebsocketSignalManager([{ server: 'ws://broken.server/signal' }, { server: broker1.url() }]);
-    const client2 = new WebsocketSignalManager([{ server: 'ws://broken.server/signal' }, { server: broker1.url() }]);
-    await openAndClose(client1, client2);
-
-    const [topic, peer1, peer2] = PublicKey.randomSequence();
-
-    const joined12 = expectPeerAvailable(client1, topic, { peerKey: peer2.toHex() });
-    const joined21 = expectPeerAvailable(client2, topic, { peerKey: peer1.toHex() });
-
-    await client1.join(Context.default(), { topic, peer: { peerKey: peer1.toHex() } });
-    await client2.join(Context.default(), { topic, peer: { peerKey: peer2.toHex() } });
-
-    await Promise.all([joined12, joined21]);
-  });
-
-  test('join two swarms with a broken signal server', { timeout: 1_000 }, async () => {
-    const client1 = new WebsocketSignalManager([{ server: 'ws://broken.server/signal' }, { server: broker1.url() }]);
-    const client2 = new WebsocketSignalManager([{ server: 'ws://broken.server/signal' }, { server: broker1.url() }]);
-    await openAndClose(client1, client2);
-
-    const [topic1, topic2, peer1, peer2] = PublicKey.randomSequence();
-
-    const joined112 = expectPeerAvailable(client1, topic1, { peerKey: peer2.toHex() });
-    const joined121 = expectPeerAvailable(client2, topic1, { peerKey: peer1.toHex() });
-
-    await client1.join(Context.default(), { topic: topic1, peer: { peerKey: peer1.toHex() } });
-    await client2.join(Context.default(), { topic: topic1, peer: { peerKey: peer2.toHex() } });
-    await Promise.all([joined112, joined121]);
-
-    const joined212 = expectPeerAvailable(client1, topic2, { peerKey: peer2.toHex() });
-    const joined221 = expectPeerAvailable(client2, topic2, { peerKey: peer1.toHex() });
-
-    await client1.join(Context.default(), { topic: topic2, peer: { peerKey: peer1.toHex() } });
-    await client2.join(Context.default(), { topic: topic2, peer: { peerKey: peer2.toHex() } });
-    await Promise.all([joined212, joined221]);
-  });
-});

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

@@ -1,188 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-import { Event, sleep, synchronized } from '@dxos/async';
-import { type Context, LifecycleState, Resource } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { RateLimitExceededError, TimeoutError } from '@dxos/protocols';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
-import { type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
-import { type JoinRequest, type LeaveRequest, type QueryRequest } from '@dxos/protocols/proto/dxos/edge/signal';
-import { BitField, safeAwaitAll } from '@dxos/util';
-
-import { SignalClient } from '../signal-client';
-import {
-  type Message,
-  type PeerInfo,
-  type SignalClientMethods,
-  type SignalMethods,
-  type SignalStatus,
-  type SwarmEvent,
-} from '../signal-methods';
-import { type SignalManager } from './signal-manager';
-import { WebsocketSignalManagerMonitor } from './websocket-signal-manager-monitor';
-
-const MAX_SERVER_FAILURES = 5;
-const WSS_SIGNAL_SERVER_REBOOT_DELAY = 3_000;
-
-/**
- * Manages connection to multiple Signal Servers over WebSocket
- * TODO(mykola): Delete.
- * @deprecated
- */
-export class WebsocketSignalManager extends Resource implements SignalManager {
-  private readonly _servers = new Map<string, SignalClientMethods>();
-  private readonly _monitor = new WebsocketSignalManagerMonitor();
-
-  /**
-   * Used to avoid logging failed server restarts more than once until the server actually recovers.
-   */
-  private readonly _failedServersBitfield: Uint8Array;
-
-  readonly failureCount = new Map<string, number>();
-  readonly statusChanged = new Event<SignalStatus[]>();
-  readonly swarmEvent = new Event<SwarmEvent>();
-
-  readonly onMessage = new Event<Message>();
-
-  constructor(
-    private readonly _hosts: Runtime.Services.Signal[],
-    private readonly _getMetadata?: () => any,
-  ) {
-    super();
-    log('Created WebsocketSignalManager', { hosts: this._hosts });
-    for (const host of this._hosts) {
-      if (this._servers.has(host.server)) {
-        continue;
-      }
-
-      // TODO(burdon): Create factory to support different variants.
-      const server = new SignalClient(host.server, this._getMetadata);
-      server.swarmEvent.on((data) => this.swarmEvent.emit(data));
-      server.onMessage.on((data) => this.onMessage.emit(data));
-
-      server.statusChanged.on(() => this.statusChanged.emit(this.getStatus()));
-
-      this._servers.set(host.server, server);
-      this.failureCount.set(host.server, 0);
-    }
-    this._failedServersBitfield = BitField.zeros(this._hosts.length);
-  }
-
-  protected override async _open(): Promise<void> {
-    log('open signal manager', { hosts: this._hosts });
-
-    await safeAwaitAll(this._servers.values(), (server) => server.open());
-  }
-
-  protected override async _close(): Promise<void> {
-    await safeAwaitAll(this._servers.values(), (server) => server.close());
-  }
-
-  async restartServer(serverName: string): Promise<void> {
-    log('restarting server', { serverName });
-    invariant(this._lifecycleState === LifecycleState.OPEN);
-
-    const server = this._servers.get(serverName);
-    invariant(server, 'server not found');
-
-    await server.close();
-    await sleep(WSS_SIGNAL_SERVER_REBOOT_DELAY);
-    await server.open();
-  }
-
-  getStatus(): SignalStatus[] {
-    return Array.from(this._servers.values()).map((server) => server.getStatus());
-  }
-
-  @synchronized
-  async join(_ctx: Context, { topic, peer }: JoinRequest): Promise<void> {
-    log('join', { topic, peer });
-    invariant(this._lifecycleState === LifecycleState.OPEN);
-    await this._forEachServer((server) => server.join(_ctx, { topic, peer }));
-  }
-
-  @synchronized
-  async leave(_ctx: Context, { topic, peer }: LeaveRequest): Promise<void> {
-    log('leaving', { topic, peer });
-    invariant(this._lifecycleState === LifecycleState.OPEN);
-    await this._forEachServer((server) => server.leave(_ctx, { topic, peer }));
-  }
-
-  async query(_ctx: Context, { topic }: QueryRequest): Promise<SwarmResponse> {
-    throw new Error('Not implemented');
-  }
-
-  async sendMessage(_ctx: Context, { author, recipient, payload }: Message): Promise<void> {
-    log('signal', { recipient });
-    invariant(this._lifecycleState === LifecycleState.OPEN);
-
-    void this._forEachServer(async (server, serverName, index) => {
-      void server
-        .sendMessage(_ctx, { author, recipient, payload })
-        .then(() => this._clearServerFailedFlag(serverName, index))
-        .catch((err) => {
-          if (err instanceof RateLimitExceededError) {
-            log.info('WSS rate limit exceeded', { err });
-            this._monitor.recordRateLimitExceeded();
-          } else if (err instanceof TimeoutError || err.constructor.name === 'TimeoutError') {
-            log.info('WSS sendMessage timeout', { err });
-            void this.checkServerFailure(serverName, index);
-          } else {
-            log.warn(`error sending to ${serverName}`, { err });
-            void this.checkServerFailure(serverName, index);
-          }
-        });
-    });
-  }
-
-  @synchronized
-  async checkServerFailure(serverName: string, index: number): Promise<void> {
-    const failureCount = this.failureCount.get(serverName!) ?? 0;
-    const isRestartRequired = failureCount > MAX_SERVER_FAILURES;
-    this._monitor.recordServerFailure({ serverName, willRestart: isRestartRequired });
-    if (isRestartRequired) {
-      if (!BitField.get(this._failedServersBitfield, index)) {
-        log.warn('too many failures for ws-server, restarting', { serverName, failureCount });
-        BitField.set(this._failedServersBitfield, index, true);
-      }
-      await this.restartServer(serverName!);
-      this.failureCount.set(serverName!, 0);
-      return;
-    }
-
-    this.failureCount.set(serverName!, (this.failureCount.get(serverName!) ?? 0) + 1);
-  }
-
-  private _clearServerFailedFlag(serverName: string, index: number): void {
-    if (BitField.get(this._failedServersBitfield, index)) {
-      log.info('server connection restored', { serverName });
-      BitField.set(this._failedServersBitfield, index, false);
-      this.failureCount.set(serverName!, 0);
-    }
-  }
-
-  async subscribeMessages(peer: PeerInfo): Promise<void> {
-    log('subscribed for message stream', { peer });
-    invariant(this._lifecycleState === LifecycleState.OPEN);
-
-    await this._forEachServer(async (server) => server.subscribeMessages(peer));
-  }
-
-  async unsubscribeMessages(peer: PeerInfo): Promise<void> {
-    log('subscribed for message stream', { peer });
-    invariant(this._lifecycleState === LifecycleState.OPEN);
-
-    await this._forEachServer(async (server) => server.unsubscribeMessages(peer));
-  }
-
-  private async _forEachServer<ReturnType>(
-    fn: (server: SignalMethods, serverName: string, index: number) => Promise<ReturnType>,
-  ): Promise<ReturnType[]> {
-    return Promise.all(
-      Array.from(this._servers.entries()).map(([serverName, server], idx) => fn(server, serverName, idx)),
-    );
-  }
-}