@streamr/dht 100.2.4-beta.0 → 100.2.4

package/src/dht/PeerManager.ts

@@ -1,19 +1,19 @@
 import {
     Logger
 } from '@streamr/utils'
+import EventEmitter from 'eventemitter3'
 import KBucket from 'k-bucket'
+import { LockID } from '../connection/ConnectionLockStates'
+import { ConnectionLocker } from '../connection/ConnectionManager'
+import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
 import {
     PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
 import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 import { RandomContactList } from './contact/RandomContactList'
-import { ReadonlySortedContactList, SortedContactList } from './contact/SortedContactList'
-import { ConnectionLocker } from '../connection/ConnectionManager'
-import EventEmitter from 'eventemitter3'
-import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
 import { RingContactList } from './contact/RingContactList'
+import { ReadonlySortedContactList, SortedContactList } from './contact/SortedContactList'
 import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentifiers'
-import { LockID } from '../connection/ConnectionLockStates'
 
 const logger = new Logger(module)
 
@@ -28,9 +28,24 @@ interface PeerManagerConfig {
     hasConnection: (nodeId: DhtAddress) => boolean
 }
 
+// Returns all offline nodes, sets contacts as active if they are online
+const pingNodes = async (nodes: DhtNodeRpcRemote[], activeContacts: Set<DhtAddress>): Promise<PeerDescriptor[]> => {
+    const offlineNeighbors: PeerDescriptor[] = []
+    await Promise.allSettled(nodes.map(async (contact) => {
+        const isOnline = await contact.ping()
+        if (!isOnline) {
+            activeContacts.delete(contact.getNodeId())
+            offlineNeighbors.push(contact.getPeerDescriptor())
+        } else {
+            activeContacts.add(contact.getNodeId())
+        }
+    }))
+    return offlineNeighbors
+}
+
 export interface PeerManagerEvents {
-    closestContactAdded: (peerDescriptor: PeerDescriptor) => void
-    closestContactRemoved: (peerDescriptor: PeerDescriptor) => void
+    nearbyContactAdded: (peerDescriptor: PeerDescriptor) => void
+    nearbyContactRemoved: (peerDescriptor: PeerDescriptor) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor) => void
     ringContactAdded: (peerDescriptor: PeerDescriptor) => void
@@ -51,7 +66,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // * 'contacts' are all non-unresponsive nodes that we know about
 
     private neighbors: KBucket<DhtNodeRpcRemote>
-    private closestContacts: SortedContactList<DhtNodeRpcRemote>
+    private nearbyContacts: SortedContactList<DhtNodeRpcRemote>
     private activeContacts: Set<DhtAddress>
     private ringContacts: RingContactList<DhtNodeRpcRemote>
     private randomContacts: RandomContactList<DhtNodeRpcRemote>
@@ -79,20 +94,20 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.neighbors.on('updated', () => {
             // TODO: Update contact info to the connection manager and reconnect
         })
-        this.closestContacts = new SortedContactList({
+        this.nearbyContacts = new SortedContactList({
             referenceId: this.config.localNodeId,
             maxSize: this.config.maxContactListSize,
             allowToContainReferenceId: false
         })
-        this.closestContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
+        this.nearbyContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
             if (this.stopped) {
                 return
             }
-            this.emit('closestContactRemoved', contact.getPeerDescriptor())
+            this.emit('nearbyContactRemoved', contact.getPeerDescriptor())
             this.randomContacts.addContact(this.config.createDhtNodeRpcRemote(contact.getPeerDescriptor()))
         })
-        this.closestContacts.on('contactAdded', (contact: DhtNodeRpcRemote) =>
-            this.emit('closestContactAdded', contact.getPeerDescriptor())
+        this.nearbyContacts.on('contactAdded', (contact: DhtNodeRpcRemote) =>
+            this.emit('nearbyContactAdded', contact.getPeerDescriptor())
         )
         this.activeContacts = new Set()
         this.randomContacts = new RandomContactList(this.config.localNodeId, this.config.maxContactListSize)
@@ -110,7 +125,6 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
         const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
             referenceId: this.config.localNodeId,
-            maxSize: 100,  // TODO use config option or named constant?
             allowToContainReferenceId: false
         })
         sortingList.addContacts(oldContacts)
