@streamr/dht 100.0.0-pretestnet.0 → 100.0.0-pretestnet.3

package/src/dht/find/FindSessionRpcLocal.ts

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

package/src/dht/find/{RemoteRecursiveFindSession.ts → FindSessionRpcRemote.ts}

@@ -3,16 +3,20 @@ import {
     PeerDescriptor,
     FindResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IRecursiveFindSessionServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IFindSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
 import { Remote } from '../contact/Remote'
 
 const logger = new Logger(module)
 
-export class RemoteRecursiveFindSession extends Remote<IRecursiveFindSessionServiceClient> {
+export class FindSessionRpcRemote extends Remote<IFindSessionRpcClient> {
 
-    sendFindResponse(routingPath: PeerDescriptor[], closestNodes: PeerDescriptor[], 
-        dataEntries: DataEntry[], noCloserNodesFound: boolean): void {
+    sendFindResponse(
+        routingPath: PeerDescriptor[],
+        closestNodes: PeerDescriptor[],
+        dataEntries: DataEntry[],
+        noCloserNodesFound: boolean
+    ): void {
         const report: FindResponse = {
             routingPath,
             closestConnectedPeers: closestNodes,
@@ -20,7 +24,7 @@ export class RemoteRecursiveFindSession extends Remote<IRecursiveFindSessionServ
             noCloserNodesFound
         }
         this.getClient().sendFindResponse(report, this.formDhtRpcOptions()).catch((_e) => {
-            logger.trace('Failed to send FindResult')
+            logger.trace('Failed to send FindResponse')
         })
     }
 }

package/src/dht/find/{RecursiveFinder.ts → Finder.ts}

@@ -9,115 +9,134 @@ import {
     RouteMessageWrapper
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { createRouteMessageAck, RoutingErrors, IRouter } from '../routing/Router'
+import { RoutingErrors, IRouter } from '../routing/Router'
 import { RoutingMode } from '../routing/RoutingSession'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RemoteRecursiveFindSession } from './RemoteRecursiveFindSession'
+import { FindSessionRpcRemote } from './FindSessionRpcRemote'
 import { v4 } from 'uuid'
-import { RecursiveFindSession, RecursiveFindSessionEvents } from './RecursiveFindSession'
-import { RemoteDhtNode } from '../RemoteDhtNode'
+import { FindSession, FindSessionEvents } from './FindSession'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { ITransport } from '../../transport/ITransport'
 import { LocalDataStore } from '../store/LocalDataStore'
-import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { RecursiveFindSessionServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { FindSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { SortedContactList } from '../contact/SortedContactList'
+import { getPreviousPeer } from '../routing/getPreviousPeer'
+import { createRouteMessageAck } from '../routing/RouterRpcLocal'
+import { ServiceID } from '../../types/ServiceID'
+import { FindRpcLocal } from './FindRpcLocal'
 
-interface RecursiveFinderConfig {
+interface FinderConfig {
     rpcCommunicator: RoutingRpcCommunicator
     sessionTransport: ITransport
-    connections: Map<PeerIDKey, RemoteDhtNode>
+    connections: Map<PeerIDKey, DhtNodeRpcRemote>
     router: IRouter
-    ownPeerDescriptor: PeerDescriptor
-    serviceId: string
+    localPeerDescriptor: PeerDescriptor
+    serviceId: ServiceID
     localDataStore: LocalDataStore
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     isPeerCloserToIdThanSelf: (peer1: PeerDescriptor, compareToId: PeerID) => boolean
 }
 
-interface RecursiveFinderFunc {
-    startRecursiveFind(idToFind: Uint8Array, fetchData?: boolean): Promise<RecursiveFindResult>
+export interface IFinder {
+    startFind(idToFind: Uint8Array, fetchData?: boolean): Promise<FindResult>
 }
 
-export interface IRecursiveFinder extends Pick<IRouterRpc, 'findRecursively'>, RecursiveFinderFunc {}
-
-export interface RecursiveFindResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
+export interface FindResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
 
 const logger = new Logger(module)
 
-export class RecursiveFinder implements IRecursiveFinder {
+export class Finder implements IFinder {
 
     private readonly rpcCommunicator: RoutingRpcCommunicator
     private readonly sessionTransport: ITransport
-    private readonly connections: Map<PeerIDKey, RemoteDhtNode>
+    private readonly connections: Map<PeerIDKey, DhtNodeRpcRemote>
     private readonly router: IRouter
-    private readonly ownPeerDescriptor: PeerDescriptor
-    private readonly serviceId: string
+    private readonly localPeerDescriptor: PeerDescriptor
+    private readonly serviceId: ServiceID
     private readonly localDataStore: LocalDataStore
-    private readonly addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     private readonly isPeerCloserToIdThanSelf: (peer1: PeerDescriptor, compareToId: PeerID) => boolean
-    private ongoingSessions: Map<string, RecursiveFindSession> = new Map()
+    private ongoingSessions: Map<string, FindSession> = new Map()
     private stopped = false
 
-    constructor(config: RecursiveFinderConfig) {
+    constructor(config: FinderConfig) {
         this.rpcCommunicator = config.rpcCommunicator
         this.sessionTransport = config.sessionTransport
         this.connections = config.connections
         this.router = config.router
-        this.ownPeerDescriptor = config.ownPeerDescriptor
+        this.localPeerDescriptor = config.localPeerDescriptor
         this.serviceId = config.serviceId
         this.localDataStore = config.localDataStore
-        this.addContact = config.addContact
         this.isPeerCloserToIdThanSelf = config.isPeerCloserToIdThanSelf
-        this.rpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'findRecursively',
-            (routedMessage: RouteMessageWrapper) => this.findRecursively(routedMessage))
+        this.registerLocalRpcMethods(config)
+    }
+
+    private registerLocalRpcMethods(config: FinderConfig) {
+        const rpcLocal = new FindRpcLocal({
+            doRouteFindRequest: (routedMessage: RouteMessageWrapper) => this.doRouteFindRequest(routedMessage),
+            addContact: (contact: PeerDescriptor, setActive?: boolean) => config.addContact(contact, setActive),
+            isMostLikelyDuplicate: (requestId: string) => this.router.isMostLikelyDuplicate(requestId),
+            addToDuplicateDetector: (requestId: string) => this.router.addToDuplicateDetector(requestId)
+        })
+        this.rpcCommunicator.registerRpcMethod(
+            RouteMessageWrapper,
+            RouteMessageAck,
+            'routeFindRequest',
+            async (routedMessage: RouteMessageWrapper) => {
+                if (this.stopped) {
+                    return createRouteMessageAck(routedMessage, 'routeFindRequest() service is not running')
+                } else {
+                    return rpcLocal.routeFindRequest(routedMessage)
+                }
+            }
+        )
     }
 
-    public async startRecursiveFind(
+    public async startFind(
         idToFind: Uint8Array,
         fetchData: boolean = false,
         excludedPeer?: PeerDescriptor
-    ): Promise<RecursiveFindResult> {
+    ): Promise<FindResult> {
         if (this.stopped) {
             return { closestNodes: [] }
         }
         const sessionId = v4()
-        const recursiveFindSession = new RecursiveFindSession({
+        const session = new FindSession({
             serviceId: sessionId,
             transport: this.sessionTransport,
             kademliaIdToFind: idToFind,
-            ownPeerId: peerIdFromPeerDescriptor(this.ownPeerDescriptor),
+            localPeerId: peerIdFromPeerDescriptor(this.localPeerDescriptor),
             waitedRoutingPathCompletions: this.connections.size > 1 ? 2 : 1,
             fetchData
         })
         if (this.connections.size === 0) {
             const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
-            recursiveFindSession.doSendFindResponse(
-                [this.ownPeerDescriptor],
-                [this.ownPeerDescriptor],
+            session.doSendFindResponse(
+                [this.localPeerDescriptor],
+                [this.localPeerDescriptor],
                 data ? Array.from(data.values()) : [],
                 true
             )
-            return recursiveFindSession.getResults()
+            return session.getResults()
         }
         const routeMessage = this.wrapFindRequest(idToFind, sessionId, fetchData)
-        this.ongoingSessions.set(sessionId, recursiveFindSession)
+        this.ongoingSessions.set(sessionId, session)
         try {
-            await runAndWaitForEvents3<RecursiveFindSessionEvents>(
-                [() => this.doFindRecursevily(routeMessage, excludedPeer)],
-                [[recursiveFindSession, 'findCompleted']],
+            await runAndWaitForEvents3<FindSessionEvents>(
+                [() => this.doRouteFindRequest(routeMessage, excludedPeer)],
+                [[session, 'findCompleted']],
                 15000
             )
         } catch (err) {
-            logger.debug(`doFindRecursively failed with error ${err}`)
+            logger.debug(`doRouteFindRequest failed with error ${err}`)
         }
-        this.findAndReportLocalData(idToFind, fetchData, [], this.ownPeerDescriptor, sessionId)
+        this.findAndReportLocalData(idToFind, fetchData, [], this.localPeerDescriptor, sessionId)
         this.ongoingSessions.delete(sessionId)
-        recursiveFindSession.stop()
-        return recursiveFindSession.getResults()
+        session.stop()
+        return session.getResults()
     }
 
     private wrapFindRequest(idToFind: Uint8Array, sessionId: string, fetchData: boolean): RouteMessageWrapper {
@@ -130,7 +149,7 @@ export class RecursiveFinder implements IRecursiveFinder {
             fetchData
         }
         const msg: Message = {
-            messageType: MessageType.RECURSIVE_FIND_REQUEST,
+            messageType: MessageType.FIND_REQUEST,
             messageId: v4(),
             serviceId: this.serviceId,
             body: {
@@ -142,7 +161,7 @@ export class RecursiveFinder implements IRecursiveFinder {
             message: msg,
             requestId: v4(),
             destinationPeer: targetDescriptor,
-            sourcePeer: this.ownPeerDescriptor,
+            sourcePeer: this.localPeerDescriptor,
             reachableThrough: [],
             routingPath: []
         }
@@ -176,29 +195,31 @@ export class RecursiveFinder implements IRecursiveFinder {
     private sendFindResponse(
         routingPath: PeerDescriptor[],
         targetPeerDescriptor: PeerDescriptor,
-        serviceId: string,
+        serviceId: ServiceID,
         closestNodes: PeerDescriptor[],
         data: Map<PeerIDKey, DataEntry> | undefined,
         noCloserNodesFound: boolean = false
     ): void {
         const dataEntries = data ? Array.from(data.values(), DataEntry.create.bind(DataEntry)) : []
-        const isOwnNode = areEqualPeerDescriptors(this.ownPeerDescriptor, targetPeerDescriptor)
+        const isOwnNode = areEqualPeerDescriptors(this.localPeerDescriptor, targetPeerDescriptor)
         if (isOwnNode && this.ongoingSessions.has(serviceId)) {
             this.ongoingSessions.get(serviceId)!
                 .doSendFindResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
         } else {
             const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.sessionTransport, { rpcRequestTimeout: 15000 })
-            const remoteSession = new RemoteRecursiveFindSession(
-                this.ownPeerDescriptor,
+            const rpcRemote = new FindSessionRpcRemote(
+                this.localPeerDescriptor,
                 targetPeerDescriptor,
                 serviceId,
-                toProtoRpcClient(new RecursiveFindSessionServiceClient(remoteCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new FindSessionRpcClient(remoteCommunicator.getRpcClientTransport())),
+                10000
             )
-            remoteSession.sendFindResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+            rpcRemote.sendFindResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+            remoteCommunicator.destroy()
         }
     }
 
-    private doFindRecursevily(routedMessage: RouteMessageWrapper, excludedPeer?: PeerDescriptor): RouteMessageAck {
+    private doRouteFindRequest(routedMessage: RouteMessageWrapper, excludedPeer?: PeerDescriptor): RouteMessageAck {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, 'DhtNode Stopped')
         }
@@ -207,14 +228,14 @@ export class RecursiveFinder implements IRecursiveFinder {
         const findRequest = msg?.body.oneofKind === 'findRequest' ? msg.body.findRequest : undefined
         const closestPeersToDestination = this.getClosestConnections(routedMessage.destinationPeer!.kademliaId, 5)
         const data = this.findLocalData(idToFind.value, findRequest!.fetchData)
-        if (areEqualPeerDescriptors(this.ownPeerDescriptor, routedMessage.destinationPeer!)) {
+        if (areEqualPeerDescriptors(this.localPeerDescriptor, routedMessage.destinationPeer!)) {
             this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
                 closestPeersToDestination, data, true)
             return createRouteMessageAck(routedMessage)
         }
-        const ack = this.router.doRouteMessage(routedMessage, RoutingMode.RECURSIVE_FIND, excludedPeer)
+        const ack = this.router.doRouteMessage(routedMessage, RoutingMode.FIND, excludedPeer)
         if (ack.error === RoutingErrors.NO_CANDIDATES_FOUND) {
-            logger.trace(`findRecursively Node found no candidates`)
+            logger.trace(`routeFindRequest Node found no candidates`)
             this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
                 closestPeersToDestination, data, true)
         } else if (ack.error) {
@@ -222,7 +243,7 @@ export class RecursiveFinder implements IRecursiveFinder {
         } else {
             const noCloserContactsFound = (
                 closestPeersToDestination.length > 0
-                && routedMessage.previousPeer
+                && getPreviousPeer(routedMessage)
                 && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], idToFind)
             )
             this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
@@ -233,7 +254,7 @@ export class RecursiveFinder implements IRecursiveFinder {
 
     private getClosestConnections(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
         const connectedPeers = Array.from(this.connections.values())
-        const closestPeers = new SortedContactList<RemoteDhtNode>(
+        const closestPeers = new SortedContactList<DhtNodeRpcRemote>(
             PeerID.fromValue(kademliaId),
             limit,
             undefined,
@@ -244,20 +265,6 @@ export class RecursiveFinder implements IRecursiveFinder {
         return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
     }
 
-    // IRouterRpc method
-    async findRecursively(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.stopped) {
-            return createRouteMessageAck(routedMessage, 'findRecursively() service is not running')
-        } else if (this.router.isMostLikelyDuplicate(routedMessage.requestId)) {
-            return createRouteMessageAck(routedMessage, 'message given to findRecursively() service is likely a duplicate')
-        }
-        const senderKey = keyFromPeerDescriptor(routedMessage.previousPeer || routedMessage.sourcePeer!)
-        logger.trace(`Received findRecursively call from ${senderKey}`)
-        this.addContact(routedMessage.sourcePeer!, true)
-        this.router.addToDuplicateDetector(routedMessage.requestId)
-        return this.doFindRecursevily(routedMessage)
-    }
-
     public stop(): void {
         this.stopped = true
         this.ongoingSessions.forEach((session, _id) => {

package/src/dht/routing/FindRpcRemote.ts

@@ -0,0 +1,40 @@
+import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { v4 } from 'uuid'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { Remote } from '../contact/Remote'
+import { Logger } from '@streamr/utils'
+import { IFindRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { getPreviousPeer } from './getPreviousPeer'
+
+const logger = new Logger(module)
+
+export class FindRpcRemote extends Remote<IFindRpcClient> {
+
+    async routeFindRequest(params: RouteMessageWrapper): Promise<boolean> {
+        const message: RouteMessageWrapper = {
+            destinationPeer: params.destinationPeer,
+            sourcePeer: params.sourcePeer,
+            message: params.message,
+            requestId: params.requestId ?? v4(),
+            reachableThrough: params.reachableThrough ?? [],
+            routingPath: params.routingPath
+        }
+        const options = this.formDhtRpcOptions()
+        try {
+            const ack = await this.getClient().routeFindRequest(message, options)
+            if (ack.error.length > 0) {
+                logger.debug('Next hop responded with error ' + ack.error)
+                return false
+            }
+        } catch (err) {
+            const previousPeer = getPreviousPeer(params)
+            const fromNode = previousPeer
+                ? keyFromPeerDescriptor(previousPeer)
+                : keyFromPeerDescriptor(params.sourcePeer!)
+            // eslint-disable-next-line max-len
+            logger.debug(`Failed to send routeFindRequest message from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+            return false
+        }
+        return true
+    }
+}