@streamr/dht 100.0.0-testnet-three.5 → 100.0.0-testnet-three.6

package/src/dht/routing/RoutingSession.ts

@@ -13,29 +13,30 @@ import { EXISTING_CONNECTION_TIMEOUT } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { pull } from 'lodash'
+import { RoutingTable, RoutingTablesCache } from './RoutingTablesCache'
 
 const logger = new Logger(module)
 
 const MAX_FAILED_HOPS = 2
-const CONTACT_LIST_MAX_SIZE = 10
+const ROUTING_TABLE_MAX_SIZE = 20
 
-class RemoteContact extends Contact {
+export class RoutingRemoteContact extends Contact {
 
     private routerRpcRemote: RouterRpcRemote
     private recursiveOperationRpcRemote: RecursiveOperationRpcRemote
 
-    constructor(peer: DhtNodeRpcRemote, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
-        super(peer.getPeerDescriptor())
+    constructor(peer: PeerDescriptor, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
+        super(peer)
         this.routerRpcRemote = new RouterRpcRemote(
             localPeerDescriptor,
-            peer.getPeerDescriptor(),
+            peer,
             rpcCommunicator,
             RouterRpcClient,
             EXISTING_CONNECTION_TIMEOUT
         )
         this.recursiveOperationRpcRemote = new RecursiveOperationRpcRemote(
             localPeerDescriptor,
-            peer.getPeerDescriptor(),
+            peer,
             rpcCommunicator,
             RecursiveOperationRpcClient,
             EXISTING_CONNECTION_TIMEOUT
@@ -71,14 +72,15 @@ interface RoutingSessionConfig {
     connections: Map<DhtAddress, DhtNodeRpcRemote>
     parallelism: number
     mode: RoutingMode
-    excludedNodeIds?: Set<DhtAddress>
+    excludedNodeIds: Set<DhtAddress>
+    routingTablesCache: RoutingTablesCache
 }
 
 export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     public readonly sessionId = v4()
     private ongoingRequests: Set<DhtAddress> = new Set()
-    private contactList: SortedContactList<RemoteContact>
+    private contactedPeers: Set<DhtAddress> = new Set()
     private failedHopCounter = 0
     private successfulHopCounter = 0
     private stopped = false
@@ -87,16 +89,6 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     constructor(config: RoutingSessionConfig) {
         super()
         this.config = config
-        const previousPeer = getPreviousPeer(config.routedMessage)
-        const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
-        this.contactList = new SortedContactList({
-            referenceId: getDhtAddressFromRaw(config.routedMessage.target),
-            maxSize: CONTACT_LIST_MAX_SIZE,
-            allowToContainReferenceId: true,
-            nodeIdDistanceLimit: previousId,
-            excludedNodeIds: config.excludedNodeIds,
-            emitEvents: false
-        })
     }
 
     private onRequestFailed(nodeId: DhtAddress) {
@@ -108,14 +100,17 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             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)
-            // TODO should call this.stop() so that we do cleanup? (after the emitFailure call)
-            this.stopped = true
             this.emitFailure()
         } else {
-            this.failedHopCounter += 1
             logger.trace('routing failed, retrying to route sessionId: ' + this.sessionId + ' failedHopCounter: ' + this.failedHopCounter)
             this.sendMoreRequests(contacts)
         }
@@ -135,17 +130,19 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             return
         }
         this.successfulHopCounter += 1
+        if (this.successfulHopCounter >= this.config.parallelism) {
+            this.emit('routingSucceeded')
+            return
+        }
         const contacts = this.updateAndGetRoutablePeers()
-        if (this.successfulHopCounter >= this.config.parallelism || contacts.length === 0) {
-            // TODO should call this.stop() so that we do cleanup? (after the routingSucceeded call)
-            this.stopped = true
+        if (contacts.length === 0) {
             this.emit('routingSucceeded')
         } else if (contacts.length > 0 && this.ongoingRequests.size === 0) {
             this.sendMoreRequests(contacts)
         }
     }
 
-    private async sendRouteMessageRequest(contact: RemoteContact): Promise<boolean> {
+    private async sendRouteMessageRequest(contact: RoutingRemoteContact): Promise<boolean> {
         if (this.stopped) {
             return false
         }
@@ -162,21 +159,36 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    updateAndGetRoutablePeers(): RemoteContact[] {
+    updateAndGetRoutablePeers(): RoutingRemoteContact[] {
         logger.trace('getRoutablePeers() sessionId: ' + this.sessionId)
-        // Remove stale contacts that may have been removed from connections
-        this.contactList.getContactIds().forEach((nodeId) => {
-            if (!this.config.connections.has(nodeId)) {
-                this.contactList.removeContact(nodeId)
-            }
-        })
-        const contacts = Array.from(this.config.connections.values())
-            .map((peer) => new RemoteContact(peer, this.config.localPeerDescriptor, this.config.rpcCommunicator))
-        this.contactList.addContacts(contacts)
-        return this.contactList.getUncontactedContacts(this.config.parallelism)
+        const previousPeer = getPreviousPeer(this.config.routedMessage)
+        const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
+        const targetId = getDhtAddressFromRaw(this.config.routedMessage.target)
+        let routingTable: RoutingTable
+        if (this.config.routingTablesCache.has(targetId, previousId)) {
+            routingTable = this.config.routingTablesCache.get(targetId, previousId)!
+        } else {
+            routingTable = new SortedContactList<RoutingRemoteContact>({
+                referenceId: getDhtAddressFromRaw(this.config.routedMessage.target),
+                maxSize: ROUTING_TABLE_MAX_SIZE,
+                allowToContainReferenceId: true,
+                nodeIdDistanceLimit: previousId,
+                emitEvents: false
+            })
+            const contacts = Array.from(this.config.connections.values())
+                .map((peer) => new RoutingRemoteContact(
+                    peer.getPeerDescriptor(),
+                    this.config.localPeerDescriptor,
+                    this.config.rpcCommunicator
+                ))
+            routingTable.addContacts(contacts)
+            this.config.routingTablesCache.set(targetId, routingTable, previousId)
+        }
+        return routingTable.getAllContacts()
+            .filter((contact) => !this.contactedPeers.has(contact.getNodeId()) && !this.config.excludedNodeIds.has(contact.getNodeId()))
     }
 
-    sendMoreRequests(uncontacted: RemoteContact[]): void {
+    sendMoreRequests(uncontacted: RoutingRemoteContact[]): void {
         logger.trace('sendMoreRequests() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
@@ -185,16 +197,11 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             this.emitFailure()
             return
         }
-        if (this.failedHopCounter >= MAX_FAILED_HOPS) {
-            logger.trace(`Stopping routing after ${MAX_FAILED_HOPS} failed attempts for sessionId: ${this.sessionId}`)
-            this.emitFailure()
-            return
-        }
         while ((this.ongoingRequests.size < this.config.parallelism) && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
             logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
-            this.contactList.setContacted(nextPeer!.getNodeId())
+            this.contactedPeers.add(nextPeer!.getNodeId())
             this.ongoingRequests.add(nextPeer!.getNodeId())
             this.addParallelRootIfSource(nextPeer!.getNodeId())
             setImmediate(async () => {
@@ -234,7 +241,6 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     public stop(): void {
         this.stopped = true
-        this.contactList.stop()
         this.emit('stopped')
         this.removeAllListeners()
     }

package/src/dht/routing/RoutingTablesCache.ts

@@ -0,0 +1,58 @@
+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>, 'getAllContacts' | '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/test/unit/Router.test.ts

@@ -53,7 +53,8 @@ describe('Router', () => {
             localPeerDescriptor: peerDescriptor1,
             rpcCommunicator: rpcCommunicator as any,
             addContact: (_contact) => {},
-            connections
+            connections,
+            handleMessage: () => {}
         })
     })
 

package/test/unit/RoutingSession.test.ts

@@ -6,12 +6,14 @@ import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
+import { RoutingTablesCache } from '../../src/dht/routing/RoutingTablesCache'
 
 describe('RoutingSession', () => {
 
     let session: RoutingSession
     let connections: Map<DhtAddress, DhtNodeRpcRemote>
     let rpcCommunicator: RoutingRpcCommunicator
+    let routingTablesCache: RoutingTablesCache
     const mockPeerDescriptor1 = createMockPeerDescriptor()
     const mockPeerDescriptor2 = createMockPeerDescriptor()
     const rpcWrapper = createWrappedClosestPeersRequest(mockPeerDescriptor1)
@@ -43,13 +45,16 @@ describe('RoutingSession', () => {
     beforeEach(() => {
         rpcCommunicator = new MockRpcCommunicator()
         connections = new Map()
+        routingTablesCache = new RoutingTablesCache()
         session = new RoutingSession({
             rpcCommunicator: rpcCommunicator,
             localPeerDescriptor: mockPeerDescriptor1,
             routedMessage,
             connections, 
             parallelism: 2,
-            mode: RoutingMode.ROUTE
+            mode: RoutingMode.ROUTE,
+            excludedNodeIds: new Set(),
+            routingTablesCache
         })
     })
 
@@ -68,6 +73,7 @@ describe('RoutingSession', () => {
         connections.set(getNodeIdFromPeerDescriptor(mockPeerDescriptor2), createMockDhtNodeRpcRemote(mockPeerDescriptor2))
         expect(session.updateAndGetRoutablePeers().length).toBe(1)
         connections.delete(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
+        routingTablesCache.onNodeDisconnected(getNodeIdFromPeerDescriptor(mockPeerDescriptor2))
         expect(session.updateAndGetRoutablePeers().length).toBe(0)
     })
 

package/test/utils/mock/Router.ts

@@ -49,4 +49,13 @@ export class MockRouter implements Methods<Router> {
         return RouteMessageAck.create()
     }
 
+    // eslint-disable-next-line class-methods-use-this
+    onNodeConnected(): void {}
+
+    // eslint-disable-next-line class-methods-use-this
+    onNodeDisconnected(): void {}
+
+    // eslint-disable-next-line class-methods-use-this
+    resetCache(): void {}
+
 }