@dxos/network-manager 0.1.0

package/src/topology/star-topology.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+import { SwarmController, Topology } from './topology';
+
+export class StarTopology implements Topology {
+  private _controller?: SwarmController;
+
+  // prettier-ignore
+  constructor(
+    private readonly _centralPeer: PublicKey
+  ) {}
+
+  toString() {
+    return `StarTopology(${this._centralPeer.truncate()})`;
+  }
+
+  init(controller: SwarmController): void {
+    assert(!this._controller, 'Already initialized.');
+    this._controller = controller;
+  }
+
+  update(): void {
+    assert(this._controller, 'Not initialized.');
+    const { candidates, connected, ownPeerId } = this._controller.getState();
+    if (!ownPeerId.equals(this._centralPeer)) {
+      log('leaf peer dropping all connections apart from central peer.');
+
+      // Drop all connections other than central peer.
+      for (const peer of connected) {
+        if (!peer.equals(this._centralPeer)) {
+          log('dropping connection', { peer });
+          this._controller.disconnect(peer);
+        }
+      }
+    }
+
+    for (const peer of candidates) {
+      // Connect to central peer.
+      if (peer.equals(this._centralPeer) || ownPeerId.equals(this._centralPeer)) {
+        log('connecting to peer', { peer });
+        this._controller.connect(peer);
+      }
+    }
+  }
+
+  async onOffer(peer: PublicKey): Promise<boolean> {
+    assert(this._controller, 'Not initialized.');
+    const { ownPeerId } = this._controller.getState();
+    log('offer', {
+      peer,
+      isCentral: peer.equals(this._centralPeer),
+      isSelfCentral: ownPeerId.equals(this._centralPeer)
+    });
+    return ownPeerId.equals(this._centralPeer) || peer.equals(this._centralPeer);
+  }
+
+  async destroy(): Promise<void> {
+    // Nothing to do.
+  }
+}

package/src/topology/topology.ts

@@ -0,0 +1,69 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { PublicKey } from '@dxos/keys';
+
+export interface SwarmController {
+  /**
+   * Get current state.
+   */
+  getState(): SwarmState;
+
+  /**
+   * Initiate a connection.
+   */
+  connect(peer: PublicKey): void;
+
+  /**
+   * Disconnect from a peer.
+   */
+  disconnect(peer: PublicKey): void;
+}
+
+export interface SwarmState {
+  /**
+   * This node's peer Id.
+   */
+  ownPeerId: PublicKey;
+
+  /**
+   * Peers with established connections.
+   */
+  connected: PublicKey[];
+
+  /**
+   * Candidates for connection. Does not intersect with a set of already connected peers.
+   */
+  candidates: PublicKey[];
+}
+
+export interface Topology {
+  /**
+   * Called when swarm is created.
+   *
+   * May be used to bind the swarm controller and initialize any asynchronous actions.
+   *
+   * @param controller
+   */
+  init(controller: SwarmController): void;
+
+  /**
+   * Called when swarm state is updated.
+   */
+  update(): void;
+
+  /**
+   * Called when remote peer offers a connection.
+   *
+   * @returns true - to accept the connection, false - to reject.
+   */
+  onOffer(peer: PublicKey): Promise<boolean>;
+
+  /**
+   * Called when swarm is destroyed or topology is changed.
+   *
+   * Any error thrown here will be a critical error for the swarm.
+   */
+  destroy(): Promise<void>;
+}

package/src/transport/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+export * from './memory-transport';
+export * from './transport';
+export * from './webrtc-transport';
+export * from './webrtc-transport-service';
+export * from './webrtc-transport-proxy';

package/src/transport/memory-transport.test.ts

