@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.0

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

@@ -0,0 +1,240 @@
+import {
+    DataEntry,
+    PeerDescriptor,
+    RecursiveOperation,
+    RecursiveOperationRequest,
+    RouteMessageAck,
+    RouteMessageError,
+    RouteMessageWrapper
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { Router } from '../routing/Router'
+import { RoutingMode } from '../routing/RoutingSession'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { Logger, areEqualBinaries, hexToBinary, runAndWaitForEvents3, wait } from '@streamr/utils'
+import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
+import { RecursiveOperationSessionRpcRemote } from './RecursiveOperationSessionRpcRemote'
+import { RecursiveOperationSession, RecursiveOperationSessionEvents } from './RecursiveOperationSession'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+import { ITransport } from '../../transport/ITransport'
+import { LocalDataStore } from '../store/LocalDataStore'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { RecursiveOperationSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { SortedContactList } from '../contact/SortedContactList'
+import { getPreviousPeer } from '../routing/getPreviousPeer'
+import { createRouteMessageAck } from '../routing/RouterRpcLocal'
+import { ServiceID } from '../../types/ServiceID'
+import { RecursiveOperationRpcLocal } from './RecursiveOperationRpcLocal'
+import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
+import { getDistance } from '../PeerManager'
+
+interface RecursiveOperationManagerConfig {
+    rpcCommunicator: RoutingRpcCommunicator
+    sessionTransport: ITransport
+    connections: Map<NodeID, DhtNodeRpcRemote>
+    router: Router
+    localPeerDescriptor: PeerDescriptor
+    serviceId: ServiceID
+    localDataStore: LocalDataStore
+    addContact: (contact: PeerDescriptor) => void
+}
+
+export interface RecursiveOperationResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
+
+const logger = new Logger(module)
+
+export class RecursiveOperationManager {
+
+    private ongoingSessions: Map<string, RecursiveOperationSession> = new Map()
+    private stopped = false
+    private readonly config: RecursiveOperationManagerConfig
+
+    constructor(config: RecursiveOperationManagerConfig) {
+        this.config = config
+        this.registerLocalRpcMethods()
+    }
+
+    private registerLocalRpcMethods() {
+        const rpcLocal = new RecursiveOperationRpcLocal({
+            doRouteRequest: (routedMessage: RouteMessageWrapper) => this.doRouteRequest(routedMessage),
+            addContact: (contact: PeerDescriptor) => this.config.addContact(contact),
+            isMostLikelyDuplicate: (requestId: string) => this.config.router.isMostLikelyDuplicate(requestId),
+            addToDuplicateDetector: (requestId: string) => this.config.router.addToDuplicateDetector(requestId)
+        })
+        this.config.rpcCommunicator.registerRpcMethod(
+            RouteMessageWrapper,
+            RouteMessageAck,
+            'routeRequest',
+            async (routedMessage: RouteMessageWrapper) => {
+                if (this.stopped) {
+                    return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
+                } else {
+                    return rpcLocal.routeRequest(routedMessage)
+                }
+            }
+        )
+    }
+
+    public async execute(
+        targetId: Uint8Array,
+        operation: RecursiveOperation,
+        excludedPeer?: PeerDescriptor,
+        waitForCompletion = true
+    ): Promise<RecursiveOperationResult> {
+        if (this.stopped) {
+            return { closestNodes: [] }
+        }
+        const session = new RecursiveOperationSession({
+            transport: this.config.sessionTransport,
+            targetId,
+            localPeerDescriptor: this.config.localPeerDescriptor,
+            // TODO use config option or named constant?
+            waitedRoutingPathCompletions: this.config.connections.size > 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) {
+            const data = this.config.localDataStore.getEntries(targetId)
+            session.onResponseReceived(
+                [this.config.localPeerDescriptor],
+                [this.config.localPeerDescriptor],
+                Array.from(data.values()),
+                true
+            )
+            return session.getResults()
+        }
+        this.ongoingSessions.set(session.getId(), session)
+        if (waitForCompletion === true) {
+            try {
+                await runAndWaitForEvents3<RecursiveOperationSessionEvents>(
+                    [() => session.start(this.config.serviceId)],
+                    [[session, 'completed']],
+                    // TODO use config option or named constant?
+                    15000
+                )
+            } catch (err) {
+                logger.debug(`start failed with error ${err}`)
+            }
+        } else {
+            session.start(this.config.serviceId)
+            // Wait for delete operation to be sent out by the router
+            // TODO: Add a feature to wait for the router to pass the message?
+            await wait(50)
+        }
+        if (operation === RecursiveOperation.FETCH_DATA) {
+            const dataEntries = Array.from(this.config.localDataStore.getEntries(targetId).values())
+            if (dataEntries.length > 0) {
+                this.sendResponse([], this.config.localPeerDescriptor, session.getId(), [], dataEntries, true)
+            }
+        } else if (operation === RecursiveOperation.DELETE_DATA) {
+            this.config.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor))
+        }
+        this.ongoingSessions.delete(session.getId())
+        session.stop()
+        return session.getResults()
+    }
+
+    private sendResponse(
+        routingPath: PeerDescriptor[],
+        targetPeerDescriptor: PeerDescriptor,
+        serviceId: ServiceID,
+        closestNodes: PeerDescriptor[],
+        dataEntries: DataEntry[],
+        noCloserNodesFound: boolean = false
+    ): void {
+        const isOwnNode = areEqualPeerDescriptors(this.config.localPeerDescriptor, targetPeerDescriptor)
+        if (isOwnNode && this.ongoingSessions.has(serviceId)) {
+            this.ongoingSessions.get(serviceId)!
+                .onResponseReceived(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+        } else {
+            // TODO use config option or named constant?
+            const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.config.sessionTransport, { rpcRequestTimeout: 15000 })
+            const rpcRemote = new RecursiveOperationSessionRpcRemote(
+                this.config.localPeerDescriptor,
+                targetPeerDescriptor,
+                serviceId,
+                remoteCommunicator,
+                RecursiveOperationSessionRpcClient,
+                // TODO use config option or named constant?
+                10000
+            )
+            rpcRemote.sendResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+            remoteCommunicator.destroy()
+        }
+    }
+
+    private doRouteRequest(routedMessage: RouteMessageWrapper, excludedPeer?: PeerDescriptor): RouteMessageAck {
+        if (this.stopped) {
+            return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
+        }
+        const targetId = getNodeIdFromBinary(routedMessage.target)
+        const request = (routedMessage.message!.body as { recursiveOperationRequest: RecursiveOperationRequest }).recursiveOperationRequest
+        // TODO use config option or named constant?
+        const closestPeersToDestination = this.getClosestConnections(routedMessage.target, 5)
+        const dataEntries = (request.operation === RecursiveOperation.FETCH_DATA) 
+            ? Array.from(this.config.localDataStore.getEntries(hexToBinary(targetId)).values())
+            : []
+        if (request.operation === RecursiveOperation.DELETE_DATA) {
+            this.config.localDataStore.markAsDeleted(hexToBinary(targetId), getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!))
+        }
+        if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, routedMessage.target)) {
+            // TODO this is also very similar case to what we do at line 255, could simplify the code paths?
+            this.sendResponse(
+                routedMessage.routingPath,
+                routedMessage.sourcePeer!,
+                request.sessionId,
+                closestPeersToDestination,
+                dataEntries,
+                true
+            )
+            return createRouteMessageAck(routedMessage)
+        } else {
+            const ack = this.config.router.doRouteMessage(routedMessage, RoutingMode.RECURSIVE, excludedPeer)
+            if ((ack.error === undefined) || (ack.error === RouteMessageError.NO_TARGETS)) {
+                const noCloserContactsFound = (ack.error === RouteMessageError.NO_TARGETS) ||
+                    (
+                        closestPeersToDestination.length > 0 
+                        && getPreviousPeer(routedMessage) 
+                        && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], targetId)
+                    )
+                this.sendResponse(
+                    routedMessage.routingPath,
+                    routedMessage.sourcePeer!,
+                    request.sessionId,
+                    closestPeersToDestination,
+                    dataEntries,
+                    noCloserContactsFound
+                )
+            }
+            return ack
+        }    
+    }
+
+    private getClosestConnections(nodeId: Uint8Array, limit: number): PeerDescriptor[] {
+        const connectedPeers = Array.from(this.config.connections.values())
+        const closestPeers = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: getNodeIdFromBinary(nodeId),
+            maxSize: limit,
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+        closestPeers.addContacts(connectedPeers)
+        return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
+    }
+
+    private isPeerCloserToIdThanSelf(peer: PeerDescriptor, compareToId: NodeID): boolean {
+        const distance1 = getDistance(getNodeIdFromPeerDescriptor(peer), compareToId)
+        const distance2 = getDistance(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), compareToId)
+        return distance1 < distance2
+    }
+
+    public stop(): void {
+        this.stopped = true
+        this.ongoingSessions.forEach((session, _id) => {
+            session.stop()
+        })
+        this.ongoingSessions.clear()
+    }
+}