@@ -151,31 +165,31 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                         logger.trace('ping failed ' + nodeId)
                         this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
                         this.removeContact(nodeId)
-                        this.addClosestContactToBucket()
+                        this.addNearbyContactToNeighbors()
                     }
                 }).catch((_e) => {
                     this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
                     this.removeContact(nodeId)
-                    this.addClosestContactToBucket()
+                    this.addNearbyContactToNeighbors()
                 })
             }
         }
     }
 
-    private addClosestContactToBucket(): void {
+    private addNearbyContactToNeighbors(): void {
         if (this.stopped) {
             return
         }
-        const closest = this.getClosestActiveContactNotInBucket()
+        const closest = this.getNearbyActiveContactNotInNeighbors()
         if (closest) {
             this.addContact(closest.getPeerDescriptor())
         }
     }
 
-    private getClosestActiveContactNotInBucket(): DhtNodeRpcRemote | undefined {
-        for (const contactId of this.closestContacts.getContactIds()) {
+    private getNearbyActiveContactNotInNeighbors(): DhtNodeRpcRemote | undefined {
+        for (const contactId of this.nearbyContacts.getContactIds()) {
             if (!this.neighbors.get(getRawFromDhtAddress(contactId)) && this.activeContacts.has(contactId)) {
-                return this.closestContacts.getContact(contactId)!
+                return this.nearbyContacts.getContact(contactId)!
             }
         }
         return undefined
@@ -186,9 +200,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         logger.trace(`Removing contact ${nodeId}`)
-        this.ringContacts.removeContact(this.closestContacts.getContact(nodeId))
+        this.ringContacts.removeContact(this.nearbyContacts.getContact(nodeId))
         this.neighbors.remove(getRawFromDhtAddress(nodeId))
-        this.closestContacts.removeContact(nodeId)
+        this.nearbyContacts.removeContact(nodeId)
         this.activeContacts.delete(nodeId)
         this.randomContacts.removeContact(nodeId)
     }
@@ -197,6 +211,15 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.neighbors.remove(getRawFromDhtAddress(nodeId))
     }
 
+    async pruneOfflineNodes(nodes: DhtNodeRpcRemote[]): Promise<void> {
+        logger.trace('Pruning offline nodes', { nodes: nodes.length })
+        const offlineNeighbors = await pingNodes(nodes, this.activeContacts)
+        offlineNeighbors.forEach((offlineNeighbor) => {
+            logger.trace('Removing offline node', { node: getNodeIdFromPeerDescriptor(offlineNeighbor) })
+            this.removeContact(getNodeIdFromPeerDescriptor(offlineNeighbor))
+        }) 
+    }
+
     stop(): void {
         this.stopped = true
         this.neighbors.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
@@ -208,23 +231,12 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             rpcRemote.leaveNotice()
             this.ringContacts.removeContact(rpcRemote)
         })
-        this.closestContacts.stop()
+        this.nearbyContacts.stop()
         this.randomContacts.stop()
     }
 
-    getClosestNeighborsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
-        const closest = new SortedContactList<DhtNodeRpcRemote>({
-            referenceId,
-            allowToContainReferenceId: true,
-            excludedNodeIds,
-            maxSize: limit
-        })
-        this.neighbors.toArray().forEach((contact) => closest.addContact(contact))
-        return closest.getClosestContacts()
-    }
-
-    getClosestContacts(): ReadonlySortedContactList<DhtNodeRpcRemote> {
-        return this.closestContacts
+    getNearbyContacts(): ReadonlySortedContactList<DhtNodeRpcRemote> {
+        return this.nearbyContacts
     }
 
     getClosestRingContactsTo(
@@ -233,10 +245,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         excludedIds?: Set<DhtAddress>
     ): { left: DhtNodeRpcRemote[], right: DhtNodeRpcRemote[] } {
         const closest = new RingContactList<DhtNodeRpcRemote>(ringIdRaw, excludedIds)
-        for (const contact of this.closestContacts.getAllContactsInUndefinedOrder()) {
-            closest.addContact(contact)
-        }
         this.ringContacts.getAllContacts().map((contact) => closest.addContact(contact))
+        // TODO use config option or named constant?
         return closest.getClosestContacts(limit ?? 8)
     }
     
@@ -248,17 +258,16 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return this.ringContacts
     }
 