@@ -0,0 +1,110 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import expect from 'expect';
+import waitForExpect from 'wait-for-expect';
+
+import { discoveryKey } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
+import { Protocol } from '@dxos/mesh-protocol';
+import { afterTest } from '@dxos/testutils';
+import { range } from '@dxos/util';
+
+import { TestProtocolPlugin, testProtocolProvider } from '../testing';
+import { MemoryTransport } from './memory-transport';
+
+// TODO(burdon): Flaky test.
+//  Cannot log after tests are done. Did you forget to wait for something async in your test?
+//  Attempted to log "Ignoring unsupported ICE candidate.".
+
+const createPair = () => {
+  const topic = PublicKey.random();
+  const peer1Id = PublicKey.random();
+  const peer2Id = PublicKey.random();
+  const sessionId = PublicKey.random();
+
+  const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
+  const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id.asBuffer(), plugin1);
+  const connection1 = new MemoryTransport(
+    peer1Id,
+    peer2Id,
+    sessionId,
+    topic,
+    protocolProvider1({ channel: discoveryKey(topic), initiator: true }).stream
+  );
+
+  afterTest(() => connection1.close());
+  afterTest(() => connection1.errors.assertNoUnhandledErrors());
+
+  const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
+  const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id.asBuffer(), plugin2);
+  const connection2 = new MemoryTransport(
+    peer2Id,
+    peer1Id,
+    sessionId,
+    topic,
+    protocolProvider2({ channel: discoveryKey(topic), initiator: false }).stream
+  );
+
+  afterTest(() => connection2.close());
+  afterTest(() => connection2.errors.assertNoUnhandledErrors());
+
+  return {
+    connection1,
+    connection2,
+    plugin1,
+    plugin2,
+    peer1Id,
+    peer2Id,
+    topic
+  };
+};
+
+describe('MemoryTransport', function () {
+  it('establish connection and send data through with protocol', async function () {
+    const { plugin1, plugin2, peer1Id } = createPair();
+
+    const received: any[] = [];
+    const mockReceive = (p: Protocol, s: string) => {
+      received.push(p, s);
+      return undefined;
+    };
+    plugin1.on('receive', mockReceive);
+
+    plugin2.on('connect', async (protocol) => {
+      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
+    });
+
+    await waitForExpect(() => {
+      expect(received.length).toBe(2);
+      expect(received[0]).toBeInstanceOf(Protocol);
+      expect(received[1]).toBe('{"message": "Hello"}');
+    });
+  });
+
+  it('10 pairs of peers connecting at the same time', async function () {
+    await Promise.all(
+      range(10).map(async () => {
+        const { plugin1, plugin2, peer1Id } = createPair();
+
+        const received: any[] = [];
+        const mockReceive = (p: Protocol, s: string) => {
+          received.push(p, s);
+          return undefined;
+        };
+        plugin1.on('receive', mockReceive);
+
+        plugin2.on('connect', async (protocol) => {
+          await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
+        });
+
+        await waitForExpect(() => {
+          expect(received.length).toBe(2);
+          expect(received[0]).toBeInstanceOf(Protocol);
+          expect(received[1]).toBe('{"message": "Hello"}');
+        });
+      })
+    );
+  });
+});

package/src/transport/memory-transport.ts

