@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,244 +0,0 @@
-import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
-import { ConnectionLocker } from '../../connection/ConnectionManager'
-import {
-    DhtAddress,
-    areEqualPeerDescriptors,
-    randomDhtAddress,
-    toDhtAddress,
-    toNodeId,
-    toDhtAddressRaw
-} from '../../identifiers'
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { ServiceID } from '../../types/ServiceID'
-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'
-import { CONTROL_LAYER_NODE_SERVICE_ID } from '../DhtNode'
-
-interface PeerDiscoveryOptions {
-    localPeerDescriptor: PeerDescriptor
-    joinNoProgressLimit: number
-    serviceId: ServiceID
-    parallelism: number
-    joinTimeout: number
-    connectionLocker?: ConnectionLocker
-    peerManager: PeerManager
-    abortSignal: AbortSignal
-    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
-}
-
-export const createDistantDhtAddress = (address: DhtAddress): DhtAddress => {
-    const raw = toDhtAddressRaw(address)
-    const flipped = raw.map((val) => ~val)
-    return toDhtAddress(flipped)
-}
-
-const logger = new Logger(module)
-
-export class PeerDiscovery {
-
-    private ongoingDiscoverySessions: Map<string, DiscoverySession> = new Map()
-    private ongoingRingDiscoverySessions: Map<string, RingDiscoverySession> = new Map()
-    
-    private rejoinOngoing = false
-    private joinCalled = false
-    private recoveryIntervalStarted = false
-    private readonly options: PeerDiscoveryOptions
-
-    constructor(options: PeerDiscoveryOptions) {
-        this.options = options
-    }
-
-    async joinDht(
-        entryPoints: PeerDescriptor[],
-        doAdditionalDistantPeerDiscovery = true,
-        retry = true
-    ): Promise<void> {
-        const contactedPeers = new Set<DhtAddress>()
-        const distantJoinOptions = doAdditionalDistantPeerDiscovery 
-            ? { enabled: true, contactedPeers: new Set<DhtAddress>() } : { enabled: false } as const
-        await Promise.all(entryPoints.map((entryPoint) => this.joinThroughEntryPoint(
-            entryPoint,
-            contactedPeers,
-            distantJoinOptions,
-            retry
-        )))
-    }
-
-    private async joinThroughEntryPoint(
-        entryPointDescriptor: PeerDescriptor,
-        // Note that this set is mutated by DiscoverySession
-        contactedPeers: Set<DhtAddress>,
-        additionalDistantJoin: { enabled: true, contactedPeers: Set<DhtAddress> } | { enabled: false },
-        retry = true
-    ): Promise<void> {
-        if (this.isStopped()) {
-            return
-        }
-        this.joinCalled = true
-        logger.debug(
-            `Joining ${this.options.serviceId === CONTROL_LAYER_NODE_SERVICE_ID
-                ? 'The Streamr Network' : `Control Layer for ${this.options.serviceId}`}`
-            + ` via entrypoint ${toNodeId(entryPointDescriptor)}`
-        )
-        if (areEqualPeerDescriptors(entryPointDescriptor, this.options.localPeerDescriptor)) {
-            return
-        }
-        this.options.connectionLocker?.lockConnection(entryPointDescriptor, `${this.options.serviceId}::joinDht`)
-        this.options.peerManager.addContact(entryPointDescriptor)
-        const targetId = toNodeId(this.options.localPeerDescriptor)
-        const sessions = [this.createSession(targetId, contactedPeers)]
-        if (additionalDistantJoin.enabled) {
-            sessions.push(this.createSession(createDistantDhtAddress(targetId), additionalDistantJoin.contactedPeers))
-        }
-        await this.runSessions(sessions, entryPointDescriptor, retry)
-        this.options.connectionLocker?.unlockConnection(entryPointDescriptor, `${this.options.serviceId}::joinDht`)
-
-    }
-
-    async joinRing(): Promise<void> {
-        const contactedPeers = new Set<DhtAddress>()
-        const sessions = [this.createRingSession(getRingIdRawFromPeerDescriptor(this.options.localPeerDescriptor), contactedPeers)]
-        await this.runRingSessions(sessions)
-    }
-
-    private createSession(targetId: DhtAddress, contactedPeers: Set<DhtAddress>): DiscoverySession {
-        const sessionOptions = {
-            targetId,
-            parallelism: this.options.parallelism,
-            noProgressLimit: this.options.joinNoProgressLimit,
-            peerManager: this.options.peerManager,
-            contactedPeers,
-            abortSignal: this.options.abortSignal,
-            createDhtNodeRpcRemote: this.options.createDhtNodeRpcRemote
-        }
-        return new DiscoverySession(sessionOptions)
-    }
-
-    private createRingSession(targetId: RingIdRaw, contactedPeers: Set<DhtAddress>): RingDiscoverySession {
-        const sessionOptions = {
-            targetId,
-            parallelism: this.options.parallelism,
-            noProgressLimit: this.options.joinNoProgressLimit,
-            peerManager: this.options.peerManager,
-            contactedPeers,
-            abortSignal: this.options.abortSignal,
-            createDhtNodeRpcRemote: this.options.createDhtNodeRpcRemote
-        }
-        return new RingDiscoverySession(sessionOptions)
-    }
-
-    private async runSessions(sessions: DiscoverySession[], entryPointDescriptor: PeerDescriptor, retry: boolean): Promise<void> {
-        try {
-            for (const session of sessions) {
-                this.ongoingDiscoverySessions.set(session.id, session)
-                await session.findClosestNodes(this.options.joinTimeout)
-            }
-        } catch (_e) {
-            logger.debug(`DHT join on ${this.options.serviceId} timed out`)
-        } finally {
-            if (!this.isStopped()) {
-                if (this.options.peerManager.getNeighborCount() === 0) {
-                    if (retry) {
-                        // TODO should we catch possible promise rejection?
-                        // TODO use options option or named constant?
-                        setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.options.abortSignal)
-                    }
-                } else {
-                    await this.ensureRecoveryIntervalIsRunning()
-                }
-            }
-            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id))
-        }
-    }
-
-    private async runRingSessions(sessions: RingDiscoverySession[]): Promise<void> {
-        try {
-            for (const session of sessions) {
-                this.ongoingRingDiscoverySessions.set(session.id, session)
-                await session.findClosestNodes(this.options.joinTimeout)
-            }
-        } catch (_e) {
-            logger.debug(`Ring join on ${this.options.serviceId} timed out`)
-        } finally {
-            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id))
-        }
-    }
-
-    public async rejoinDht(
-        entryPoint: PeerDescriptor,
-        contactedPeers: Set<DhtAddress> = new Set(),
-        distantJoinContactPeers: Set<DhtAddress> = new Set()
-    ): Promise<void> {
-        if (this.isStopped() || this.rejoinOngoing) {
-            return
-        }
-        logger.debug(`Rejoining DHT ${this.options.serviceId}`)
-        this.rejoinOngoing = true
-        try {
-            await this.joinThroughEntryPoint(entryPoint, contactedPeers, { enabled: true, contactedPeers: distantJoinContactPeers })
-            logger.debug(`Rejoined DHT successfully ${this.options.serviceId}!`)
-        } catch {
-            logger.warn(`Rejoining DHT ${this.options.serviceId} failed`)
-            if (!this.isStopped()) {
-                // TODO should we catch possible promise rejection?
-                // TODO use options option or named constant?
-                setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.options.abortSignal)
-            }
-        } finally {
-            this.rejoinOngoing = false
-        }
-    }
-
-    private async ensureRecoveryIntervalIsRunning(): Promise<void> {
-        if (!this.recoveryIntervalStarted) {
-            this.recoveryIntervalStarted = true
-            // TODO use options option or named constant?
-            await scheduleAtInterval(() => this.fetchClosestAndRandomNeighbors(), 60000, true, this.options.abortSignal)
-        }
-    }
-
-    private async fetchClosestAndRandomNeighbors(): Promise<void> {
-        if (this.isStopped()) {
-            return
-        }
-        const localNodeId = toNodeId(this.options.localPeerDescriptor)
-        const nodes = this.getClosestNeighbors(localNodeId, this.options.parallelism)
-        const randomNodes = this.getClosestNeighbors(randomDhtAddress(), 1)
-        await Promise.allSettled([
-            ...nodes.map(async (node: PeerDescriptor) => {
-                const remote = this.options.createDhtNodeRpcRemote(node)
-                const contacts = await remote.getClosestPeers(localNodeId)
-                for (const contact of contacts) {
-                    this.options.peerManager.addContact(contact)
-                }
-            }),
-            ...randomNodes.map(async (node: PeerDescriptor) => {
-                const remote = this.options.createDhtNodeRpcRemote(node)
-                const contacts = await remote.getClosestPeers(randomDhtAddress())
-                for (const contact of contacts) {
-                    this.options.peerManager.addContact(contact)
-                }
-            })
-        ])
-    }
-
-    private getClosestNeighbors(referenceId: DhtAddress, maxCount: number): PeerDescriptor[] {
-        return getClosestNodes(referenceId, this.options.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()), { maxCount })
-    }
-
-    public isJoinOngoing(): boolean {
-        return !this.joinCalled ? true : this.ongoingDiscoverySessions.size > 0
-    }
-
-    public isJoinCalled(): boolean {
-        return this.joinCalled
-    }
-
-    private isStopped() {
-        return this.options.abortSignal.aborted
-    }
-}

