@streamr/dht 100.2.2 → 100.2.4-beta.0

package/src/dht/contact/RingContactList.ts

@@ -3,16 +3,14 @@ import { OrderedMap } from '@js-sdsl/ordered-map'
 import { RingDistance, RingId, RingIdRaw, getLeftDistance, getRightDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from './ringIdentifiers'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import EventEmitter from 'eventemitter3'
+import { Events } from './ContactList'
 
 export interface RingContacts { 
     left: PeerDescriptor[]
     right: PeerDescriptor[]
 }
-export interface RingContactListEvents {  
-    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
-    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
-}
-export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }> extends EventEmitter<RingContactListEvents> {
+
+export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }> extends EventEmitter<Events<C>> {
 
     private readonly numNeighborsPerSide = 5
     private readonly referenceId: RingId
@@ -59,16 +57,11 @@ export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }>
         }
 
         if (this.hasEventListeners() && (elementAdded || elementRemoved)) {
-            const closestContacts = this.getClosestContacts()
-            const closestDescriptors = { 
-                left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
-                right: closestContacts.right.map((c) => c.getPeerDescriptor())
-            }
             if (elementAdded) {
-                this.emit('ringContactAdded', contact.getPeerDescriptor(), closestDescriptors)
+                this.emit('contactAdded', contact)
             }
             if (elementRemoved) {
-                this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+                this.emit('contactRemoved', contact)
             }
         }
     }
@@ -91,10 +84,7 @@ export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }>
         }
 
         if (this.hasEventListeners() && elementRemoved) {
-            const closestContacts = this.getClosestContacts()
-            const closestDescriptors = { left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
-                right: closestContacts.right.map((c) => c.getPeerDescriptor()) }
-            this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+            this.emit('contactRemoved', contact)
         }
     }
 

package/src/dht/contact/SortedContactList.ts

@@ -4,6 +4,10 @@ import EventEmitter from 'eventemitter3'
 import { getDistance } from '../PeerManager'
 import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
 
+// add other getters in the future if needed
+export type ReadonlySortedContactList<C extends { getNodeId: () => DhtAddress }> =
+    Pick<SortedContactList<C>, 'getClosestContacts' | 'getAllContactsInUndefinedOrder'>
+
 export interface SortedContactListConfig {
     referenceId: DhtAddress  // all contacts in this list are in sorted by the distance to this ID
     allowToContainReferenceId: boolean
@@ -53,8 +57,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
                 if (this.hasEventListeners()) {
                     this.emit(
                         'contactAdded',
-                        contact,
-                        this.getClosestContacts()
+                        contact
                     )
                 }
             } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contactId) > 0) {
@@ -65,16 +68,13 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
                 const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
                 this.contactIds.splice(index, 0, contactId)
                 if (this.hasEventListeners()) {
-                    const closestContacts = this.getClosestContacts()
                     this.emit(
                         'contactRemoved',
-                        removedContact,
-                        closestContacts
+                        removedContact
                     )
                     this.emit(
                         'contactAdded',
-                        contact,
-                        closestContacts
+                        contact
                     )
                 }
             }
@@ -133,8 +133,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
             if (this.hasEventListeners()) {
                 this.emit(
                     'contactRemoved',
-                    removed,
-                    this.getClosestContacts()
+                    removed
                 )
             }
             return true
@@ -142,7 +141,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return false
     }
 