@@ -0,0 +1,128 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import assert from 'node:assert';
+import { Transform } from 'stream';
+
+import { Event } from '@dxos/async';
+import { ErrorStream } from '@dxos/debug';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
+import { ComplexMap } from '@dxos/util';
+
+import { Transport, TransportFactory } from './transport';
+
+type ConnectionKey = [topic: PublicKey, nodeId: PublicKey, remoteId: PublicKey];
+
+// Delay (in milliseconds) for data being sent through in-memory connections to simulate network latency.
+const MEMORY_TRANSPORT_DELAY = 1;
+
+/**
+ * Creates a binary stream that delays data being sent through the stream by the specified amount of time.
+ */
+const createStreamDelay = (delay: number): NodeJS.ReadWriteStream =>
+  new Transform({
+    objectMode: true,
+    transform: (chunk, _, cb) => {
+      setTimeout(() => cb(null, chunk), delay); // TODO(burdon): Randomize.
+    }
+  });
+
+/**
+ * Fake transport.
+ */
+// TODO(burdon): Remove static variables.
+export class MemoryTransport implements Transport {
+  // TODO(burdon): Remove global properties.
+  private static readonly _connections = new ComplexMap<ConnectionKey, MemoryTransport>(
+    ([topic, nodeId, remoteId]) => topic.toHex() + nodeId.toHex() + remoteId.toHex()
+  );
+
+  public readonly closed = new Event<void>();
+  public readonly connected = new Event<void>();
+  public readonly errors = new ErrorStream();
+
+  private readonly _ownKey: ConnectionKey;
+  private readonly _remoteKey: ConnectionKey;
+
+  private readonly _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+  private readonly _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+
+  private _remoteConnection?: MemoryTransport;
+
+  constructor(
+    private readonly _ownId: PublicKey,
+    private readonly _remoteId: PublicKey,
+    private readonly _sessionId: PublicKey,
+    private readonly _topic: PublicKey,
+    private readonly _stream: NodeJS.ReadWriteStream
+  ) {
+    log('creating', { topic: this._topic, peerId: this._ownId, remoteId: this._remoteId });
+
+    this._ownKey = [this._topic, this._ownId, this._remoteId];
+    this._remoteKey = [this._topic, this._remoteId, this._ownId];
+
+    assert(!MemoryTransport._connections.has(this._ownKey), 'Duplicate memory connection');
+    MemoryTransport._connections.set(this._ownKey, this);
+
+    this._remoteConnection = MemoryTransport._connections.get(this._remoteKey);
+    if (this._remoteConnection) {
+      this._remoteConnection._remoteConnection = this;
+
+      log('connected', { topic: this._topic, peerId: this._ownId, remoteId: this._remoteId });
+      this._stream
+        .pipe(this._outgoingDelay)
+        .pipe(this._remoteConnection._stream)
+        .pipe(this._incomingDelay)
+        .pipe(this._stream);
+
+      this.connected.emit();
+      this._remoteConnection.connected.emit();
+    }
+  }
+
+  get remoteId(): PublicKey {
+    return this._remoteId;
+  }
+
+  get sessionId(): PublicKey {
+    return this._sessionId;
+  }
+
+  async signal(signal: Signal) {
+    // No-op.
+  }
+
+  async close(): Promise<void> {
+    log('closing', { topic: this._topic, peerId: this._ownId, remoteId: this._remoteId });
+
+    MemoryTransport._connections.delete(this._ownKey);
+    if (this._remoteConnection) {
+      MemoryTransport._connections.delete(this._remoteKey);
+
+      // TODO(dmaretskyi): Hypercore streams do not seem to have the unpipe method.
+      //  NOTE(burdon): Using readable-stream.wrap() might help (see feed-store).
+      // code this._stream
+      // code   .unpipe(this._outgoingDelay)
+      // code   .unpipe(this._remoteConnection._stream)
+      // code   .unpipe(this._incomingDelay)
+      // code   .unpipe(this._stream);
+
+      this._outgoingDelay.unpipe();
+      this._incomingDelay.unpipe();
+
+      this._remoteConnection.closed.emit();
+      this._remoteConnection._remoteConnection = undefined;
+      this._remoteConnection = undefined;
+    }
+
+    this.closed.emit();
+    log('closed', { topic: this._topic });
+  }
+}
+
+export const MemoryTransportFactory: TransportFactory = {
+  create: (opts) => new MemoryTransport(opts.ownId, opts.remoteId, opts.sessionId, opts.topic, opts.stream)
+};

package/src/transport/transport.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { ErrorStream } from '@dxos/debug';
+import { PublicKey } from '@dxos/keys';
+import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
+
+import { SignalMessage } from '../signal';
+
+/**
+ * Abstraction over a P2P connection transport. Currently either WebRTC or in-memory.
+ */
+export interface Transport {
+  closed: Event;
+  connected: Event;
+  errors: ErrorStream;
+  signal(signal: Signal): Promise<void>; // TODO(burdon): Remove async?
+  close(): Promise<void>;
+}
+
+export type TransportOptions = {
+  /**
+   * Did local node initiate this connection.
+   */
+  initiator: boolean;
+
+  ownId: PublicKey;
+  remoteId: PublicKey;
+  sessionId: PublicKey;
+  topic: PublicKey;
+
+  /**
+   * Wire protocol.
+   */
+  stream: NodeJS.ReadWriteStream;
+
+  /**
+   * Send a signal message to remote peer.
+   */
+  sendSignal: (msg: SignalMessage) => Promise<void>; // TODO(burdon): Remove async?
+};
+
+export interface TransportFactory {
+  create(options: TransportOptions): Transport;
+}