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

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/src/dht/store/StoreManager.ts

@@ -98,7 +98,7 @@ export class StoreManager {
 
     public async storeDataToDht(key: DhtAddress, data: Any, creator: DhtAddress): Promise<PeerDescriptor[]> {
         logger.debug(`Storing data to DHT ${this.config.serviceId}`)
-        const result = await this.config.recursiveOperationManager.execute(key, RecursiveOperation.FIND_NODE)
+        const result = await this.config.recursiveOperationManager.execute(key, RecursiveOperation.FIND_CLOSEST_NODES)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
         const ttl = this.config.highestTtl // ToDo: make TTL decrease according to some nice curve

package/src/exports.ts

@@ -17,6 +17,7 @@ export { ClientWebsocket } from './connection/websocket/ClientWebsocket'
 export { ManagedConnection } from './connection/ManagedConnection'
 export { ConnectionType } from './connection/IConnection'
 export { ServiceID } from './types/ServiceID'
+export { RingContacts } from './dht/contact/RingContactList'
 export { 
     DhtAddress,
     DhtAddressRaw,

package/src/helpers/createPeerDescriptor.ts

@@ -29,7 +29,7 @@ const calculateNodeIdRaw = (ipAddress: number, privateKey: Uint8Array): DhtAddre
     return nodeIdRaw
 }
 
-export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse, nodeId?: DhtAddress): PeerDescriptor => {
+export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse, region: number, nodeId?: DhtAddress): PeerDescriptor => {
     const privateKey = crypto.randomBytes(32)
     const publicKey = crypto.randomBytes(20)  // TODO calculate publicKey from privateKey
     let nodeIdRaw: DhtAddressRaw
@@ -42,6 +42,7 @@ export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse,
         nodeId: nodeIdRaw,
         type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
         ipAddress: connectivityResponse.ipAddress,
+        region,
         publicKey 
     }
     if (connectivityResponse.websocket) {

package/src/helpers/version.ts

@@ -0,0 +1,32 @@
+export const LOCAL_PROTOCOL_VERSION = '1.0'
+
+/*
+ * When two nodes negotiate whether they are compatible or not, it is up to the
+ * newer version to decide if it supports the old version or not.
+ * 
+ * The older version assumes optimistically that it may be supported by the newer
+ * version. It can't know for sure, but the other node will tell if it is not
+ * supported (e.g. rejecting the handshake with UNSUPPORTED_VERSION error).
+ */
+export const isMaybeSupportedVersion = (remoteVersion: string): boolean => {
+    const localMajor = parseVersion(LOCAL_PROTOCOL_VERSION)!.major
+    const remoteMajor = parseVersion(remoteVersion)?.major
+    if ((remoteMajor === undefined) || (remoteMajor < localMajor)) {
+        return false
+    } else {
+        // TODO implement proper checking when there are new protocol versions
+        return true
+    }
+}
+
+export const parseVersion = (version: string): { major: number, minor: number } | undefined => {
+    const parts = version.split('.')
+    if (parts.length === 2) {
+        const values = parts.map((p) => Number(p))
+        if (!values.some((v) => isNaN(v))) {
+            return { major: values[0], minor: values[1] }
+        }
+    } else {
+        return undefined
+    }
+}

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -4,8 +4,8 @@
 import { ExternalApiRpc } from "./DhtRpc";
 import type { ExternalStoreDataResponse } from "./DhtRpc";
 import type { ExternalStoreDataRequest } from "./DhtRpc";
-import type { ExternalFindDataResponse } from "./DhtRpc";
-import type { ExternalFindDataRequest } from "./DhtRpc";
+import type { ExternalFetchDataResponse } from "./DhtRpc";
+import type { ExternalFetchDataRequest } from "./DhtRpc";
 import { ConnectionLockRpc } from "./DhtRpc";
 import type { DisconnectNotice } from "./DhtRpc";
 import type { UnlockRequest } from "./DhtRpc";
@@ -35,6 +35,8 @@ import type { Empty } from "../../../google/protobuf/empty";
 import type { LeaveNotice } from "./DhtRpc";
 import type { PingResponse } from "./DhtRpc";
 import type { PingRequest } from "./DhtRpc";
+import type { ClosestRingPeersResponse } from "./DhtRpc";
+import type { ClosestRingPeersRequest } from "./DhtRpc";
 import { stackIntercept } from "@protobuf-ts/runtime-rpc";
 import type { ClosestPeersResponse } from "./DhtRpc";
 import type { ClosestPeersRequest } from "./DhtRpc";
@@ -48,6 +50,10 @@ export interface IDhtNodeRpcClient {
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(input: ClosestPeersRequest, options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse>;
+    /**
+     * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
+     */
+    getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse>;
     /**
      * @generated from protobuf rpc: ping(dht.PingRequest) returns (dht.PingResponse);
      */
@@ -73,18 +79,25 @@ export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
         return stackIntercept<ClosestPeersRequest, ClosestPeersResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
+     */
+    getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ClosestRingPeersRequest, ClosestRingPeersResponse>("unary", this._transport, method, opt, input);
+    }
     /**
      * @generated from protobuf rpc: ping(dht.PingRequest) returns (dht.PingResponse);
      */
     ping(input: PingRequest, options?: RpcOptions): UnaryCall<PingRequest, PingResponse> {
-        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
         return stackIntercept<PingRequest, PingResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: leaveNotice(dht.LeaveNotice) returns (google.protobuf.Empty);
      */
     leaveNotice(input: LeaveNotice, options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
-        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
         return stackIntercept<LeaveNotice, Empty>("unary", this._transport, method, opt, input);
     }
 }
@@ -352,9 +365,9 @@ export class ConnectionLockRpcClient implements IConnectionLockRpcClient, Servic
  */
 export interface IExternalApiRpcClient {
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse>;
+    externalFetchData(input: ExternalFetchDataRequest, options?: RpcOptions): UnaryCall<ExternalFetchDataRequest, ExternalFetchDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */
@@ -370,11 +383,11 @@ export class ExternalApiRpcClient implements IExternalApiRpcClient, ServiceInfo
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse> {
+    externalFetchData(input: ExternalFetchDataRequest, options?: RpcOptions): UnaryCall<ExternalFetchDataRequest, ExternalFetchDataResponse> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<ExternalFindDataRequest, ExternalFindDataResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<ExternalFetchDataRequest, ExternalFetchDataResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);

package/src/proto/packages/dht/protos/DhtRpc.server.ts

@@ -3,8 +3,8 @@
 // tslint:disable
 import { ExternalStoreDataResponse } from "./DhtRpc";
 import { ExternalStoreDataRequest } from "./DhtRpc";
-import { ExternalFindDataResponse } from "./DhtRpc";
-import { ExternalFindDataRequest } from "./DhtRpc";
+import { ExternalFetchDataResponse } from "./DhtRpc";
+import { ExternalFetchDataRequest } from "./DhtRpc";
 import { DisconnectNotice } from "./DhtRpc";
 import { UnlockRequest } from "./DhtRpc";
 import { LockResponse } from "./DhtRpc";
@@ -24,6 +24,8 @@ import { Empty } from "../../../google/protobuf/empty";
 import { LeaveNotice } from "./DhtRpc";
 import { PingResponse } from "./DhtRpc";
 import { PingRequest } from "./DhtRpc";
+import { ClosestRingPeersResponse } from "./DhtRpc";
+import { ClosestRingPeersRequest } from "./DhtRpc";
 import { ClosestPeersResponse } from "./DhtRpc";
 import { ClosestPeersRequest } from "./DhtRpc";
 import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
@@ -35,6 +37,10 @@ export interface IDhtNodeRpc<T = ServerCallContext> {
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(request: ClosestPeersRequest, context: T): Promise<ClosestPeersResponse>;
+    /**
+     * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
+     */
+    getClosestRingPeers(request: ClosestRingPeersRequest, context: T): Promise<ClosestRingPeersResponse>;
     /**
      * @generated from protobuf rpc: ping(dht.PingRequest) returns (dht.PingResponse);
      */
@@ -140,9 +146,9 @@ export interface IConnectionLockRpc<T = ServerCallContext> {
  */
 export interface IExternalApiRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(request: ExternalFindDataRequest, context: T): Promise<ExternalFindDataResponse>;
+    externalFetchData(request: ExternalFetchDataRequest, context: T): Promise<ExternalFetchDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */