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

package/src/dht/routing/RouterRpcLocal.ts

@@ -1,78 +0,0 @@
-import { Logger, areEqualBinaries } from '@streamr/utils'
-import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-import { IRouterRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
-import { DuplicateDetector } from './DuplicateDetector'
-import { RoutingMode } from './RoutingSession'
-import { areEqualPeerDescriptors, toDhtAddress, toNodeId } from '../../identifiers'
-import { v4 } from 'uuid'
-
-interface RouterRpcLocalOptions {
-    doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
-    setForwardingEntries: (routedMessage: RouteMessageWrapper) => void
-    handleMessage: (message: Message) => void
-    duplicateRequestDetector: DuplicateDetector
-    localPeerDescriptor: PeerDescriptor
-}
-
-const logger = new Logger(module)
-
-export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?: RouteMessageError): RouteMessageAck => {
-    const ack: RouteMessageAck = {
-        requestId: routedMessage.requestId,
-        error
-    }
-    return ack
-}
-
-export class RouterRpcLocal implements IRouterRpc {
-
-    private readonly options: RouterRpcLocalOptions
-
-    constructor(options: RouterRpcLocalOptions) {
-        this.options = options
-    }
-
-    async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.options.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
-            logger.trace(`Routing message ${routedMessage.requestId} from ${toNodeId(routedMessage.sourcePeer!)} `
-                + `to ${toDhtAddress(routedMessage.target)} is likely a duplicate`)
-            return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
-        }
-        logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
-        this.options.duplicateRequestDetector.add(routedMessage.requestId)
-        if (areEqualBinaries(this.options.localPeerDescriptor.nodeId, routedMessage.target)) {
-            logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
-            this.options.setForwardingEntries(routedMessage)
-            this.options.handleMessage(routedMessage.message!)
-            return createRouteMessageAck(routedMessage)
-        } else {
-            return this.options.doRouteMessage(routedMessage)
-        }
-    }
-
-    async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.options.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
-            logger.trace(`Forwarding message ${forwardMessage.requestId} from ${toNodeId(forwardMessage.sourcePeer!)} `
-                + `to ${toDhtAddress(forwardMessage.target)} is likely a duplicate`)
-            return createRouteMessageAck(forwardMessage, RouteMessageError.DUPLICATE)
-        }
-        logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
-        this.options.duplicateRequestDetector.add(forwardMessage.requestId)
-        if (areEqualBinaries(this.options.localPeerDescriptor.nodeId, forwardMessage.target)) {
-            return this.forwardToDestination(forwardMessage)
-        } else {
-            return this.options.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
-        }
-    }
-
-    private forwardToDestination(routedMessage: RouteMessageWrapper): RouteMessageAck {
-        logger.trace(`Forwarding found message targeted to self ${routedMessage.requestId}`)
-        const forwardedMessage = routedMessage.message!
-        if (areEqualPeerDescriptors(this.options.localPeerDescriptor, forwardedMessage.targetDescriptor!)) {
-            this.options.handleMessage(forwardedMessage)
-            return createRouteMessageAck(routedMessage)
-        }
-        return this.options.doRouteMessage({ ...routedMessage, requestId: v4(), target: forwardedMessage.targetDescriptor!.nodeId })
-    }
-
-}

package/src/dht/routing/RouterRpcRemote.ts

@@ -1,80 +0,0 @@
-import { Logger, areEqualBinaries } from '@streamr/utils'
-import { v4 } from 'uuid'
-import { RouteMessageError, RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-import { RouterRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-import { RpcRemote } from '../contact/RpcRemote'
-import { getPreviousPeer } from './getPreviousPeer'
-import { toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-// default timeout
-export const ROUTING_TIMEOUT = 2000
-
-export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
-
-    async routeMessage(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().routeMessage(message, options)
-            // Success signal if sent to destination and error includes duplicate
-            if (ack.error === RouteMessageError.DUPLICATE
-                && areEqualBinaries(params.target, this.getPeerDescriptor().nodeId)
-            ) {
-                return true
-            } else if (ack.error !== undefined) {
-                return false
-            }
-        } catch (err) {
-            const previousPeer = getPreviousPeer(params)
-            const fromNode = previousPeer
-                ? toNodeId(previousPeer)
-                : toNodeId(params.sourcePeer!)
-            const toNode = toNodeId(this.getPeerDescriptor())
-            logger.trace(`Failed to send routeMessage from ${fromNode} to ${toNode}`, { err })
-            return false
-        }
-        return true
-    }
-
-    async forwardMessage(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().forwardMessage(message, options)
-            if (ack.error !== undefined) {
-                return false
-            }
-        } catch (err) {
-            const previousPeer = getPreviousPeer(params)
-            const fromNode = previousPeer
-                ? toNodeId(previousPeer)
-                : toNodeId(params.sourcePeer!)
-            const toNode = toNodeId(this.getPeerDescriptor())
-            logger.trace(`Failed to send forwardMessage from ${fromNode} to ${toNode}`, { err })
-            return false
-        }
-        return true
-    }
-}

