@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/dht/routing/RoutingSession.ts

@@ -1,14 +1,14 @@
-import { PeerDescriptor } from '../../exports'
-import { DhtPeer } from '../DhtPeer'
+import { RemoteDhtNode } from '../RemoteDhtNode'
 import { SortedContactList } from '../contact/SortedContactList'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
-import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { RemoteRouter } from './RemoteRouter'
+import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { RouterRpcRemote } from './RouterRpcRemote'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RoutingServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Contact } from '../contact/Contact'
 
@@ -18,19 +18,19 @@ const MAX_FAILED_HOPS = 2
 
 class RemoteContact extends Contact {
 
-    private router: RemoteRouter
+    private router: RouterRpcRemote
 
-    constructor(peer: DhtPeer, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
+    constructor(peer: RemoteDhtNode, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
         super(peer.getPeerDescriptor())
-        this.router = new RemoteRouter(
+        this.router = new RouterRpcRemote(
             ownPeerDescriptor,
             peer.getPeerDescriptor(),
             peer.getServiceId(),
-            toProtoRpcClient(new RoutingServiceClient(rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new RouterRpcClient(rpcCommunicator.getRpcClientTransport()))
         )
     }
 
-    getRouter(): RemoteRouter {
+    getRouter(): RouterRpcRemote {
         return this.router
     }
 }
@@ -58,7 +58,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     private contactList: SortedContactList<RemoteContact>
     private readonly ownPeerDescriptor: PeerDescriptor
     private readonly messageToRoute: RouteMessageWrapper
-    private connections: Map<PeerIDKey, DhtPeer>
+    private connections: Map<PeerIDKey, RemoteDhtNode>
     private readonly parallelism: number
     private failedHopCounter = 0
     private successfulHopCounter = 0
@@ -69,7 +69,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         rpcCommunicator: RoutingRpcCommunicator,
         ownPeerDescriptor: PeerDescriptor,
         messageToRoute: RouteMessageWrapper,
-        connections: Map<PeerIDKey, DhtPeer>,
+        connections: Map<PeerIDKey, RemoteDhtNode>,
         parallelism: number,
         mode: RoutingMode = RoutingMode.ROUTE,
         destinationId?: Uint8Array,
@@ -122,7 +122,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    private onRequestSucceeded = (_peerId: PeerID) => {
+    private onRequestSucceeded = () => {
         logger.trace('onRequestSucceeded() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
@@ -187,14 +187,14 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         while ((this.ongoingRequests.size) < this.parallelism && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
-            logger.trace(`Sending routeMessage request from ${this.ownPeerDescriptor.kademliaId} to contact: ${nextPeer!.getPeerId()} (sessionId=${this.sessionId})`)
+            logger.trace(`Sending routeMessage request to contact: ${keyFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
             this.contactList.setContacted(nextPeer!.getPeerId())
             this.ongoingRequests.add(nextPeer!.getPeerId().toKey())
             setImmediate(async () => {
                 try {
                     const succeeded = await this.sendRouteMessageRequest(nextPeer!)
                     if (succeeded) {
-                        this.onRequestSucceeded(nextPeer!.getPeerId())
+                        this.onRequestSucceeded()
                     } else {
                         this.onRequestFailed(nextPeer!.getPeerId())
                     }

package/src/dht/store/{DataStore.ts → StoreRpcLocal.ts}

@@ -7,20 +7,20 @@ import { Any } from '../../proto/google/protobuf/any'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { StoreServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { IRecursiveFinder } from '../find/RecursiveFinder'
-import { isSamePeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
-import { IStoreService } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { RemoteStore } from './RemoteStore'
+import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { StoreRpcRemote } from './StoreRpcRemote'
 import { Timestamp } from '../../proto/google/protobuf/timestamp'
 import EventEmitter from 'eventemitter3'
 import { Events } from '../DhtNode'
 import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
-import { DhtPeer } from '../DhtPeer'
+import { RemoteDhtNode } from '../RemoteDhtNode'
 
 interface DataStoreConfig {
     rpcCommunicator: RoutingRpcCommunicator
@@ -30,14 +30,14 @@ interface DataStoreConfig {
     serviceId: string
     maxTtl: number
     highestTtl: number
-    numberOfCopies: number
+    redundancyFactor: number
     dhtNodeEmitter: EventEmitter<Events>
-    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtPeer[]
+    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 }
 
 const logger = new Logger(module)
 
-export class DataStore implements IStoreService {
+export class StoreRpcLocal implements IStoreRpc {
 
     private readonly rpcCommunicator: RoutingRpcCommunicator
     private readonly recursiveFinder: IRecursiveFinder
@@ -46,9 +46,9 @@ export class DataStore implements IStoreService {
     private readonly serviceId: string
     private readonly maxTtl: number
     private readonly highestTtl: number
-    private readonly numberOfCopies: number
+    private readonly redundancyFactor: number
     private readonly dhtNodeEmitter: EventEmitter<Events>
-    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtPeer[]
+    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 
     constructor(config: DataStoreConfig) {
         this.rpcCommunicator = config.rpcCommunicator
@@ -58,7 +58,7 @@ export class DataStore implements IStoreService {
         this.serviceId = config.serviceId
         this.maxTtl = config.maxTtl
         this.highestTtl = config.highestTtl
-        this.numberOfCopies = config.numberOfCopies
+        this.redundancyFactor = config.redundancyFactor
         this.dhtNodeEmitter = config.dhtNodeEmitter
         this.getNodesClosestToIdFromBucket = config.getNodesClosestToIdFromBucket
         this.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
@@ -68,7 +68,7 @@ export class DataStore implements IStoreService {
         this.rpcCommunicator.registerRpcMethod(DeleteDataRequest, DeleteDataResponse, 'deleteData',
             (request: DeleteDataRequest, context: ServerCallContext) => this.deleteData(request, context))
 
-        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor, _closestPeers: PeerDescriptor[]) => {
+        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor) => {
             this.localDataStore.getStore().forEach((dataMap, _dataKey) => {
                 dataMap.forEach((dataEntry) => {
                     if (this.shouldMigrateDataToNewNode(dataEntry.dataEntry, peerDescriptor)) {
@@ -114,10 +114,10 @@ export class DataStore implements IStoreService {
             }
         }
 
-        // if new node is within the storeNumberOfCopies closest nodes to the data
+        // if new node is within the storageRedundancyFactor closest nodes to the data
         // do migrate data to it
 
-        if (index < this.numberOfCopies) {
+        if (index < this.redundancyFactor) {
             this.localDataStore.setStale(dataId, dataEntry.storer!, false)
             return true
         } else {
@@ -127,19 +127,19 @@ export class DataStore implements IStoreService {
     }
 
     private async migrateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor, doNotConnect: boolean = false): Promise<void> {
-        const remoteStore = new RemoteStore(
+        const rpcRemote = new StoreRpcRemote(
             this.ownPeerDescriptor,
             contact,
             this.serviceId,
-            toProtoRpcClient(new StoreServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
         )
         try {
-            const response = await remoteStore.migrateData({ dataEntry }, doNotConnect)
+            const response = await rpcRemote.migrateData({ dataEntry }, doNotConnect)
             if (response.error) {
-                logger.trace('RemoteStore::migrateData() returned error: ' + response.error)
+                logger.trace('migrateData() returned error: ' + response.error)
             }
         } catch (e) {
-            logger.trace('RemoteStore::migrateData() threw an exception ' + e)
+            logger.trace('migrateData() threw an exception ' + e)
         }
     }
 
@@ -150,8 +150,8 @@ export class DataStore implements IStoreService {
         const successfulNodes: PeerDescriptor[] = []
         const ttl = this.highestTtl // ToDo: make TTL decrease according to some nice curve
         const storerTime = Timestamp.now()
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
-            if (isSamePeerDescriptor(this.ownPeerDescriptor, closestNodes[i])) {
+        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
+            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.storeEntry({
                     kademliaId: key, 
                     storer: this.ownPeerDescriptor,
@@ -165,22 +165,22 @@ export class DataStore implements IStoreService {
                 successfulNodes.push(closestNodes[i])
                 continue
             }
-            const remoteStore = new RemoteStore(
+            const rpcRemote = new StoreRpcRemote(
                 this.ownPeerDescriptor,
                 closestNodes[i],
                 this.serviceId,
-                toProtoRpcClient(new StoreServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
             try {
-                const response = await remoteStore.storeData({ kademliaId: key, data, ttl, storerTime })
+                const response = await rpcRemote.storeData({ kademliaId: key, data, ttl, storerTime })
                 if (!response.error) {
                     successfulNodes.push(closestNodes[i])
-                    logger.trace('remoteStore.storeData() returned success')
+                    logger.trace('remote.storeData() returned success')
                 } else {
-                    logger.trace('remoteStore.storeData() returned error: ' + response.error)
+                    logger.trace('remote.storeData() returned error: ' + response.error)
                 }
             } catch (e) {
-                logger.trace('remoteStore.storeData() threw an exception ' + e)
+                logger.trace('remote.storeData() threw an exception ' + e)
             }
         }
         return successfulNodes
@@ -188,8 +188,8 @@ export class DataStore implements IStoreService {
 
     private selfIsOneOfClosestPeers(dataId: Uint8Array): boolean {
         const ownPeerId = PeerID.fromValue(this.ownPeerDescriptor.kademliaId)
-        const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.numberOfCopies)
-        const sortedList = new SortedContactList<Contact>(ownPeerId, this.numberOfCopies, undefined, true)
+        const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.redundancyFactor)
+        const sortedList = new SortedContactList<Contact>(ownPeerId, this.redundancyFactor, undefined, true)
         sortedList.addContact(new Contact(this.ownPeerDescriptor))
         closestPeers.forEach((con) => sortedList.addContact(new Contact(con.getPeerDescriptor())))
         return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(ownPeerId))
@@ -200,28 +200,28 @@ export class DataStore implements IStoreService {
         const result = await this.recursiveFinder.startRecursiveFind(key)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
-            if (isSamePeerDescriptor(this.ownPeerDescriptor, closestNodes[i])) {
+        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
+            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.markAsDeleted(key, peerIdFromPeerDescriptor(this.ownPeerDescriptor))
                 successfulNodes.push(closestNodes[i])
                 continue
             }
-            const remoteStore = new RemoteStore(
+            const rpcRemote = new StoreRpcRemote(
                 this.ownPeerDescriptor,
                 closestNodes[i],
                 this.serviceId,
-                toProtoRpcClient(new StoreServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
             try {
-                const response = await remoteStore.deleteData({ kademliaId: key })
+                const response = await rpcRemote.deleteData({ kademliaId: key })
                 if (response.deleted) {
-                    logger.trace('remoteStore.deleteData() returned success')
+                    logger.trace('remote.deleteData() returned success')
                 } else {
-                    logger.trace('could not delete data from ' + PeerID.fromValue(closestNodes[i].kademliaId))
+                    logger.trace('could not delete data from ' + keyFromPeerDescriptor(closestNodes[i]))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {
-                logger.trace('remoteStore.deleteData() threw an exception ' + e)
+                logger.trace('remote.deleteData() threw an exception ' + e)
             }
         }
     }
@@ -246,7 +246,7 @@ export class DataStore implements IStoreService {
             this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(kademliaId))
         }
 
-        logger.trace(this.ownPeerDescriptor.nodeName + ' storeData()')
+        logger.trace('storeData()')
         return StoreDataResponse.create()
     }
 
@@ -260,7 +260,7 @@ export class DataStore implements IStoreService {
 
     // RPC service implementation
     public async migrateData(request: MigrateDataRequest, context: ServerCallContext): Promise<MigrateDataResponse> {
-        logger.trace(this.ownPeerDescriptor.nodeName + ' server-side migrateData()')
+        logger.trace('server-side migrateData()')
         const dataEntry = request.dataEntry!
 
         const wasStored = this.localDataStore.storeEntry(dataEntry)
@@ -271,7 +271,7 @@ export class DataStore implements IStoreService {
         if (!this.selfIsOneOfClosestPeers(dataEntry.kademliaId)) {
             this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(dataEntry.kademliaId))
         }
-        logger.trace(this.ownPeerDescriptor.nodeName + ' server-side migrateData() at end')
+        logger.trace('server-side migrateData() at end')
         return MigrateDataResponse.create()
     }
 
@@ -283,7 +283,7 @@ export class DataStore implements IStoreService {
         const incomingPeerId = PeerID.fromValue(incomingPeer.kademliaId)
         const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.kademliaId, 10)
 
-        const sortedList = new SortedContactList<Contact>(dataId, this.numberOfCopies, undefined, true)
+        const sortedList = new SortedContactList<Contact>(dataId, this.redundancyFactor, undefined, true)
         sortedList.addContact(new Contact(this.ownPeerDescriptor))
 
         closestToData.forEach((con) => {
@@ -307,7 +307,7 @@ export class DataStore implements IStoreService {
                 })
             }
         } else {
-            // if we are the closest to the data, migrate to all storeNumberOfCopies nearest
+            // if we are the closest to the data, migrate to all storageRedundancyFactor nearest
             sortedList.getAllContacts().forEach((contact) => {
                 const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().kademliaId)
                 if (!incomingPeerId.equals(contactPeerId) && !ownPeerId.equals(contactPeerId)) {

package/src/dht/store/{RemoteStore.ts → StoreRpcRemote.ts}

@@ -1,5 +1,5 @@
 import { Remote } from '../contact/Remote'
-import { IStoreServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IStoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { 
     DeleteDataRequest,
     DeleteDataResponse,
@@ -10,7 +10,7 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
-export class RemoteStore extends Remote<IStoreServiceClient> {
+export class StoreRpcRemote extends Remote<IStoreRpcClient> {
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         const options = this.formDhtRpcOptions({

package/src/exports.ts

@@ -6,14 +6,8 @@ export { getRandomRegion, getRegionDelayMatrix } from './connection/Simulator/pi
 export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
 export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
-export { PeerID, PeerIDKey } from './helpers/PeerID'
-export { UUID } from './helpers/UUID'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
-export { protoClasses } from './helpers/protoClasses'
-export { SortedContactList } from './dht/contact/SortedContactList'
-export { Contact } from './dht/contact/Contact'
 export { Remote } from './dht/contact/Remote'
-export { RecursiveFindResult } from './dht/find/RecursiveFinder'
-export { peerIdFromPeerDescriptor, keyFromPeerDescriptor, isSamePeerDescriptor } from './helpers/peerIdFromPeerDescriptor'
-export { IceServer } from './connection/WebRTC/WebRtcConnector'
+export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
+export { IceServer } from './connection/WebRTC/WebRtcConnectorRpcLocal'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'

package/src/helpers/PeerID.ts

@@ -49,13 +49,6 @@ export class PeerID {
         return new PeerID({ stringValue })
     }
 
-    static generateRandom(): PeerID {
-        // generate 160 bit random Uint8array
-        const value = new Uint8Array(20)
-        crypto.randomFillSync(value)
-        return new PeerID({ value })
-    }
-
     // TODO convert to static method?
     // eslint-disable-next-line class-methods-use-this
     private ip2Int(ip: string): number {

package/src/helpers/browser/isBrowserEnvironment.ts

@@ -0,0 +1 @@
+export const isBrowserEnvironment = (): boolean => false

package/src/helpers/browser/isBrowserEnvironment_override.ts

@@ -0,0 +1,3 @@
+// webpack overwrites the isBrowserEnvironment.ts with this file when it creates the browser bundle
+
+export const isBrowserEnvironment = (): boolean => true

package/src/helpers/kademliaId.ts

@@ -0,0 +1,8 @@
+import crypto from 'crypto'
+
+// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
+const KADEMLIA_ID_LENGTH_IN_BYTES = 20
+
+export const createRandomKademliaId = (): Uint8Array => {
+    return crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES)
+}

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -9,6 +9,6 @@ export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey
     return PeerID.fromValue(peerDescriptor.kademliaId).toKey()
 }
 
-export const isSamePeerDescriptor = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
+export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
     return peerIdFromPeerDescriptor(peerDescriptor1).equals(peerIdFromPeerDescriptor(peerDescriptor2))
 }

package/src/helpers/protoClasses.ts

@@ -13,8 +13,8 @@ import {
     PeerDescriptor, 
     PingRequest, 
     PingResponse, 
-    RecursiveFindReport, 
-    RecursiveFindRequest, 
+    FindResponse, 
+    FindRequest, 
     RouteMessageAck, 
     RouteMessageWrapper,
     WebSocketConnectionRequest,
@@ -32,8 +32,8 @@ import {
 export const protoClasses: Array<IMessageType<any>> = [
     ClosestPeersRequest,
     ClosestPeersResponse,
-    RecursiveFindRequest,
-    RecursiveFindReport,
+    FindRequest,
+    FindResponse,
     PingRequest,
     PingResponse,
     LeaveNotice,