package/src/dht/{find/FindRpcLocal.ts → recursive-operation/RecursiveOperationRpcLocal.ts}

@@ -1,35 +1,35 @@
 import { Logger } from '@streamr/utils'
 import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { IFindRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { IRecursiveOperationRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { createRouteMessageAck } from '../routing/RouterRpcLocal'
 import { getPreviousPeer } from '../routing/getPreviousPeer'
 
 const logger = new Logger(module)
 
-interface FindRpcLocalConfig {
-    doRouteFindRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck
+interface RecursiveOperationRpcLocalConfig {
+    doRouteRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     isMostLikelyDuplicate: (requestId: string) => boolean
     addToDuplicateDetector: (requestId: string) => void
 }
 
-export class FindRpcLocal implements IFindRpc {
+export class RecursiveOperationRpcLocal implements IRecursiveOperationRpc {
 
-    private readonly config: FindRpcLocalConfig
+    private readonly config: RecursiveOperationRpcLocalConfig
 
-    constructor(config: FindRpcLocalConfig) {
+    constructor(config: RecursiveOperationRpcLocalConfig) {
         this.config = config
     }
 
-    async routeFindRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+    async routeRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.config.isMostLikelyDuplicate(routedMessage.requestId)) {
             return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         const senderId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
-        logger.trace(`Received routeFindRequest call from ${senderId}`)
+        logger.trace(`Received routeRequest call from ${senderId}`)
         this.config.addContact(routedMessage.sourcePeer!, true)
         this.config.addToDuplicateDetector(routedMessage.requestId)
-        return this.config.doRouteFindRequest(routedMessage)
+        return this.config.doRouteRequest(routedMessage)
     }
 }

package/src/dht/{routing/FindRpcRemote.ts → recursive-operation/RecursiveOperationRpcRemote.ts}

@@ -1,18 +1,18 @@
-import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { RecursiveOperationRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RpcRemote } from '../contact/RpcRemote'
-import { Logger } from '@streamr/utils'
-import { IFindRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { getPreviousPeer } from './getPreviousPeer'
+import { getPreviousPeer } from '../routing/getPreviousPeer'
 
 const logger = new Logger(module)
 
-export class FindRpcRemote extends RpcRemote<IFindRpcClient> {
+export class RecursiveOperationRpcRemote extends RpcRemote<RecursiveOperationRpcClient> {
 
-    async routeFindRequest(params: RouteMessageWrapper): Promise<boolean> {
+    async routeRequest(params: RouteMessageWrapper): Promise<boolean> {
         const message: RouteMessageWrapper = {
-            destinationPeer: params.destinationPeer,
+            target: params.target,
             sourcePeer: params.sourcePeer,
             message: params.message,
             requestId: params.requestId ?? v4(),
@@ -20,10 +20,10 @@ export class FindRpcRemote extends RpcRemote<IFindRpcClient> {
             routingPath: params.routingPath
         }
         const options = this.formDhtRpcOptions({
-            doNotConnect: true
+            connect: false
         })
         try {
-            const ack = await this.getClient().routeFindRequest(message, options)
+            const ack = await this.getClient().routeRequest(message, options)
             if (ack.error !== undefined) {
                 logger.trace('Next hop responded with error ' + ack.error)
                 return false
@@ -34,7 +34,7 @@ export class FindRpcRemote extends RpcRemote<IFindRpcClient> {
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             // eslint-disable-next-line max-len
-            logger.debug(`Failed to send routeFindRequest message from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+            logger.debug(`Failed to send routeRequest message from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
             return false
         }
         return true

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

@@ -0,0 +1,224 @@
+import EventEmitter from 'eventemitter3'
+import { v4 } from 'uuid'
+import { 
+    DataEntry,
+    PeerDescriptor,
+    RecursiveOperationResponse,
+    RecursiveOperation,
+    RouteMessageWrapper,
+    RouteMessageAck,
+    RecursiveOperationRequest,
+    Message,
+    MessageType
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { ITransport } from '../../transport/ITransport'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { Contact } from '../contact/Contact'
+import { SortedContactList } from '../contact/SortedContactList'
+import { RecursiveOperationResult } from './RecursiveOperationManager'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { ServiceID } from '../../types/ServiceID'
+import { RecursiveOperationSessionRpcLocal } from './RecursiveOperationSessionRpcLocal'
+import { NodeID, areEqualNodeIds, getNodeIdFromBinary } from '../../helpers/nodeId'
+
+export interface RecursiveOperationSessionEvents {
+    completed: () => void
+}
+
+export interface RecursiveOperationSessionConfig {
+    transport: ITransport
+    targetId: Uint8Array
+    localPeerDescriptor: PeerDescriptor
+    waitedRoutingPathCompletions: number
+    operation: RecursiveOperation
+    doRouteRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck
+}
+
+export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSessionEvents> {
+
+    private readonly id = v4()
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+    private results: SortedContactList<Contact>
+    private foundData: Map<NodeID, DataEntry> = new Map()
+    private allKnownHops: Set<NodeID> = new Set()
+    private reportedHops: Set<NodeID> = new Set()
+    private timeoutTask?: NodeJS.Timeout 
+    private completionEventEmitted = false
+    private noCloserNodesReceivedCounter = 0
+    private readonly config: RecursiveOperationSessionConfig
+
+    constructor(config: RecursiveOperationSessionConfig) {
+        super()
+        this.config = config
+        this.results = new SortedContactList({
+            referenceId: getNodeIdFromBinary(config.targetId), 
+            maxSize: 10,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+        this.rpcCommunicator = new ListeningRpcCommunicator(this.id, config.transport, {
+            rpcRequestTimeout: 15000  // TODO use config option or named constant?
+        })
+        this.registerLocalRpcMethods()
+    }
+
+    private registerLocalRpcMethods() {
+        const rpcLocal = new RecursiveOperationSessionRpcLocal({
+            onResponseReceived: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => {
+                this.onResponseReceived(routingPath, nodes, dataEntries, noCloserNodesFound)
+            }
+        })
+        this.rpcCommunicator.registerRpcNotification(RecursiveOperationResponse, 'sendResponse',
+            (req: RecursiveOperationResponse) => rpcLocal.sendResponse(req))
+    }
+
+    public start(serviceId: ServiceID): void {
+        const routeMessage = this.wrapRequest(serviceId)
+        this.config.doRouteRequest(routeMessage)
+    }
+
+    private wrapRequest(serviceId: ServiceID): RouteMessageWrapper {
+        const request: RecursiveOperationRequest = {
+            sessionId: this.getId(),
+            operation: this.config.operation
+        }
+        const msg: Message = {
+            messageType: MessageType.RECURSIVE_OPERATION_REQUEST,
+            messageId: v4(),
+            serviceId,
+            body: {
+                oneofKind: 'recursiveOperationRequest',
+                recursiveOperationRequest: request
+            }
+        }
+        const routeMessage: RouteMessageWrapper = {
+            message: msg,
+            requestId: v4(),
+            target: this.config.targetId,
+            sourcePeer: this.config.localPeerDescriptor,
+            reachableThrough: [],
+            routingPath: []
+        }
+        return routeMessage
+    }
+
+    private isCompleted(): boolean {
+        const unreportedHops: Set<NodeID> = new Set(this.allKnownHops)
+        this.reportedHops.forEach((id) => {
+            unreportedHops.delete(id)
+        })
+        if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
+            if (this.config.operation === RecursiveOperation.FETCH_DATA
+                && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.config.waitedRoutingPathCompletions)) {
+                return true
+            } else if (this.config.operation === RecursiveOperation.FETCH_DATA) {
+                return false
+            }
+            return true
+        }
+        return false
+    }
+
+    private hasNonStaleData(): boolean {
+        return Array.from(this.foundData.values()).some((entry) => entry.stale === false)
+    }
+
+    public onResponseReceived(
+        routingPath: PeerDescriptor[],
+        nodes: PeerDescriptor[],
+        dataEntries: DataEntry[],
+        noCloserNodesFound: boolean
+    ): void {
+        this.addKnownHops(routingPath)
+        if (routingPath.length >= 1) {
+            this.setHopAsReported(routingPath[routingPath.length - 1])
+        }
+        nodes.forEach((descriptor: PeerDescriptor) => {
+            this.results.addContact(new Contact(descriptor))
+        })
+        this.processFoundData(dataEntries)
+        if (noCloserNodesFound) {
+            this.onNoCloserPeersFound()
+        }
+    }
+
+    private addKnownHops(routingPath: PeerDescriptor[]) {
+        const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        routingPath.forEach((desc) => {
+            const newNodeId = getNodeIdFromPeerDescriptor(desc)
+            if (!areEqualNodeIds(localNodeId, newNodeId)) {
+                this.allKnownHops.add(newNodeId)
+            }
+        })
+    }
+
+    private setHopAsReported(desc: PeerDescriptor) {
+        const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const newNodeId = getNodeIdFromPeerDescriptor(desc)
+        if (!areEqualNodeIds(localNodeId, newNodeId)) {
+            this.reportedHops.add(newNodeId)
+        }
+        if (this.isCompleted()) {
+            if (!this.completionEventEmitted && this.isCompleted()) {
+                if (this.timeoutTask) {
+                    clearTimeout(this.timeoutTask)
+                    this.timeoutTask = undefined
+                }
+                this.emit('completed')
+                this.completionEventEmitted = true
+            }
+        }
+    }
+
+    private processFoundData(dataEntries: DataEntry[]): void {
+        dataEntries.forEach((entry) => {
+            const creatorNodeId = getNodeIdFromBinary(entry.creator)
+            const existingEntry = this.foundData.get(creatorNodeId)
+            if (!existingEntry || existingEntry.createdAt! < entry.createdAt! 
+                || (existingEntry.createdAt! <= entry.createdAt! && entry.deleted)) {
+                this.foundData.set(creatorNodeId, entry)
+            }
+        })
+    }
+
+    private onNoCloserPeersFound(): void {
+        this.noCloserNodesReceivedCounter += 1
+        if (this.isCompleted()) {
+            this.emit('completed')
+            this.completionEventEmitted = true
+            if (this.timeoutTask) {
+                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?
+            }
+        }
+    }
+
+    public getResults(): RecursiveOperationResult {
+        return {
+            closestNodes: this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()),
+            dataEntries: Array.from(this.foundData.values())
+        }
+    }
+
+    public getId(): string {
+        return this.id
+    }
+
+    public stop(): void {
+        if (this.timeoutTask) {
+            clearTimeout(this.timeoutTask)
+            this.timeoutTask = undefined
+        }
+        this.rpcCommunicator.destroy()
+        this.emit('completed')
+    }
+}

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

@@ -0,0 +1,25 @@
+import { IRecursiveOperationSessionRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { DataEntry, RecursiveOperationResponse, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { Logger } from '@streamr/utils'
+
+const logger = new Logger(module)
+
+interface RecursiveOperationSessionRpcLocalConfig {
+    onResponseReceived: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => void
+}
+
+export class RecursiveOperationSessionRpcLocal implements IRecursiveOperationSessionRpc {
+
+    private readonly config: RecursiveOperationSessionRpcLocalConfig
+
+    constructor(config: RecursiveOperationSessionRpcLocalConfig) {
+        this.config = config
+    }
+    
+    async sendResponse(report: RecursiveOperationResponse): Promise<Empty> {
+        logger.trace('RecursiveOperationResponse arrived: ' + JSON.stringify(report))
+        this.config.onResponseReceived(report.routingPath, report.closestConnectedPeers, report.dataEntries, report.noCloserNodesFound)
+        return {}
+    }
+}

package/src/dht/{find/FindSessionRpcRemote.ts → recursive-operation/RecursiveOperationSessionRpcRemote.ts}

@@ -1,30 +1,30 @@
+import { Logger } from '@streamr/utils'
 import {
     DataEntry,
     PeerDescriptor,
-    FindResponse
+    RecursiveOperationResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IFindSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { Logger } from '@streamr/utils'
+import { RecursiveOperationSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RpcRemote } from '../contact/RpcRemote'
 
 const logger = new Logger(module)
 
-export class FindSessionRpcRemote extends RpcRemote<IFindSessionRpcClient> {
+export class RecursiveOperationSessionRpcRemote extends RpcRemote<RecursiveOperationSessionRpcClient> {
 
-    sendFindResponse(
+    sendResponse(
         routingPath: PeerDescriptor[],
         closestNodes: PeerDescriptor[],
         dataEntries: DataEntry[],
         noCloserNodesFound: boolean
     ): void {
-        const report: FindResponse = {
+        const report: RecursiveOperationResponse = {
             routingPath,
             closestConnectedPeers: closestNodes,
             dataEntries,
             noCloserNodesFound
         }
-        this.getClient().sendFindResponse(report, this.formDhtRpcOptions()).catch((_e) => {
-            logger.trace('Failed to send FindResponse')
+        this.getClient().sendResponse(report, this.formDhtRpcOptions()).catch((_e) => {
+            logger.trace('Failed to send RecursiveOperationResponse')
         })
     }
 }