package/src/dht/routing/RoutingSession.ts

@@ -1,243 +0,0 @@
-import { SortedContactList } from '../contact/SortedContactList'
-import { Logger } from '@streamr/utils'
-import EventEmitter from 'eventemitter3'
-import { v4 } from 'uuid'
-import { PeerDescriptor, RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-import { RouterRpcRemote, ROUTING_TIMEOUT } from './RouterRpcRemote'
-import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RecursiveOperationRpcClient, RouterRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-import { Contact } from '../contact/Contact'
-import { RecursiveOperationRpcRemote } from '../recursive-operation/RecursiveOperationRpcRemote'
-import { getPreviousPeer } from './getPreviousPeer'
-import { DhtAddress, areEqualPeerDescriptors, toDhtAddress, toNodeId } from '../../identifiers'
-import { pull } from 'lodash'
-import { RoutingTable, RoutingTablesCache } from './RoutingTablesCache'
-
-const logger = new Logger(module)
-
-const MAX_FAILED_HOPS = 2
-const ROUTING_TABLE_MAX_SIZE = 20
-
-export class RoutingRemoteContact extends Contact {
-
-    private routerRpcRemote: RouterRpcRemote
-    private recursiveOperationRpcRemote: RecursiveOperationRpcRemote
-
-    constructor(peer: PeerDescriptor, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
-        super(peer)
-        this.routerRpcRemote = new RouterRpcRemote(
-            localPeerDescriptor,
-            peer,
-            rpcCommunicator,
-            RouterRpcClient,
-            ROUTING_TIMEOUT
-        )
-        this.recursiveOperationRpcRemote = new RecursiveOperationRpcRemote(
-            localPeerDescriptor,
-            peer,
-            rpcCommunicator,
-            RecursiveOperationRpcClient,
-            ROUTING_TIMEOUT
-        )
-    }
-
-    getRouterRpcRemote(): RouterRpcRemote {
-        return this.routerRpcRemote
-    }
-
-    getRecursiveOperationRpcRemote(): RecursiveOperationRpcRemote {
-        return this.recursiveOperationRpcRemote
-    }
-}
-
-export interface RoutingSessionEvents {
-    // This event is emitted when a peer responds with a success ack
-    // to routeMessage call
-    routingSucceeded: () => void
-    partialSuccess: () => void
-    // This event is emitted when all the candidates have been gone
-    // through, and none of them responds with a success ack
-    routingFailed: () => void
-    stopped: () => void
-}
-
-export enum RoutingMode { ROUTE, FORWARD, RECURSIVE }
-
-interface RoutingSessionOptions {
-    rpcCommunicator: RoutingRpcCommunicator
-    localPeerDescriptor: PeerDescriptor
-    routedMessage: RouteMessageWrapper
-    parallelism: number
-    mode: RoutingMode
-    excludedNodeIds: Set<DhtAddress>
-    routingTablesCache: RoutingTablesCache
-    getConnections: () => PeerDescriptor[]
-}
-
-export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
-
-    public readonly sessionId = v4()
-    private ongoingRequests: Set<DhtAddress> = new Set()
-    private contactedPeers: Set<DhtAddress> = new Set()
-    private failedHopCounter = 0
-    private successfulHopCounter = 0
-    private stopped = false
-    private readonly options: RoutingSessionOptions
-
-    constructor(options: RoutingSessionOptions) {
-        super()
-        this.options = options
-    }
-
-    private onRequestFailed(nodeId: DhtAddress) {
-        logger.trace('onRequestFailed() sessionId: ' + this.sessionId)
-        if (this.stopped) {
-            return
-        }
-        if (this.ongoingRequests.has(nodeId)) {
-            this.ongoingRequests.delete(nodeId)
-        }
-        this.deleteParallelRootIfSource(nodeId)
-        this.failedHopCounter += 1
-        if (this.failedHopCounter >= MAX_FAILED_HOPS) {
-            logger.trace(`Stopping routing after ${MAX_FAILED_HOPS} failed attempts for sessionId: ${this.sessionId}`)
-            this.emitFailure()
-            return
-        }
-        const contacts = this.updateAndGetRoutablePeers()
-        if (contacts.length === 0 && this.ongoingRequests.size === 0) {
-            logger.trace('routing failed, emitting routingFailed sessionId: ' + this.sessionId)
-            this.emitFailure()
-        } else {
-            logger.trace('routing failed, retrying to route sessionId: ' + this.sessionId + ' failedHopCounter: ' + this.failedHopCounter)
-            this.sendMoreRequests(contacts)
-        }
-    }
-
-    private emitFailure() {
-        if (this.successfulHopCounter >= 1) {
-            this.emit('partialSuccess')
-        } else {
-            this.emit('routingFailed')
-        }
-    }
-
-    private onRequestSucceeded() {
-        logger.trace('onRequestSucceeded() sessionId: ' + this.sessionId)
-        if (this.stopped) {
-            return
-        }
-        this.successfulHopCounter += 1
-        if (this.successfulHopCounter >= this.options.parallelism) {
-            this.emit('routingSucceeded')
-            return
-        }
-        const contacts = this.updateAndGetRoutablePeers()
-        if (contacts.length === 0) {
-            this.emit('routingSucceeded')
-        } else if (contacts.length > 0 && this.ongoingRequests.size === 0) {
-            this.sendMoreRequests(contacts)
-        }
-    }
-
-    private async sendRouteMessageRequest(contact: RoutingRemoteContact): Promise<boolean> {
-        if (this.stopped) {
-            return false
-        }
-        const msg = {
-            ...this.options.routedMessage,
-            routingPath: this.options.routedMessage.routingPath.concat([this.options.localPeerDescriptor])
-        }
-        if (this.options.mode === RoutingMode.FORWARD) {
-            return contact.getRouterRpcRemote().forwardMessage(msg)
-        } else if (this.options.mode === RoutingMode.RECURSIVE) {
-            return contact.getRecursiveOperationRpcRemote().routeRequest(msg)
-        } else {
-            return contact.getRouterRpcRemote().routeMessage(msg)
-        }
-    }
-
-    updateAndGetRoutablePeers(): RoutingRemoteContact[] {
-        logger.trace('getRoutablePeers() sessionId: ' + this.sessionId)
-        const previousPeer = getPreviousPeer(this.options.routedMessage)
-        const previousId = previousPeer ? toNodeId(previousPeer) : undefined
-        const targetId = toDhtAddress(this.options.routedMessage.target)
-        let routingTable: RoutingTable
-        if (this.options.routingTablesCache.has(targetId, previousId)) {
-            routingTable = this.options.routingTablesCache.get(targetId, previousId)!
-        } else {
-            routingTable = new SortedContactList<RoutingRemoteContact>({
-                referenceId: toDhtAddress(this.options.routedMessage.target),
-                maxSize: ROUTING_TABLE_MAX_SIZE,
-                allowToContainReferenceId: true,
-                nodeIdDistanceLimit: previousId
-            })
-            const contacts = this.options.getConnections()
-                .map((peer) => new RoutingRemoteContact(
-                    peer,
-                    this.options.localPeerDescriptor,
-                    this.options.rpcCommunicator
-                ))
-            routingTable.addContacts(contacts)
-            this.options.routingTablesCache.set(targetId, routingTable, previousId)
-        }
-        return routingTable.getClosestContacts()
-            .filter((contact) => !this.contactedPeers.has(contact.getNodeId()) && !this.options.excludedNodeIds.has(contact.getNodeId()))
-    }
-
-    sendMoreRequests(uncontacted: RoutingRemoteContact[]): void {
-        logger.trace('sendMoreRequests() sessionId: ' + this.sessionId)
-        if (this.stopped) {
-            return
-        }
-        if (uncontacted.length === 0) {
-            this.emitFailure()
-            return
-        }
-        while ((this.ongoingRequests.size < this.options.parallelism) && (uncontacted.length > 0) && !this.stopped) {
-            const nextPeer = uncontacted.shift()
-            logger.trace(`Sending routeMessage request to contact: ${toNodeId(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
-            this.contactedPeers.add(nextPeer!.getNodeId())
-            this.ongoingRequests.add(nextPeer!.getNodeId())
-            this.addParallelRootIfSource(nextPeer!.getNodeId())
-            setImmediate(async () => {
-                try {
-                    const succeeded = await this.sendRouteMessageRequest(nextPeer!)
-                    if (succeeded) {
-                        this.onRequestSucceeded()
-                    } else {
-                        this.onRequestFailed(nextPeer!.getNodeId())
-                    }
-                } catch (err) {
-                    logger.debug('Unable to route message ', { err })
-                } finally {
-                    logger.trace('sendRouteMessageRequest returned')
-                }
-            })
-        }
-    }
-
-    private addParallelRootIfSource(nodeId: DhtAddress) {
-        if (
-            this.options.mode === RoutingMode.RECURSIVE
-            && areEqualPeerDescriptors(this.options.localPeerDescriptor, this.options.routedMessage.sourcePeer!)
-        ) {
-            this.options.routedMessage.parallelRootNodeIds.push(nodeId)
-        }
-    }
-
-    private deleteParallelRootIfSource(nodeId: DhtAddress) {
-        if (
-            this.options.mode === RoutingMode.RECURSIVE
-            && areEqualPeerDescriptors(this.options.localPeerDescriptor, this.options.routedMessage.sourcePeer!)
-        ) {
-            pull(this.options.routedMessage.parallelRootNodeIds, nodeId)
-        }
-    }
-
-    public stop(): void {
-        this.stopped = true
-        this.emit('stopped')
-        this.removeAllListeners()
-    }
-}

package/src/dht/routing/RoutingTablesCache.ts

@@ -1,60 +0,0 @@
-import { DhtAddress } from '../../identifiers'
-import { SortedContactList } from '../contact/SortedContactList'
-import { RoutingRemoteContact } from './RoutingSession'
-import { LRUCache } from 'lru-cache'
-
-type RoutingTableID = string
-export type RoutingTable = Pick<
-    SortedContactList<RoutingRemoteContact>,
-    'getClosestContacts' | 'addContacts' | 'addContact' | 'removeContact' | 'stop'>
-
-const createRoutingTableId = (targetId: DhtAddress, previousId?: DhtAddress): RoutingTableID => {
-    return targetId + (previousId ? previousId : '')
-}
-
-const DEFAULT_LRU_OPTIONS = {
-    max: 1000,
-    maxAge: 15 * 1000
-}
-
-/**
- * RoutingTablesCache is a cache for routing tables. 
- * It is used to store the routing tables for a specific targetId and previousId.
- * Storing the previousId is important as it is used as a minimum distance for the contacts in the table.
- * Calculating a RoutingTable from scratch is an O(n log n) operation (n = number of connections of a node)
- * However,
- * - Adding a contact to a RoutingTable is an O(log n) operation.
- * - Deleting a contact from a RoutingTable is an O(1) operation.
- * Thus, holding the most frequently used routing tables in memory to be updated on 
- * connections and disconnections is hugely beneficial in terms of performance.
-*/
-
-export class RoutingTablesCache {
-
-    private readonly tables: LRUCache<RoutingTableID, RoutingTable> = new LRUCache(DEFAULT_LRU_OPTIONS)
-
-    get(targetId: DhtAddress, previousId?: DhtAddress): RoutingTable | undefined {
-        return this.tables.get(createRoutingTableId(targetId, previousId))
-    }
-
-    set(targetId: DhtAddress, table: RoutingTable, previousId?: DhtAddress): void {
-        this.tables.set(createRoutingTableId(targetId, previousId), table)
-    }
-
-    has(targetId: DhtAddress, previousId?: DhtAddress): boolean {
-        return this.tables.has(createRoutingTableId(targetId, previousId))
-    }
-
-    onNodeDisconnected(nodeId: DhtAddress): void {
-        this.tables.forEach((table) => table.removeContact(nodeId))
-    }
-
-    onNodeConnected(remote: RoutingRemoteContact): void {
-        this.tables.forEach((table) => table.addContact(remote))
-    }
-
-    reset(): void {
-        this.tables.forEach((table) => table.stop())
-        this.tables.clear()
-    }
-}

package/src/dht/routing/getPreviousPeer.ts

@@ -1,6 +0,0 @@
-import { last } from 'lodash'
-import { PeerDescriptor, RouteMessageWrapper } from '../../../generated/packages/dht/protos/DhtRpc'
-
-export const getPreviousPeer = (routeMessage: RouteMessageWrapper): PeerDescriptor | undefined => {
-    return last(routeMessage.routingPath)
-}

package/src/dht/store/LocalDataStore.ts

@@ -1,84 +0,0 @@
-import { DataEntry } from '../../../generated/packages/dht/protos/DhtRpc'
-import { DhtAddress, toDhtAddress } from '../../identifiers'
-import { MapWithTtl } from '@streamr/utils'
-
-export class LocalDataStore {
-
-    private readonly maxTtl: number
-
-    constructor(maxTtl: number) {
-        this.maxTtl = maxTtl
-    }
-
-    // A map into which each node can store one value per data key
-    // The first key is the key of the data, the second key is the
-    // DhtAddress of the creator of the data
-    private store: Map<DhtAddress, MapWithTtl<DhtAddress, DataEntry>> = new Map()
-
-    public storeEntry(dataEntry: DataEntry): boolean {
-        const key = toDhtAddress(dataEntry.key)
-        const creatorNodeId = toDhtAddress(dataEntry.creator)
-        if (!this.store.has(key)) {
-            this.store.set(key, new MapWithTtl((e) => Math.min(e.ttl, this.maxTtl)))
-        }
-        if (this.store.get(key)!.has(creatorNodeId)) {
-            const storedMillis = (dataEntry.createdAt!.seconds * 1000) + (dataEntry.createdAt!.nanos / 1000000)
-            const oldLocalEntry = this.store.get(key)!.get(creatorNodeId)!
-            const oldStoredMillis = (oldLocalEntry.createdAt!.seconds * 1000) + (oldLocalEntry.createdAt!.nanos / 1000000)
-            // do nothing if old entry is newer than the one being replicated
-            if (oldStoredMillis >= storedMillis) {
-                return false
-            }
-        }
-        this.store.get(key)!.set(creatorNodeId, dataEntry)
-        return true
-    }
-
-    public markAsDeleted(key: DhtAddress, creator: DhtAddress): boolean {
-        const item = this.store.get(key)
-        if ((item === undefined) || !item.has(creator)) {
-            return false
-        }
-        const storedEntry = item.get(creator)
-        storedEntry!.deleted = true
-        return true
-    }
-
-    public* values(key?: DhtAddress): IterableIterator<DataEntry> {
-        if (key !== undefined) {
-            const map = this.store.get(key)
-            if (map !== undefined) {
-                yield* map.values()
-            }
-        } else {
-            for (const v of this.store.values()) {
-                yield* v.values()
-            }
-        }
-    }
-
-    public keys(): IterableIterator<DhtAddress> {
-        return this.store.keys()
-    }
-
-    public setAllEntriesAsStale(key: DhtAddress): void {
-        this.store.get(key)?.forEach((value) => {
-            value.stale = true
-        })
-    }
-
-    public deleteEntry(key: DhtAddress, creator: DhtAddress): void {
-        const storedEntry = this.store.get(key)?.get(creator)
-        if (storedEntry) {
-            this.store.get(key)?.delete(creator)
-            if (this.store.get(key)?.size() === 0) {
-                this.store.delete(key)
-            }
-        }
-    }
-
-    public clear(): void {
-        this.store.forEach((value) => value.clear())
-        this.store.clear()
-    }
-}