rhizome/src/node.ts

import Debug from 'debug';
import {CREATOR, HTTP_API_ADDR, HTTP_API_ENABLE, HTTP_API_PORT, PEER_ID, PUB_SUB_TOPIC, PUBLISH_BIND_ADDR, PUBLISH_BIND_HOST, PUBLISH_BIND_PORT, REQUEST_BIND_ADDR, REQUEST_BIND_HOST, REQUEST_BIND_PORT, SEED_PEERS} from './config.js';
import {DeltaStream} from './deltas.js';
import {HttpServer} from './http/index.js';
import {Lossless} from './lossless.js';
import {Peers} from './peers.js';
import {PubSub} from './pub-sub.js';
import {RequestReply} from './request-reply.js';
import {PeerAddress} from './types.js';
const debug = Debug('rhizome-node');

export type RhizomeNodeConfig = {
  requestBindAddr: string;
  requestBindHost: string;
  requestBindPort: number;
  publishBindAddr: string;
  publishBindHost: string;
  publishBindPort: number;
  httpAddr: string;
  httpPort: number;
  httpEnable: boolean;
  seedPeers: PeerAddress[];
  peerId: string;
  creator: string; // TODO each host should be able to support multiple users
  pubSubTopic: string;
};

// So that we can run more than one instance in the same process (for testing)
export class RhizomeNode {
  config: RhizomeNodeConfig;
  pubSub: PubSub;
  requestReply: RequestReply;
  httpServer: HttpServer;
  deltaStream: DeltaStream;
  lossless: Lossless;
  peers: Peers;
  myRequestAddr: PeerAddress;
  myPublishAddr: PeerAddress;

  constructor(config?: Partial<RhizomeNodeConfig>) {
    this.config = {
      requestBindAddr: REQUEST_BIND_ADDR,
      requestBindHost: REQUEST_BIND_HOST,
      requestBindPort: REQUEST_BIND_PORT,
      publishBindAddr: PUBLISH_BIND_ADDR,
      publishBindHost: PUBLISH_BIND_HOST,
      publishBindPort: PUBLISH_BIND_PORT,
      httpAddr: HTTP_API_ADDR,
      httpPort: HTTP_API_PORT,
      httpEnable: HTTP_API_ENABLE,
      seedPeers: SEED_PEERS,
      peerId: PEER_ID,
      creator: CREATOR,
      pubSubTopic: PUB_SUB_TOPIC,
      ...config
    };
    debug('config', this.config);
    this.myRequestAddr = new PeerAddress(
      this.config.requestBindHost,
      this.config.requestBindPort
    );
    this.myPublishAddr = new PeerAddress(
      this.config.publishBindHost,
      this.config.publishBindPort
    );
    this.pubSub = new PubSub(this);
    this.requestReply = new RequestReply(this);
    this.httpServer = new HttpServer(this);
    this.deltaStream = new DeltaStream(this);
    this.peers = new Peers(this);
    this.lossless = new Lossless();
  }

  async start() {
    // Connect our lossless view to the delta stream
    this.deltaStream.subscribeDeltas((delta) => this.lossless.ingestDelta(delta));

    // Start ZeroMQ publish and reply sockets
    await this.pubSub.start();
    this.requestReply.start();

    // Start HTTP server
    if (this.config.httpEnable) {
      this.httpServer.start();
    }

    // Start libp2p subscription
    this.peers.start();

    // Wait a short time for sockets to initialize
    await new Promise((resolve) => setTimeout(resolve, 500));

    // Subscribe to seed peers
    this.peers.subscribeToSeeds();

    // Wait a short time for sockets to initialize
    await new Promise((resolve) => setTimeout(resolve, 500));

    // Ask all peers for all deltas
    this.peers.askAllPeersForDeltas();

    // Wait to receive all deltas
    await new Promise((resolve) => setTimeout(resolve, 1000));
  }

  async stop() {
    await this.pubSub.stop();
    await this.requestReply.stop();
    await this.httpServer.stop();
  }
}