@libp2p/daemon-server 0.0.1 → 1.0.1

package/src/index.ts

@@ -1,24 +1,18 @@
 /* eslint max-depth: ["error", 6] */
 
 import { TCP } from '@libp2p/tcp'
-import { Multiaddr } from '@multiformats/multiaddr'
+import { Multiaddr, protocols } 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 { StreamHandler } from '@libp2p/daemon-protocol/stream-handler'
+import { passThroughUpgrader } from '@libp2p/daemon-protocol/upgrader'
 import {
   Request,
   DHTRequest,
   PeerstoreRequest,
   PSRequest,
-  StreamInfo,
-  IRequest,
-  IStreamInfo,
-  IPSRequest,
-  IDHTRequest,
-  IPeerstoreRequest
+  StreamInfo
 } from '@libp2p/daemon-protocol'
 import type { Listener } from '@libp2p/interfaces/transport'
 import type { Connection, Stream } from '@libp2p/interfaces/connection'
@@ -30,15 +24,15 @@ 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 { peerIdFromBytes } from '@libp2p/peer-id'
 import { PubSubOperations } from './pubsub.js'
 import { logger } from '@libp2p/logger'
 
 const LIMIT = 1 << 22 // 4MB
-const log = logger('libp2p:daemon')
+const log = logger('libp2p:daemon-server')
 
 export interface OpenStream {
-  streamInfo: IStreamInfo,
+  streamInfo: StreamInfo
   connection: Stream
 }
 
