@dxos/signal 2.33.9-dev.43c233c0 → 2.33.9-dev.62131029

package/src/transporter/index.js

@@ -1,179 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import { EventEmitter } from 'events';
-import { discoveryKey } from 'hypercore-crypto';
-import hyperswarm from 'hyperswarm';
-import assert from 'node:assert';
-import pEvent from 'p-event';
-import Protocol from 'simple-hypercore-protocol';
-
-import { BootstrapNode } from './bootstrap-node';
-import { Messenger } from './messenger';
-
-const { Transporters: { Base: BaseTransporter } } = require('moleculer'); // eslint-disable-line @typescript-eslint/no-var-requires
-
-export class ProtocolTransporter extends BaseTransporter {
-  static keyPair () {
-    return Protocol.keyPair();
-  }
-
-  constructor (opts) {
-    const { topic, keyPair, hyperswarm = {}, asBootstrap = false, bootstrapPort } = opts;
-
-    assert(Buffer.isBuffer(topic), 'topic is required and must be a buffer of 32 bytes');
-    assert(keyPair && Buffer.isBuffer(keyPair.publicKey) && Buffer.isBuffer(keyPair.secretKey), 'keyPair is required and must be an object of { publicKey: Buffer<32>, secretKey: Buffer<32> }');
-
-    super(opts);
-
-    this._topic = topic;
-    this._keyPair = keyPair;
-    this._discoveryKey = discoveryKey(topic);
-    this._hyperswarmOptions = hyperswarm;
-    this._messenger = new Messenger(this._topic, this._keyPair);
-
-    this._ee = new EventEmitter();
-    this._nanomessage = null;
-    this._swarm = null;
-    this._bootstrapNode = null;
-
-    if (asBootstrap) {
-      this._bootstrapNode = new BootstrapNode({ port: bootstrapPort });
-    }
-
-    this.onPeerConnection = this.onPeerConnection.bind(this);
-    this._messenger.on('message', message => this._ee.emit(message.topic, message.data));
-    this._messenger.on('peer-added', (peer) => this._ee.emit('peer-added', peer));
-    this._messenger.on('peer-deleted', (peer) => this._ee.emit('peer-deleted', peer));
-  }
-
-  get dht () {
-    return this._swarm && this._swarm.network.discovery && this._swarm.network.discovery.dht;
-  }
-
-  get onlyLocal () {
-    return this._messenger.peers.length === 0;
-  }
-
-  get peers () {
-    return this._messenger ? this._messenger.peers : [];
-  }
-
-  on (event, handler) {
-    this._ee.on(event, handler);
-  }
-
-  off (event, handler) {
-    this._ee.off(event, handler);
-  }
-
-  waitForConnected () {
-    if (this.connected) {
-      return;
-    }
-    return pEvent(this, 'connected');
-  }
-
-  async connect () {
-    const opts = {
-      ...this._hyperswarmOptions
-    };
-
-    if (this._bootstrapNode) {
-      await this._bootstrapNode.start(this.broker);
-
-      if (!opts.bootstrap) {
-        opts.bootstrap = [];
-      }
-
-      const address = await this._bootstrapNode.getAddress();
-      opts.bootstrap.push(`${address.address}:${address.port}`);
-    }
-
-    if (opts.bootstrap) {
-      opts.bootstrap = [...new Set(opts.bootstrap)];
-    }
-
-    this.logger.info('Bootstrap nodes', opts.bootstrap ? opts.bootstrap : 'default');
-
-    this._swarm = hyperswarm(opts);
-    this._swarm.on('connection', this.onPeerConnection);
-    this._swarm.once('close', () => {
-      if (this.connected) {
-        this.connected = false;
-      }
-
-      this._swarm.removeListener('connection', this.onPeerConnection);
-      this.logger.warn('ProtocolTransporter disconnected');
-    });
-
-    await this._messenger.open();
-
-    return new Promise((resolve, reject) => {
-      const onError = (err) => {
-        this.logger.error('ProtocolTransporter error', err.message);
-        reject(err);
-      };
-
-      this._swarm.once('error', onError);
-
-      this._swarm.join(this._discoveryKey, {
-        lookup: true,
-        announce: true
-      }, () => {
-        this.logger.info('ProtocolTransporter connected');
-        this._swarm.removeListener('error', onError);
-        this._ee.emit('connected');
-        void this.onConnected().then(resolve);
-      });
-    });
-  }
-
-  async disconnect () {
-    if (this._bootstrapNode) {
-      await this._bootstrapNode.stop();
-    }
-
-    if (this._swarm) {
-      await new Promise(resolve => this._swarm.destroy(() => resolve()));
-      await this._messenger.close();
-    }
-  }
-
-  subscribe (cmd, nodeID) {
-    const t = this.getTopicName(cmd, nodeID);
-
-    this._ee.on(t, msg => this.receive(cmd, msg));
-
-    return Promise.resolve();
-  }
-
-  /**
-   * Send data buffer.
-   *
-   * @param {String} topic
-   * @param {Buffer} data
-   * @param {Object} meta
-   *
-   * @returns {Promise}
-   */
-  send (topic, data, { packet }) {
-    if (!this._swarm || this._messenger.closed || this._messenger.closing || this._messenger.peers.length === 0) {
-      return Promise.resolve();
-    }
-
-    const sended = this._messenger.send(packet.target, { topic, data });
-    if (!sended) {
-      return this._messenger.broadcast({ topic, data });
-    }
-  }
-
-  async onPeerConnection (socket, info) {
-    try {
-      await this._messenger.addPeer(socket, info);
-    } catch (err) {
-      this.logger.error('Peer error', err);
-    }
-  }
-}

