@dxos/messaging 0.10.0 → 0.11.0

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

@@ -1,339 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-import { DeferredTask, Event, Trigger, scheduleTask, scheduleTaskInterval, sleep } from '@dxos/async';
-import { type Context, Resource, cancelWithContext } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-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 { SignalState } from '@dxos/protocols/proto/dxos/mesh/signal';
-
-import {
-  type Message,
-  type PeerInfo,
-  type SignalClientMethods,
-  type SignalStatus,
-  type SwarmEvent,
-} from '../signal-methods';
-import { SignalClientMonitor } from './signal-client-monitor';
-import { SignalLocalState } from './signal-local-state';
-import { SignalRPCClient } from './signal-rpc-client';
-
-const DEFAULT_RECONNECT_TIMEOUT = 100;
-const MAX_RECONNECT_TIMEOUT = 5_000;
-const ERROR_RECONCILE_DELAY = 1_000;
-const RECONCILE_INTERVAL = 5_000;
-
-/**
- * KUBE-specific signaling client.
- * Establishes a websocket connection to signal server and provides RPC methods.
- * Subscription state updates are executed immediately against the local state which
- * is reconciled periodically.
- * TODO(mykola): Delete.
- * @deprecated
- */
-// TODO(burdon): Rename impl.
-export class SignalClient extends Resource implements SignalClientMethods {
-  private readonly _monitor = new SignalClientMonitor();
-
-  private _state = SignalState.CLOSED;
-  private _lastError?: Error;
-  private _lastReconciliationFailed = false;
-
-  private readonly _clientReady = new Trigger();
-  private _connectionCtx?: Context;
-  private _client?: SignalRPCClient;
-
-  private _reconcileTask?: DeferredTask;
-  private _reconnectTask?: DeferredTask;
-
-  /**
-   * Number of milliseconds after which the connection will be attempted again in case of error.
-   */
-  private _reconnectAfter = DEFAULT_RECONNECT_TIMEOUT;
-
-  /**
-   * @internal
-   */
-  readonly localState: SignalLocalState;
-
-  readonly statusChanged = new Event<SignalStatus>();
-
-  public readonly onMessage = new Event<Message>();
-  public readonly swarmEvent = new Event<SwarmEvent>();
-
-  /**
-   * @param _host Signal server websocket URL.
-   * @param onMessage called when a new message is received.
-   * @param onSwarmEvent called when a new swarm event is received.
-   * @param _getMetadata signal-message metadata provider, called for every message.
-   */
-  constructor(
-    private readonly _host: string,
-    private readonly _getMetadata?: () => any,
-  ) {
-    super();
-    if (!this._host.startsWith('wss://') && !this._host.startsWith('ws://')) {
-      throw new Error(`Signal server requires a websocket URL. Provided: ${this._host}`);
-    }
-
-    this.localState = new SignalLocalState(
-      async (message) => {
-        this._monitor.recordMessageReceived(message);
-        this.onMessage.emit(message);
-      },
-      async (event) => this.swarmEvent.emit(event),
-    );
-  }
-
-  protected override async _open(): Promise<void> {
-    log('opening signal client');
-
-    if ([SignalState.CONNECTED, SignalState.CONNECTING].includes(this._state)) {
-      return;
-    }
-    this._setState(SignalState.CONNECTING);
-
-    this._reconcileTask = new DeferredTask(this._ctx, async () => {
-      try {
-        await cancelWithContext(this._connectionCtx!, this._clientReady.wait({ timeout: 5_000 }));
-        invariant(this._state === SignalState.CONNECTED, 'Not connected to Signal Server');
-        await this.localState.reconcile(this._connectionCtx!, this._client!);
-        this._monitor.recordReconciliation({ success: true });
-        this._lastReconciliationFailed = false;
-      } catch (err) {
-        this._lastReconciliationFailed = true;
-        this._monitor.recordReconciliation({ success: false });
-        throw err;
-      }
-    });
-
-    // Reconcile subscriptions periodically.
-    scheduleTaskInterval(
-      this._ctx,
-      async () => {
-        if (this._state === SignalState.CONNECTED) {
-          this._reconcileTask!.schedule();
-        }
-      },
-      RECONCILE_INTERVAL,
-    );
-
-    this._reconnectTask = new DeferredTask(this._ctx, async () => {
-      try {
-        await this._reconnect();
-        this._monitor.recordReconnect({ success: true });
-      } catch (err) {
-        this._monitor.recordReconnect({ success: false });
-        throw err;
-      }
-    });
-
-    this._createClient();
-    log('opened signal client');
-  }
-
-  protected override async _catch(err: Error): Promise<void> {
-    if (this._state === SignalState.CLOSED || this._ctx.disposed) {
-      return;
-    }
-    // Don't log consecutive reconciliation failures.
-    if (this._state === SignalState.CONNECTED && !this._lastReconciliationFailed) {
-      log.warn('SignalClient error:', err);
-    }
-    this._scheduleReconcileAfterError();
-  }
-
-  protected override async _close(): Promise<void> {
-    log('closing...');
-    if ([SignalState.CLOSED].includes(this._state)) {
-      return;
-    }
-
-    this._setState(SignalState.CLOSED);
-    await this._safeResetClient();
-
-    log('closed');
-  }
-
-  getStatus(): SignalStatus {
-    return {
-      host: this._host,
-      state: this._state,
-      error: this._lastError?.message,
-      reconnectIn: this._reconnectAfter,
-      ...this._monitor.getRecordedTimestamps(),
-    };
-  }
-
-  async join(_ctx: Context, args: JoinRequest): Promise<void> {
-    log('joining', { topic: args.topic, peerId: args.peer.peerKey });
-    this._monitor.recordJoin();
-    this.localState.join({ topic: args.topic, peerId: PublicKey.from(args.peer.peerKey) });
-    this._reconcileTask?.schedule();
-  }
-
-  async leave(_ctx: Context, args: LeaveRequest): Promise<void> {
-    log('leaving', { topic: args.topic, peerId: args.peer.peerKey });
-    this._monitor.recordLeave();
-    this.localState.leave({ topic: args.topic, peerId: PublicKey.from(args.peer.peerKey) });
-  }
-
-  async query(_ctx: Context, params: QueryRequest): Promise<SwarmResponse> {
-    throw new Error('Not implemented');
-  }
-
-  async sendMessage(_ctx: Context, msg: Message): Promise<void> {
-    return this._monitor.recordMessageSending(msg, async () => {
-      await this._clientReady.wait();
-      invariant(this._state === SignalState.CONNECTED, 'Not connected to Signal Server');
-      invariant(msg.author.peerKey, 'Author key required');
-      invariant(msg.recipient.peerKey, 'Recipient key required');
-      await this._client!.sendMessage({
-        author: PublicKey.from(msg.author.peerKey),
-        recipient: PublicKey.from(msg.recipient.peerKey),
-        payload: msg.payload,
-      });
-    });
-  }
-
-  async subscribeMessages(peer: PeerInfo): Promise<void> {
-    invariant(peer.peerKey, 'Peer key required');
-    log('subscribing to messages', { peer });
-    this.localState.subscribeMessages(PublicKey.from(peer.peerKey));
-    this._reconcileTask?.schedule();
-  }
-
-  async unsubscribeMessages(peer: PeerInfo): Promise<void> {
-    invariant(peer.peerKey, 'Peer key required');
-    log('unsubscribing from messages', { peer });
-    this.localState.unsubscribeMessages(PublicKey.from(peer.peerKey));
-  }
-
-  private _scheduleReconcileAfterError(): void {
-    scheduleTask(this._ctx, () => this._reconcileTask!.schedule(), ERROR_RECONCILE_DELAY);
-  }
-
-  private _createClient(): void {
-    log('creating client', { host: this._host, state: this._state });
-    invariant(!this._client, 'Client already created');
-
-    this._monitor.recordConnectionStartTime();
-
-    // Create new context for each connection.
-    this._connectionCtx = this._ctx.derive();
-    this._connectionCtx.onDispose(async () => {
-      log('connection context disposed');
-      const { failureCount } = await this.localState.safeCloseStreams();
-      this._monitor.recordStreamCloseErrors(failureCount);
-    });
-
-    try {
-      const client = new SignalRPCClient({
-        url: this._host,
-        callbacks: {
-          onConnected: () => {
-            if (client === this._client) {
-              log('socket connected');
-              this._onConnected();
-            }
-          },
-
-          onDisconnected: () => {
-            if (client !== this._client) {
-              return;
-            }
-            log('socket disconnected', { state: this._state });
-            if (this._state === SignalState.ERROR) {
-              // Ignore disconnects after error.
-              // Handled by error handler before disconnect handler.
-              this._setState(SignalState.DISCONNECTED);
-            } else {
-              this._onDisconnected();
-            }
-          },
-
-          onError: (error) => {
-            if (client === this._client) {
-              log('socket error', { error, state: this._state });
-              this._onDisconnected({ error });
-            }
-          },
-          getMetadata: this._getMetadata,
-        },
-      });
-      this._client = client;
-    } catch (error: any) {
-      this._client = undefined;
-      this._onDisconnected({ error });
-    }
-  }
-
-  private async _reconnect(): Promise<void> {
-    log(`reconnecting in ${this._reconnectAfter}ms`, { state: this._state });
-
-    if (this._state === SignalState.RECONNECTING) {
-      log.info('Signal api already reconnecting.');
-      return;
-    }
-    if (this._state === SignalState.CLOSED) {
-      return;
-    }
-    this._setState(SignalState.RECONNECTING);
-
-    await this._safeResetClient();
-
-    await cancelWithContext(this._ctx!, sleep(this._reconnectAfter));
-
-    this._createClient();
-  }
-
-  private _onConnected(): void {
-    this._lastError = undefined;
-    this._lastReconciliationFailed = false;
-    this._reconnectAfter = DEFAULT_RECONNECT_TIMEOUT;
-    this._setState(SignalState.CONNECTED);
-    this._clientReady.wake();
-    this._reconcileTask!.schedule();
-  }
-
-  private _onDisconnected(options?: { error: Error }): void {
-    this._updateReconnectTimeout();
-    if (this._state === SignalState.CLOSED) {
-      return;
-    }
-    if (options?.error) {
-      this._lastError = options.error;
-      this._setState(SignalState.ERROR);
-    } else {
-      this._setState(SignalState.DISCONNECTED);
-    }
-    this._reconnectTask!.schedule();
-  }
-
-  private _setState(newState: SignalState): void {
-    this._state = newState;
-    this._monitor.recordStateChangeTime();
-    log('signal state changed', { status: this.getStatus() });
-    this.statusChanged.emit(this.getStatus());
-  }
-
-  private _updateReconnectTimeout(): void {
-    if (this._state !== SignalState.CONNECTED && this._state !== SignalState.CONNECTING) {
-      this._reconnectAfter *= 2;
-      this._reconnectAfter = Math.min(this._reconnectAfter, MAX_RECONNECT_TIMEOUT);
-    }
-  }
-
-  private async _safeResetClient(): Promise<void> {
-    await this._connectionCtx?.dispose();
-    this._connectionCtx = undefined;
-
-    this._clientReady.reset();
-    await this._client?.close().catch(() => {});
-    this._client = undefined;
-  }
-}

