@libp2p/kad-dht 14.0.2-d34642db1 → 14.1.0-a5cd8cfbe

package/src/reprovider.ts

@@ -0,0 +1,226 @@
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
+import { Queue } from '@libp2p/utils/queue'
+import drain from 'it-drain'
+import { PROVIDERS_VALIDITY, REPROVIDE_CONCURRENCY, REPROVIDE_INTERVAL, REPROVIDE_MAX_QUEUE_SIZE, REPROVIDE_THRESHOLD } from './constants.js'
+import { parseProviderKey, readProviderTime, timeOperationMethod } from './utils.js'
+import type { ContentRouting } from './content-routing/index.js'
+import type { OperationMetrics } from './kad-dht.js'
+import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
+import type { AddressManager } from '@libp2p/interface-internal'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { Datastore } from 'interface-datastore'
+import type { Mortice } from 'mortice'
+import type { CID } from 'multiformats/cid'
+
+export interface ReproviderComponents {
+  peerId: PeerId
+  datastore: Datastore
+  logger: ComponentLogger
+  addressManager: AddressManager
+  metrics?: Metrics
+}
+
+export interface ReproviderInit {
+  logPrefix: string
+  metricsPrefix: string
+  datastorePrefix: string
+  contentRouting: ContentRouting
+  lock: Mortice
+  operationMetrics: OperationMetrics
+  concurrency?: number
+  maxQueueSize?: number
+  threshold?: number
+  validity?: number
+  interval?: number
+  timeout?: Omit<AdaptiveTimeoutInit, 'metricsName' | 'metrics'>
+}
+
+interface QueueJobOptions extends AbortOptions {
+  cid: CID
+}
+
+interface ReprovideEvents {
+  'reprovide:start': CustomEvent
+  'reprovide:end': CustomEvent
+}
+
+export class Reprovider extends TypedEventEmitter<ReprovideEvents> {
+  private readonly log: Logger
+  private readonly reprovideQueue: Queue<void, QueueJobOptions>
+  private readonly maxQueueSize: number
+  private readonly datastore: Datastore
+  private timeout?: ReturnType<typeof setTimeout>
+  private readonly reprovideTimeout: AdaptiveTimeout
+  private running: boolean
+  private shutdownController?: AbortController
+  private readonly reprovideThreshold: number
+  private readonly contentRouting: ContentRouting
+  private readonly datastorePrefix: string
+  private readonly addressManager: AddressManager
+  private readonly validity: number
+  private readonly interval: number
+  private readonly lock: Mortice
+  private readonly peerId: PeerId
+
+  constructor (components: ReproviderComponents, init: ReproviderInit) {
+    super()
+
+    this.log = components.logger.forComponent(`${init.logPrefix}:reprovider`)
+    this.peerId = components.peerId
+    this.reprovideQueue = new Queue({
+      concurrency: init.concurrency ?? REPROVIDE_CONCURRENCY,
+      metrics: components.metrics,
+      metricName: `${init.metricsPrefix}_reprovide_queue`
+    })
+    this.reprovideTimeout = new AdaptiveTimeout({
+      ...(init.timeout ?? {}),
+      metrics: components.metrics,
+      metricName: `${init.metricsPrefix}_reprovide_timeout_milliseconds`
+    })
+    this.datastore = components.datastore
+    this.addressManager = components.addressManager
+    this.datastorePrefix = `/${init.datastorePrefix}/provider`
+    this.reprovideThreshold = init.threshold ?? REPROVIDE_THRESHOLD
+    this.maxQueueSize = init.maxQueueSize ?? REPROVIDE_MAX_QUEUE_SIZE
+    this.validity = init.validity ?? PROVIDERS_VALIDITY
+    this.interval = init.interval ?? REPROVIDE_INTERVAL
+    this.contentRouting = init.contentRouting
+    this.lock = init.lock
+    this.running = false
+
+    this.reprovide = timeOperationMethod(this.reprovide.bind(this), init.operationMetrics, 'PROVIDE')
+  }
+
+  start (): void {
+    if (this.running) {
+      return
+    }
+
+    this.running = true
+
+    this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
+
+    this.timeout = setTimeout(() => {
+      this.cleanUp().catch(err => {
+        this.log.error('error running reprovide/cleanup - %e', err)
+      })
+    }, this.interval)
+  }
+
+  stop (): void {
+    this.running = false
+    this.reprovideQueue.clear()
+    clearTimeout(this.timeout)
+    this.shutdownController?.abort()
+  }
+
+  /**
+   * Check all provider records. Delete them if they have expired, reprovide
+   * them if the provider is us and the expiry is within the reprovide window.
+   */
+  private async cleanUp (): Promise<void> {
+    const release = await this.lock.writeLock()
+
+    try {
+      this.safeDispatchEvent('reprovide:start')
+
+      // Get all provider entries from the datastore
+      for await (const entry of this.datastore.query({
+        prefix: this.datastorePrefix
+      })) {
+        try {
+          // Add a delete to the batch for each expired entry
+          const { cid, peerId } = parseProviderKey(entry.key)
+          const created = readProviderTime(entry.value).getTime()
+          const expires = created + this.validity
+          const now = Date.now()
+          const expired = now > expires
+
+          this.log.trace('comparing: %d < %d = %s %s', created, now - this.validity, expired, expired ? '(expired)' : '')
+
+          // delete the record if it has expired
+          if (expired) {
+            await this.datastore.delete(entry.key)
+          }
+
+          // if the provider is us and we are within the reprovide threshold,
+          // reprovide the record
+          if (this.peerId.equals(peerId) && (now - expires) < this.reprovideThreshold) {
+            this.queueReprovide(cid)
+              .catch(err => {
+                this.log.error('could not reprovide %c - %e', cid, err)
+              })
+          }
+        } catch (err: any) {
+          this.log.error('error processing datastore key %s - %e', entry.key, err.message)
+        }
+      }
+
+      this.log('reprovide/cleanup successful')
+    } finally {
+      release()
+      this.safeDispatchEvent('reprovide:end')
+
+      if (this.running) {
+        this.timeout = setTimeout(() => {
+          this.cleanUp().catch(err => {
+            this.log.error('error running re-provide - %e', err)
+          })
+        }, this.interval)
+      }
+    }
+  }
+
+  private async queueReprovide (cid: CID): Promise<void> {
+    if (!this.running) {
+      return
+    }
+
+    this.log.trace('waiting for queue capacity before adding %c to re-provide queue', cid)
+    await this.reprovideQueue.onSizeLessThan(this.maxQueueSize)
+
+    const existingJob = this.reprovideQueue.queue.find(job => job.options.cid.equals(cid))
+
+    if (existingJob != null) {
+      this.log.trace('not adding %c to re-provide queue - already in queue', cid)
+      return existingJob.join()
+    }
+
+    this.log.trace('adding %c to re-provide queue', cid)
+
+    this.reprovideQueue.add(async (options): Promise<void> => {
+      options.signal?.throwIfAborted()
+
+      if (!this.running) {
+        return
+      }
+
+      this.log.trace('re-providing %c', cid)
+
+      // use adaptive timeout
+      const signal = this.reprovideTimeout.getTimeoutSignal(options)
+
+      try {
+        // reprovide
+        await this.reprovide(options.cid, options)
+      } finally {
+        this.reprovideTimeout.cleanUp(signal)
+      }
+
+      this.log.trace('re-provided %c', cid)
+    }, {
+      signal: this.shutdownController?.signal,
+      cid
+    })
+      .catch(err => {
+        this.log.error('could not re-provide key %c - %e', cid, err)
+      })
+  }
+
+  private async reprovide (cid: CID, options?: AbortOptions): Promise<void> {
+    // reprovide
+    await drain(this.contentRouting.provide(cid, this.addressManager.getAddresses(), options))
+  }
+}

