@libp2p/daemon-server 0.0.0

package/src/index.ts

@@ -0,0 +1,513 @@
+/* eslint max-depth: ["error", 6] */
+
+import { TCP } from '@libp2p/tcp'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { CID } from 'multiformats/cid'
+import * as lp from 'it-length-prefixed'
+import { pipe } from 'it-pipe'
+import { StreamHandler } from './stream-handler.js'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { passThroughUpgrader } from './util/index.js'
+import {
+  Request,
+  DHTRequest,
+  PeerstoreRequest,
+  PSRequest,
+  StreamInfo,
+  IRequest,
+  IStreamInfo,
+  IPSRequest,
+  IDHTRequest,
+  IPeerstoreRequest
+} from '@libp2p/daemon-protocol'
+import type { Listener } from '@libp2p/interfaces/transport'
+import type { Connection, Stream } from '@libp2p/interfaces/connection'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { StreamHandler as StreamCallback } from '@libp2p/interfaces/registrar'
+import type { DualDHT } from '@libp2p/interfaces/dht'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PeerStore } from '@libp2p/interfaces/peer-store'
+import { ErrorResponse, OkResponse } from './responses.js'
+import { DHTOperations } from './dht.js'
+import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
+import { PubSubOperations } from './pubsub.js'
+import { logger } from '@libp2p/logger'
+
+const LIMIT = 1 << 22 // 4MB
+const log = logger('libp2p:daemon')
+
+export interface OpenStream {
+  streamInfo: IStreamInfo,
+  connection: Stream
+}
+
+export interface Libp2p {
+  peerId: PeerId
+  peerStore: PeerStore
+  pubsub?: PubSub
+  dht?: DualDHT
+
+  getConnections: (peerId?: PeerId) => Connection[]
+  getPeers: () => PeerId[]
+  dial: (peer: PeerId | Multiaddr, options?: AbortOptions) => Promise<Connection>
+  handle: (protocol: string | string[], handler: StreamCallback) => Promise<void>
+  start: () => void | Promise<void>
+  stop: () => void | Promise<void>
+  getMultiaddrs: () => Multiaddr[]
+}
+
+export interface DaemonInit {
+  multiaddr: Multiaddr,
+  libp2pNode: any
+}
+
+export interface Libp2pServer {
+  start: () => Promise<void>
+  stop: () => Promise<void>
+  getMultiaddrs: () => Multiaddr[]
+}
+
+export class Server implements Libp2pServer {
+  private multiaddr: Multiaddr
+  private libp2p: Libp2p
+  private tcp: TCP
+  private listener: Listener
+  private streamHandlers: Record<string, StreamHandler>
+  private dhtOperations?: DHTOperations
+  private pubsubOperations?: PubSubOperations
+
+  constructor (init: DaemonInit) {
+    const { multiaddr, libp2pNode } = init
+
+    this.multiaddr = multiaddr
+    this.libp2p = libp2pNode
+    this.tcp = new TCP()
+    this.listener = this.tcp.createListener({
+      handler: this.handleConnection.bind(this),
+      upgrader: passThroughUpgrader
+    })
+    this.streamHandlers = {}
+    this._onExit = this._onExit.bind(this)
+
+    if (libp2pNode.dht != null) {
+      this.dhtOperations = new DHTOperations({ dht: libp2pNode.dht })
+    }
+
+    if (libp2pNode.pubsub != null) {
+      this.pubsubOperations = new PubSubOperations({ pubsub: libp2pNode.pubsub })
+    }
+  }
+
+  /**
+   * Connects the daemons libp2p node to the peer provided
+   */
+  async connect (request: IRequest): Promise<Connection> {
+    if (request.connect == null || request.connect.addrs == null) {
+      throw new Error('Invalid request')
+    }
+
+    const peer = request.connect.peer
+    const addrs = request.connect.addrs.map((a) => new Multiaddr(a))
+    const peerId = peerIdFromBytes(peer)
+
+    await this.libp2p.peerStore.addressBook.set(peerId, addrs)
+    return this.libp2p.dial(peerId)
+  }
+
+  /**
+   * Opens a stream on one of the given protocols to the given peer
+   */
+  async openStream (request: IRequest): Promise<OpenStream> {
+    if (request.streamOpen == null || request.streamOpen.proto == null) {
+      throw new Error('Invalid request')
+    }
+
+    const { peer, proto } = request.streamOpen
+
+    const peerId = peerIdFromString(uint8ArrayToString(peer, 'base58btc'))
+
+    const connection = await this.libp2p.dial(peerId)
+    const { stream, protocol } = await connection.newStream(proto)
+
+    return {
+      streamInfo: {
+        peer: peerId.toBytes(),
+        addr: connection.remoteAddr.bytes,
+        proto: protocol
+      },
+      connection: stream
+    }
+  }
+
+  /**
+   * Sends inbound requests for the given protocol
+   * to the unix socket path provided. If an existing handler
+   * is registered at the path, it will be overridden.
+   *
+   * @param {StreamHandlerRequest} request
+   * @returns {Promise<void>}
+   */
+  async registerStreamHandler (request: IRequest): Promise<void> {
+    if (request.streamHandler == null || request.streamHandler.proto == null) {
+      throw new Error('Invalid request')
+    }
+
+    const protocols = request.streamHandler.proto
+    const addr = new Multiaddr(request.streamHandler.addr)
+    const addrString = addr.toString()
+
+    // If we have a handler, end it
+    if (this.streamHandlers[addrString]) {
+      this.streamHandlers[addrString].close()
+      delete this.streamHandlers[addrString]
+    }
+
+    protocols.forEach((proto) => {
+      // Connect the client socket with the libp2p connection
+      this.libp2p.handle(proto, ({ connection, stream, protocol }) => {
+        const message = StreamInfo.encode({
+          peer: connection.remotePeer.toBytes(),
+          addr: connection.remoteAddr.bytes,
+          proto: protocol
+        }).finish()
+        const encodedMessage = lp.encode.single(message)
+
+        // Tell the client about the new connection
+        // And then begin piping the client and peer connection
+
+        pipe(
+          [encodedMessage, stream.source],
+          clientConnection,
+          stream.sink
+        )
+      })
+    })
+
+    const clientConnection = await this.tcp.dial(addr, {
+      upgrader: passThroughUpgrader
+    })
+  }
+
+  /**
+   * Listens for process exit to handle cleanup
+   *
+   * @private
+   * @returns {void}
+   */
+  _listen () {
+    // listen for graceful termination
+    process.on('SIGTERM', this._onExit)
+    process.on('SIGINT', this._onExit)
+    process.on('SIGHUP', this._onExit)
+  }
+
+  _onExit () {
+    this.stop({ exit: true })
+  }
+
+  /**
+   * Starts the daemon
+   */
+  async start () {
+    this._listen()
+    await this.libp2p.start()
+    await this.listener.listen(this.multiaddr)
+  }
+
+  getMultiaddrs (): Multiaddr[] {
+    return this.listener.getAddrs()
+  }
+
+  /**
+   * Stops the daemon
+   *
+   * @param {object} options
+   * @param {boolean} options.exit - If the daemon process should exit
+   * @returns {Promise<void>}
+   */
+  async stop (options = { exit: false }) {
+    await this.libp2p.stop()
+    await this.listener.close()
+    if (options.exit) {
+      log('server closed, exiting')
+    }
+    process.removeListener('SIGTERM', this._onExit)
+    process.removeListener('SIGINT', this._onExit)
+    process.removeListener('SIGHUP', this._onExit)
+  }
+
+  async * handlePeerStoreRequest (request: IPeerstoreRequest) {
+    try {
+      switch (request.type) {
+        case PeerstoreRequest.Type.GET_PROTOCOLS:
+          if (request.id == null) {
+            throw new Error('Invalid request')
+          }
+
+          const peerId = peerIdFromBytes(request.id)
+          const peer = await this.libp2p.peerStore.get(peerId)
+          const protos = peer.protocols
+          yield OkResponse({ peerStore: { protos } })
+          return
+        case PeerstoreRequest.Type.GET_PEER_INFO:
+          throw new Error('ERR_NOT_IMPLEMENTED')
+        default:
+          throw new Error('ERR_INVALID_REQUEST_TYPE')
+      }
+    } catch (err: any) {
+      yield ErrorResponse(err)
+    }
+  }
+
+  /**
+   * Parses and responds to PSRequests
+   */
+  async * handlePubsubRequest (request: IPSRequest) {
+    try {
+      if (this.libp2p.pubsub == null || !this.pubsubOperations) {
+        throw new Error('PubSub not configured')
+      }
+
+      switch (request.type) {
+        case PSRequest.Type.GET_TOPICS:
+          yield * this.pubsubOperations.getTopics()
+          return
+        case PSRequest.Type.SUBSCRIBE:
+          if (request.topic == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.pubsubOperations.subscribe(request.topic)
+          return
+        case PSRequest.Type.PUBLISH:
+          if (request.topic == null || request.data == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.pubsubOperations.publish(request.topic, request.data)
+          return
+        default:
+          throw new Error('ERR_INVALID_REQUEST_TYPE')
+      }
+    } catch (err: any) {
+      yield ErrorResponse(err)
+    }
+  }
+
+  /**
+   * Parses and responds to DHTRequests
+   */
+  async * handleDHTRequest (request: IDHTRequest) {
+    try {
+      if (this.libp2p.dht == null || !this.dhtOperations) {
+        throw new Error('DHT not configured')
+      }
+
+      switch (request.type) {
+        case DHTRequest.Type.FIND_PEER:
+          if (request.peer == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.findPeer(peerIdFromBytes(request.peer))
+          return
+        case DHTRequest.Type.FIND_PROVIDERS:
+          if (request.cid == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.findProviders(CID.decode(request.cid), request.count ?? 20)
+          return
+        case DHTRequest.Type.PROVIDE:
+          if (request.cid == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.provide(CID.decode(request.cid))
+          return
+        case DHTRequest.Type.GET_CLOSEST_PEERS:
+          if (request.key == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.getClosestPeers(request.key)
+          return
+        case DHTRequest.Type.GET_PUBLIC_KEY:
+          if (request.peer == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.getPublicKey(peerIdFromBytes(request.peer))
+          return
+        case DHTRequest.Type.GET_VALUE:
+          if (request.key == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.getValue(request.key)
+          return
+        case DHTRequest.Type.PUT_VALUE:
+          if (request.key == null || request.value == null) {
+            throw new Error('Invalid request')
+          }
+
+          yield * this.dhtOperations.putValue(request.key, request.value)
+          return
+        default:
+          throw new Error('ERR_INVALID_REQUEST_TYPE')
+      }
+    } catch (err: any) {
+      yield ErrorResponse(err)
+    }
+  }
+
+  /**
+   * Handles requests for the given connection
+   */
+  async handleConnection (connection: Connection) {
+    const daemon = this
+    // @ts-expect-error connection may actually be a maconn?
+    const streamHandler = new StreamHandler({ stream: connection, maxLength: LIMIT })
+
+    await pipe(
+      streamHandler.decoder,
+      source => (async function * () {
+        let request: Request
+
+        for await (let buf of source) {
+          try {
+            request = Request.decode(buf)
+          } catch (err) {
+            yield ErrorResponse(new Error('ERR_INVALID_MESSAGE'))
+            continue
+          }
+
+          switch (request.type) {
+            // Connect to another peer
+            case Request.Type.CONNECT: {
+              try {
+                await daemon.connect(request)
+              } catch (err: any) {
+                yield ErrorResponse(err)
+                break
+              }
+              yield OkResponse()
+              break
+            }
+            // Get the daemon peer id and addresses
+            case Request.Type.IDENTIFY: {
+              yield OkResponse({
+                identify: {
+                  id: daemon.libp2p.peerId.toBytes(),
+                  addrs: daemon.libp2p.getMultiaddrs().map(m => m.bytes)
+                }
+              })
+              break
+            }
+            // Get a list of our current peers
+            case Request.Type.LIST_PEERS: {
+              const peers = []
+
+              for (const peerId of daemon.libp2p.getPeers()) {
+                const conn = daemon.libp2p.getConnections(peerId)[0]
+
+                peers.push({
+                  id: peerId.toBytes(),
+                  addrs: [conn.remoteAddr.bytes]
+                })
+              }
+
+              yield OkResponse({ peers })
+              break
+            }
+            case Request.Type.STREAM_OPEN: {
+              let response
+              try {
+                response = await daemon.openStream(request)
+              } catch (err: any) {
+                yield ErrorResponse(err.message)
+                break
+              }
+
+              // write the response
+              yield OkResponse({
+                streamInfo: response.streamInfo
+              })
+
+              const stream = streamHandler.rest()
+              // then pipe the connection to the client
+              await pipe(
+                stream,
+                response.connection,
+                stream
+              )
+              // Exit the iterator, no more requests can come through
+              return
+            }
+            case Request.Type.STREAM_HANDLER: {
+              try {
+                await daemon.registerStreamHandler(request)
+              } catch (err: any) {
+                yield ErrorResponse(err)
+                break
+              }
+
+              // write the response
+              yield OkResponse()
+              break
+            }
+            case Request.Type.PEERSTORE: {
+              if (request.peerStore == null) {
+                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                break
+              }
+
+              yield * daemon.handlePeerStoreRequest(request.peerStore)
+              break
+            }
+            case Request.Type.PUBSUB: {
+              if (request.pubsub == null) {
+                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                break
+              }
+
+              yield * daemon.handlePubsubRequest(request.pubsub)
+              break
+            }
+            case Request.Type.DHT: {
+              if (request.dht == null) {
+                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                break
+              }
+
+              yield * daemon.handleDHTRequest(request.dht)
+              break
+            }
+            // Not yet supported or doesn't exist
+            default:
+              yield ErrorResponse(new Error('ERR_INVALID_REQUEST_TYPE'))
+              break
+          }
+        }
+      })(),
+      async function (source) {
+        for await (const result of source) {
+          streamHandler.write(result)
+        }
+      }
+    )
+  }
+}
+
+/**
+ * Creates a daemon from the provided Daemon Options
+ */
+export const createServer = async (multiaddr: Multiaddr, libp2pNode: Libp2p): Promise<Libp2pServer> => {
+  const daemon = new Server({
+    multiaddr,
+    libp2pNode
+  })
+
+  return daemon
+}

package/src/pubsub.ts

@@ -0,0 +1,57 @@
+/* eslint max-depth: ["error", 6] */
+
+import {
+  PSMessage
+} from '@libp2p/daemon-protocol'
+import { OkResponse } from './responses.js'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { pushable } from 'it-pushable'
+
+export interface PubSubOperationsInit {
+  pubsub: PubSub
+}
+
+export class PubSubOperations {
+  private pubsub: PubSub
+
+  constructor (init: PubSubOperationsInit) {
+    const { pubsub } = init
+
+    this.pubsub = pubsub
+  }
+
+  async * getTopics () {
+    yield OkResponse({
+      pubsub: {
+        topics: this.pubsub.getTopics()
+      }
+    })
+  }
+
+  async * subscribe (topic: string) {
+    const onMessage = pushable<Uint8Array>()
+
+    await this.pubsub.addEventListener(topic, (evt) => {
+      const msg = evt.detail
+
+      onMessage.push(PSMessage.encode({
+        from: msg.from.toBytes(),
+        data: msg.data,
+        seqno: msg.sequenceNumber == null ? undefined : uint8ArrayFromString(msg.sequenceNumber.toString(16).padStart(16, '0'), 'base16'),
+        topicIDs: [msg.topic],
+        signature: msg.signature,
+        key: msg.key
+      }).finish())
+    })
+
+    yield OkResponse()
+    yield * onMessage
+  }
+
+  async * publish (topic: string, data: Uint8Array) {
+    this.pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+    yield OkResponse()
+  }
+
+}

package/src/responses.ts

@@ -0,0 +1,23 @@
+import { IResponse, Response } from '@libp2p/daemon-protocol'
+
+/**
+ * Creates and encodes an OK response
+ */
+ export function OkResponse (data?: Partial<IResponse>): Uint8Array {
+  return Response.encode({
+    type: Response.Type.OK,
+    ...data
+  }).finish()
+}
+
+/**
+ * Creates and encodes an ErrorResponse
+ */
+export function ErrorResponse (err: Error): Uint8Array {
+  return Response.encode({
+    type: Response.Type.ERROR,
+    error: {
+      msg: err.message
+    }
+  }).finish()
+}

package/src/stream-handler.ts

@@ -0,0 +1,65 @@
+import * as lp from 'it-length-prefixed'
+import { handshake } from 'it-handshake'
+import { logger } from '@libp2p/logger'
+import type { Duplex, Source } from 'it-stream-types'
+import type { Handshake } from 'it-handshake'
+
+const log = logger('libp2p:daemon-client:stream-handler')
+
+export interface StreamHandlerOptions {
+  stream: Duplex<Uint8Array>
+  maxLength?: number
+}
+
+export class StreamHandler {
+  private stream: Duplex<Uint8Array>
+  private shake: Handshake
+  public decoder: Source<Uint8Array>
+  /**
+   * Create a stream handler for connection
+   */
+  constructor (opts: StreamHandlerOptions) {
+    const { stream, maxLength } = opts
+
+    this.stream = stream
+    this.shake = handshake(this.stream)
+    this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength ?? 4096 })
+  }
+
+  /**
+   * Read and decode message
+   */
+  async read () {
+    // @ts-expect-error decoder is really a generator
+    const msg = await this.decoder.next()
+    if (msg.value) {
+      return msg.value.slice()
+    }
+    log('read received no value, closing stream')
+    // End the stream, we didn't get data
+    this.close()
+  }
+
+  write (msg: Uint8Array) {
+    log('write message')
+    this.shake.write(
+      lp.encode.single(msg).slice()
+    )
+  }
+
+  /**
+   * Return the handshake rest stream and invalidate handler
+   */
+  rest () {
+    this.shake.rest()
+    return this.shake.stream
+  }
+
+  /**
+   * Close the stream
+   */
+  close () {
+    log('closing the stream')
+    this.rest().sink([])
+  }
+}

package/src/util/index.ts

@@ -0,0 +1,30 @@
+import type { Upgrader } from '@libp2p/interfaces/transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import { resolve } from 'path'
+import os from 'os'
+
+export const passThroughUpgrader: Upgrader = {
+  // @ts-expect-error
+  upgradeInbound: async maConn => maConn,
+  // @ts-expect-error
+  upgradeOutbound: async maConn => maConn
+}
+
+/**
+ * Converts the multiaddr to a nodejs NET compliant option
+ * for .connect or .listen
+ *
+ * @param {Multiaddr} addr
+ * @returns {string|object} A nodejs NET compliant option
+ */
+export function multiaddrToNetConfig (addr: Multiaddr) {
+  const listenPath = addr.getPath()
+  // unix socket listening
+  if (listenPath) {
+    return resolve(listenPath)
+  }
+  // tcp listening
+  return addr.nodeAddress()
+}
+
+export const isWindows = os.platform() === 'win32'