package/src/signal-client/signal-local-state.ts

@@ -1,174 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event, asyncTimeout } from '@dxos/async';
-import type { Stream } from '@dxos/codec-protobuf/stream';
-import { type Context, cancelWithContext } from '@dxos/context';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import {
-  type Message as SignalMessage,
-  type SwarmEvent as SwarmEventProto,
-} from '@dxos/protocols/proto/dxos/mesh/signal';
-import { ComplexMap, ComplexSet, safeAwaitAll } from '@dxos/util';
-
-import type { Message, SwarmEvent } from '../signal-methods';
-import { type SignalRPCClient } from './signal-rpc-client';
-
-export class SignalLocalState {
-  /**
-   * Swarm events streams. Keys represent actually joined topic and peerId.
-   */
-  private readonly _swarmStreams = new ComplexMap<{ topic: PublicKey; peerId: PublicKey }, Stream<SwarmEventProto>>(
-    ({ topic, peerId }) => topic.toHex() + peerId.toHex(),
-  );
-
-  /**
-   * Represent desired joined topic and peerId.
-   */
-  private readonly _joinedTopics = new ComplexSet<{ topic: PublicKey; peerId: PublicKey }>(
-    ({ topic, peerId }) => topic.toHex() + peerId.toHex(),
-  );
-
-  /**
-   * Represent desired message subscriptions.
-   */
-  private readonly _subscribedMessages = new ComplexSet<{ peerId: PublicKey }>(({ peerId }) => peerId.toHex());
-
-  /**
-   * Message streams. Keys represents actually subscribed peers.
-   * @internal
-   */
-  readonly messageStreams = new ComplexMap<PublicKey, Stream<SignalMessage>>((key) => key.toHex());
-
-  /**
-   * Event to use in tests to wait till subscription is successfully established.
-   * @internal
-   */
-  readonly reconciled = new Event();
-
-  constructor(
-    private readonly _onMessage: (params: Message) => Promise<void>,
-    private readonly _onSwarmEvent: (params: SwarmEvent) => Promise<void>,
-  ) {}
-
-  async safeCloseStreams(): Promise<{ failureCount: number }> {
-    const streams = ([...this._swarmStreams.values()] as Stream<any>[]).concat([...this.messageStreams.values()]);
-    this._swarmStreams.clear();
-    this.messageStreams.clear();
-    const failureCount = (await safeAwaitAll(streams, (s) => s.close())).length;
-    return { failureCount };
-  }
-
-  join({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }): void {
-    this._joinedTopics.add({ topic, peerId });
-  }
-
-  leave({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }): void {
-    void this._swarmStreams.get({ topic, peerId })?.close();
-    this._swarmStreams.delete({ topic, peerId });
-    this._joinedTopics.delete({ topic, peerId });
-  }
-
-  subscribeMessages(peerId: PublicKey): void {
-    this._subscribedMessages.add({ peerId });
-  }
-
-  unsubscribeMessages(peerId: PublicKey): void {
-    log('unsubscribing from messages', { peerId });
-    this._subscribedMessages.delete({ peerId });
-    void this.messageStreams.get(peerId)?.close();
-    this.messageStreams.delete(peerId);
-  }
-
-  public async reconcile(ctx: Context, client: SignalRPCClient): Promise<void> {
-    await this._reconcileSwarmSubscriptions(ctx, client);
-    await this._reconcileMessageSubscriptions(ctx, client);
-    this.reconciled.emit();
-  }
-
-  private async _reconcileSwarmSubscriptions(ctx: Context, client: SignalRPCClient): Promise<void> {
-    // Unsubscribe from topics that are no longer needed.
-    for (const { topic, peerId } of this._swarmStreams.keys()) {
-      // Join desired topics.
-      if (this._joinedTopics.has({ topic, peerId })) {
-        continue;
-      }
-
-      void this._swarmStreams.get({ topic, peerId })?.close();
-      this._swarmStreams.delete({ topic, peerId });
-    }
-
-    // Subscribe to topics that are needed.
-    for (const { topic, peerId } of this._joinedTopics.values()) {
-      // Join desired topics.
-      if (this._swarmStreams.has({ topic, peerId })) {
-        continue;
-      }
-
-      const swarmStream = await asyncTimeout(cancelWithContext(ctx, client.join({ topic, peerId })), 5_000);
-      // Subscribing to swarm events.
-      // TODO(mykola): What happens when the swarm stream is closed? Maybe send leave event for each peer?
-      swarmStream.subscribe(async (swarmEvent: SwarmEventProto) => {
-        if (this._joinedTopics.has({ topic, peerId })) {
-          log('swarm event', { swarmEvent });
-          const event: SwarmEvent = swarmEvent.peerAvailable
-            ? {
-                topic,
-                peerAvailable: {
-                  ...swarmEvent.peerAvailable,
-                  peer: { peerKey: PublicKey.from(swarmEvent.peerAvailable.peer).toHex() },
-                },
-              }
-            : {
-                topic,
-                peerLeft: {
-                  ...swarmEvent.peerLeft,
-                  peer: { peerKey: PublicKey.from(swarmEvent.peerLeft!.peer).toHex() },
-                },
-              };
-          await this._onSwarmEvent(event);
-        }
-      });
-
-      // Saving swarm stream.
-      this._swarmStreams.set({ topic, peerId }, swarmStream);
-    }
-  }
-
-  private async _reconcileMessageSubscriptions(ctx: Context, client: SignalRPCClient): Promise<void> {
-    // Unsubscribe from messages that are no longer needed.
-    for (const peerId of this.messageStreams.keys()) {
-      // Join desired topics.
-      if (this._subscribedMessages.has({ peerId })) {
-        continue;
-      }
-
-      void this.messageStreams.get(peerId)?.close();
-      this.messageStreams.delete(peerId);
-    }
-
-    // Subscribe to messages that are needed.
-    for (const { peerId } of this._subscribedMessages.values()) {
-      if (this.messageStreams.has(peerId)) {
-        continue;
-      }
-
-      const messageStream = await asyncTimeout(cancelWithContext(ctx, client.receiveMessages(peerId)), 5_000);
-      messageStream.subscribe(async (signalMessage: SignalMessage) => {
-        if (this._subscribedMessages.has({ peerId })) {
-          const message: Message = {
-            author: { peerKey: PublicKey.from(signalMessage.author).toHex() },
-            recipient: { peerKey: PublicKey.from(signalMessage.recipient).toHex() },
-            payload: signalMessage.payload,
-          };
-          await this._onMessage(message);
-        }
-      });
-
-      // Saving message stream.
-      this.messageStreams.set(peerId, messageStream);
-    }
-  }
-}

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

