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

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

@@ -1,43 +0,0 @@
-import { Logger } from '@streamr/utils'
-import { v4 } from 'uuid'
-import { RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-import { RecursiveOperationRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-import { RpcRemote } from '../contact/RpcRemote'
-import { getPreviousPeer } from '../routing/getPreviousPeer'
-import { toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-export class RecursiveOperationRpcRemote extends RpcRemote<RecursiveOperationRpcClient> {
-
-    async routeRequest(params: RouteMessageWrapper): Promise<boolean> {
-        const message: RouteMessageWrapper = {
-            target: params.target,
-            sourcePeer: params.sourcePeer,
-            message: params.message,
-            requestId: params.requestId ?? v4(),
-            reachableThrough: params.reachableThrough ?? [],
-            routingPath: params.routingPath,
-            parallelRootNodeIds: params.parallelRootNodeIds
-        }
-        const options = this.formDhtRpcOptions({
-            connect: false
-        })
-        try {
-            const ack = await this.getClient().routeRequest(message, options)
-            if (ack.error !== undefined) {
-                logger.trace('Next hop responded with error ' + ack.error)
-                return false
-            }
-        } catch (err) {
-            const previousPeer = getPreviousPeer(params)
-            const fromNode = previousPeer
-                ? toNodeId(previousPeer)
-                : toNodeId(params.sourcePeer!)
-            const toNode = toNodeId(this.getPeerDescriptor())
-            logger.debug(`Failed to send routeRequest message from ${fromNode} to ${toNode}`, { err })
-            return false
-        }
-        return true
-    }
-}

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

@@ -1,231 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { v4 } from 'uuid'
-import { 
-    DataEntry,
-    PeerDescriptor,
-    RecursiveOperationResponse,
-    RecursiveOperation,
-    RouteMessageWrapper,
-    RouteMessageAck,
-    RecursiveOperationRequest,
-    Message
-} from '../../../generated/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 { ServiceID } from '../../types/ServiceID'
-import { RecursiveOperationSessionRpcLocal } from './RecursiveOperationSessionRpcLocal'
-import { DhtAddress, toDhtAddress, toNodeId, toDhtAddressRaw } from '../../identifiers'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-
-export interface RecursiveOperationSessionEvents {
-    completed: () => void
-}
-
-export const RECURSIVE_OPERATION_TIMEOUT = 10 * 1000
-
-export interface RecursiveOperationSessionOptions {
-    transport: ITransport
-    targetId: DhtAddress
-    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<DhtAddress, DataEntry> = new Map()
-    private allKnownHops: Set<DhtAddress> = new Set()
-    private reportedHops: Set<DhtAddress> = new Set()
-    private timeoutTask?: NodeJS.Timeout 
-    private completionEventEmitted = false
-    private noCloserNodesReceivedCounter = 0
-    private readonly noCloserNodesReceivedFrom: Set<DhtAddress> = new Set()
-    private readonly options: RecursiveOperationSessionOptions
-
-    constructor(options: RecursiveOperationSessionOptions) {
-        super()
-        this.options = options
-        this.results = new SortedContactList({
-            referenceId: options.targetId, 
-            maxSize: 10,  // TODO use options option or named constant?
-            allowToContainReferenceId: true
-        })
-        this.rpcCommunicator = new ListeningRpcCommunicator(this.id, options.transport, {
-            rpcRequestTimeout: RECURSIVE_OPERATION_TIMEOUT
-        })
-        this.registerLocalRpcMethods()
-    }
-
-    private registerLocalRpcMethods() {
-        const rpcLocal = new RecursiveOperationSessionRpcLocal({
-            onResponseReceived: (
-                remoteNodeId: DhtAddress,
-                routingPath: PeerDescriptor[],
-                closestConnectedNodes: PeerDescriptor[],
-                dataEntries: DataEntry[],
-                noCloserNodesFound: boolean
-            ) => {
-                this.onResponseReceived(remoteNodeId, routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
-            }
-        })
-        this.rpcCommunicator.registerRpcNotification(RecursiveOperationResponse, 'sendResponse',
-            (req: RecursiveOperationResponse, context: ServerCallContext) => rpcLocal.sendResponse(req, context))
-    }
-
-    public start(serviceId: ServiceID): void {
-        const routeMessage = this.wrapRequest(serviceId)
-        this.options.doRouteRequest(routeMessage)
-    }
-
-    private wrapRequest(serviceId: ServiceID): RouteMessageWrapper {
-        const request: RecursiveOperationRequest = {
-            sessionId: this.getId(),
-            operation: this.options.operation
-        }
-        const msg: Message = {
-            messageId: v4(),
-            serviceId,
-            body: {
-                oneofKind: 'recursiveOperationRequest',
-                recursiveOperationRequest: request
-            }
-        }
-        const routeMessage: RouteMessageWrapper = {
-            message: msg,
-            requestId: v4(),
-            target: toDhtAddressRaw(this.options.targetId),
-            sourcePeer: this.options.localPeerDescriptor,
-            reachableThrough: [],
-            routingPath: [],
-            parallelRootNodeIds: []
-        }
-        return routeMessage
-    }
-
-    private isCompleted(): boolean {
-        const unreportedHops: Set<DhtAddress> = new Set(this.allKnownHops)
-        this.reportedHops.forEach((id) => {
-            unreportedHops.delete(id)
-        })
-        if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
-            if (this.options.operation === RecursiveOperation.FETCH_DATA
-                && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.options.waitedRoutingPathCompletions)) {
-                return true
-            } else if (this.options.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(
-        remoteNodeId: DhtAddress,
-        routingPath: PeerDescriptor[],
-        closestConnectedNodes: PeerDescriptor[],
-        dataEntries: DataEntry[],
-        noCloserNodesFound: boolean
-    ): void {
-        this.addKnownHops(routingPath)
-        if (routingPath.length >= 1) {
-            this.setHopAsReported(routingPath[routingPath.length - 1])
-        }
-        closestConnectedNodes.forEach((descriptor: PeerDescriptor) => {
-            this.results.addContact(new Contact(descriptor))
-        })
-        this.processFoundData(dataEntries)
-        if (noCloserNodesFound || this.noCloserNodesReceivedFrom.has(remoteNodeId)) {
-            this.onNoCloserPeersFound(remoteNodeId)
-        }
-    }
-
-    private addKnownHops(routingPath: PeerDescriptor[]) {
-        const localNodeId = toNodeId(this.options.localPeerDescriptor)
-        routingPath.forEach((desc) => {
-            const newNodeId = toNodeId(desc)
-            if (localNodeId !== newNodeId) {
-                this.allKnownHops.add(newNodeId)
-            }
-        })
-    }
-
-    private setHopAsReported(desc: PeerDescriptor) {
-        const localNodeId = toNodeId(this.options.localPeerDescriptor)
-        const newNodeId = toNodeId(desc)
-        if (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 = toDhtAddress(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(remoteNodeId: DhtAddress): void {
-        this.noCloserNodesReceivedCounter += 1
-        this.noCloserNodesReceivedFrom.add(remoteNodeId)
-        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 options option or named constant?
-        }
-    }
-
-    public getResults(): RecursiveOperationResult {
-        return {
-            closestNodes: this.results.getClosestContacts().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

@@ -1,35 +0,0 @@
-import { IRecursiveOperationSessionRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
-import { Empty } from '../../../generated/google/protobuf/empty'
-import { DataEntry, RecursiveOperationResponse, PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { Logger } from '@streamr/utils'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-import { DhtAddress, toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-interface RecursiveOperationSessionRpcLocalOptions {
-    onResponseReceived: (
-        remoteNodeId: DhtAddress,
-        routingPath: PeerDescriptor[],
-        nodes: PeerDescriptor[],
-        dataEntries: DataEntry[],
-        noCloserNodesFound: boolean
-    ) => void
-}
-
-export class RecursiveOperationSessionRpcLocal implements IRecursiveOperationSessionRpc {
-
-    private readonly options: RecursiveOperationSessionRpcLocalOptions
-
-    constructor(options: RecursiveOperationSessionRpcLocalOptions) {
-        this.options = options
-    }
-    
-    async sendResponse(report: RecursiveOperationResponse, context: ServerCallContext): Promise<Empty> {
-        const remoteNodeId = toNodeId((context as DhtCallContext).incomingSourceDescriptor!)
-        logger.trace('RecursiveOperationResponse arrived: ' + JSON.stringify(report))
-        this.options.onResponseReceived(remoteNodeId, report.routingPath, report.closestConnectedNodes, report.dataEntries, report.noCloserNodesFound)
-        return {}
-    }
-}

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

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

package/src/dht/routing/DuplicateDetector.ts

@@ -1,34 +0,0 @@
-export class DuplicateDetector {
-
-    private values: Set<string> = new Set()
-    private queue: Array<string> = []
-    private maxItemCount: number
-
-    constructor(
-        maxItemCount: number,
-    ) {
-        this.maxItemCount = maxItemCount
-    }
-
-    public add(value: string): void {
-        this.values.add(value)
-        this.queue.push(value)
-        if (this.queue.length > this.maxItemCount) {
-            const removed = this.queue.shift()!
-            this.values.delete(removed)
-        }
-    }
-
-    public isMostLikelyDuplicate(value: string): boolean {
-        return this.values.has(value)
-    }
-
-    public size(): number {
-        return this.values.size
-    }
-
-    public clear(): void {
-        this.values.clear()
-        this.queue = []
-    }
-}

package/src/dht/routing/Router.ts

@@ -1,246 +0,0 @@
-import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-import { RoutingMode, RoutingRemoteContact, RoutingSession, RoutingSessionEvents } from './RoutingSession'
-import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
-import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { DuplicateDetector } from './DuplicateDetector'
-import { v4 } from 'uuid'
-import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
-import { DhtAddress, areEqualPeerDescriptors, toDhtAddress, toNodeId } from '../../identifiers'
-import { RoutingTablesCache } from './RoutingTablesCache'
-
-export interface RouterOptions {
-    rpcCommunicator: RoutingRpcCommunicator
-    localPeerDescriptor: PeerDescriptor
-    handleMessage: (message: Message) => void
-    getConnections: () => PeerDescriptor[]
-}
-
-interface ForwardingTableEntry {
-    timeout: NodeJS.Timeout
-    peerDescriptors: PeerDescriptor[]
-}
-
-const logger = new Logger(module)
-
-export class Router {
-
-    private readonly forwardingTable: Map<DhtAddress, ForwardingTableEntry> = new Map()
-    private readonly routingTablesCache = new RoutingTablesCache()
-    private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
-    // TODO use options option or named constant?
-    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(10000)
-    private stopped = false
-    private readonly options: RouterOptions
-    private messagesRouted = 0
-    private messagesSent = 0
-
-    constructor(options: RouterOptions) {
-        this.options = options
-        this.registerLocalRpcMethods()
-    }
-
-    private registerLocalRpcMethods() {
-        const rpcLocal = new RouterRpcLocal({
-            doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => this.doRouteMessage(routedMessage, mode),
-            setForwardingEntries: (routedMessage: RouteMessageWrapper) => this.setForwardingEntries(routedMessage),
-            duplicateRequestDetector: this.duplicateRequestDetector,
-            localPeerDescriptor: this.options.localPeerDescriptor,
-            handleMessage: this.options.handleMessage
-        })
-        this.options.rpcCommunicator.registerRpcMethod(
-            RouteMessageWrapper,
-            RouteMessageAck,
-            'routeMessage',
-            async (routedMessage: RouteMessageWrapper) => {
-                if (this.stopped) {
-                    return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
-                }
-                return rpcLocal.routeMessage(routedMessage)
-            }
-        )
-        this.options.rpcCommunicator.registerRpcMethod(
-            RouteMessageWrapper,
-            RouteMessageAck,
-            'forwardMessage',
-            async (forwardMessage: RouteMessageWrapper) => {
-                if (this.stopped) {
-                    return createRouteMessageAck(forwardMessage, RouteMessageError.STOPPED)
-                }
-                return rpcLocal.forwardMessage(forwardMessage)
-            }
-        )
-
-    }
-
-    public send(msg: Message, reachableThrough: PeerDescriptor[]): void {
-        msg.sourceDescriptor = this.options.localPeerDescriptor
-        const targetPeerDescriptor = msg.targetDescriptor!
-        const forwardingEntry = this.forwardingTable.get(toNodeId(targetPeerDescriptor))
-        if (forwardingEntry && forwardingEntry.peerDescriptors.length > 0) {
-            const forwardedMessage: RouteMessageWrapper = {
-                message: msg,
-                requestId: v4(),
-                target: forwardingEntry.peerDescriptors[0].nodeId,
-                sourcePeer: this.options.localPeerDescriptor,
-                reachableThrough,
-                routingPath: [],
-                parallelRootNodeIds: []
-            }
-            const ack = this.doRouteMessage(forwardedMessage, RoutingMode.FORWARD)
-            if (ack.error !== undefined) {
-                const error = 'Could not forward message with error ' + ack.error
-                logger.debug(error)
-                throw new Error(error)
-            }
-        } else {
-            const routedMessage: RouteMessageWrapper = {
-                message: msg,
-                requestId: v4(),
-                target: targetPeerDescriptor.nodeId,
-                sourcePeer: this.options.localPeerDescriptor,
-                reachableThrough,
-                routingPath: [],
-                parallelRootNodeIds: []
-            }
-            const ack = this.doRouteMessage(routedMessage, RoutingMode.ROUTE)
-            if (ack.error !== undefined) {
-                const error = 'Could not route message with error ' + ack.error
-                logger.debug(error)
-                throw new Error(error)
-            }
-        }
-        this.messagesSent += 1
-    }
-
-    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: DhtAddress): RouteMessageAck {
-        if (this.stopped) {
-            return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
-        }
-        logger.trace(`Routing message ${routedMessage.requestId} from ${toNodeId(routedMessage.sourcePeer!)} `
-            + `to ${toDhtAddress(routedMessage.target)}`)
-        const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
-        const contacts = session.updateAndGetRoutablePeers()
-        if (contacts.length > 0) {
-            this.addRoutingSession(session)
-            logger.trace('starting to raceEvents from routingSession: ' + session.sessionId)
-            let eventReceived: Promise<unknown>
-            executeSafePromise(async () => {
-                eventReceived = raceEvents3<RoutingSessionEvents>(
-                    session,
-                    ['routingSucceeded', 'partialSuccess', 'routingFailed', 'stopped'],
-                    null
-                )
-            })
-            setImmediate(async () => {
-                try {
-                    // TODO use options option or named constant?
-                    await withTimeout(eventReceived, 10000)
-                    logger.trace('raceEvents ended from routingSession: ' + session.sessionId)
-                } catch {
-                    logger.trace('raceEvents timed out for routingSession ' + session.sessionId) 
-                }
-                session.stop()
-                this.removeRoutingSession(session.sessionId) 
-            })
-            session.sendMoreRequests(contacts)
-            this.messagesRouted += 1
-            return createRouteMessageAck(routedMessage)
-        } else {
-            logger.trace('no targets', { sessionId: session.sessionId })
-            return createRouteMessageAck(routedMessage, RouteMessageError.NO_TARGETS)
-        }
-    }
-
-    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedNode?: DhtAddress): RoutingSession {
-        const excludedNodeIds = new Set<DhtAddress>(routedMessage.routingPath.map((descriptor) => toNodeId(descriptor)))
-        if (excludedNode) {
-            excludedNodeIds.add(excludedNode)
-        }
-        routedMessage.parallelRootNodeIds.forEach((nodeId) => {
-            excludedNodeIds.add(nodeId as DhtAddress)
-        })
-        return new RoutingSession({
-            rpcCommunicator: this.options.rpcCommunicator,
-            localPeerDescriptor: this.options.localPeerDescriptor,
-            routedMessage,
-            // TODO use options option or named constant?
-            parallelism: areEqualPeerDescriptors(this.options.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
-            mode,
-            excludedNodeIds,
-            routingTablesCache: this.routingTablesCache,
-            getConnections: this.options.getConnections
-        })
-    }
-
-    public isMostLikelyDuplicate(requestId: string): boolean {
-        return this.duplicateRequestDetector.isMostLikelyDuplicate(requestId)
-    }
-
-    public addToDuplicateDetector(requestId: string): void {
-        this.duplicateRequestDetector.add(requestId)
-    }
-
-    public addRoutingSession(session: RoutingSession): void {
-        this.ongoingRoutingSessions.set(session.sessionId, session)
-    }
-
-    public removeRoutingSession(sessionId: string): void {
-        this.ongoingRoutingSessions.delete(sessionId)
-    }
-
-    onNodeConnected(peerDescriptor: PeerDescriptor): void {
-        const remote = new RoutingRemoteContact(peerDescriptor, this.options.localPeerDescriptor, this.options.rpcCommunicator)
-        this.routingTablesCache.onNodeConnected(remote)
-    }
-
-    onNodeDisconnected(peerDescriptor: PeerDescriptor): void {
-        this.routingTablesCache.onNodeDisconnected(toNodeId(peerDescriptor))
-    }
-
-    public resetCache(): void {
-        this.routingTablesCache.reset()
-    }
-
-    public stop(): void {
-        this.stopped = true
-        this.ongoingRoutingSessions.forEach((session, _id) => {
-            session.stop()
-        })
-        this.ongoingRoutingSessions.clear()
-        this.forwardingTable.forEach((entry) => {
-            clearTimeout(entry.timeout)
-        })
-        this.forwardingTable.clear()
-        this.duplicateRequestDetector.clear()
-        this.routingTablesCache.reset()
-    }
-
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {
-            messagesRouted: this.messagesRouted,
-            messagesSent: this.messagesSent
-        }
-    }
-
-    private setForwardingEntries(routedMessage: RouteMessageWrapper): void {
-        const reachableThroughWithoutSelf = routedMessage.reachableThrough.filter((peer) => {
-            return !areEqualPeerDescriptors(peer, this.options.localPeerDescriptor)
-        })
-        
-        if (reachableThroughWithoutSelf.length > 0) {
-            const sourceNodeId = toNodeId(routedMessage.sourcePeer!)
-            if (this.forwardingTable.has(sourceNodeId)) {
-                const oldEntry = this.forwardingTable.get(sourceNodeId)
-                clearTimeout(oldEntry!.timeout)
-                this.forwardingTable.delete(sourceNodeId)
-            }
-            const forwardingEntry: ForwardingTableEntry = {
-                peerDescriptors: reachableThroughWithoutSelf,
-                timeout: setTimeout(() => {
-                    this.forwardingTable.delete(sourceNodeId)
-                }, 10000)  // TODO use options option or named constant?
-            }
-            this.forwardingTable.set(sourceNodeId, forwardingEntry)
-        }
-    }
-}