package/src/dht/discovery/RingDiscoverySession.ts

@@ -1,148 +0,0 @@
-import { Gate, Logger, withTimeout } from '@streamr/utils'
-import { v4 } from 'uuid'
-import { DhtAddress, toNodeId } from '../../identifiers'
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { PeerManager } from '../PeerManager'
-import { RingContacts } from '../contact/RingContactList'
-import { RingId, RingIdRaw, getLeftDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from '../contact/ringIdentifiers'
-
-const logger = new Logger(module)
-
-interface RingDiscoverySessionOptions {
-    targetId: RingIdRaw
-    parallelism: number
-    noProgressLimit: number
-    peerManager: PeerManager
-    // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
-    contactedPeers: Set<DhtAddress>
-    abortSignal: AbortSignal
-}
-
-export class RingDiscoverySession {
-
-    public readonly id = v4()
-    private noProgressCounter = 0
-    private ongoingRequests: Set<DhtAddress> = new Set()
-    private doneGate = new Gate(false)
-    private readonly options: RingDiscoverySessionOptions
-    private numContactedPeers = 0
-    private targetIdAsRingId: RingId
-
-    constructor(options: RingDiscoverySessionOptions) {
-        this.options = options
-        this.targetIdAsRingId = getRingIdFromRaw(this.options.targetId)
-    }
-
-    private addContacts(contacts: PeerDescriptor[]): void {
-        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
-            return
-        }
-        for (const contact of contacts) {
-            this.options.peerManager.addContact(contact)
-        }
-    }
-
-    private async fetchClosestContactsFromRemote(contact: DhtNodeRpcRemote): Promise<RingContacts> {
-        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
-            return { left: [], right: [] }
-        }
-        logger.trace(`Getting closest ring peers from contact: ${toNodeId(contact.getPeerDescriptor())}`)
-        this.numContactedPeers++
-        this.options.contactedPeers.add(contact.getNodeId())
-        const returnedContacts = await contact.getClosestRingPeers(this.options.targetId)
-        this.options.peerManager.setContactActive(contact.getNodeId())
-        return returnedContacts
-    }
-
-    private onRequestSucceeded(nodeId: DhtAddress, contacts: RingContacts) {
-        if (!this.ongoingRequests.has(nodeId)) {
-            return
-        }
-        this.ongoingRequests.delete(nodeId)
-        const oldClosestContacts = this.options.peerManager.getClosestRingContactsTo(this.options.targetId, 1)
-        const oldClosestLeftDistance = getLeftDistance(
-            this.targetIdAsRingId,
-            getRingIdFromPeerDescriptor(oldClosestContacts.left[0].getPeerDescriptor())
-        )
-        const oldClosestRightDistance = getLeftDistance(
-            this.targetIdAsRingId,
-            getRingIdFromPeerDescriptor(oldClosestContacts.right[0].getPeerDescriptor())
-        )
-        this.addContacts(contacts.left.concat(contacts.right))
-        const newClosestContacts = this.options.peerManager.getClosestRingContactsTo(this.options.targetId, 1)
-        const newClosestLeftDistance = getLeftDistance(this.targetIdAsRingId,
-            getRingIdFromPeerDescriptor(newClosestContacts.left[0].getPeerDescriptor()))
-        const newClosestRightDistance = getLeftDistance(this.targetIdAsRingId,
-            getRingIdFromPeerDescriptor(newClosestContacts.right[0].getPeerDescriptor()))
-        if (newClosestLeftDistance >= oldClosestLeftDistance && newClosestRightDistance >= oldClosestRightDistance) {
-            this.noProgressCounter++
-        }
-    }
-
-    private onRequestFailed(peer: DhtNodeRpcRemote) {
-        if (!this.ongoingRequests.has(peer.getNodeId())) {
-            return
-        }
-        this.ongoingRequests.delete(peer.getNodeId())
-        this.options.peerManager.removeContact(peer.getNodeId())
-    }
-
-    private findMoreContacts(): void {
-        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
-            return
-        }
-        const uncontacted = this.options.peerManager.getClosestRingContactsTo(
-            this.options.targetId,
-            this.options.parallelism,
-            this.options.contactedPeers
-        )
-        if ((uncontacted.left.length === 0 && uncontacted.right.length === 0)
-            || this.noProgressCounter >= this.options.noProgressLimit) {
-            this.doneGate.open()
-            return
-        }
-        // ask from both sides equally
-        const merged = []
-        const alreadyInMerged: Set<DhtAddress> = new Set()
-        const length = Math.max(uncontacted.left.length, uncontacted.right.length)
-        for (let i = 0; i < length; i++) {
-            if (i < uncontacted.left.length) {
-                if (!alreadyInMerged.has(uncontacted.left[i].getNodeId())) {
-                    merged.push(uncontacted.left[i])
-                    alreadyInMerged.add(uncontacted.left[i].getNodeId())
-                }
-            }
-            if (i < uncontacted.right.length) {
-                if (!alreadyInMerged.has(uncontacted.right[i].getNodeId())) {
-                    merged.push(uncontacted.right[i])
-                    alreadyInMerged.add(uncontacted.right[i].getNodeId())
-                }
-            }
-        }
-
-        for (const nextPeer of merged) {
-            if (this.ongoingRequests.size >= this.options.parallelism) {
-                break
-            }
-            this.ongoingRequests.add(nextPeer.getNodeId())
-            // eslint-disable-next-line promise/catch-or-return
-            this.fetchClosestContactsFromRemote(nextPeer)
-                .then((contacts) => this.onRequestSucceeded(nextPeer.getNodeId(), contacts))
-                .catch(() => this.onRequestFailed(nextPeer))
-                .finally(() => {
-                    this.findMoreContacts()
-                })
-        }
-    }
-
-    public async findClosestNodes(timeout: number): Promise<void> {
-        if (this.options.peerManager.getNearbyContactCount(this.options.contactedPeers) === 0) {
-            return
-        }
-        setImmediate(() => {
-            this.findMoreContacts()
-        })
-        await withTimeout(this.doneGate.waitUntilOpen(), timeout, 'discovery session timed out', this.options.abortSignal)
-    }
-}

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