@@ -1,15 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { trace } from '@dxos/tracing';
-
-export class SignalRpcClientMonitor {
-  public recordClientCloseFailure(params: { failureReason: string }): void {
-    trace.metrics.increment('dxos.mesh.signal.signal-rpc-client.close-failure', 1, {
-      tags: {
-        reason: params.failureReason,
-      },
-    });
-  }
-}

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

@@ -1,102 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { afterAll, beforeAll, describe, expect, onTestFinished, test } from 'vitest';
-
-import { type Any } from '@dxos/codec-protobuf';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { schema } from '@dxos/protocols/proto';
-import { type Message as SignalMessage, type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
-import { type SignalServerRunner, runTestSignalServer } from '@dxos/signal';
-
-import { SignalRPCClient } from './signal-rpc-client';
-
-describe('SignalRPCClient', () => {
-  let broker: SignalServerRunner;
-
-  beforeAll(async () => {
-    broker = await runTestSignalServer();
-  });
-
-  afterAll(() => {
-    void broker.stop();
-  });
-
-  // TODO(burdon): Convert to TestBuilder pattern.
-  const setupClient = async () => {
-    const client = new SignalRPCClient({ url: broker.url() });
-    onTestFinished(async () => await client.close());
-    return client;
-  };
-
-  test('signal between 2 peers', { timeout: 2_000 }, async () => {
-    const client1 = await setupClient();
-    const client2 = await setupClient();
-
-    const peerId1 = PublicKey.random();
-    const peerId2 = PublicKey.random();
-
-    const stream1 = await client1.receiveMessages(peerId1);
-    const payload: Any = {
-      type_url: 'example.testing.data.TestPayload',
-      value: schema.getCodecForType('example.testing.data.TestPayload').encode({ data: 'Some payload' }),
-    };
-
-    const received: Promise<SignalMessage> = new Promise((resolve) => {
-      stream1.subscribe(
-        (message) => {
-          resolve(message);
-        },
-        (error) => {
-          if (error) {
-            log.catch(error);
-            throw error;
-          }
-        },
-      );
-    });
-
-    await client2.sendMessage({
-      author: peerId2,
-      recipient: peerId1,
-      payload,
-    });
-
-    expect((await received).author).toEqual(peerId2.asBuffer());
-    expect((await received).payload).toEqual(expect.objectContaining(payload));
-    void stream1.close();
-  });
-
-  test('join', { timeout: 2_000 }, async () => {
-    const client1 = await setupClient();
-    const client2 = await setupClient();
-
-    const peerId1 = PublicKey.random();
-    const peerId2 = PublicKey.random();
-    const topic = PublicKey.random();
-
-    const stream1 = await client1.join({ topic, peerId: peerId1 });
-    const promise = new Promise<SwarmEvent>((resolve) => {
-      stream1.subscribe(
-        (event: SwarmEvent) => {
-          if (event.peerAvailable && peerId2.equals(event.peerAvailable.peer!)) {
-            resolve(event);
-          }
-        },
-        (error: any) => {
-          if (error) {
-            log.error(error);
-            throw error;
-          }
-        },
-      );
-    });
-    const stream2 = await client2.join({ topic, peerId: peerId2 });
-
-    expect((await promise).peerAvailable?.peer).toEqual(peerId2.asBuffer());
-    void stream1.close();
-    void stream2.close();
-  });
-});