package/src/routing-table/closest-peers.ts

@@ -42,6 +42,7 @@ export class ClosestPeers implements Startable {
   private readonly closeTagName: string
   private readonly closeTagValue: number
   private readonly log: Logger
+  private running: boolean
 
   constructor (components: ClosestPeersComponents, init: ClosestPeersInit) {
     this.components = components
@@ -54,9 +55,16 @@ export class ClosestPeers implements Startable {
 
     this.closestPeers = new PeerSet()
     this.onPeerPing = this.onPeerPing.bind(this)
+    this.running = false
   }
 
   async start (): Promise<void> {
+    if (this.running) {
+      return
+    }
+
+    this.running = true
+
     const targetKadId = await convertPeerId(this.components.peerId)
     this.newPeers = new PeerDistanceList(targetKadId, this.peerSetSize)
     this.routingTable.addEventListener('peer:ping', this.onPeerPing)
@@ -70,6 +78,7 @@ export class ClosestPeers implements Startable {
   }
 
   stop (): void {
+    this.running = false
     this.routingTable.removeEventListener('peer:ping', this.onPeerPing)
     clearTimeout(this.timeout)
   }

package/src/routing-table/index.ts

@@ -30,6 +30,7 @@ export const POPULATE_FROM_DATASTORE_LIMIT = 1000
 
 export interface RoutingTableInit {
   logPrefix: string
+  metricsPrefix: string
   protocol: string
   prefixLength?: number
   splitThreshold?: number
@@ -116,26 +117,26 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     this.pingOldContactQueue = new PeerQueue({
       concurrency: init.pingOldContactConcurrency ?? PING_OLD_CONTACT_CONCURRENCY,
-      metricName: `${init.logPrefix.replaceAll(':', '_')}_ping_old_contact_queue`,
+      metricName: `${init.metricsPrefix}_ping_old_contact_queue`,
       metrics: this.components.metrics,
       maxSize: init.pingOldContactMaxQueueSize ?? PING_OLD_CONTACT_MAX_QUEUE_SIZE
     })
     this.pingOldContactTimeout = new AdaptiveTimeout({
       ...(init.pingOldContactTimeout ?? {}),
       metrics: this.components.metrics,
-      metricName: `${init.logPrefix.replaceAll(':', '_')}_routing_table_ping_old_contact_time_milliseconds`
+      metricName: `${init.metricsPrefix}_routing_table_ping_old_contact_time_milliseconds`
     })
 
     this.pingNewContactQueue = new PeerQueue({
       concurrency: init.pingNewContactConcurrency ?? PING_NEW_CONTACT_CONCURRENCY,
-      metricName: `${init.logPrefix.replaceAll(':', '_')}_ping_new_contact_queue`,
+      metricName: `${init.metricsPrefix}_ping_new_contact_queue`,
       metrics: this.components.metrics,
       maxSize: init.pingNewContactMaxQueueSize ?? PING_NEW_CONTACT_MAX_QUEUE_SIZE
     })
     this.pingNewContactTimeout = new AdaptiveTimeout({
       ...(init.pingNewContactTimeout ?? {}),
       metrics: this.components.metrics,
-      metricName: `${init.logPrefix.replaceAll(':', '_')}_routing_table_ping_new_contact_time_milliseconds`
+      metricName: `${init.metricsPrefix}_routing_table_ping_new_contact_time_milliseconds`
     })
 
     this.kb = new KBucket({
@@ -161,13 +162,13 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     if (this.components.metrics != null) {
       this.metrics = {
-        routingTableSize: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_size`),
-        routingTableKadBucketTotal: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_total`),
-        routingTableKadBucketAverageOccupancy: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_average_occupancy`),
-        routingTableKadBucketMinOccupancy: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_min_occupancy`),
-        routingTableKadBucketMaxOccupancy: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_max_occupancy`),
-        routingTableKadBucketMaxDepth: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_max_depth`),
-        kadBucketEvents: this.components.metrics.registerCounterGroup(`${init.logPrefix.replaceAll(':', '_')}_kad_bucket_events_total`)
+        routingTableSize: this.components.metrics.registerMetric(`${init.metricsPrefix}_routing_table_size`),
+        routingTableKadBucketTotal: this.components.metrics.registerMetric(`${init.metricsPrefix}_routing_table_kad_bucket_total`),
+        routingTableKadBucketAverageOccupancy: this.components.metrics.registerMetric(`${init.metricsPrefix}_routing_table_kad_bucket_average_occupancy`),
+        routingTableKadBucketMinOccupancy: this.components.metrics.registerMetric(`${init.metricsPrefix}_routing_table_kad_bucket_min_occupancy`),
+        routingTableKadBucketMaxOccupancy: this.components.metrics.registerMetric(`${init.metricsPrefix}_routing_table_kad_bucket_max_occupancy`),
+        routingTableKadBucketMaxDepth: this.components.metrics.registerMetric(`${init.metricsPrefix}_routing_table_kad_bucket_max_depth`),
+        kadBucketEvents: this.components.metrics.registerCounterGroup(`${init.metricsPrefix}_kad_bucket_events_total`)
       }
     }
   }
@@ -177,6 +178,10 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   }
 
   async start (): Promise<void> {
+    if (this.running) {
+      return
+    }
+
     this.running = true
 
     await start(this.closestPeerTagger)

package/src/rpc/handlers/get-value.ts

@@ -28,9 +28,11 @@ export class GetValueHandler implements DHTMessageHandler {
   private readonly datastore: Datastore
   private readonly peerRouting: PeerRouting
   private readonly log: Logger
+  private readonly datastorePrefix: string
 
   constructor (components: GetValueHandlerComponents, init: GetValueHandlerInit) {
     this.log = components.logger.forComponent(`${init.logPrefix}:rpc:handlers:get-value`)
+    this.datastorePrefix = `/${init.logPrefix.replaceAll(':', '/')}/record`
     this.peerStore = components.peerStore
     this.datastore = components.datastore
     this.peerRouting = init.peerRouting
@@ -108,7 +110,7 @@ export class GetValueHandler implements DHTMessageHandler {
    */
   async _checkLocalDatastore (key: Uint8Array): Promise<Libp2pRecord | undefined> {
     this.log('checkLocalDatastore looking for %b', key)
-    const dsKey = bufferToRecordKey(key)
+    const dsKey = bufferToRecordKey(this.datastorePrefix, key)
 
     // Fetch value from ds
     let rawRecord

package/src/rpc/handlers/put-value.ts

@@ -22,12 +22,14 @@ export class PutValueHandler implements DHTMessageHandler {
   private readonly components: PutValueHandlerComponents
   private readonly validators: Validators
   private readonly log: Logger
+  private readonly datastorePrefix: string
 
   constructor (components: PutValueHandlerComponents, init: PutValueHandlerInit) {
     const { validators } = init
 
     this.components = components
     this.log = components.logger.forComponent(`${init.logPrefix}:rpc:handlers:put-value`)
+    this.datastorePrefix = `/${init.logPrefix.replaceAll(':', '/')}/record`
     this.validators = validators
   }
 
@@ -48,7 +50,7 @@ export class PutValueHandler implements DHTMessageHandler {
       await verifyRecord(this.validators, deserializedRecord)
 
       deserializedRecord.timeReceived = new Date()
-      const recordKey = bufferToRecordKey(deserializedRecord.key)
+      const recordKey = bufferToRecordKey(this.datastorePrefix, deserializedRecord.key)
       await this.components.datastore.put(recordKey, deserializedRecord.serialize().subarray())
       this.log('put record for %b into datastore under key %k', key, recordKey)
     } catch (err: any) {

package/src/rpc/index.ts

@@ -24,6 +24,7 @@ export interface RPCInit {
   peerRouting: PeerRouting
   validators: Validators
   logPrefix: string
+  metricsPrefix: string
   peerInfoMapper: PeerInfoMapper
 }
 
@@ -41,21 +42,20 @@ export class RPC {
   }
 
   constructor (components: RPCComponents, init: RPCInit) {
-    const { providers, peerRouting, validators, logPrefix, peerInfoMapper } = init
     this.metrics = {
-      operations: components.metrics?.registerCounterGroup(`${logPrefix.replaceAll(':', '_')}_inbound_rpc_requests_total`),
-      errors: components.metrics?.registerCounterGroup(`${logPrefix.replaceAll(':', '_')}_inbound_rpc_errors_total`)
+      operations: components.metrics?.registerCounterGroup(`${init.metricsPrefix}_inbound_rpc_requests_total`),
+      errors: components.metrics?.registerCounterGroup(`${init.metricsPrefix}_inbound_rpc_errors_total`)
     }
 
-    this.log = components.logger.forComponent(`${logPrefix}:rpc`)
+    this.log = components.logger.forComponent(`${init.logPrefix}:rpc`)
     this.routingTable = init.routingTable
     this.handlers = {
-      [MessageType.GET_VALUE.toString()]: new GetValueHandler(components, { peerRouting, logPrefix }),
-      [MessageType.PUT_VALUE.toString()]: new PutValueHandler(components, { validators, logPrefix }),
-      [MessageType.FIND_NODE.toString()]: new FindNodeHandler(components, { peerRouting, logPrefix, peerInfoMapper }),
-      [MessageType.ADD_PROVIDER.toString()]: new AddProviderHandler(components, { providers, logPrefix }),
-      [MessageType.GET_PROVIDERS.toString()]: new GetProvidersHandler(components, { peerRouting, providers, logPrefix, peerInfoMapper }),
-      [MessageType.PING.toString()]: new PingHandler(components, { logPrefix })
+      [MessageType.GET_VALUE.toString()]: new GetValueHandler(components, init),
+      [MessageType.PUT_VALUE.toString()]: new PutValueHandler(components, init),
+      [MessageType.FIND_NODE.toString()]: new FindNodeHandler(components, init),
+      [MessageType.ADD_PROVIDER.toString()]: new AddProviderHandler(components, init),
+      [MessageType.GET_PROVIDERS.toString()]: new GetProvidersHandler(components, init),
+      [MessageType.PING.toString()]: new PingHandler(components, init)
     }
   }
 

package/src/utils.ts

@@ -1,13 +1,16 @@
-import { peerIdFromMultihash } from '@libp2p/peer-id'
+import { peerIdFromMultihash, peerIdFromString } from '@libp2p/peer-id'
 import { Libp2pRecord } from '@libp2p/record'
 import { isPrivateIp } from '@libp2p/utils/private-ip'
 import { Key } from 'interface-datastore/key'
+import { CID } from 'multiformats/cid'
+import * as raw from 'multiformats/codecs/raw'
 import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
+import * as varint from 'uint8-varint'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { RECORD_KEY_PREFIX } from './constants.js'
+import type { Operation, OperationMetrics } from './kad-dht.js'
 import type { PeerId, PeerInfo } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -110,8 +113,8 @@ export function bufferToKey (buf: Uint8Array): Key {
 /**
  * Convert a Uint8Array to their SHA2-256 hash
  */
-export function bufferToRecordKey (buf: Uint8Array): Key {
-  return new Key(`${RECORD_KEY_PREFIX}/${uint8ArrayToString(buf, 'base32')}`, false)
+export function bufferToRecordKey (prefix: string, buf: Uint8Array): Key {
+  return new Key(`${prefix}/${uint8ArrayToString(buf, 'base32')}`, false)
 }
 
 /**
@@ -189,3 +192,98 @@ export function multiaddrIsPublic (multiaddr: Multiaddr): boolean {
 
   return false
 }
+
+/**
+ * Parse the CID and provider peer id from the key
+ */
+export function parseProviderKey (key: Key): { cid: CID, peerId: PeerId } {
+  const parts = key.toString().split('/')
+  const peerIdStr = parts.pop()
+  const cidStr = parts.pop()
+
+  if (peerIdStr == null || cidStr == null) {
+    throw new Error(`incorrectly formatted provider entry key in datastore: ${key.toString()}`)
+  }
+
+  return {
+    cid: CID.createV1(raw.code, Digest.decode(uint8ArrayFromString(cidStr, 'base32'))),
+    peerId: peerIdFromString(peerIdStr)
+  }
+}
+
+/**
+ * Encode the given key its matching datastore key
+ */
+export function toProviderKey (prefix: string, cid: CID | string, peerId?: PeerId): Key {
+  const cidStr = typeof cid === 'string' ? cid : uint8ArrayToString(cid.multihash.bytes, 'base32')
+
+  const parts = [
+    prefix,
+    cidStr
+  ]
+
+  if (peerId != null) {
+    parts.push(peerId.toString())
+  }
+
+  return new Key(parts.join('/'))
+}
+
+export function readProviderTime (buf: Uint8Array): Date {
+  return new Date(varint.decode(buf))
+}
+
+/**
+ * Wraps the passed generator function with timing metrics
+ */
+export function timeOperationGenerator (fn: (...args: any[]) => AsyncGenerator<any>, operationMetrics: OperationMetrics, type: Operation): (...args: any[]) => AsyncGenerator<any> {
+  return async function * (...args: any[]): AsyncGenerator<any> {
+    const stopSuccessTimer = operationMetrics.queryTime?.timer(type)
+    const stopErrorTimer = operationMetrics.errorTime?.timer(type)
+    let errored = false
+
+    try {
+      operationMetrics.queries?.increment({ [type]: true })
+
+      yield * fn(...args)
+    } catch (err) {
+      errored = true
+      stopErrorTimer?.()
+      operationMetrics.errors?.increment({ [type]: true })
+
+      throw err
+    } finally {
+      operationMetrics.queries?.decrement({ [type]: true })
+
+      if (!errored) {
+        stopSuccessTimer?.()
+      }
+    }
+  }
+}
+
+export function timeOperationMethod (fn: (...args: any[]) => Promise<any>, operationMetrics: OperationMetrics, type: Operation): (...args: any[]) => Promise<any> {
+  return async function (...args: any[]): Promise<any> {
+    const stopSuccessTimer = operationMetrics?.queryTime?.timer(type)
+    const stopErrorTimer = operationMetrics?.errorTime?.timer(type)
+    let errored = false
+
+    try {
+      operationMetrics.queries?.increment({ [type]: true })
+
+      return await fn(...args)
+    } catch (err) {
+      errored = true
+      stopErrorTimer?.()
+      operationMetrics.errors?.increment({ [type]: true })
+
+      throw err
+    } finally {
+      operationMetrics.queries?.decrement({ [type]: true })
+
+      if (!errored) {
+        stopSuccessTimer?.()
+      }
+    }
+  }
+}