@libp2p/mdns 9.0.14 → 10.0.0

package/src/index.ts

@@ -76,185 +76,23 @@
  * ```
  */
 
-import { CustomEvent, TypedEventEmitter } from '@libp2p/interface/events'
-import { peerDiscovery } from '@libp2p/interface/peer-discovery'
-import { logger } from '@libp2p/logger'
-import multicastDNS from 'multicast-dns'
-import * as query from './query.js'
-import { stringGen } from './utils.js'
-import type { PeerDiscovery, PeerDiscoveryEvents } from '@libp2p/interface/peer-discovery'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { Startable } from '@libp2p/interface/src/startable.js'
-import type { AddressManager } from '@libp2p/interface-internal/address-manager'
-
-const log = logger('libp2p:mdns')
+import { MulticastDNS } from './mdns.js'
+import type { ComponentLogger, PeerDiscovery } from '@libp2p/interface'
+import type { AddressManager } from '@libp2p/interface-internal'
 
 export interface MulticastDNSInit {
-  /**
-   * (true/false) announce our presence through mDNS, default `true`
-   */
   broadcast?: boolean
-
-  /**
-   * query interval, default 10 \* 1000 (10 seconds)
-   */
   interval?: number
-
-  /**
-   * name of the service announce , default '_p2p._udp.local\`
-   */
   serviceTag?: string
-  /**
-   * Peer name to announce (should not be peeer id), default random string
-   */
   peerName?: string
-
-  /**
-   * UDP port to broadcast to
-   */
   port?: number
-
-  /**
-   * UDP IP to broadcast to
-   */
   ip?: string
 }
 
 export interface MulticastDNSComponents {
   addressManager: AddressManager
-}
-
-class MulticastDNS extends TypedEventEmitter<PeerDiscoveryEvents> implements PeerDiscovery, Startable {
-  public mdns?: multicastDNS.MulticastDNS
-
-  private readonly broadcast: boolean
-  private readonly interval: number
-  private readonly serviceTag: string
-  private readonly peerName: string
-  private readonly port: number
-  private readonly ip: string
-  private _queryInterval: ReturnType<typeof setInterval> | null
-  private readonly components: MulticastDNSComponents
-
-  constructor (components: MulticastDNSComponents, init: MulticastDNSInit = {}) {
-    super()
-
-    this.broadcast = init.broadcast !== false
-    this.interval = init.interval ?? (1e3 * 10)
-    this.serviceTag = init.serviceTag ?? '_p2p._udp.local'
-    this.ip = init.ip ?? '224.0.0.251'
-    this.peerName = init.peerName ?? stringGen(63)
-    // 63 is dns label limit
-    if (this.peerName.length >= 64) {
-      throw new Error('Peer name should be less than 64 chars long')
-    }
-    this.port = init.port ?? 5353
-    this.components = components
-    this._queryInterval = null
-    this._onMdnsQuery = this._onMdnsQuery.bind(this)
-    this._onMdnsResponse = this._onMdnsResponse.bind(this)
-    this._onMdnsWarning = this._onMdnsWarning.bind(this)
-    this._onMdnsError = this._onMdnsError.bind(this)
-  }
-
-  readonly [peerDiscovery] = this
-
-  readonly [Symbol.toStringTag] = '@libp2p/mdns'
-
-  isStarted (): boolean {
-    return Boolean(this.mdns)
-  }
-
-  /**
-   * Start sending queries to the LAN.
-   *
-   * @returns {void}
-   */
-  async start (): Promise<void> {
-    if (this.mdns != null) {
-      return
-    }
-
-    this.mdns = multicastDNS({ port: this.port, ip: this.ip })
-    this.mdns.on('query', this._onMdnsQuery)
-    this.mdns.on('response', this._onMdnsResponse)
-    this.mdns.on('warning', this._onMdnsWarning)
-    this.mdns.on('error', this._onMdnsError)
-
-    this._queryInterval = query.queryLAN(this.mdns, this.serviceTag, this.interval)
-  }
-
-  _onMdnsQuery (event: multicastDNS.QueryPacket): void {
-    if (this.mdns == null) {
-      return
-    }
-
-    log.trace('received incoming mDNS query')
-    query.gotQuery(
-      event,
-      this.mdns,
-      this.peerName,
-      this.components.addressManager.getAddresses(),
-      this.serviceTag,
-      this.broadcast)
-  }
-
-  _onMdnsResponse (event: multicastDNS.ResponsePacket): void {
-    log.trace('received mDNS query response')
-
-    try {
-      const foundPeer = query.gotResponse(event, this.peerName, this.serviceTag)
-
-      if (foundPeer != null) {
-        log('discovered peer in mDNS query response %p', foundPeer.id)
-
-        this.dispatchEvent(new CustomEvent<PeerInfo>('peer', {
-          detail: foundPeer
-        }))
-      }
-    } catch (err) {
-      log.error('Error processing peer response', err)
-    }
-  }
-
-  _onMdnsWarning (err: Error): void {
-    log.error('mdns warning', err)
-  }
-
-  _onMdnsError (err: Error): void {
-    log.error('mdns error', err)
-  }
-
-  /**
-   * Stop sending queries to the LAN.
-   *
-   * @returns {Promise}
-   */
-  async stop (): Promise<void> {
-    if (this.mdns == null) {
-      return
-    }
-
-    this.mdns.removeListener('query', this._onMdnsQuery)
-    this.mdns.removeListener('response', this._onMdnsResponse)
-    this.mdns.removeListener('warning', this._onMdnsWarning)
-    this.mdns.removeListener('error', this._onMdnsError)
-
-    if (this._queryInterval != null) {
-      clearInterval(this._queryInterval)
-      this._queryInterval = null
-    }
-
-    await new Promise<void>((resolve) => {
-      if (this.mdns != null) {
-        this.mdns.destroy(resolve)
-      } else {
-        resolve()
-      }
-    })
+  logger: ComponentLogger
 
-    this.mdns = undefined
-  }
 }
 
 export function mdns (init: MulticastDNSInit = {}): (components: MulticastDNSComponents) => PeerDiscovery {

package/src/mdns.ts

@@ -0,0 +1,149 @@
+import { CustomEvent, TypedEventEmitter, peerDiscoverySymbol } from '@libp2p/interface'
+import multicastDNS from 'multicast-dns'
+import * as query from './query.js'
+import { stringGen } from './utils.js'
+import type { MulticastDNSComponents, MulticastDNSInit } from './index.js'
+import type { Logger, PeerDiscovery, PeerDiscoveryEvents, PeerInfo } from '@libp2p/interface'
+import type { Startable } from '@libp2p/interface/src/startable.js'
+
+export class MulticastDNS extends TypedEventEmitter<PeerDiscoveryEvents> implements PeerDiscovery, Startable {
+  public mdns?: multicastDNS.MulticastDNS
+
+  private readonly log: Logger
+  private readonly broadcast: boolean
+  private readonly interval: number
+  private readonly serviceTag: string
+  private readonly peerName: string
+  private readonly port: number
+  private readonly ip: string
+  private _queryInterval: ReturnType<typeof setInterval> | null
+  private readonly components: MulticastDNSComponents
+
+  constructor (components: MulticastDNSComponents, init: MulticastDNSInit = {}) {
+    super()
+
+    this.log = components.logger.forComponent('libp2p:mdns')
+    this.broadcast = init.broadcast !== false
+    this.interval = init.interval ?? (1e3 * 10)
+    this.serviceTag = init.serviceTag ?? '_p2p._udp.local'
+    this.ip = init.ip ?? '224.0.0.251'
+    this.peerName = init.peerName ?? stringGen(63)
+    // 63 is dns label limit
+    if (this.peerName.length >= 64) {
+      throw new Error('Peer name should be less than 64 chars long')
+    }
+    this.port = init.port ?? 5353
+    this.components = components
+    this._queryInterval = null
+    this._onMdnsQuery = this._onMdnsQuery.bind(this)
+    this._onMdnsResponse = this._onMdnsResponse.bind(this)
+    this._onMdnsWarning = this._onMdnsWarning.bind(this)
+    this._onMdnsError = this._onMdnsError.bind(this)
+  }
+
+  readonly [peerDiscoverySymbol] = this
+
+  readonly [Symbol.toStringTag] = '@libp2p/mdns'
+
+  isStarted (): boolean {
+    return Boolean(this.mdns)
+  }
+
+  /**
+   * Start sending queries to the LAN.
+   *
+   * @returns {void}
+   */
+  async start (): Promise<void> {
+    if (this.mdns != null) {
+      return
+    }
+
+    this.mdns = multicastDNS({ port: this.port, ip: this.ip })
+    this.mdns.on('query', this._onMdnsQuery)
+    this.mdns.on('response', this._onMdnsResponse)
+    this.mdns.on('warning', this._onMdnsWarning)
+    this.mdns.on('error', this._onMdnsError)
+
+    this._queryInterval = query.queryLAN(this.mdns, this.serviceTag, this.interval, {
+      log: this.log
+    })
+  }
+
+  _onMdnsQuery (event: multicastDNS.QueryPacket): void {
+    if (this.mdns == null) {
+      return
+    }
+
+    this.log.trace('received incoming mDNS query')
+    query.gotQuery(
+      event,
+      this.mdns,
+      this.peerName,
+      this.components.addressManager.getAddresses(),
+      this.serviceTag,
+      this.broadcast, {
+        log: this.log
+      }
+    )
+  }
+
+  _onMdnsResponse (event: multicastDNS.ResponsePacket): void {
+    this.log.trace('received mDNS query response')
+
+    try {
+      const foundPeer = query.gotResponse(event, this.peerName, this.serviceTag, {
+        log: this.log
+      })
+
+      if (foundPeer != null) {
+        this.log('discovered peer in mDNS query response %p', foundPeer.id)
+
+        this.dispatchEvent(new CustomEvent<PeerInfo>('peer', {
+          detail: foundPeer
+        }))
+      }
+    } catch (err) {
+      this.log.error('Error processing peer response', err)
+    }
+  }
+
+  _onMdnsWarning (err: Error): void {
+    this.log.error('mdns warning', err)
+  }
+
+  _onMdnsError (err: Error): void {
+    this.log.error('mdns error', err)
+  }
+
+  /**
+   * Stop sending queries to the LAN.
+   *
+   * @returns {Promise}
+   */
+  async stop (): Promise<void> {
+    if (this.mdns == null) {
+      return
+    }
+
+    this.mdns.removeListener('query', this._onMdnsQuery)
+    this.mdns.removeListener('response', this._onMdnsResponse)
+    this.mdns.removeListener('warning', this._onMdnsWarning)
+    this.mdns.removeListener('error', this._onMdnsError)
+
+    if (this._queryInterval != null) {
+      clearInterval(this._queryInterval)
+      this._queryInterval = null
+    }
+
+    await new Promise<void>((resolve) => {
+      if (this.mdns != null) {
+        this.mdns.destroy(resolve)
+      } else {
+        resolve()
+      }
+    })
+
+    this.mdns = undefined
+  }
+}

package/src/query.ts

@@ -1,16 +1,13 @@
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
 import { multiaddr, type Multiaddr, protocols } from '@multiformats/multiaddr'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { LoggerOptions, PeerInfo } from '@libp2p/interface'
 import type { Answer, StringAnswer, TxtAnswer } from 'dns-packet'
 import type { MulticastDNS, QueryPacket, ResponsePacket } from 'multicast-dns'
 
-const log = logger('libp2p:mdns:query')
-
-export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: number): ReturnType<typeof setInterval> {
+export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: number, options?: LoggerOptions): ReturnType<typeof setInterval> {
   const query = (): void => {
-    log.trace('query', serviceTag)
+    options?.log.trace('query', serviceTag)
 
     mdns.query({
       questions: [{
@@ -25,7 +22,7 @@ export function queryLAN (mdns: MulticastDNS, serviceTag: string, interval: numb
   return setInterval(query, interval)
 }
 
-export function gotResponse (rsp: ResponsePacket, localPeerName: string, serviceTag: string): PeerInfo | undefined {
+export function gotResponse (rsp: ResponsePacket, localPeerName: string, serviceTag: string, options?: LoggerOptions): PeerInfo | undefined {
   if (rsp.answers == null) {
     return
   }
@@ -70,21 +67,20 @@ export function gotResponse (rsp: ResponsePacket, localPeerName: string, service
     if (peerId == null) {
       throw new Error("Multiaddr doesn't contain PeerId")
     }
-    log('peer found %p', peerId)
+    options?.log('peer found %p', peerId)
 
     return {
       id: peerIdFromString(peerId),
-      multiaddrs: multiaddrs.map(addr => addr.decapsulateCode(protocols('p2p').code)),
-      protocols: []
+      multiaddrs: multiaddrs.map(addr => addr.decapsulateCode(protocols('p2p').code))
     }
   } catch (e) {
-    log.error('failed to parse mdns response', e)
+    options?.log.error('failed to parse mdns response', e)
   }
 }
 
-export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string, multiaddrs: Multiaddr[], serviceTag: string, broadcast: boolean): void {
+export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string, multiaddrs: Multiaddr[], serviceTag: string, broadcast: boolean, options?: LoggerOptions): void {
   if (!broadcast) {
-    log('not responding to mDNS query as broadcast mode is false')
+    options?.log('not responding to mDNS query as broadcast mode is false')
     return
   }
 
@@ -113,13 +109,13 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string
         // TXT record fields have a max data length of 255 bytes
         // see 6.1 - https://www.ietf.org/rfc/rfc6763.txt
         if (data.length > 255) {
-          log('multiaddr %a is too long to use in mDNS query response', addr)
+          options?.log('multiaddr %a is too long to use in mDNS query response', addr)
           return
         }
 
         // spec mandates multiaddr contains peer id
         if (addr.getPeerId() == null) {
-          log('multiaddr %a did not have a peer ID so cannot be used in mDNS query response', addr)
+          options?.log('multiaddr %a did not have a peer ID so cannot be used in mDNS query response', addr)
           return
         }
 
@@ -132,7 +128,7 @@ export function gotQuery (qry: QueryPacket, mdns: MulticastDNS, peerName: string
         })
       })
 
-    log.trace('responding to query')
+    options?.log.trace('responding to query')
     mdns.respond(answers)
   }
 }