@libp2p/kad-dht 14.0.2 → 14.1.0-02f285fc8

package/src/providers.ts

@@ -1,292 +1,105 @@
-import { peerIdFromString } from '@libp2p/peer-id'
-import cache from 'hashlru'
-import { Key } from 'interface-datastore/key'
-import Queue from 'p-queue'
+import { PeerMap } from '@libp2p/peer-collections'
 import * as varint from 'uint8-varint'
-import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import {
-  PROVIDERS_CLEANUP_INTERVAL,
-  PROVIDERS_VALIDITY,
-  PROVIDERS_LRU_CACHE_SIZE,
-  PROVIDER_KEY_PREFIX
-} from './constants.js'
-import type { ComponentLogger, Logger, PeerId, Startable } from '@libp2p/interface'
+import { parseProviderKey, readProviderTime, toProviderKey } from './utils.js'
+import type { ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { Datastore } from 'interface-datastore'
+import type { Mortice } from 'mortice'
 import type { CID } from 'multiformats'
 
 export interface ProvidersInit {
-  /**
-   * @default 256
-   */
-  cacheSize?: number
-  /**
-   * How often invalid records are cleaned. (in seconds)
-   *
-   * @default 5400
-   */
-  cleanupInterval?: number
-  /**
-   * How long is a provider valid for. (in seconds)
-   *
-   * @default 86400
-   */
-  provideValidity?: number
+  logPrefix: string
+  datastorePrefix: string
+  lock: Mortice
 }
 
 export interface ProvidersComponents {
   datastore: Datastore
   logger: ComponentLogger
+  metrics?: Metrics
 }
 
 /**
- * This class manages known providers.
- * A provider is a peer that we know to have the content for a given CID.
- *
- * Every `cleanupInterval` providers are checked if they
- * are still valid, i.e. younger than the `provideValidity`.
- * If they are not, they are deleted.
- *
- * To ensure the list survives restarts of the daemon,
- * providers are stored in the datastore, but to ensure
- * access is fast there is an LRU cache in front of that.
+ * Provides a mechanism to add and remove provider records from the datastore
  */
-export class Providers implements Startable {
+export class Providers {
   private readonly log: Logger
   private readonly datastore: Datastore
-  private readonly cache: ReturnType<typeof cache>
-  private readonly cleanupInterval: number
-  private readonly provideValidity: number
-  private readonly syncQueue: Queue
-  private started: boolean
-  private cleaner?: ReturnType<typeof setInterval>
-
-  constructor (components: ProvidersComponents, init: ProvidersInit = {}) {
-    const { cacheSize, cleanupInterval, provideValidity } = init
+  private readonly datastorePrefix: string
+  private readonly lock: Mortice
 
-    this.log = components.logger.forComponent('libp2p:kad-dht:providers')
+  constructor (components: ProvidersComponents, init: ProvidersInit) {
+    this.log = components.logger.forComponent(`${init.logPrefix}:providers`)
+    this.datastorePrefix = `/${init.datastorePrefix}/provider`
     this.datastore = components.datastore
-    this.cleanupInterval = cleanupInterval ?? PROVIDERS_CLEANUP_INTERVAL
-    this.provideValidity = provideValidity ?? PROVIDERS_VALIDITY
-    this.cache = cache(cacheSize ?? PROVIDERS_LRU_CACHE_SIZE)
-    this.syncQueue = new Queue({ concurrency: 1 })
-    this.started = false
-  }
-
-  isStarted (): boolean {
-    return this.started
+    this.lock = init.lock
   }
 
   /**
-   * Start the provider cleanup service
+   * Add a new provider for the given CID
    */
-  async start (): Promise<void> {
-    if (this.started) {
-      return
-    }
-
-    this.started = true
+  async addProvider (cid: CID, provider: PeerId): Promise<void> {
+    const release = await this.lock.readLock()
 
-    this.cleaner = setInterval(
-      () => {
-        this._cleanup().catch(err => {
-          this.log.error(err)
-        })
-      },
-      this.cleanupInterval
-    )
+    try {
+      this.log('%p provides %s', provider, cid)
+      await this.writeProviderEntry(cid, provider)
+    } finally {
+      release()
+    }
   }
 
   /**
-   * Release any resources.
+   * Remove a provider for the given CID
    */
-  async stop (): Promise<void> {
-    this.started = false
-
-    if (this.cleaner != null) {
-      clearInterval(this.cleaner)
-      this.cleaner = undefined
+  async removeProvider (cid: CID, provider: PeerId): Promise<void> {
+    const release = await this.lock.writeLock()
+
+    try {
+      const key = toProviderKey(this.datastorePrefix, cid, provider)
+      this.log('%p no longer provides %s', provider, cid)
+      await this.datastore.delete(key)
+    } finally {
+      release()
     }
   }
 
   /**
-   * Check all providers if they are still valid, and if not delete them
+   * Get a list of providers for the given CID
    */
-  async _cleanup (): Promise<void> {
-    await this.syncQueue.add(async () => {
-      const start = Date.now()
-
-      let count = 0
-      let deleteCount = 0
-      const deleted = new Map<string, Set<string>>()
-      const batch = this.datastore.batch()
-
-      // Get all provider entries from the datastore
-      const query = this.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
-
-      for await (const entry of query) {
-        try {
-          // Add a delete to the batch for each expired entry
-          const { cid, peerId } = parseProviderKey(entry.key)
-          const time = readTime(entry.value).getTime()
-          const now = Date.now()
-          const delta = now - time
-          const expired = delta > this.provideValidity
-
-          this.log('comparing: %d - %d = %d > %d %s', now, time, delta, this.provideValidity, expired ? '(expired)' : '')
-
-          if (expired) {
-            deleteCount++
-            batch.delete(entry.key)
-            const peers = deleted.get(cid) ?? new Set<string>()
-            peers.add(peerId)
-            deleted.set(cid, peers)
-          }
-          count++
-        } catch (err: any) {
-          this.log.error(err.message)
-        }
-      }
-
-      // Commit the deletes to the datastore
-      if (deleted.size > 0) {
-        this.log('deleting %d / %d entries', deleteCount, count)
-        await batch.commit()
-      } else {
-        this.log('nothing to delete')
-      }
-
-      // Clear expired entries from the cache
-      for (const [cid, peers] of deleted) {
-        const key = makeProviderKey(cid)
-        const provs = this.cache.get(key)
-
-        if (provs != null) {
-          for (const peerId of peers) {
-            provs.delete(peerId)
-          }
-
-          if (provs.size === 0) {
-            this.cache.remove(key)
-          } else {
-            this.cache.set(key, provs)
-          }
-        }
-      }
-
-      this.log('Cleanup successful (%dms)', Date.now() - start)
-    })
-  }
+  async getProviders (cid: CID): Promise<PeerId[]> {
+    const release = await this.lock.readLock()
 
-  /**
-   * Get the currently known provider peer ids for a given CID
-   */
-  async _getProvidersMap (cid: CID): Promise<Map<string, Date>> {
-    const cacheKey = makeProviderKey(cid)
-    let provs: Map<string, Date> = this.cache.get(cacheKey)
+    try {
+      this.log('get providers for %s', cid)
+      const provs = await this.loadProviders(cid)
 
-    if (provs == null) {
-      provs = await loadProviders(this.datastore, cid)
-      this.cache.set(cacheKey, provs)
+      return [...provs.keys()]
+    } finally {
+      release()
     }
-
-    return provs
   }
 
   /**
-   * Add a new provider for the given CID
+   * Write a provider into the given store
    */
-  async addProvider (cid: CID, provider: PeerId): Promise<void> {
-    await this.syncQueue.add(async () => {
-      this.log('%p provides %s', provider, cid)
-      const provs = await this._getProvidersMap(cid)
-
-      this.log('loaded %s provs', provs.size)
-      const now = new Date()
-      provs.set(provider.toString(), now)
-
-      const dsKey = makeProviderKey(cid)
-      this.cache.set(dsKey, provs)
+  private async writeProviderEntry (cid: CID, peerId: PeerId, time: Date = new Date()): Promise<void> {
+    const key = toProviderKey(this.datastorePrefix, cid, peerId)
+    const buffer = varint.encode(time.getTime())
 
-      await writeProviderEntry(this.datastore, cid, provider, now)
-    })
+    await this.datastore.put(key, buffer)
   }
 
   /**
-   * Get a list of providers for the given CID
+   * Load providers for the given CID from the store
    */
-  async getProviders (cid: CID): Promise<PeerId[]> {
-    return this.syncQueue.add(async () => {
-      this.log('get providers for %s', cid)
-      const provs = await this._getProvidersMap(cid)
-
-      return [...provs.keys()].map(peerIdStr => {
-        return peerIdFromString(peerIdStr)
-      })
-    }, {
-      // no timeout is specified for this queue so it will not
-      // throw, but this is required to get the right return
-      // type since p-queue@7.3.4
-      throwOnTimeout: true
-    })
-  }
-}
-
-/**
- * Encode the given key its matching datastore key
- */
-function makeProviderKey (cid: CID | string): string {
-  const cidStr = typeof cid === 'string' ? cid : uint8ArrayToString(cid.multihash.bytes, 'base32')
-
-  return `${PROVIDER_KEY_PREFIX}/${cidStr}`
-}
-
-/**
- * Write a provider into the given store
- */
-async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, time: Date): Promise<void> {
-  const dsKey = [
-    makeProviderKey(cid),
-    '/',
-    peer.toString()
-  ].join('')
+  private async loadProviders (cid: CID): Promise<PeerMap<Date>> {
+    const providers = new PeerMap<Date>()
 
-  const key = new Key(dsKey)
-  const buffer = varint.encode(time.getTime())
-
-  await store.put(key, buffer)
-}
-
-/**
- * Parse the CID and provider peer id from the key
- */
-function parseProviderKey (key: Key): { cid: string, peerId: string } {
-  const parts = key.toString().split('/')
-
-  if (parts.length !== 5) {
-    throw new Error(`incorrectly formatted provider entry key in datastore: ${key.toString()}`)
-  }
-
-  return {
-    cid: parts[3],
-    peerId: parts[4]
-  }
-}
-
-/**
- * Load providers for the given CID from the store
- */
-async function loadProviders (store: Datastore, cid: CID): Promise<Map<string, Date>> {
-  const providers = new Map<string, Date>()
-  const query = store.query({ prefix: makeProviderKey(cid) })
+    for await (const entry of this.datastore.query({ prefix: toProviderKey(this.datastorePrefix, cid).toString() })) {
+      const { peerId } = parseProviderKey(entry.key)
+      providers.set(peerId, readProviderTime(entry.value))
+    }
 
-  for await (const entry of query) {
-    const { peerId } = parseProviderKey(entry.key)
-    providers.set(peerId, readTime(entry.value))
+    return providers
   }
-
-  return providers
-}
-
-function readTime (buf: Uint8Array): Date {
-  return new Date(varint.decode(buf))
 }

package/src/query/manager.ts

@@ -12,7 +12,7 @@ import { queryPath } from './query-path.js'
 import type { QueryFunc } from './types.js'
 import type { QueryEvent } from '../index.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { ComponentLogger, Counter, Metric, Metrics, PeerId, RoutingOptions, Startable } from '@libp2p/interface'
+import type { ComponentLogger, Metrics, PeerId, RoutingOptions, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { DeferredPromise } from 'p-defer'
 
@@ -22,6 +22,7 @@ export interface CleanUpEvents {
 
 export interface QueryManagerInit {
   logPrefix: string
+  metricsPrefix: string
   disjointPaths?: number
   alpha?: number
   initialQuerySelfHasRun: DeferredPromise<void>
@@ -58,35 +59,23 @@ export class QueryManager implements Startable {
   private readonly routingTable: RoutingTable
   private initialQuerySelfHasRun?: DeferredPromise<void>
   private readonly logPrefix: string
-  private readonly metrics: {
-    queries?: Counter
-    errors?: Counter
-    queryTime?: Metric
-  }
 
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
-    const { disjointPaths = K, alpha = ALPHA, logPrefix } = init
-
-    this.logPrefix = logPrefix
-    this.disjointPaths = disjointPaths ?? K
-    this.running = false
-    this.alpha = alpha ?? ALPHA
+    this.logPrefix = init.logPrefix
+    this.disjointPaths = init.disjointPaths ?? K
+    this.alpha = init.alpha ?? ALPHA
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
     this.routingTable = init.routingTable
     this.logger = components.logger
     this.peerId = components.peerId
     this.connectionManager = components.connectionManager
 
-    this.metrics = {
-      queries: components.metrics?.registerCounter(`${logPrefix.replaceAll(':', '_')}_queries_total`),
-      errors: components.metrics?.registerCounter(`${logPrefix.replaceAll(':', '_')}_query_errors_total`),
-      queryTime: components.metrics?.registerMetric(`${logPrefix.replaceAll(':', '_')}_query_time_seconds`)
-    }
-
     // allow us to stop queries on shut down
     this.shutDownController = new AbortController()
     // make sure we don't make a lot of noise in the logs
     setMaxListeners(Infinity, this.shutDownController.signal)
+
+    this.running = false
   }
 
   isStarted (): boolean {
@@ -97,6 +86,10 @@ export class QueryManager implements Startable {
    * Starts the query manager
    */
   async start (): Promise<void> {
+    if (this.running) {
+      return
+    }
+
     this.running = true
 
     // allow us to stop queries on shut down
@@ -119,8 +112,6 @@ export class QueryManager implements Startable {
       throw new Error('QueryManager not started')
     }
 
-    const stopQueryTimer = this.metrics.queryTime?.timer()
-
     if (options.signal == null) {
       // don't let queries run forever
       const signal = AbortSignal.timeout(DEFAULT_QUERY_TIMEOUT)
@@ -152,7 +143,6 @@ export class QueryManager implements Startable {
     const log = this.logger.forComponent(`${this.logPrefix}:query:` + uint8ArrayToString(key, 'base58btc'))
 
     // query a subset of peers up to `kBucketSize / 2` in length
-    const startTime = Date.now()
     let queryFinished = false
 
     try {
@@ -165,7 +155,6 @@ export class QueryManager implements Startable {
       }
 
       log('query:start')
-      this.metrics?.queries?.increment()
 
       const id = await convertBuffer(key)
       const peers = this.routingTable.closestPeers(id)
@@ -220,10 +209,6 @@ export class QueryManager implements Startable {
 
       queryFinished = true
     } catch (err: any) {
-      if (!queryFinished) {
-        this.metrics?.errors?.increment()
-      }
-
       if (!this.running && err.name === 'QueryAbortedError') {
         // ignore query aborted errors that were thrown during query manager shutdown
       } else {
@@ -237,8 +222,7 @@ export class QueryManager implements Startable {
 
       signal.clear()
 
-      stopQueryTimer?.()
-      log('query:done in %dms', Date.now() - startTime)
+      log('query:done')
     }
   }
 }

package/src/query-self.ts

@@ -6,6 +6,8 @@ import take from 'it-take'
 import pDefer from 'p-defer'
 import { pEvent } from 'p-event'
 import { QUERY_SELF_INTERVAL, QUERY_SELF_TIMEOUT, K, QUERY_SELF_INITIAL_INTERVAL } from './constants.js'
+import { timeOperationMethod } from './utils.js'
+import type { OperationMetrics } from './kad-dht.js'
 import type { PeerRouting } from './peer-routing/index.js'
 import type { RoutingTable } from './routing-table/index.js'
 import type { ComponentLogger, Logger, PeerId, Startable } from '@libp2p/interface'
@@ -20,6 +22,7 @@ export interface QuerySelfInit {
   initialInterval?: number
   queryTimeout?: number
   initialQuerySelfHasRun: DeferredPromise<void>
+  operationMetrics: OperationMetrics
 }
 
 export interface QuerySelfComponents {
@@ -39,37 +42,37 @@ export class QuerySelf implements Startable {
   private readonly interval: number
   private readonly initialInterval: number
   private readonly queryTimeout: number
-  private started: boolean
+  private running: boolean
   private timeoutId?: ReturnType<typeof setTimeout>
   private controller?: AbortController
   private initialQuerySelfHasRun?: DeferredPromise<void>
   private querySelfPromise?: DeferredPromise<void>
 
   constructor (components: QuerySelfComponents, init: QuerySelfInit) {
-    const { peerRouting, logPrefix, count, interval, queryTimeout, routingTable } = init
-
     this.peerId = components.peerId
-    this.log = components.logger.forComponent(`${logPrefix}:query-self`)
-    this.started = false
-    this.peerRouting = peerRouting
-    this.routingTable = routingTable
-    this.count = count ?? K
-    this.interval = interval ?? QUERY_SELF_INTERVAL
+    this.log = components.logger.forComponent(`${init.logPrefix}:query-self`)
+    this.running = false
+    this.peerRouting = init.peerRouting
+    this.routingTable = init.routingTable
+    this.count = init.count ?? K
+    this.interval = init.interval ?? QUERY_SELF_INTERVAL
     this.initialInterval = init.initialInterval ?? QUERY_SELF_INITIAL_INTERVAL
-    this.queryTimeout = queryTimeout ?? QUERY_SELF_TIMEOUT
+    this.queryTimeout = init.queryTimeout ?? QUERY_SELF_TIMEOUT
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
+
+    this.querySelf = timeOperationMethod(this.querySelf.bind(this), init.operationMetrics, 'SELF_QUERY')
   }
 
   isStarted (): boolean {
-    return this.started
+    return this.running
   }
 
   start (): void {
-    if (this.started) {
+    if (this.running) {
       return
     }
 
-    this.started = true
+    this.running = true
     clearTimeout(this.timeoutId)
     this.timeoutId = setTimeout(() => {
       this.querySelf()
@@ -80,7 +83,7 @@ export class QuerySelf implements Startable {
   }
 
   stop (): void {
-    this.started = false
+    this.running = false
 
     if (this.timeoutId != null) {
       clearTimeout(this.timeoutId)
@@ -92,7 +95,7 @@ export class QuerySelf implements Startable {
   }
 
   async querySelf (): Promise<void> {
-    if (!this.started) {
+    if (!this.running) {
       this.log('skip self-query because we are not started')
       return
     }
@@ -104,7 +107,7 @@ export class QuerySelf implements Startable {
 
     this.querySelfPromise = pDefer()
 
-    if (this.started) {
+    if (this.running) {
       this.controller = new AbortController()
       const signals = [this.controller.signal]
 
@@ -157,7 +160,7 @@ export class QuerySelf implements Startable {
     this.querySelfPromise.resolve()
     this.querySelfPromise = undefined
 
-    if (!this.started) {
+    if (!this.running) {
       return
     }