-    // TODO rename getNearbyContactsCount
-    getContactCount(excludedNodeIds?: Set<DhtAddress>): number {
-        return this.closestContacts.getSize(excludedNodeIds)
+    getNearbyContactCount(excludedNodeIds?: Set<DhtAddress>): number {
+        return this.nearbyContacts.getSize(excludedNodeIds)
     }
 
     getNeighborCount(): number {
         return this.neighbors.count()
     }
 
-    getNeighbors(): PeerDescriptor[] {
-        return this.neighbors.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    getNeighbors(): ReadonlyArray<DhtNodeRpcRemote> {
+        return this.neighbors.toArray()
     }
 
     setContactActive(nodeId: DhtAddress): void {
@@ -274,17 +283,17 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             logger.trace(`Adding new contact ${nodeId}`)
             const remote = this.config.createDhtNodeRpcRemote(peerDescriptor)
             const isInNeighbors = (this.neighbors.get(peerDescriptor.nodeId) !== null)
-            const isInClosestContacts = (this.closestContacts.getContact(nodeId) !== undefined)
+            const isInNearbyContacts = (this.nearbyContacts.getContact(nodeId) !== undefined)
             const isInRingContacts = this.ringContacts.getContact(peerDescriptor) !== undefined
 
-            if (isInNeighbors || isInClosestContacts) {
+            if (isInNeighbors || isInNearbyContacts) {
                 this.randomContacts.addContact(remote)
             }
             if (!isInNeighbors) {
                 this.neighbors.add(remote)
             }
-            if (!isInClosestContacts) {
-                this.closestContacts.addContact(remote)
+            if (!isInNearbyContacts) {
+                this.nearbyContacts.addContact(remote)
             }
             if (!isInRingContacts) {
                 this.ringContacts.addContact(remote)

package/src/dht/contact/ContactList.ts

@@ -13,17 +13,14 @@ export class ContactList<C extends { getNodeId: () => DhtAddress }> extends Even
     protected contactIds: DhtAddress[] = []
     protected localNodeId: DhtAddress
     protected maxSize: number
-    protected defaultContactQueryLimit
 
     constructor(
         localNodeId: DhtAddress,
-        maxSize: number,
-        defaultContactQueryLimit = 20
+        maxSize: number
     ) {
         super()
         this.localNodeId = localNodeId
         this.maxSize = maxSize
-        this.defaultContactQueryLimit = defaultContactQueryLimit
     }
 
     public getContact(id: DhtAddress): C | undefined {

package/src/dht/contact/RandomContactList.ts

@@ -8,10 +8,9 @@ export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extend
     constructor(
         localNodeId: DhtAddress,
         maxSize: number,
-        randomness = 0.20,
-        defaultContactQueryLimit?: number
+        randomness = 0.20
     ) {
-        super(localNodeId, maxSize, defaultContactQueryLimit)
+        super(localNodeId, maxSize)
         this.randomness = randomness
     }
 
@@ -48,7 +47,10 @@ export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extend
         return false
     }
 
-    public getContacts(limit = this.defaultContactQueryLimit): C[] {
-        return this.contactIds.slice(0, limit).map((contactId) => this.contactsById.get(contactId)!)
+    public getContacts(limit?: number): C[] {
+        const items = (limit === undefined)
+            ? this.contactIds
+            : this.contactIds.slice(0, Math.max(limit, 0))
+        return items.map((contactId) => this.contactsById.get(contactId)!)
     }
 }

package/src/dht/contact/{getClosestContacts.ts → getClosestNodes.ts}

@@ -1,22 +1,24 @@
+import { PeerDescriptor } from '../../exports'
 import { DhtAddress } from '../../identifiers'
+import { Contact } from './Contact'
 import { SortedContactList } from './SortedContactList'
 
-export const getClosestContacts = <C extends { getNodeId: () => DhtAddress }>(
+export const getClosestNodes = (
     referenceId: DhtAddress,
-    contacts: Iterable<C>,
+    contacts: Iterable<PeerDescriptor>,
     opts?: {
         maxCount?: number
         excludedNodeIds?: Set<DhtAddress>
     }
-): C[] => {
-    const list = new SortedContactList<C>({
+): PeerDescriptor[] => {
+    const list = new SortedContactList<Contact>({
         referenceId,
         allowToContainReferenceId: true,
         excludedNodeIds: opts?.excludedNodeIds,
         maxSize: opts?.maxCount
     })
     for (const contact of contacts) {
-        list.addContact(contact)
+        list.addContact(new Contact(contact))
     }
-    return list.getClosestContacts()
+    return list.getClosestContacts().map((n) => n.getPeerDescriptor())
 }

package/src/dht/discovery/DiscoverySession.ts

@@ -4,7 +4,7 @@ import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '.
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { PeerManager, getDistance } from '../PeerManager'
-import { getClosestContacts } from '../contact/getClosestContacts'
+import { getClosestNodes } from '../contact/getClosestNodes'
 
 const logger = new Logger(module)
 
@@ -16,6 +16,7 @@ interface DiscoverySessionConfig {
     // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
     contactedPeers: Set<DhtAddress>
     abortSignal: AbortSignal
+    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
 }
 
 export class DiscoverySession {
@@ -39,14 +40,16 @@ export class DiscoverySession {
         }
     }
 
-    private async fetchClosestNeighborsFromRemote(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
+    private async fetchClosestNeighborsFromRemote(peerDescriptor: PeerDescriptor): Promise<PeerDescriptor[]> {
         if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
             return []
         }
-        logger.trace(`Getting closest neighbors from remote: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
-        this.config.contactedPeers.add(contact.getNodeId())
-        const returnedContacts = await contact.getClosestPeers(this.config.targetId)
-        this.config.peerManager.setContactActive(contact.getNodeId())
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        logger.trace(`Getting closest neighbors from remote: ${nodeId}`)
+        this.config.contactedPeers.add(nodeId)
+        const remote = this.config.createDhtNodeRpcRemote(peerDescriptor)
+        const returnedContacts = await remote.getClosestPeers(this.config.targetId)
+        this.config.peerManager.setContactActive(nodeId)
         return returnedContacts
     }
 
@@ -56,31 +59,39 @@ export class DiscoverySession {
         }
         this.ongoingRequests.delete(nodeId)
         const targetId = getRawFromDhtAddress(this.config.targetId)
-        const oldClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
-        const oldClosestDistance = getDistance(targetId, getRawFromDhtAddress(oldClosestNeighbor.getNodeId()))
+        const oldClosestNeighbor = this.getClosestNeighbor()
+        const oldClosestDistance = getDistance(targetId, oldClosestNeighbor.nodeId)
         this.addContacts(contacts)
-        const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
-        const newClosestDistance = getDistance(targetId, getRawFromDhtAddress(newClosestNeighbor.getNodeId()))
+        const newClosestNeighbor = this.getClosestNeighbor()
+        const newClosestDistance = getDistance(targetId, newClosestNeighbor.nodeId)
         if (newClosestDistance >= oldClosestDistance) {
             this.noProgressCounter++
         }
     }
 
-    private onRequestFailed(peer: DhtNodeRpcRemote) {
-        if (!this.ongoingRequests.has(peer.getNodeId())) {
+    private getClosestNeighbor(): PeerDescriptor {
+        return getClosestNodes(
+            this.config.targetId,
+            this.config.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()),
+            { maxCount: 1 }
+        )[0]
+    }
+
+    private onRequestFailed(nodeId: DhtAddress) {
+        if (!this.ongoingRequests.has(nodeId)) {
             return
         }
-        this.ongoingRequests.delete(peer.getNodeId())
-        this.config.peerManager.removeContact(peer.getNodeId())
+        this.ongoingRequests.delete(nodeId)
+        this.config.peerManager.removeContact(nodeId)
     }
 
     private findMoreContacts(): void {
         if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
             return
         }
-        const uncontacted = getClosestContacts(
+        const uncontacted = getClosestNodes(
             this.config.targetId,
-            this.config.peerManager.getClosestContacts().getAllContactsInUndefinedOrder(),
+            Array.from(this.config.peerManager.getNearbyContacts().getAllContactsInUndefinedOrder(), (c) => c.getPeerDescriptor()), 
             {
                 maxCount: this.config.parallelism,
                 excludedNodeIds: this.config.contactedPeers
@@ -90,15 +101,16 @@ export class DiscoverySession {
             this.doneGate.open()
             return
         }
-        for (const nextPeer of uncontacted) {
+        for (const node of uncontacted) {
             if (this.ongoingRequests.size >= this.config.parallelism) {
                 break
             }
-            this.ongoingRequests.add(nextPeer.getNodeId())
+            const nodeId = getNodeIdFromPeerDescriptor(node)
+            this.ongoingRequests.add(nodeId)
             // eslint-disable-next-line promise/catch-or-return
-            this.fetchClosestNeighborsFromRemote(nextPeer)
-                .then((contacts) => this.onRequestSucceeded(nextPeer.getNodeId(), contacts))
-                .catch(() => this.onRequestFailed(nextPeer))
+            this.fetchClosestNeighborsFromRemote(node)
+                .then((contacts) => this.onRequestSucceeded(nodeId, contacts))
+                .catch(() => this.onRequestFailed(nodeId))
                 .finally(() => {
                     this.findMoreContacts()
                 })
@@ -106,7 +118,7 @@ export class DiscoverySession {
     }
 
     public async findClosestNodes(timeout: number): Promise<void> {
-        if (this.config.peerManager.getContactCount(this.config.contactedPeers) === 0) {
+        if (this.config.peerManager.getNearbyContactCount(this.config.contactedPeers) === 0) {
             return
         }
         setImmediate(() => {

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,13 +1,21 @@
-import { DiscoverySession } from './DiscoverySession'
-import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
 import { ConnectionLocker } from '../../connection/ConnectionManager'
-import { PeerManager } from '../PeerManager'
-import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
+import {
+    DhtAddress,
+    areEqualPeerDescriptors,
+    createRandomDhtAddress,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor,
+    getRawFromDhtAddress
+} from '../../identifiers'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ServiceID } from '../../types/ServiceID'
-import { RingDiscoverySession } from './RingDiscoverySession'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+import { PeerManager } from '../PeerManager'
+import { getClosestNodes } from '../contact/getClosestNodes'
 import { RingIdRaw, getRingIdRawFromPeerDescriptor } from '../contact/ringIdentifiers'
+import { DiscoverySession } from './DiscoverySession'
+import { RingDiscoverySession } from './RingDiscoverySession'
 
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
@@ -17,6 +25,8 @@ interface PeerDiscoveryConfig {
     joinTimeout: number
     connectionLocker?: ConnectionLocker
     peerManager: PeerManager
+    abortSignal: AbortSignal
+    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
 }
 
 export const createDistantDhtAddress = (address: DhtAddress): DhtAddress => {
@@ -34,13 +44,11 @@ export class PeerDiscovery {
     
     private rejoinOngoing = false
     private joinCalled = false
-    private readonly abortController: AbortController
     private recoveryIntervalStarted = false
     private readonly config: PeerDiscoveryConfig
 
     constructor(config: PeerDiscoveryConfig) {
         this.config = config
-        this.abortController = new AbortController()
     }
 
     async joinDht(
@@ -102,7 +110,8 @@ export class PeerDiscovery {
             noProgressLimit: this.config.joinNoProgressLimit,
             peerManager: this.config.peerManager,
             contactedPeers,
-            abortSignal: this.abortController.signal
+            abortSignal: this.config.abortSignal,
+            createDhtNodeRpcRemote: this.config.createDhtNodeRpcRemote
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -113,7 +122,9 @@ export class PeerDiscovery {
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
             peerManager: this.config.peerManager,
-            contactedPeers
+            contactedPeers,
+            abortSignal: this.config.abortSignal,
+            createDhtNodeRpcRemote: this.config.createDhtNodeRpcRemote
         }
         return new RingDiscoverySession(sessionOptions)
     }
@@ -132,7 +143,7 @@ export class PeerDiscovery {
                     if (retry) {
                         // TODO should we catch possible promise rejection?
                         // TODO use config option or named constant?
-                        setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
+                        setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.config.abortSignal)
                     }
                 } else {
                     await this.ensureRecoveryIntervalIsRunning()
@@ -173,7 +184,7 @@ export class PeerDiscovery {
             if (!this.isStopped()) {
                 // TODO should we catch possible promise rejection?
                 // TODO use config option or named constant?
-                setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.abortController.signal)
+                setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.config.abortSignal)
             }
         } finally {
             this.rejoinOngoing = false
@@ -184,27 +195,37 @@ export class PeerDiscovery {
         if (!this.recoveryIntervalStarted) {
             this.recoveryIntervalStarted = true
             // TODO use config option or named constant?
-            await scheduleAtInterval(() => this.fetchClosestNeighbors(), 60000, true, this.abortController.signal)
+            await scheduleAtInterval(() => this.fetchClosestAndRandomNeighbors(), 60000, true, this.config.abortSignal)
         }
     }
 
-    private async fetchClosestNeighbors(): Promise<void> {
+    private async fetchClosestAndRandomNeighbors(): Promise<void> {
         if (this.isStopped()) {
             return
         }
         const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-        const nodes = this.config.peerManager.getClosestNeighborsTo(
-            localNodeId,
-            this.config.parallelism
-        )
-        await Promise.allSettled(
-            nodes.map(async (node: DhtNodeRpcRemote) => {
-                const contacts = await node.getClosestPeers(localNodeId)
+        const nodes = this.getClosestNeighbors(localNodeId, this.config.parallelism)
+        const randomNodes = this.getClosestNeighbors(createRandomDhtAddress(), 1)
+        await Promise.allSettled([
+            ...nodes.map(async (node: PeerDescriptor) => {
+                const remote = this.config.createDhtNodeRpcRemote(node)
+                const contacts = await remote.getClosestPeers(localNodeId)
+                for (const contact of contacts) {
+                    this.config.peerManager.addContact(contact)
+                }
+            }),
+            ...randomNodes.map(async (node: PeerDescriptor) => {
+                const remote = this.config.createDhtNodeRpcRemote(node)
+                const contacts = await remote.getClosestPeers(createRandomDhtAddress())
                 for (const contact of contacts) {
                     this.config.peerManager.addContact(contact)
                 }
             })
-        )
+        ])
+    }
+
+    private getClosestNeighbors(referenceId: DhtAddress, maxCount: number): PeerDescriptor[] {
+        return getClosestNodes(referenceId, this.config.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()), { maxCount })
     }
 
     public isJoinOngoing(): boolean {
@@ -216,13 +237,6 @@ export class PeerDiscovery {
     }
 
     private isStopped() {
-        return this.abortController.signal.aborted
-    }
-
-    public stop(): void {
-        this.abortController.abort()
-        this.ongoingRingDiscoverySessions.forEach((session) => {
-            session.stop()
-        })
+        return this.config.abortSignal.aborted
     }
 }