fix!: only discover bootstrap peers once and tag them on discovery (#142)

Bootstrap peers should be used in an intial DHT self query to find peers
that are KAD-close to us.

We do not need to rediscover the same peers over and over again, instead
we should just discover them once, use them to query for peers near our
PeerId then we can disconnect from them like any other peer

1. Instead of "discovering" the same peers every few seconds, only
discover them once
2. Tag the peers in the peer store with an expiring value to prevent any
potential connection being culled before we've used the bootstrap nodes
to query for peers close to us

BREAKING CHANGE: the `interval` option has been renamed `timeout` and
peers are now only discovered once

Author: achingbrain

README.md

@@ -24,37 +24,49 @@ $ npm i @libp2p/bootstrap
 
 ## Usage
 
+The configured bootstrap peers will be discovered after the configured timeout. This will ensure
+there are some peers in the peer store for the node to use to discover other peers.
+
+They will be tagged with a tag with the name `'bootstrap'` tag, the value `50` and it will expire
+after two minutes which means the nodes connections may be closed if the maximum number of
+connections is reached.
+
+Clients that need constant connections to bootstrap nodes (e.g. browsers) can set the TTL to `Infinity`.
+
 ```JavaScript
-const Libp2p = require('libp2p')
-const Bootstrap = require('libp2p-bootstrap')
-const TCP = require('libp2p-tcp')
-const { NOISE } = require('libp2p-noise')
-const MPLEX = require('libp2p-mplex')
+import { createLibp2p } from 'libp2p'
+import { Bootstrap } from '@libp2p/bootstrap'
+import { TCP } from 'libp2p/tcp'
+import { Noise } from '@libp2p/noise'
+import { Mplex } from '@libp2p/mplex'
 
 let options = {
-    modules: {
-        transport: [ TCP ],
-        peerDiscovery: [ Bootstrap ],
-        streamMuxer: [ MPLEX ],
-        encryption: [ NOISE ]
-    },
-    config: {
-        peerDiscovery: {
-            [Bootstrap.tag]: {
-                list: [ // a list of bootstrap peer multiaddrs to connect to on node startup
-                  "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
-                  "/dnsaddr/bootstrap.libp2p.io/ipfs/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
-                  "/dnsaddr/bootstrap.libp2p.io/ipfs/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa"
-                  ],
-                  interval: 5000 // default is 10 ms,
-                  enabled: true
-            }
-        }
-    }
+  transports: [
+    new TCP()
+  ],
+  streamMuxers: [
+    new Mplex()
+  ],
+  connectionEncryption: [
+    new Noise()
+  ],
+  peerDiscovery: [
+    new Bootstrap({
+      list: [ // a list of bootstrap peer multiaddrs to connect to on node startup
+        "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
+        "/dnsaddr/bootstrap.libp2p.io/ipfs/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
+        "/dnsaddr/bootstrap.libp2p.io/ipfs/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa"
+      ],
+      timeout: 1000, // in ms,
+      tagName: 'bootstrap',
+      tagValue: 50,
+      tagTTL: 120000 // in ms
+    })
+  ]
 }
 
 async function start () {
-  let libp2p = await Libp2p.create(options)
+  let libp2p = await createLibp2p(options)
 
   libp2p.on('peer:discovery', function (peerId) {
     console.log('found peer: ', peerId.toB58String())

examples/try.js

@@ -138,17 +138,21 @@
     "release": "aegir release"
   },
   "dependencies": {
+    "@libp2p/components": "^2.0.0",
     "@libp2p/interface-peer-discovery": "^1.0.1",
     "@libp2p/interface-peer-info": "^1.0.3",
     "@libp2p/interfaces": "^3.0.3",
-    "@libp2p/logger": "^2.0.0",
+    "@libp2p/logger": "^2.0.1",
     "@libp2p/peer-id": "^1.1.15",
     "@multiformats/mafmt": "^11.0.3",
     "@multiformats/multiaddr": "^11.0.0"
   },
   "devDependencies": {
     "@libp2p/interface-peer-discovery-compliance-tests": "^1.0.2",
     "@libp2p/interface-peer-id": "^1.0.4",
-    "aegir": "^37.5.3"
+    "@libp2p/peer-store": "^3.1.5",
+    "aegir": "^37.5.3",
+    "datastore-core": "^8.0.1",
+    "delay": "^5.0.0"
   }
 }

package.json

@@ -6,38 +6,61 @@ import type { PeerDiscovery, PeerDiscoveryEvents } from '@libp2p/interface-peer-
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { symbol } from '@libp2p/interface-peer-discovery'
+import { Components, Initializable } from '@libp2p/components'
 
 const log = logger('libp2p:bootstrap')
 
+const DEFAULT_BOOTSTRAP_TAG_NAME = 'bootstrap'
+const DEFAULT_BOOTSTRAP_TAG_VALUE = 50
+const DEFAULT_BOOTSTRAP_TAG_TTL = 120000
+const DEFAULT_BOOTSTRAP_DISCOVERY_TIMEOUT = 1000
+
 export interface BootstrapOptions {
   /**
    * The list of peer addresses in multi-address format
    */
   list: string[]
 
   /**
-   * The interval between emitting addresses in milliseconds
+   * How long to wait before discovering bootstrap nodes
+   */
+  timeout?: number
+
+  /**
+   * Tag a bootstrap peer with this name before "discovering" it (default: 'bootstrap')
+   */
+  tagName?: string
+
+  /**
+   * The bootstrap peer tag will have this value (default: 50)
+   */
+  tagValue?: number
+
+  /**
+   * Cause the bootstrap peer tag to be removed after this number of ms (default: 2 minutes)
    */
-  interval?: number
+  tagTTL?: number
 }
 
 /**
  * Emits 'peer' events on a regular interval for each peer in the provided list.
  */
-export class Bootstrap extends EventEmitter<PeerDiscoveryEvents> implements PeerDiscovery {
+export class Bootstrap extends EventEmitter<PeerDiscoveryEvents> implements PeerDiscovery, Initializable {
   static tag = 'bootstrap'
 
-  private timer?: ReturnType<typeof setInterval>
+  private timer?: ReturnType<typeof setTimeout>
   private readonly list: PeerInfo[]
-  private readonly interval: number
+  private readonly timeout: number
+  private components: Components = new Components()
+  private readonly _init: BootstrapOptions
 
   constructor (options: BootstrapOptions = { list: [] }) {
     if (options.list == null || options.list.length === 0) {
       throw new Error('Bootstrap requires a list of peer addresses')
     }
     super()
 
-    this.interval = options.interval ?? 10000
+    this.timeout = options.timeout ?? DEFAULT_BOOTSTRAP_DISCOVERY_TIMEOUT
     this.list = []
 
     for (const candidate of options.list) {
@@ -62,6 +85,12 @@ export class Bootstrap extends EventEmitter<PeerDiscoveryEvents> implements Peer
 
       this.list.push(peerData)
     }
+
+    this._init = options
+  }
+
+  init (components: Components) {
+    this.components = components
   }
 
   get [symbol] (): true {
@@ -80,34 +109,48 @@ export class Bootstrap extends EventEmitter<PeerDiscoveryEvents> implements Peer
    * Start emitting events
    */
   start () {
-    if (this.timer != null) {
+    if (this.isStarted()) {
       return
     }
 
-    this.timer = setInterval(() => this._discoverBootstrapPeers(), this.interval)
-    log('Starting bootstrap node discovery')
-    this._discoverBootstrapPeers()
+    log('Starting bootstrap node discovery, discovering peers after %s ms', this.timeout)
+    this.timer = setTimeout(() => {
+      void this._discoverBootstrapPeers()
+        .catch(err => {
+          log.error(err)
+        })
+    }, this.timeout)
   }
 
   /**
    * Emit each address in the list as a PeerInfo
    */
-  _discoverBootstrapPeers () {
+  async _discoverBootstrapPeers () {
     if (this.timer == null) {
       return
     }
 
-    this.list.forEach((peerData) => {
+    for (const peerData of this.list) {
+      await this.components.getPeerStore().tagPeer(peerData.id, this._init.tagName ?? DEFAULT_BOOTSTRAP_TAG_NAME, {
+        value: this._init.tagValue ?? DEFAULT_BOOTSTRAP_TAG_VALUE,
+        ttl: this._init.tagTTL ?? DEFAULT_BOOTSTRAP_TAG_TTL
+      })
+
+      // check we are still running
+      if (this.timer == null) {
+        return
+      }
+
       this.dispatchEvent(new CustomEvent<PeerInfo>('peer', { detail: peerData }))
-    })
+    }
   }
 
   /**
    * Stop emitting events
    */
   stop () {
     if (this.timer != null) {
-      clearInterval(this.timer)
+      clearTimeout(this.timer)
     }
 
     this.timer = undefined

src/index.ts

@@ -5,38 +5,106 @@ import { IPFS } from '@multiformats/mafmt'
 import { Bootstrap } from '../src/index.js'
 import peerList from './fixtures/default-peers.js'
 import partialValidPeerList from './fixtures/some-invalid-peers.js'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { isPeerId } from '@libp2p/interface-peer-id'
+import { Components } from '@libp2p/components'
+import { PersistentPeerStore } from '@libp2p/peer-store'
+import { MemoryDatastore } from 'datastore-core'
+import { multiaddr } from '@multiformats/multiaddr'
+import { peerIdFromString } from '@libp2p/peer-id'
+import delay from 'delay'
 
 describe('bootstrap', () => {
+  let components: Components
+
+  beforeEach(() => {
+    const datastore = new MemoryDatastore()
+    const peerStore = new PersistentPeerStore()
+
+    components = new Components({
+      peerStore,
+      datastore
+    })
+
+    peerStore.init(components)
+  })
+
   it('should throw if no peer list is provided', () => {
     expect(() => new Bootstrap())
       .to.throw('Bootstrap requires a list of peer addresses')
   })
 
-  it('find the other peer', async function () {
+  it('should discover bootstrap peers', async function () {
     this.timeout(5 * 1000)
     const r = new Bootstrap({
       list: peerList,
-      interval: 2000
+      timeout: 100
+    })
+    r.init(components)
+
+    const p = new Promise((resolve) => r.addEventListener('peer', resolve, {
+      once: true
+    }))
+    r.start()
+
+    await p
+    r.stop()
+  })
+
+  it('should tag bootstrap peers', async function () {
+    this.timeout(5 * 1000)
+
+    const tagName = 'tag-tag'
+    const tagValue = 10
+    const tagTTL = 50
+
+    const r = new Bootstrap({
+      list: peerList,
+      timeout: 100,
+      tagName,
+      tagValue,
+      tagTTL
     })
+    r.init(components)
 
     const p = new Promise((resolve) => r.addEventListener('peer', resolve, {
       once: true
     }))
     r.start()
 
     await p
+
+    const bootstrapper0ma = multiaddr(peerList[0])
+    const bootstrapper0PeerIdStr = bootstrapper0ma.getPeerId()
+
+    if (bootstrapper0PeerIdStr == null) {
+      throw new Error('bootstrapper had no PeerID')
+    }
+
+    const bootstrapper0PeerId = peerIdFromString(bootstrapper0PeerIdStr)
+
+    const tags = await components.getPeerStore().getTags(bootstrapper0PeerId)
+
+    expect(tags).to.have.lengthOf(1, 'bootstrap tag was not set')
+    expect(tags).to.have.nested.property('[0].name', tagName, 'bootstrap tag had incorrect name')
+    expect(tags).to.have.nested.property('[0].value', tagValue, 'bootstrap tag had incorrect value')
+
+    await delay(tagTTL * 2)
+
+    const tags2 = await components.getPeerStore().getTags(bootstrapper0PeerId)
+
+    expect(tags2).to.have.lengthOf(0, 'bootstrap tag did not expire')
+
     r.stop()
   })
 
-  it('not fail on malformed peers in peer list', async function () {
+  it('should not fail on malformed peers in peer list', async function () {
     this.timeout(5 * 1000)
 
     const r = new Bootstrap({
       list: partialValidPeerList,
-      interval: 2000
+      timeout: 100
     })
+    r.init(components)
 
     const p = new Promise<void>((resolve) => {
       r.addEventListener('peer', (evt) => {
@@ -55,28 +123,4 @@ describe('bootstrap', () => {
     await p
     r.stop()
   })
-
-  it('stop emitting events when stop() called', async function () {
-    const interval = 100
-    const r = new Bootstrap({
-      list: peerList,
-      interval
-    })
-
-    let emitted: PeerInfo[] = []
-    r.addEventListener('peer', p => emitted.push(p.detail))
-
-    // Should fire emit event for each peer in list on start,
-    // so wait 50 milliseconds then check
-    const p = new Promise((resolve) => setTimeout(resolve, 50))
-    r.start()
-    await p
-    expect(emitted).to.have.length(peerList.length)
-
-    // After stop is called, no more peers should be emitted
-    emitted = []
-    r.stop()
-    await new Promise((resolve) => setTimeout(resolve, interval))
-    expect(emitted).to.have.length(0)
-  })
 })