package/src/transporter/messenger.js

@@ -1,223 +0,0 @@
-//
-// Copyright 2021 DXOS.org
-//
-
-import eos from 'end-of-stream';
-import { EventEmitter } from 'events';
-import crypto from 'hypercore-crypto';
-import { NanoresourcePromise } from 'nanoresource-promise/emitter';
-import Protocol from 'simple-hypercore-protocol';
-import varint from 'varint';
-
-import { Broadcast } from '@dxos/broadcast';
-
-const BROADCAST_CHANNEL = 0;
-const DIRECT_CHANNEL = 1;
-
-const packetCodec = {
-  encode: (obj) => {
-    const length = Buffer.byteLength(obj.topic, 'utf8');
-    const buf = Buffer.allocUnsafe(varint.encodingLength(length) + length + obj.data.length);
-    varint.encode(length, buf);
-    buf.write(obj.topic, varint.encode.bytes, length, 'utf8');
-    obj.data.copy(buf, varint.encode.bytes + length);
-    return buf;
-  },
-  decode: (buf) => {
-    const length = varint.decode(buf);
-    const topic = buf.slice(varint.decode.bytes, varint.decode.bytes + length);
-    const data = buf.slice(varint.decode.bytes + length);
-    return { topic: topic.toString(), data };
-  }
-};
-
-class Peer extends EventEmitter {
-  constructor ({ initiator, socket, topic, keyPair }) {
-    super();
-
-    this._initiator = initiator;
-    this._socket = socket;
-    this._initializeProtocol(topic, keyPair);
-  }
-
-  get destroyed () {
-    return this._socket.destroyed;
-  }
-
-  get initiator () {
-    return this._initiator;
-  }
-
-  get publicKey () {
-    return this._protocol.publicKey;
-  }
-
-  get remotePublicKey () {
-    return this._protocol.remotePublicKey;
-  }
-
-  get sessionKey () {
-    return this._protocol.handshakeHash ? crypto.discoveryKey(this._protocol.handshakeHash) : null;
-  }
-
-  // The broadcast use an `id` prop.
-  get id () {
-    return this.remotePublicKey;
-  }
-
-  broadcast (buf) {
-    if (this._socket.destroyed) {
-      return;
-    }
-    this._protocol.extension(BROADCAST_CHANNEL, 0, buf);
-  }
-
-  send (buf) {
-    if (this._socket.destroyed) {
-      return;
-    }
-    this._protocol.extension(DIRECT_CHANNEL, 0, buf);
-  }
-
-  destroy () {
-    if (this._socket.destroyed) {
-      return;
-    }
-    return this._socket.destroy();
-  }
-
-  _initializeProtocol (topic, keyPair) {
-    const socket = this._socket;
-
-    this._protocol = new Protocol(this._initiator, {
-      keyPair,
-      send (data) {
-        socket.write(data);
-      },
-      onclose () {
-        if (socket.destroyed) {
-          return;
-        }
-        socket.destroy();
-      },
-      onhandshake: () => this.emit('handshake'),
-      onextension: (ch, id, data) => this.emit('message', ch, data)
-    });
-
-    socket.on('data', (data) => this._protocol.recv(data));
-
-    eos(socket, () => this._protocol.destroy());
-  }
-}
-
-class Messenger extends NanoresourcePromise {
-  constructor (topic, keyPair) {
-    super();
-
-    this._topic = topic;
-    this._keyPair = keyPair;
-    this._maxAge = 30 * 1000;
-    this._broadcast = new Broadcast(this._middleware(), {
-      id: this.publicKey,
-      maxAge: this._maxAge,
-      maxSize: Number.MAX_SAFE_INTEGER
-    });
-    this._peers = new Set();
-  }
-
-  get publicKey () {
-    return this._keyPair.publicKey;
-  }
-
-  get peers () {
-    return Array.from(this._peers.values());
-  }
-
-  addPeer (socket, info) {
-    const peer = new Peer({
-      initiator: info.client,
-      socket,
-      topic: this._topic,
-      keyPair: this._keyPair
-    });
-
-    peer.on('handshake', () => {
-      if (socket.destroyed) {
-        return;
-      }
-      if (info.deduplicate(peer.remotePublicKey, peer.publicKey)) {
-        return;
-      }
-      this._peers.add(peer);
-      this._broadcast.updatePeers(this.peers);
-      this.emit('peer-added', { initiator: peer.initiator, sessionKey: peer.sessionKey, peerId: peer.id });
-    });
-
-    const onBroadcast = (ch, message) => this.emit('peer-message', ch, message);
-    peer.on('message', onBroadcast);
-
-    eos(socket, () => {
-      this._peers.delete(peer);
-      this._broadcast.updatePeers(this.peers);
-      peer.off('message', onBroadcast);
-      this.emit('peer-deleted', { initiator: peer.initiator, sessionKey: peer.sessionKey, peerId: peer.id });
-    });
-
-    return peer;
-  }
-
-  broadcast (message, options) {
-    return this._broadcast.publish(packetCodec.encode(message), options);
-  }
-
-  send (id, message) {
-    const peer = this.peers.find(p => p.remotePublicKey.toString('hex') === id);
-
-    if (!peer) {
-      return false;
-    }
-
-    return peer.send(packetCodec.encode(message));
-  }
-
-  async _open () {
-    await this._broadcast.open();
-
-    this._pruneCacheInterval = setInterval(() => {
-      this._broadcast.pruneCache();
-    }, this._maxAge);
-  }
-
-  async _close () {
-    await this._broadcast.close();
-    clearInterval(this._pruneCacheInterval);
-  }
-
-  _middleware () {
-    return {
-      // Send must be async.
-      send: async (packet, node) => node.broadcast(packet),
-      subscribe: (onData) => {
-        const onMessage = (ch, message) => {
-          try {
-            if (ch === BROADCAST_CHANNEL) {
-              const response = onData(message);
-              if (response && response.data) {
-                this.emit('message', packetCodec.decode(response.data));
-              }
-            } else {
-              this.emit('message', packetCodec.decode(message));
-            }
-          } catch (err) {}
-        };
-
-        this.on('peer-message', onMessage);
-        return () => {
-          this.off('peer-message', onMessage);
-        };
-      }
-    };
-  }
-}
-
-exports.Messenger = Messenger;