@@ -1,251 +0,0 @@
-import {
-    DataEntry,
-    PeerDescriptor,
-    RecursiveOperation,
-    RecursiveOperationRequest,
-    RouteMessageAck,
-    RouteMessageError,
-    RouteMessageWrapper
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { Router } from '../routing/Router'
-import { RoutingMode } from '../routing/RoutingSession'
-import { Logger, areEqualBinaries, runAndWaitForEvents3, wait } from '@streamr/utils'
-import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RecursiveOperationSessionRpcRemote } from './RecursiveOperationSessionRpcRemote'
-import { RECURSIVE_OPERATION_TIMEOUT, 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 '../../../generated/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 { DhtAddress, areEqualPeerDescriptors, toDhtAddress, toNodeId, toDhtAddressRaw } from '../../identifiers'
-import { getDistance } from '../PeerManager'
-import { ConnectionsView } from '../../exports'
-
-interface RecursiveOperationManagerOptions {
-    rpcCommunicator: RoutingRpcCommunicator
-    sessionTransport: ITransport
-    router: Router
-    connectionsView: ConnectionsView
-    localPeerDescriptor: PeerDescriptor
-    serviceId: ServiceID
-    localDataStore: LocalDataStore
-    addContact: (contact: PeerDescriptor) => void
-    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
-}
-
-export interface RecursiveOperationResult { closestNodes: PeerDescriptor[], dataEntries?: DataEntry[] }
-
-const logger = new Logger(module)
-
-export class RecursiveOperationManager {
-
-    private ongoingSessions: Map<string, RecursiveOperationSession> = new Map()
-    private stopped = false
-    private readonly options: RecursiveOperationManagerOptions
-
-    constructor(options: RecursiveOperationManagerOptions) {
-        this.options = options
-        this.registerLocalRpcMethods()
-    }
-
-    private registerLocalRpcMethods() {
-        const rpcLocal = new RecursiveOperationRpcLocal({
-            doRouteRequest: (routedMessage: RouteMessageWrapper) => this.doRouteRequest(routedMessage),
-            addContact: (contact: PeerDescriptor) => this.options.addContact(contact),
-            isMostLikelyDuplicate: (requestId: string) => this.options.router.isMostLikelyDuplicate(requestId),
-            addToDuplicateDetector: (requestId: string) => this.options.router.addToDuplicateDetector(requestId)
-        })
-        this.options.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: DhtAddress,
-        operation: RecursiveOperation,
-        excludedPeer?: DhtAddress,
-        waitForCompletion = true
-    ): Promise<RecursiveOperationResult> {
-        if (this.stopped) {
-            return { closestNodes: [] }
-        }
-        const session = new RecursiveOperationSession({
-            transport: this.options.sessionTransport,
-            targetId,
-            localPeerDescriptor: this.options.localPeerDescriptor,
-            // TODO use options option or named constant?
-            waitedRoutingPathCompletions: this.options.connectionsView.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.options.connectionsView.getConnectionCount() === 0) {
-            const dataEntries = Array.from(this.options.localDataStore.values(targetId))
-            session.onResponseReceived(
-                toNodeId(this.options.localPeerDescriptor),
-                [this.options.localPeerDescriptor],
-                [this.options.localPeerDescriptor],
-                dataEntries,
-                true
-            )
-            return session.getResults()
-        }
-        this.ongoingSessions.set(session.getId(), session)
-        if (waitForCompletion === true) {
-            try {
-                await runAndWaitForEvents3<RecursiveOperationSessionEvents>(
-                    [() => session.start(this.options.serviceId)],
-                    [[session, 'completed']],
-                    // TODO use options option or named constant?
-                    RECURSIVE_OPERATION_TIMEOUT
-                )
-            } catch (err) {
-                logger.debug('start failed', { err })
-            }
-        } else {
-            session.start(this.options.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.options.localDataStore.values(targetId))
-            if (dataEntries.length > 0) {
-                this.sendResponse([this.options.localPeerDescriptor], this.options.localPeerDescriptor, session.getId(), [], dataEntries, true)
-            }
-        } else if (operation === RecursiveOperation.DELETE_DATA) {
-            this.options.localDataStore.markAsDeleted(targetId, toNodeId(this.options.localPeerDescriptor))
-        }
-        this.ongoingSessions.delete(session.getId())
-        session.stop()
-        return session.getResults()
-    }
-
-    private sendResponse(
-        routingPath: PeerDescriptor[],
-        targetPeerDescriptor: PeerDescriptor,
-        serviceId: ServiceID,
-        closestConnectedNodes: PeerDescriptor[],
-        dataEntries: DataEntry[],
-        noCloserNodesFound: boolean = false
-    ): void {
-        const isOwnNode = areEqualPeerDescriptors(this.options.localPeerDescriptor, targetPeerDescriptor)
-        if (isOwnNode && this.ongoingSessions.has(serviceId)) {
-            this.ongoingSessions.get(serviceId)!
-                .onResponseReceived(
-                    toNodeId(this.options.localPeerDescriptor),
-                    routingPath,
-                    closestConnectedNodes,
-                    dataEntries,
-                    noCloserNodesFound
-                )
-        } else {
-            // TODO use options option or named constant?
-            const remoteCommunicator = new ListeningRpcCommunicator(
-                serviceId,
-                this.options.sessionTransport,
-                { rpcRequestTimeout: RECURSIVE_OPERATION_TIMEOUT }
-            )
-            const rpcRemote = new RecursiveOperationSessionRpcRemote(
-                this.options.localPeerDescriptor,
-                targetPeerDescriptor,
-                remoteCommunicator,
-                RecursiveOperationSessionRpcClient,
-                // TODO use options option or named constant?
-                10000
-            )
-            rpcRemote.sendResponse(routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
-            remoteCommunicator.destroy()
-        }
-    }
-
-    private doRouteRequest(routedMessage: RouteMessageWrapper, excludedPeer?: DhtAddress): RouteMessageAck {
-        if (this.stopped) {
-            return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
-        }
-        const targetId = toDhtAddress(routedMessage.target)
-        const request = (routedMessage.message!.body as { recursiveOperationRequest: RecursiveOperationRequest }).recursiveOperationRequest
-        // TODO use options option or named constant?
-        const closestConnectedNodes = this.getClosestConnectedNodes(targetId, 5)
-        const dataEntries = (request.operation === RecursiveOperation.FETCH_DATA) 
-            ? Array.from(this.options.localDataStore.values(targetId))
-            : []
-        if (request.operation === RecursiveOperation.DELETE_DATA) {
-            this.options.localDataStore.markAsDeleted(targetId, toNodeId(routedMessage.sourcePeer!))
-        }
-        if (areEqualBinaries(this.options.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,
-                closestConnectedNodes,
-                dataEntries,
-                true
-            )
-            return createRouteMessageAck(routedMessage)
-        } else {
-            const ack = this.options.router.doRouteMessage(routedMessage, RoutingMode.RECURSIVE, excludedPeer)
-            if ((ack.error === undefined) || (ack.error === RouteMessageError.NO_TARGETS)) {
-                const noCloserContactsFound = (ack.error === RouteMessageError.NO_TARGETS) ||
-                    (
-                        closestConnectedNodes.length > 0 
-                        && getPreviousPeer(routedMessage) 
-                        && !this.isPeerCloserToIdThanSelf(closestConnectedNodes[0], targetId)
-                    )
-                this.sendResponse(
-                    routedMessage.routingPath,
-                    routedMessage.sourcePeer!,
-                    request.sessionId,
-                    closestConnectedNodes,
-                    dataEntries,
-                    noCloserContactsFound
-                )
-            }
-            return ack
-        }    
-    }
-
-    private getClosestConnectedNodes(referenceId: DhtAddress, limit: number): PeerDescriptor[] {
-        const connectedNodes = this.options.connectionsView.getConnections().map((c) => this.options.createDhtNodeRpcRemote(c))
-        const sorted = new SortedContactList<DhtNodeRpcRemote>({
-            referenceId,
-            maxSize: limit,
-            allowToContainReferenceId: true
-        })
-        sorted.addContacts(connectedNodes)
-        return sorted.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
-    }
-
-    private isPeerCloserToIdThanSelf(peer: PeerDescriptor, nodeIdOrDataKey: DhtAddress): boolean {
-        const nodeIdOrDataKeyRaw = toDhtAddressRaw(nodeIdOrDataKey)
-        const distance1 = getDistance(peer.nodeId, nodeIdOrDataKeyRaw)
-        const distance2 = getDistance(this.options.localPeerDescriptor.nodeId, nodeIdOrDataKeyRaw)
-        return distance1 < distance2
-    }
-
-    public stop(): void {
-        this.stopped = true
-        this.ongoingSessions.forEach((session, _id) => {
-            session.stop()
-        })
-        this.ongoingSessions.clear()
-    }
-}

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

@@ -1,34 +0,0 @@
-import { Logger } from '@streamr/utils'
-import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-import { IRecursiveOperationRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
-import { createRouteMessageAck } from '../routing/RouterRpcLocal'
-import { getPreviousPeer } from '../routing/getPreviousPeer'
-import { toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-interface RecursiveOperationRpcLocalOptions {
-    doRouteRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck
-    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
-    isMostLikelyDuplicate: (requestId: string) => boolean
-    addToDuplicateDetector: (requestId: string) => void
-}
-
-export class RecursiveOperationRpcLocal implements IRecursiveOperationRpc {
-
-    private readonly options: RecursiveOperationRpcLocalOptions
-
-    constructor(options: RecursiveOperationRpcLocalOptions) {
-        this.options = options
-    }
-
-    async routeRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.options.isMostLikelyDuplicate(routedMessage.requestId)) {
-            return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
-        }
-        const remoteNodeId = toNodeId(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
-        logger.trace(`Received routeRequest call from ${remoteNodeId}`)
-        this.options.addToDuplicateDetector(routedMessage.requestId)
-        return this.options.doRouteRequest(routedMessage)
-    }
-}