@libp2p/daemon-server 6.0.3 → 7.0.0

package/src/index.ts

@@ -2,27 +2,27 @@
 
 import {
   Request,
+  Response,
   DHTRequest,
   PeerstoreRequest,
   PSRequest,
   StreamInfo
 } from '@libp2p/daemon-protocol'
-import { StreamHandler } from '@libp2p/daemon-protocol/stream-handler'
 import { passThroughUpgrader } from '@libp2p/daemon-protocol/upgrader'
 import { defaultLogger, logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { tcp } from '@libp2p/tcp'
 import { multiaddr, protocols } from '@multiformats/multiaddr'
 import * as lp from 'it-length-prefixed'
+import { lpStream } from 'it-length-prefixed-stream'
 import { pipe } from 'it-pipe'
+import { pbStream } from 'it-protobuf-stream'
 import { CID } from 'multiformats/cid'
 import { DHTOperations } from './dht.js'
 import { PubSubOperations } from './pubsub.js'
 import { ErrorResponse, OkResponse } from './responses.js'
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub'
-import type { Libp2p } from '@libp2p/interface'
-import type { Connection, MultiaddrConnection, Stream } from '@libp2p/interface/connection'
-import type { Listener, Transport } from '@libp2p/interface/transport'
+import type { Libp2p, Connection, MultiaddrConnection, Stream, Listener, Transport } from '@libp2p/interface'
 import type { KadDHT } from '@libp2p/kad-dht'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -59,10 +59,10 @@ export class Server implements Libp2pServer {
     this.multiaddr = multiaddr
     this.libp2p = libp2pNode
     this.tcp = tcp()({
-      // @ts-expect-error this field will be present post v1
       logger: defaultLogger()
     })
     this.listener = this.tcp.createListener({
+      // @ts-expect-error connection may actually be a maconn?
       handler: this.handleConnection.bind(this),
       upgrader: passThroughUpgrader
     })
@@ -383,153 +383,160 @@ export class Server implements Libp2pServer {
   /**
    * Handles requests for the given connection
    */
-  handleConnection (connection: Connection): void {
-    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 })
-
-    void pipe(
-      streamHandler.decoder,
-      source => (async function * () {
-        let request: Request
-
-        for await (const buf of source) {
-          try {
-            request = Request.decode(buf)
-
-            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
+  handleConnection (maConn: MultiaddrConnection): void {
+    void Promise.resolve().then(async () => {
+      const daemon = this // eslint-disable-line @typescript-eslint/no-this-alias
+
+      const pb = pbStream(maConn, {
+        maxDataLength: LIMIT
+      })
+
+      const request = await pb.read(Request)
+      log('read', request)
+
+      try {
+        switch (request.type) {
+          // Connect to another peer
+          case Request.Type.CONNECT: {
+            await daemon.connect(request)
+            await pb.write({
+              type: Response.Type.OK
+            }, Response)
+
+            break
+          }
+          // Get the daemon peer id and addresses
+          case Request.Type.IDENTIFY: {
+            await pb.write({
+              type: Response.Type.OK,
+              identify: {
+                id: daemon.libp2p.peerId.toBytes(),
+                addrs: daemon.libp2p.getMultiaddrs().map(ma => ma.decapsulateCode(protocols('p2p').code)).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
+            }, Response)
+
+            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
               }
-              // 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()
+              seen.add(peerId)
 
-                  if (seen.has(peerId)) {
-                    continue
-                  }
+              peers.push({
+                id: connection.remotePeer.toBytes(),
+                addrs: [connection.remoteAddr.bytes]
+              })
+            }
 
-                  seen.add(peerId)
+            await pb.write({
+              type: Response.Type.OK,
+              peers
+            }, Response)
 
-                  peers.push({
-                    id: connection.remotePeer.toBytes(),
-                    addrs: [connection.remoteAddr.bytes]
-                  })
-                }
+            break
+          }
+          case Request.Type.STREAM_OPEN: {
+            const response = await daemon.openStream(request)
+
+            // write the response
+            await pb.write({
+              type: Response.Type.OK,
+              streamInfo: response.streamInfo
+            }, Response)
+
+            const stream = pb.unwrap()
+
+            // then pipe the connection to the client
+            await pipe(
+              stream,
+              response.connection,
+              stream
+            )
+
+            // Exit the iterator, no more requests can come through
+            break
+          }
+          case Request.Type.STREAM_HANDLER: {
+            await daemon.registerStreamHandler(request)
 
-                yield OkResponse({ peers })
-                break
-              }
-              case Request.Type.STREAM_OPEN: {
-                let response
-                try {
-                  response = await daemon.openStream(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,
-                  async function * (source) {
-                    for await (const list of source) {
-                      yield * list
-                    }
-                  },
-                  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
+            // write the response
+            await pb.write({
+              type: Response.Type.OK
+            }, Response)
+
+            break
+          }
+          case Request.Type.PEERSTORE: {
+            if (request.peerStore == null) {
+              throw new Error('ERR_INVALID_REQUEST')
             }
-          } catch (err: any) {
-            log.error(err)
-            yield ErrorResponse(err)
-            continue
+
+            const stream = pb.unwrap()
+            const lp = lpStream(stream)
+
+            for await (const buf of daemon.handlePeerStoreRequest(request.peerStore)) {
+              await lp.write(buf)
+            }
+
+            break
           }
+          case Request.Type.PUBSUB: {
+            if (request.pubsub == null) {
+              throw new Error('ERR_INVALID_REQUEST')
+            }
+
+            const stream = pb.unwrap()
+            const lp = lpStream(stream)
+
+            for await (const buf of daemon.handlePubsubRequest(request.pubsub)) {
+              await lp.write(buf)
+            }
+
+            break
+          }
+          case Request.Type.DHT: {
+            if (request.dht == null) {
+              throw new Error('ERR_INVALID_REQUEST')
+            }
+
+            const stream = pb.unwrap()
+            const lp = lpStream(stream)
+
+            for await (const buf of daemon.handleDHTRequest(request.dht)) {
+              await lp.write(buf)
+            }
+
+            break
+          }
+          // Not yet supported or doesn't exist
+          default:
+            throw new Error('ERR_INVALID_REQUEST_TYPE')
         }
-      })(),
-      async function (source) {
-        for await (const result of source) {
-          streamHandler.write(result)
-        }
+      } catch (err: any) {
+        log.error(err)
+        await pb.write({
+          type: Response.Type.ERROR,
+          error: {
+            msg: err.message
+          },
+          peers: []
+        }, Response)
+      } finally {
+        await pb.unwrap().close()
       }
-    ).catch(err => {
-      log(err)
     })
+      .catch(err => {
+        log.error('error handling incoming connection', err)
+      })
   }
 }