@@ -58,24 +52,24 @@ export interface Libp2p {
 }
 
 export interface DaemonInit {
-  multiaddr: Multiaddr,
+  multiaddr: Multiaddr
   libp2pNode: any
 }
 
 export interface Libp2pServer {
   start: () => Promise<void>
   stop: () => Promise<void>
-  getMultiaddrs: () => Multiaddr[]
+  getMultiaddr: () => 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
+  private readonly multiaddr: Multiaddr
+  private readonly libp2p: Libp2p
+  private readonly tcp: TCP
+  private readonly listener: Listener
+  private readonly streamHandlers: Record<string, StreamHandler>
+  private readonly dhtOperations?: DHTOperations
+  private readonly pubsubOperations?: PubSubOperations
 
   constructor (init: DaemonInit) {
     const { multiaddr, libp2pNode } = init
@@ -102,7 +96,7 @@ export class Server implements Libp2pServer {
   /**
    * Connects the daemons libp2p node to the peer provided
    */
-  async connect (request: IRequest): Promise<Connection> {
+  async connect (request: Request): Promise<Connection> {
     if (request.connect == null || request.connect.addrs == null) {
       throw new Error('Invalid request')
     }
@@ -112,20 +106,20 @@ export class Server implements Libp2pServer {
     const peerId = peerIdFromBytes(peer)
 
     await this.libp2p.peerStore.addressBook.set(peerId, addrs)
-    return this.libp2p.dial(peerId)
+    return await this.libp2p.dial(peerId)
   }
 
   /**
    * Opens a stream on one of the given protocols to the given peer
    */
-  async openStream (request: IRequest): Promise<OpenStream> {
+  async openStream (request: Request): 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 peerId = peerIdFromBytes(peer)
 
     const connection = await this.libp2p.dial(peerId)
     const { stream, protocol } = await connection.newStream(proto)
@@ -144,11 +138,8 @@ export class Server implements Libp2pServer {
    * 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> {
+  async registerStreamHandler (request: Request): Promise<void> {
     if (request.streamHandler == null || request.streamHandler.proto == null) {
       throw new Error('Invalid request')
     }
@@ -158,31 +149,34 @@ export class Server implements Libp2pServer {
     const addrString = addr.toString()
 
     // If we have a handler, end it
-    if (this.streamHandlers[addrString]) {
-      this.streamHandlers[addrString].close()
-      delete this.streamHandlers[addrString]
+    if (this.streamHandlers[addrString] != null) {
+      await this.streamHandlers[addrString].close()
+      delete this.streamHandlers[addrString] // eslint-disable-line @typescript-eslint/no-dynamic-delete
     }
 
-    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
-        )
+    await Promise.all(
+      protocols.map(async (proto) => {
+        // Connect the client socket with the libp2p connection
+        await this.libp2p.handle(proto, ({ connection, stream, protocol }) => {
+          const message = StreamInfo.encode({
+            peer: connection.remotePeer.toBytes(),
+            addr: connection.remoteAddr.bytes,
+            proto: protocol
+          })
+          const encodedMessage = lp.encode.single(message)
+
+          // Tell the client about the new connection
+          // And then begin piping the client and peer connection
+          void pipe(
+            [encodedMessage, stream.source],
+            clientConnection,
+            stream.sink
+          ).catch(err => {
+            log.error(err)
+          })
+        })
       })
-    })
+    )
 
     const clientConnection = await this.tcp.dial(addr, {
       upgrader: passThroughUpgrader
@@ -191,9 +185,6 @@ export class Server implements Libp2pServer {
 
   /**
    * Listens for process exit to handle cleanup
-   *
-   * @private
-   * @returns {void}
    */
   _listen () {
     // listen for graceful termination
@@ -203,7 +194,9 @@ export class Server implements Libp2pServer {
   }
 
   _onExit () {
-    this.stop({ exit: true })
+    void this.stop({ exit: true }).catch(err => {
+      log.error(err)
+    })
   }
 
   /**
@@ -215,16 +208,18 @@ export class Server implements Libp2pServer {
     await this.listener.listen(this.multiaddr)
   }
 
-  getMultiaddrs (): Multiaddr[] {
-    return this.listener.getAddrs()
+  getMultiaddr (): Multiaddr {
+    const addrs = this.listener.getAddrs()
+
+    if (addrs.length > 0) {
+      return addrs[0]
+    }
+
+    throw new Error('Not started')
   }
 
   /**
    * 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()
@@ -237,7 +232,7 @@ export class Server implements Libp2pServer {
     process.removeListener('SIGHUP', this._onExit)
   }
 
-  async * handlePeerStoreRequest (request: IPeerstoreRequest) {
+  async * handlePeerStoreRequest (request: PeerstoreRequest) {
     try {
       switch (request.type) {
         case PeerstoreRequest.Type.GET_PROTOCOLS:
@@ -245,9 +240,9 @@ export class Server implements Libp2pServer {
             throw new Error('Invalid request')
           }
 
-          const peerId = peerIdFromBytes(request.id)
-          const peer = await this.libp2p.peerStore.get(peerId)
-          const protos = peer.protocols
+          const peerId = peerIdFromBytes(request.id) // eslint-disable-line no-case-declarations
+          const peer = await this.libp2p.peerStore.get(peerId) // eslint-disable-line no-case-declarations
+          const protos = peer.protocols // eslint-disable-line no-case-declarations
           yield OkResponse({ peerStore: { protos } })
           return
         case PeerstoreRequest.Type.GET_PEER_INFO:
@@ -256,6 +251,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
+      log.error(err)
       yield ErrorResponse(err)
     }
   }
@@ -263,9 +259,9 @@ export class Server implements Libp2pServer {
   /**
    * Parses and responds to PSRequests
    */
-  async * handlePubsubRequest (request: IPSRequest) {
+  async * handlePubsubRequest (request: PSRequest) {
     try {
-      if (this.libp2p.pubsub == null || !this.pubsubOperations) {
+      if (this.libp2p.pubsub == null || (this.pubsubOperations == null)) {
         throw new Error('PubSub not configured')
       }
 
@@ -291,6 +287,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
+      log.error(err)
       yield ErrorResponse(err)
     }
   }
@@ -298,9 +295,9 @@ export class Server implements Libp2pServer {
   /**
    * Parses and responds to DHTRequests
    */
-  async * handleDHTRequest (request: IDHTRequest) {
+  async * handleDHTRequest (request: DHTRequest) {
     try {
-      if (this.libp2p.dht == null || !this.dhtOperations) {
+      if (this.libp2p.dht == null || (this.dhtOperations == null)) {
         throw new Error('DHT not configured')
       }
 
@@ -358,6 +355,7 @@ export class Server implements Libp2pServer {
           throw new Error('ERR_INVALID_REQUEST_TYPE')
       }
     } catch (err: any) {
+      log.error(err)
       yield ErrorResponse(err)
     }
   }
@@ -365,129 +363,137 @@ export class Server implements Libp2pServer {
   /**
    * Handles requests for the given connection
    */
-  async handleConnection (connection: Connection) {
-    const daemon = this
+  handleConnection (connection: Connection) {
+    const daemon = this // eslint-disable-line @typescript-eslint/no-this-alias
     // @ts-expect-error connection may actually be a maconn?
     const streamHandler = new StreamHandler({ stream: connection, maxLength: LIMIT })
 
-    await pipe(
+    void pipe(
       streamHandler.decoder,
       source => (async function * () {
         let request: Request
 
-        for await (let buf of source) {
+        for await (const 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)
+            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
               }
-              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)
+              // Get the daemon peer id and addresses
+              case Request.Type.IDENTIFY: {
+                yield OkResponse({
+                  identify: {
+                    id: daemon.libp2p.peerId.toBytes(),
+                    addrs: daemon.libp2p.getMultiaddrs().map(ma => ma.decapsulateCode(protocols('p2p').code)).map(m => m.bytes)
+                  }
+                })
+                break
+              }
+              // Get a list of our current peers
+              case Request.Type.LIST_PEERS: {
+                const peers = []
+                const seen = new Set<string>()
+
+                for (const connection of daemon.libp2p.getConnections()) {
+                  const peerId = connection.remotePeer.toString()
+
+                  if (seen.has(peerId)) {
+                    continue
+                  }
+
+                  seen.add(peerId)
+
+                  peers.push({
+                    id: connection.remotePeer.toBytes(),
+                    addrs: [connection.remoteAddr.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]
+                yield OkResponse({ peers })
+                break
+              }
+              case Request.Type.STREAM_OPEN: {
+                let response
+                try {
+                  response = await daemon.openStream(request)
+                } catch (err: any) {
+                  yield ErrorResponse(err)
+                  break
+                }
 
-                peers.push({
-                  id: peerId.toBytes(),
-                  addrs: [conn.remoteAddr.bytes]
+                // write the response
+                yield OkResponse({
+                  streamInfo: response.streamInfo
                 })
-              }
 
-              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
+                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({
-                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)
+                // write the response
+                yield OkResponse()
                 break
               }
+              case Request.Type.PEERSTORE: {
+                if (request.peerStore == null) {
+                  yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                  break
+                }
 
-              // write the response
-              yield OkResponse()
-              break
-            }
-            case Request.Type.PEERSTORE: {
-              if (request.peerStore == null) {
-                yield ErrorResponse(new Error('ERR_INVALID_REQUEST'))
+                yield * daemon.handlePeerStoreRequest(request.peerStore)
                 break
               }
+              case Request.Type.PUBSUB: {
+                if (request.pubsub == 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'))
+                yield * daemon.handlePubsubRequest(request.pubsub)
                 break
               }
+              case Request.Type.DHT: {
+                if (request.dht == 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'))
+                yield * daemon.handleDHTRequest(request.dht)
                 break
               }
-
-              yield * daemon.handleDHTRequest(request.dht)
-              break
+              // Not yet supported or doesn't exist
+              default:
+                yield ErrorResponse(new Error('ERR_INVALID_REQUEST_TYPE'))
+                break
             }
-            // Not yet supported or doesn't exist
-            default:
-              yield ErrorResponse(new Error('ERR_INVALID_REQUEST_TYPE'))
-              break
+          } catch (err: any) {
+            log.error(err)
+            yield ErrorResponse(err)
+            continue
           }
         }
       })(),
@@ -496,14 +502,16 @@ export class Server implements Libp2pServer {
           streamHandler.write(result)
         }
       }
-    )
+    ).catch(err => {
+      log(err)
+    })
   }
 }
 
 /**
  * Creates a daemon from the provided Daemon Options
  */
-export const createServer = async (multiaddr: Multiaddr, libp2pNode: Libp2p): Promise<Libp2pServer> => {
+export const createServer = (multiaddr: Multiaddr, libp2pNode: Libp2p): Libp2pServer => {
   const daemon = new Server({
     multiaddr,
     libp2pNode

package/src/pubsub.ts

@@ -3,17 +3,21 @@
 import {
   PSMessage
 } from '@libp2p/daemon-protocol'
-import { OkResponse } from './responses.js'
+import { ErrorResponse, OkResponse } from './responses.js'
 import type { PubSub } from '@libp2p/interfaces/pubsub'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { pushable } from 'it-pushable'
+import { CustomEvent } from '@libp2p/interfaces'
+import { logger } from '@libp2p/logger'
+
+const log = logger('libp2p:daemon-server:pubsub')
 
 export interface PubSubOperationsInit {
   pubsub: PubSub
 }
 
 export class PubSubOperations {
-  private pubsub: PubSub
+  private readonly pubsub: PubSub
 
   constructor (init: PubSubOperationsInit) {
     const { pubsub } = init
@@ -22,36 +26,51 @@ export class PubSubOperations {
   }
 
   async * getTopics () {
-    yield OkResponse({
-      pubsub: {
-        topics: this.pubsub.getTopics()
-      }
-    })
+    try {
+      yield OkResponse({
+        pubsub: {
+          topics: this.pubsub.getTopics(),
+          peerIDs: []
+        }
+      })
+    } catch (err: any) {
+      log.error(err)
+      yield ErrorResponse(err)
+    }
   }
 
   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
+    try {
+      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
+        }))
+      })
+
+      yield OkResponse()
+      yield * onMessage
+    } catch (err: any) {
+      log.error(err)
+      yield ErrorResponse(err)
+    }
   }
 
   async * publish (topic: string, data: Uint8Array) {
-    this.pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
-    yield OkResponse()
+    try {
+      this.pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      yield OkResponse()
+    } catch (err: any) {
+      log.error(err)
+      yield ErrorResponse(err)
+    }
   }
-
 }

package/src/responses.ts

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