-    public getAllContactsInUndefinedOrder(): IterableIterator<C> {
+    public getAllContactsInUndefinedOrder(): Iterable<C> {
         return this.contactsById.values()
     }
 

package/src/dht/contact/getClosestContacts.ts

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

package/src/dht/discovery/DiscoverySession.ts

@@ -1,17 +1,13 @@
-import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
-import EventEmitter from 'eventemitter3'
+import { Gate, Logger, withTimeout } from '@streamr/utils'
 import { v4 } from 'uuid'
+import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { PeerManager, getDistance } from '../PeerManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
+import { PeerManager, getDistance } from '../PeerManager'
+import { getClosestContacts } from '../contact/getClosestContacts'
 
 const logger = new Logger(module)
 
-interface DiscoverySessionEvents {
-    discoveryCompleted: () => void
-}
-
 interface DiscoverySessionConfig {
     targetId: DhtAddress
     parallelism: number
@@ -19,15 +15,15 @@ interface DiscoverySessionConfig {
     peerManager: PeerManager
     // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
     contactedPeers: Set<DhtAddress>
+    abortSignal: AbortSignal
 }
 
 export class DiscoverySession {
 
     public readonly id = v4()
-    private stopped = false
-    private emitter = new EventEmitter<DiscoverySessionEvents>()
     private noProgressCounter = 0
-    private ongoingClosestPeersRequests: Set<DhtAddress> = new Set()
+    private ongoingRequests: Set<DhtAddress> = new Set()
+    private doneGate = new Gate(false)
     private readonly config: DiscoverySessionConfig
 
     constructor(config: DiscoverySessionConfig) {
@@ -35,7 +31,7 @@ export class DiscoverySession {
     }
 
     private addContacts(contacts: PeerDescriptor[]): void {
-        if (this.stopped) {
+        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
             return
         }
         for (const contact of contacts) {
@@ -43,22 +39,22 @@ export class DiscoverySession {
         }
     }
 
-    private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
-        if (this.stopped) {
+    private async fetchClosestNeighborsFromRemote(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
+        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
             return []
         }
-        logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        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())
         return returnedContacts
     }
 
-    private onClosestPeersRequestSucceeded(nodeId: DhtAddress, contacts: PeerDescriptor[]) {
-        if (!this.ongoingClosestPeersRequests.has(nodeId)) {
+    private onRequestSucceeded(nodeId: DhtAddress, contacts: PeerDescriptor[]) {
+        if (!this.ongoingRequests.has(nodeId)) {
             return
         }
-        this.ongoingClosestPeersRequests.delete(nodeId)
+        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()))
@@ -70,37 +66,39 @@ export class DiscoverySession {
         }
     }
 
-    private onClosestPeersRequestFailed(peer: DhtNodeRpcRemote) {
-        if (!this.ongoingClosestPeersRequests.has(peer.getNodeId())) {
+    private onRequestFailed(peer: DhtNodeRpcRemote) {
+        if (!this.ongoingRequests.has(peer.getNodeId())) {
             return
         }
-        this.ongoingClosestPeersRequests.delete(peer.getNodeId())
+        this.ongoingRequests.delete(peer.getNodeId())
         this.config.peerManager.removeContact(peer.getNodeId())
     }
 
     private findMoreContacts(): void {
-        if (this.stopped) {
+        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
             return
         }
-        const uncontacted = this.config.peerManager.getClosestContactsTo(
+        const uncontacted = getClosestContacts(
             this.config.targetId,
-            this.config.parallelism,
-            this.config.contactedPeers
+            this.config.peerManager.getClosestContacts().getAllContactsInUndefinedOrder(),
+            {
+                maxCount: this.config.parallelism,
+                excludedNodeIds: this.config.contactedPeers
+            }
         )
-        if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
-            this.emitter.emit('discoveryCompleted')
-            this.stopped = true
+        if ((uncontacted.length === 0 && this.ongoingRequests.size === 0) || (this.noProgressCounter >= this.config.noProgressLimit)) {
+            this.doneGate.open()
             return
         }
         for (const nextPeer of uncontacted) {
-            if (this.ongoingClosestPeersRequests.size >= this.config.parallelism) {
+            if (this.ongoingRequests.size >= this.config.parallelism) {
                 break
             }
-            this.ongoingClosestPeersRequests.add(nextPeer.getNodeId())
+            this.ongoingRequests.add(nextPeer.getNodeId())
             // eslint-disable-next-line promise/catch-or-return
-            this.getClosestPeersFromContact(nextPeer)
-                .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getNodeId(), contacts))
-                .catch(() => this.onClosestPeersRequestFailed(nextPeer))
+            this.fetchClosestNeighborsFromRemote(nextPeer)
+                .then((contacts) => this.onRequestSucceeded(nextPeer.getNodeId(), contacts))
+                .catch(() => this.onRequestFailed(nextPeer))
                 .finally(() => {
                     this.findMoreContacts()
                 })
@@ -111,17 +109,9 @@ export class DiscoverySession {
         if (this.config.peerManager.getContactCount(this.config.contactedPeers) === 0) {
             return
         }
-        // TODO add abortController and signal it in stop()
-        await runAndWaitForEvents3<DiscoverySessionEvents>(
-            [this.findMoreContacts.bind(this)],
-            [[this.emitter, 'discoveryCompleted']],
-            timeout
-        )
-    }
-
-    public stop(): void {
-        this.stopped = true
-        this.emitter.emit('discoveryCompleted')
-        this.emitter.removeAllListeners()
+        setImmediate(() => {
+            this.findMoreContacts()
+        })
+        await withTimeout(this.doneGate.waitUntilOpen(), timeout, 'discovery session timed out', this.config.abortSignal)
     }
 }

package/src/dht/discovery/PeerDiscovery.ts

@@ -12,7 +12,6 @@ import { RingIdRaw, getRingIdRawFromPeerDescriptor } from '../contact/ringIdenti
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
     joinNoProgressLimit: number
-    peerDiscoveryQueryBatchSize: number
     serviceId: ServiceID
     parallelism: number
     joinTimeout: number
@@ -102,7 +101,8 @@ export class PeerDiscovery {
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
             peerManager: this.config.peerManager,
-            contactedPeers
+            contactedPeers,
+            abortSignal: this.abortController.signal
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -184,11 +184,11 @@ export class PeerDiscovery {
         if (!this.recoveryIntervalStarted) {
             this.recoveryIntervalStarted = true
             // TODO use config option or named constant?
-            await scheduleAtInterval(() => this.fetchClosestPeersFromBucket(), 60000, true, this.abortController.signal)
+            await scheduleAtInterval(() => this.fetchClosestNeighbors(), 60000, true, this.abortController.signal)
         }
     }
 
-    private async fetchClosestPeersFromBucket(): Promise<void> {
+    private async fetchClosestNeighbors(): Promise<void> {
         if (this.isStopped()) {
             return
         }
@@ -198,8 +198,8 @@ export class PeerDiscovery {
             this.config.parallelism
         )
         await Promise.allSettled(
-            nodes.map(async (peer: DhtNodeRpcRemote) => {
-                const contacts = await peer.getClosestPeers(localNodeId)
+            nodes.map(async (node: DhtNodeRpcRemote) => {
+                const contacts = await node.getClosestPeers(localNodeId)
                 for (const contact of contacts) {
                     this.config.peerManager.addContact(contact)
                 }
@@ -221,9 +221,6 @@ export class PeerDiscovery {
 
     public stop(): void {
         this.abortController.abort()
-        this.ongoingDiscoverySessions.forEach((session) => {
-            session.stop()
-        })
         this.ongoingRingDiscoverySessions.forEach((session) => {
             session.stop()
         })

package/src/dht/discovery/RingDiscoverySession.ts

@@ -29,7 +29,7 @@ export class RingDiscoverySession {
     private stopped = false
     private emitter = new EventEmitter<RingDiscoverySessionEvents>()
     private noProgressCounter = 0
-    private ongoingClosestPeersRequests: Set<DhtAddress> = new Set()
+    private ongoingRequests: Set<DhtAddress> = new Set()
     private readonly config: RingDiscoverySessionConfig
     private numContactedPeers = 0
     private targetIdAsRingId: RingId
@@ -48,7 +48,7 @@ export class RingDiscoverySession {
         }
     }
 
-    private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<RingContacts> {
+    private async fetchClosestContactsFromRemote(contact: DhtNodeRpcRemote): Promise<RingContacts> {
         if (this.stopped) {
             return { left: [], right: [] }
         }
@@ -60,11 +60,11 @@ export class RingDiscoverySession {
         return returnedContacts
     }
 
-    private onClosestPeersRequestSucceeded(nodeId: DhtAddress, contacts: RingContacts) {
-        if (!this.ongoingClosestPeersRequests.has(nodeId)) {
+    private onRequestSucceeded(nodeId: DhtAddress, contacts: RingContacts) {
+        if (!this.ongoingRequests.has(nodeId)) {
             return
         }
-        this.ongoingClosestPeersRequests.delete(nodeId)
+        this.ongoingRequests.delete(nodeId)
         const oldClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
         const oldClosestLeftDistance = getLeftDistance(
             this.targetIdAsRingId,
@@ -85,11 +85,11 @@ export class RingDiscoverySession {
         }
     }
 
-    private onClosestPeersRequestFailed(peer: DhtNodeRpcRemote) {
-        if (!this.ongoingClosestPeersRequests.has(peer.getNodeId())) {
+    private onRequestFailed(peer: DhtNodeRpcRemote) {
+        if (!this.ongoingRequests.has(peer.getNodeId())) {
             return
         }
-        this.ongoingClosestPeersRequests.delete(peer.getNodeId())
+        this.ongoingRequests.delete(peer.getNodeId())
         this.config.peerManager.removeContact(peer.getNodeId())
     }
 
@@ -128,14 +128,14 @@ export class RingDiscoverySession {
         }
 
         for (const nextPeer of merged) {
-            if (this.ongoingClosestPeersRequests.size >= this.config.parallelism) {
+            if (this.ongoingRequests.size >= this.config.parallelism) {
                 break
             }
-            this.ongoingClosestPeersRequests.add(nextPeer.getNodeId())
+            this.ongoingRequests.add(nextPeer.getNodeId())
             // eslint-disable-next-line promise/catch-or-return
-            this.getClosestPeersFromContact(nextPeer)
-                .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getNodeId(), contacts))
-                .catch(() => this.onClosestPeersRequestFailed(nextPeer))
+            this.fetchClosestContactsFromRemote(nextPeer)
+                .then((contacts) => this.onRequestSucceeded(nextPeer.getNodeId(), contacts))
+                .catch(() => this.onRequestFailed(nextPeer))
                 .finally(() => {
                     this.findMoreContacts()
                 })

package/src/dht/recursive-operation/RecursiveOperationManager.ts

@@ -29,12 +29,12 @@ import { getDistance } from '../PeerManager'
 interface RecursiveOperationManagerConfig {
     rpcCommunicator: RoutingRpcCommunicator
     sessionTransport: ITransport
-    connections: Map<DhtAddress, DhtNodeRpcRemote>
     router: Router
     localPeerDescriptor: PeerDescriptor
     serviceId: ServiceID
     localDataStore: LocalDataStore
     addContact: (contact: PeerDescriptor) => void
+    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
 }
 
 export interface RecursiveOperationResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
@@ -87,14 +87,14 @@ export class RecursiveOperationManager {
             targetId,
             localPeerDescriptor: this.config.localPeerDescriptor,
             // TODO use config option or named constant?
-            waitedRoutingPathCompletions: this.config.connections.size > 1 ? 2 : 1,
+            waitedRoutingPathCompletions: this.config.sessionTransport.getConnectionCount() > 1 ? 2 : 1,
             operation,
             // TODO would it make sense to give excludedPeer as one of the fields RecursiveOperationSession?
             doRouteRequest: (routedMessage: RouteMessageWrapper) => {
                 return this.doRouteRequest(routedMessage, excludedPeer)
             }
         })
-        if (this.config.connections.size === 0) {
+        if (this.config.sessionTransport.getConnectionCount() === 0) {
             const dataEntries = Array.from(this.config.localDataStore.values(targetId))
             session.onResponseReceived(
                 getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
@@ -140,7 +140,7 @@ export class RecursiveOperationManager {
         routingPath: PeerDescriptor[],
         targetPeerDescriptor: PeerDescriptor,
         serviceId: ServiceID,
-        closestNodes: PeerDescriptor[],
+        closestConnectedNodes: PeerDescriptor[],
         dataEntries: DataEntry[],
         noCloserNodesFound: boolean = false
     ): void {
@@ -150,7 +150,7 @@ export class RecursiveOperationManager {
                 .onResponseReceived(
                     getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
                     routingPath,
-                    closestNodes,
+                    closestConnectedNodes,
                     dataEntries,
                     noCloserNodesFound
                 )
@@ -165,7 +165,7 @@ export class RecursiveOperationManager {
                 // TODO use config option or named constant?
                 10000
             )
-            rpcRemote.sendResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+            rpcRemote.sendResponse(routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
             remoteCommunicator.destroy()
         }
     }
@@ -177,7 +177,7 @@ export class RecursiveOperationManager {
         const targetId = getDhtAddressFromRaw(routedMessage.target)
         const request = (routedMessage.message!.body as { recursiveOperationRequest: RecursiveOperationRequest }).recursiveOperationRequest
         // TODO use config option or named constant?
-        const closestPeersToDestination = this.getClosestConnections(targetId, 5)
+        const closestConnectedNodes = this.getClosestConnectedNodes(targetId, 5)
         const dataEntries = (request.operation === RecursiveOperation.FETCH_DATA) 
             ? Array.from(this.config.localDataStore.values(targetId))
             : []
@@ -190,7 +190,7 @@ export class RecursiveOperationManager {
                 routedMessage.routingPath,
                 routedMessage.sourcePeer!,
                 request.sessionId,
-                closestPeersToDestination,
+                closestConnectedNodes,
                 dataEntries,
                 true
             )
@@ -200,15 +200,15 @@ export class RecursiveOperationManager {
             if ((ack.error === undefined) || (ack.error === RouteMessageError.NO_TARGETS)) {
                 const noCloserContactsFound = (ack.error === RouteMessageError.NO_TARGETS) ||
                     (
-                        closestPeersToDestination.length > 0 
+                        closestConnectedNodes.length > 0 
                         && getPreviousPeer(routedMessage) 
-                        && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], targetId)
+                        && !this.isPeerCloserToIdThanSelf(closestConnectedNodes[0], targetId)
                     )
                 this.sendResponse(
                     routedMessage.routingPath,
                     routedMessage.sourcePeer!,
                     request.sessionId,
-                    closestPeersToDestination,
+                    closestConnectedNodes,
                     dataEntries,
                     noCloserContactsFound
                 )
@@ -217,15 +217,15 @@ export class RecursiveOperationManager {
         }    
     }
 
-    private getClosestConnections(referenceId: DhtAddress, limit: number): PeerDescriptor[] {
-        const connectedPeers = Array.from(this.config.connections.values())
-        const closestPeers = new SortedContactList<DhtNodeRpcRemote>({
+    private getClosestConnectedNodes(referenceId: DhtAddress, limit: number): PeerDescriptor[] {
+        const connectedNodes = this.config.sessionTransport.getConnections().map((c) => this.config.createDhtNodeRpcRemote(c))
+        const sorted = new SortedContactList<DhtNodeRpcRemote>({
             referenceId,
             maxSize: limit,
             allowToContainReferenceId: true
         })
-        closestPeers.addContacts(connectedPeers)
-        return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
+        sorted.addContacts(connectedNodes)
+        return sorted.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
     }
 
     private isPeerCloserToIdThanSelf(peer: PeerDescriptor, nodeIdOrDataKey: DhtAddress): boolean {

package/src/dht/recursive-operation/RecursiveOperationSession.ts

@@ -66,11 +66,11 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             onResponseReceived: (
                 sourceId: DhtAddress,
                 routingPath: PeerDescriptor[],
-                nodes: PeerDescriptor[],
+                closestConnectedNodes: PeerDescriptor[],
                 dataEntries: DataEntry[],
                 noCloserNodesFound: boolean
             ) => {
-                this.onResponseReceived(sourceId, routingPath, nodes, dataEntries, noCloserNodesFound)
+                this.onResponseReceived(sourceId, routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
             }
         })
         this.rpcCommunicator.registerRpcNotification(RecursiveOperationResponse, 'sendResponse',
@@ -131,7 +131,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     public onResponseReceived(
         sourceId: DhtAddress,
         routingPath: PeerDescriptor[],
-        nodes: PeerDescriptor[],
+        closestConnectedNodes: PeerDescriptor[],
         dataEntries: DataEntry[],
         noCloserNodesFound: boolean
     ): void {
@@ -139,7 +139,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         if (routingPath.length >= 1) {
             this.setHopAsReported(routingPath[routingPath.length - 1])
         }
-        nodes.forEach((descriptor: PeerDescriptor) => {
+        closestConnectedNodes.forEach((descriptor: PeerDescriptor) => {
             this.results.addContact(new Contact(descriptor))
         })
         this.processFoundData(dataEntries)
@@ -197,15 +197,13 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
                 clearTimeout(this.timeoutTask)
                 this.timeoutTask = undefined
             }
-        } else {
-            if (!this.timeoutTask && !this.completionEventEmitted) {
-                this.timeoutTask = setTimeout(() => {
-                    if (!this.completionEventEmitted) {
-                        this.emit('completed')
-                        this.completionEventEmitted = true
-                    }
-                }, 4000)  // TODO use config option or named constant?
-            }
+        } else if (!this.timeoutTask && !this.completionEventEmitted) {
+            this.timeoutTask = setTimeout(() => {
+                if (!this.completionEventEmitted) {
+                    this.emit('completed')
+                    this.completionEventEmitted = true
+                }
+            }, 4000)  // TODO use config option or named constant?
         }
     }
 

package/src/dht/recursive-operation/RecursiveOperationSessionRpcLocal.ts

@@ -29,7 +29,7 @@ export class RecursiveOperationSessionRpcLocal implements IRecursiveOperationSes
     async sendResponse(report: RecursiveOperationResponse, context: ServerCallContext): Promise<Empty> {
         const sourceId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
         logger.trace('RecursiveOperationResponse arrived: ' + JSON.stringify(report))
-        this.config.onResponseReceived(sourceId, report.routingPath, report.closestConnectedPeers, report.dataEntries, report.noCloserNodesFound)
+        this.config.onResponseReceived(sourceId, report.routingPath, report.closestConnectedNodes, report.dataEntries, report.noCloserNodesFound)
         return {}
     }
 }

package/src/dht/recursive-operation/RecursiveOperationSessionRpcRemote.ts

@@ -13,13 +13,13 @@ export class RecursiveOperationSessionRpcRemote extends RpcRemote<RecursiveOpera
 
     sendResponse(
         routingPath: PeerDescriptor[],
-        closestNodes: PeerDescriptor[],
+        closestConnectedNodes: PeerDescriptor[],
         dataEntries: DataEntry[],
         noCloserNodesFound: boolean
     ): void {
         const report: RecursiveOperationResponse = {
             routingPath,
-            closestConnectedPeers: closestNodes,
+            closestConnectedNodes,
             dataEntries,
             noCloserNodesFound
         }

package/src/dht/routing/Router.ts

@@ -3,7 +3,6 @@ import { RoutingMode, RoutingRemoteContact, RoutingSession, RoutingSessionEvents
 import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { DuplicateDetector } from './DuplicateDetector'
-import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { v4 } from 'uuid'
 import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
@@ -12,8 +11,8 @@ import { RoutingTablesCache } from './RoutingTablesCache'
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
-    connections: Map<DhtAddress, DhtNodeRpcRemote>
     handleMessage: (message: Message) => void
+    getConnections: () => PeerDescriptor[]
 }
 
 interface ForwardingTableEntry {
@@ -158,17 +157,16 @@ export class Router {
         routedMessage.parallelRootNodeIds.forEach((nodeId) => {
             excludedNodeIds.add(nodeId as DhtAddress)
         })
-        logger.trace('routing session created with connections: ' + this.config.connections.size)
         return new RoutingSession({
             rpcCommunicator: this.config.rpcCommunicator,
             localPeerDescriptor: this.config.localPeerDescriptor,
             routedMessage,
-            connections: this.config.connections,
             // TODO use config option or named constant?
             parallelism: areEqualPeerDescriptors(this.config.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
             excludedNodeIds,
-            routingTablesCache: this.routingTablesCache
+            routingTablesCache: this.routingTablesCache,
+            getConnections: this.config.getConnections
         })
     }