@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/src/dht/routing/RoutingSession.ts

@@ -1,16 +1,19 @@
-import { RemoteDhtNode } from '../RemoteDhtNode'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
 import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { RouterRpcRemote } from './RouterRpcRemote'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { FindRpcClient, RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Contact } from '../contact/Contact'
+import { FindRpcRemote } from './FindRpcRemote'
+import { EXISTING_CONNECTION_TIMEOUT } from '../contact/Remote'
+import { getPreviousPeer } from './getPreviousPeer'
 
 const logger = new Logger(module)
 
@@ -18,20 +21,33 @@ const MAX_FAILED_HOPS = 2
 
 class RemoteContact extends Contact {
 
-    private router: RouterRpcRemote
+    private routerRpcRemote: RouterRpcRemote
+    private findRpcRemote: FindRpcRemote
 
-    constructor(peer: RemoteDhtNode, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
+    constructor(peer: DhtNodeRpcRemote, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
         super(peer.getPeerDescriptor())
-        this.router = new RouterRpcRemote(
-            ownPeerDescriptor,
+        this.routerRpcRemote = new RouterRpcRemote(
+            localPeerDescriptor,
             peer.getPeerDescriptor(),
             peer.getServiceId(),
-            toProtoRpcClient(new RouterRpcClient(rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new RouterRpcClient(rpcCommunicator.getRpcClientTransport())),
+            EXISTING_CONNECTION_TIMEOUT
         )
+        this.findRpcRemote = new FindRpcRemote(
+            localPeerDescriptor,
+            peer.getPeerDescriptor(),
+            peer.getServiceId(),
+            toProtoRpcClient(new FindRpcClient(rpcCommunicator.getRpcClientTransport())),
+            EXISTING_CONNECTION_TIMEOUT
+        )
+    }
+
+    getRouterRpcRemote(): RouterRpcRemote {
+        return this.routerRpcRemote
     }
 
-    getRouter(): RouterRpcRemote {
-        return this.router
+    getFindRpcRemote(): FindRpcRemote {
+        return this.findRpcRemote
     }
 }
 
@@ -45,10 +61,9 @@ export interface RoutingSessionEvents {
     // through, and none of them responds with a success ack
     routingFailed: (sessionId: string) => void
     stopped: (sessionId: string) => void
-    noCandidatesFound: (sessionId: string) => void
 }
 
-export enum RoutingMode { ROUTE, FORWARD, RECURSIVE_FIND }
+export enum RoutingMode { ROUTE, FORWARD, FIND }
 
 export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
@@ -56,9 +71,9 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     private readonly rpcCommunicator: RoutingRpcCommunicator
     private ongoingRequests: Set<PeerIDKey> = new Set()
     private contactList: SortedContactList<RemoteContact>
-    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly localPeerDescriptor: PeerDescriptor
     private readonly messageToRoute: RouteMessageWrapper
-    private connections: Map<PeerIDKey, RemoteDhtNode>
+    private connections: Map<PeerIDKey, DhtNodeRpcRemote>
     private readonly parallelism: number
     private failedHopCounter = 0
     private successfulHopCounter = 0
@@ -67,24 +82,24 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     constructor(
         rpcCommunicator: RoutingRpcCommunicator,
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         messageToRoute: RouteMessageWrapper,
-        connections: Map<PeerIDKey, RemoteDhtNode>,
+        connections: Map<PeerIDKey, DhtNodeRpcRemote>,
         parallelism: number,
         mode: RoutingMode = RoutingMode.ROUTE,
-        destinationId?: Uint8Array,
         excludedPeerIDs?: PeerID[]
     ) {
         super()
         this.rpcCommunicator = rpcCommunicator
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.messageToRoute = messageToRoute
         this.connections = connections
         this.parallelism = parallelism
         this.mode = mode
-        const previousId = messageToRoute.previousPeer ? PeerID.fromValue(messageToRoute.previousPeer.kademliaId) : undefined
+        const previousPeer = getPreviousPeer(messageToRoute)
+        const previousId = previousPeer ? PeerID.fromValue(previousPeer.kademliaId) : undefined
         this.contactList = new SortedContactList(
-            destinationId ? PeerID.fromValue(destinationId) : PeerID.fromValue(this.messageToRoute.destinationPeer!.kademliaId),
+            PeerID.fromValue(this.messageToRoute.destinationPeer!.kademliaId),
             10000,
             undefined,
             true,
@@ -93,7 +108,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         )
     }
 
-    private onRequestFailed = (peerId: PeerID) => {
+    private onRequestFailed(peerId: PeerID) {
         logger.trace('onRequestFailed() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
@@ -102,8 +117,9 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             this.ongoingRequests.delete(peerId.toKey())
         }
         const contacts = this.findMoreContacts()
-        if (contacts.length < 1 && this.ongoingRequests.size < 1) {
+        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 {
@@ -113,69 +129,63 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    private emitFailure = () => {
+    private emitFailure() {
         if (this.successfulHopCounter >= 1) {
             this.emit('partialSuccess', this.sessionId)
-
         } else {
             this.emit('routingFailed', this.sessionId)
         }
     }
 
-    private onRequestSucceeded = () => {
+    private onRequestSucceeded() {
         logger.trace('onRequestSucceeded() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
         }
         this.successfulHopCounter += 1
         const contacts = this.findMoreContacts()
-        if (this.successfulHopCounter >= this.parallelism || contacts.length < 1) {
+        if (this.successfulHopCounter >= this.parallelism || contacts.length === 0) {
+            // TODO should call this.stop() so that we do cleanup? (after the routingSucceeded call)
             this.stopped = true
             this.emit('routingSucceeded', this.sessionId)
-        } else if (contacts.length > 0 && this.ongoingRequests.size < 1) {
+        } else if (contacts.length > 0 && this.ongoingRequests.size === 0) {
             this.sendMoreRequests(contacts)
         }
     }
 
-    private sendRouteMessageRequest = async (contact: RemoteContact): Promise<boolean> => {
+    private async sendRouteMessageRequest(contact: RemoteContact): Promise<boolean> {
         if (this.stopped) {
             return false
         }
-        const router = contact.getRouter()
+        const msg = {
+            ...this.messageToRoute,
+            routingPath: this.messageToRoute.routingPath.concat([this.localPeerDescriptor])
+        }
         if (this.mode === RoutingMode.FORWARD) {
-            return router.forwardMessage({
-                ...this.messageToRoute,
-                previousPeer: this.ownPeerDescriptor
-            })
-        } else if (this.mode === RoutingMode.RECURSIVE_FIND) {
-            return router.findRecursively({
-                ...this.messageToRoute,
-                previousPeer: this.ownPeerDescriptor
-            })
+            return contact.getRouterRpcRemote().forwardMessage(msg)
+        } else if (this.mode === RoutingMode.FIND) {
+            return contact.getFindRpcRemote().routeFindRequest(msg)
         } else {
-            return router.routeMessage({
-                ...this.messageToRoute,
-                previousPeer: this.ownPeerDescriptor
-            })
+            return contact.getRouterRpcRemote().routeMessage(msg)
         }
     }
 
-    private findMoreContacts = (): RemoteContact[] => {
+    findMoreContacts(): RemoteContact[] {
         logger.trace('findMoreContacts() sessionId: ' + this.sessionId)
         // the contents of the connections might have changed between the rounds
         // addContacts() will only add new contacts that were not there yet
         const contacts = Array.from(this.connections.values())
-            .map((peer) => new RemoteContact(peer, this.ownPeerDescriptor, this.rpcCommunicator))
+            .map((peer) => new RemoteContact(peer, this.localPeerDescriptor, this.rpcCommunicator))
         this.contactList.addContacts(contacts)
         return this.contactList.getUncontactedContacts(this.parallelism)
     }
 
-    private sendMoreRequests = (uncontacted: RemoteContact[]) => {
+    sendMoreRequests(uncontacted: RemoteContact[]): void {
         logger.trace('sendMoreRequests() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
         }
-        if (uncontacted.length < 1) {
+        if (uncontacted.length === 0) {
             this.emitFailure()
             return
         }
@@ -184,10 +194,10 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             this.emitFailure()
             return
         }
-        while ((this.ongoingRequests.size) < this.parallelism && (uncontacted.length > 0) && !this.stopped) {
+        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 to contact: ${keyFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
+            logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
             this.contactList.setContacted(nextPeer!.getPeerId())
             this.ongoingRequests.add(nextPeer!.getPeerId().toKey())
             setImmediate(async () => {
@@ -207,25 +217,10 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    public start(): void {
-        logger.trace('start() sessionId: ' + this.sessionId)
-        const contacts = this.findMoreContacts()
-        if (contacts.length < 1) {
-            logger.trace('start() throwing noCandidatesFound sessionId: ' + this.sessionId)
-            
-            this.stopped = true
-            this.emit('noCandidatesFound', this.sessionId)
-            throw new Error('noCandidatesFound ' + this.sessionId)
-        }
-        this.sendMoreRequests(contacts)
-    }
-
     public stop(): void {
         this.stopped = true
         this.contactList.stop()
-
         this.emit('stopped', this.sessionId)
         this.removeAllListeners()
     }
-
 }

package/src/dht/routing/getPreviousPeer.ts

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

package/src/dht/store/StoreRpcLocal.ts

@@ -9,8 +9,8 @@ import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { IRecursiveFinder } from '../find/RecursiveFinder'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { IFinder } from '../find/Finder'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
@@ -20,19 +20,21 @@ import EventEmitter from 'eventemitter3'
 import { Events } from '../DhtNode'
 import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
-import { RemoteDhtNode } from '../RemoteDhtNode'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+import { ServiceID } from '../../types/ServiceID'
 
 interface DataStoreConfig {
     rpcCommunicator: RoutingRpcCommunicator
-    recursiveFinder: IRecursiveFinder
-    ownPeerDescriptor: PeerDescriptor
+    finder: IFinder
+    localPeerDescriptor: PeerDescriptor
     localDataStore: LocalDataStore
-    serviceId: string
+    serviceId: ServiceID
     maxTtl: number
     highestTtl: number
     redundancyFactor: number
     dhtNodeEmitter: EventEmitter<Events>
-    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
+    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtNodeRpcRemote[]
+    rpcRequestTimeout?: number
 }
 
 const logger = new Logger(module)
@@ -40,26 +42,28 @@ const logger = new Logger(module)
 export class StoreRpcLocal implements IStoreRpc {
 
     private readonly rpcCommunicator: RoutingRpcCommunicator
-    private readonly recursiveFinder: IRecursiveFinder
-    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly finder: IFinder
+    private readonly localPeerDescriptor: PeerDescriptor
     private readonly localDataStore: LocalDataStore
-    private readonly serviceId: string
+    private readonly serviceId: ServiceID
     private readonly maxTtl: number
     private readonly highestTtl: number
     private readonly redundancyFactor: number
     private readonly dhtNodeEmitter: EventEmitter<Events>
-    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
+    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtNodeRpcRemote[]
+    private readonly rpcRequestTimeout?: number
 
     constructor(config: DataStoreConfig) {
         this.rpcCommunicator = config.rpcCommunicator
-        this.recursiveFinder = config.recursiveFinder
-        this.ownPeerDescriptor = config.ownPeerDescriptor
+        this.finder = config.finder
+        this.localPeerDescriptor = config.localPeerDescriptor
         this.localDataStore = config.localDataStore
         this.serviceId = config.serviceId
         this.maxTtl = config.maxTtl
         this.highestTtl = config.highestTtl
         this.redundancyFactor = config.redundancyFactor
         this.dhtNodeEmitter = config.dhtNodeEmitter
+        this.rpcRequestTimeout = config.rpcRequestTimeout
         this.getNodesClosestToIdFromBucket = config.getNodesClosestToIdFromBucket
         this.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
             (request: StoreDataRequest, context: ServerCallContext) => this.storeData(request, context))
@@ -83,12 +87,12 @@ export class StoreRpcLocal implements IStoreRpc {
 
         const dataId = PeerID.fromValue(dataEntry.kademliaId)
         const newNodeId = PeerID.fromValue(newNode.kademliaId)
-        const ownPeerId = PeerID.fromValue(this.ownPeerDescriptor.kademliaId)
+        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.kademliaId)
 
         const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.kademliaId, 10)
 
         const sortedList = new SortedContactList<Contact>(dataId, 20, undefined, true)
-        sortedList.addContact(new Contact(this.ownPeerDescriptor))
+        sortedList.addContact(new Contact(this.localPeerDescriptor))
 
         closestToData.forEach((con) => {
             if (!newNodeId.equals(PeerID.fromValue(con.getPeerDescriptor().kademliaId))) {
@@ -96,7 +100,7 @@ export class StoreRpcLocal implements IStoreRpc {
             }
         })
 
-        if (!sortedList.getAllContacts()[0].getPeerId().equals(ownPeerId)) {
+        if (!sortedList.getAllContacts()[0].getPeerId().equals(localPeerId)) {
             // If we are not the closes node to the data, do not migrate
             return false
         }
@@ -128,10 +132,11 @@ export class StoreRpcLocal implements IStoreRpc {
 
     private async migrateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor, doNotConnect: boolean = false): Promise<void> {
         const rpcRemote = new StoreRpcRemote(
-            this.ownPeerDescriptor,
+            this.localPeerDescriptor,
             contact,
             this.serviceId,
-            toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
+            this.rpcRequestTimeout
         )
         try {
             const response = await rpcRemote.migrateData({ dataEntry }, doNotConnect)
@@ -145,16 +150,16 @@ export class StoreRpcLocal implements IStoreRpc {
 
     public async storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]> {
         logger.debug(`Storing data to DHT ${this.serviceId}`)
-        const result = await this.recursiveFinder.startRecursiveFind(key)
+        const result = await this.finder.startFind(key)
         const closestNodes = result.closestNodes
         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.redundancyFactor; i++) {
-            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
+            if (areEqualPeerDescriptors(this.localPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.storeEntry({
                     kademliaId: key, 
-                    storer: this.ownPeerDescriptor,
+                    storer: this.localPeerDescriptor,
                     ttl, 
                     storedAt: Timestamp.now(), 
                     data,
@@ -166,10 +171,11 @@ export class StoreRpcLocal implements IStoreRpc {
                 continue
             }
             const rpcRemote = new StoreRpcRemote(
-                this.ownPeerDescriptor,
+                this.localPeerDescriptor,
                 closestNodes[i],
                 this.serviceId,
-                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
+                this.rpcRequestTimeout
             )
             try {
                 const response = await rpcRemote.storeData({ kademliaId: key, data, ttl, storerTime })
@@ -187,37 +193,38 @@ export class StoreRpcLocal implements IStoreRpc {
     }
 
     private selfIsOneOfClosestPeers(dataId: Uint8Array): boolean {
-        const ownPeerId = PeerID.fromValue(this.ownPeerDescriptor.kademliaId)
+        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.kademliaId)
         const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.redundancyFactor)
-        const sortedList = new SortedContactList<Contact>(ownPeerId, this.redundancyFactor, undefined, true)
-        sortedList.addContact(new Contact(this.ownPeerDescriptor))
+        const sortedList = new SortedContactList<Contact>(localPeerId, this.redundancyFactor, undefined, true)
+        sortedList.addContact(new Contact(this.localPeerDescriptor))
         closestPeers.forEach((con) => sortedList.addContact(new Contact(con.getPeerDescriptor())))
-        return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(ownPeerId))
+        return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(localPeerId))
     }
 
     public async deleteDataFromDht(key: Uint8Array): Promise<void> {
         logger.debug(`Deleting data from DHT ${this.serviceId}`)
-        const result = await this.recursiveFinder.startRecursiveFind(key)
+        const result = await this.finder.startFind(key)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
         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))
+            if (areEqualPeerDescriptors(this.localPeerDescriptor, closestNodes[i])) {
+                this.localDataStore.markAsDeleted(key, peerIdFromPeerDescriptor(this.localPeerDescriptor))
                 successfulNodes.push(closestNodes[i])
                 continue
             }
             const rpcRemote = new StoreRpcRemote(
-                this.ownPeerDescriptor,
+                this.localPeerDescriptor,
                 closestNodes[i],
                 this.serviceId,
-                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
+                this.rpcRequestTimeout
             )
             try {
                 const response = await rpcRemote.deleteData({ kademliaId: key })
                 if (response.deleted) {
                     logger.trace('remote.deleteData() returned success')
                 } else {
-                    logger.trace('could not delete data from ' + keyFromPeerDescriptor(closestNodes[i]))
+                    logger.trace('could not delete data from ' + getNodeIdFromPeerDescriptor(closestNodes[i]))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {
@@ -278,25 +285,25 @@ export class StoreRpcLocal implements IStoreRpc {
     private migrateDataToNeighborsIfNeeded(incomingPeer: PeerDescriptor, dataEntry: DataEntry): void {
 
         // sort own contact list according to data id
-        const ownPeerId = PeerID.fromValue(this.ownPeerDescriptor.kademliaId)
+        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.kademliaId)
         const dataId = PeerID.fromValue(dataEntry.kademliaId)
         const incomingPeerId = PeerID.fromValue(incomingPeer.kademliaId)
         const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.kademliaId, 10)
 
         const sortedList = new SortedContactList<Contact>(dataId, this.redundancyFactor, undefined, true)
-        sortedList.addContact(new Contact(this.ownPeerDescriptor))
+        sortedList.addContact(new Contact(this.localPeerDescriptor))
 
         closestToData.forEach((con) => {
             sortedList.addContact(new Contact(con.getPeerDescriptor()))
         })
 
-        if (!sortedList.getAllContacts()[0].getPeerId().equals(ownPeerId)) {
+        if (!sortedList.getAllContacts()[0].getPeerId().equals(localPeerId)) {
             // If we are not the closest node to the data, migrate only to the 
             // closest one to the data
 
             const contact = sortedList.getAllContacts()[0]
             const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().kademliaId)
-            if (!incomingPeerId.equals(contactPeerId) && !ownPeerId.equals(contactPeerId)) {
+            if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
                 setImmediate(async () => {
                     try {
                         await this.migrateDataToContact(dataEntry, contact.getPeerDescriptor())
@@ -310,8 +317,8 @@ export class StoreRpcLocal implements IStoreRpc {
             // 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)) {
-                    if (!incomingPeerId.equals(contactPeerId) && !ownPeerId.equals(contactPeerId)) {
+                if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
+                    if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
                         setImmediate(async () => {
                             try {
                                 await this.migrateDataToContact(dataEntry, contact.getPeerDescriptor())

package/src/dht/store/StoreRpcRemote.ts

@@ -1,4 +1,4 @@
-import { Remote } from '../contact/Remote'
+import { EXISTING_CONNECTION_TIMEOUT, Remote } from '../contact/Remote'
 import { IStoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { 
     DeleteDataRequest,
@@ -8,19 +8,17 @@ import {
     StoreDataRequest,
     StoreDataResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 export class StoreRpcRemote extends Remote<IStoreRpcClient> {
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
-        const options = this.formDhtRpcOptions({
-            timeout: 10000
-        })
+        const options = this.formDhtRpcOptions()
         try {
             return await this.getClient().storeData(request, options)
         } catch (err) {
-            const to = keyFromPeerDescriptor(this.getPeerDescriptor())
-            const from = keyFromPeerDescriptor(this.getLocalPeerDescriptor())
+            const to = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
+            const from = getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())
             throw Error(
                 `Could not store data to ${to} from ${from} ${err}`
             )
@@ -28,21 +26,19 @@ export class StoreRpcRemote extends Remote<IStoreRpcClient> {
     }
 
     async deleteData(request: DeleteDataRequest): Promise<DeleteDataResponse> {
-        const options = this.formDhtRpcOptions({
-            timeout: 10000
-        })
+        const options = this.formDhtRpcOptions()
         try {
             return await this.getClient().deleteData(request, options)
         } catch (err) {
             throw Error(
-                `Could not call delete data to ${keyFromPeerDescriptor(this.getPeerDescriptor())} ${err}`
+                `Could not call delete data to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} ${err}`
             )
         }
     }
 
     async migrateData(request: MigrateDataRequest, doNotConnect: boolean = false): Promise<MigrateDataResponse> {
         const options = this.formDhtRpcOptions({
-            timeout: 10000,
+            timeout: EXISTING_CONNECTION_TIMEOUT,
             doNotConnect
         })
         return this.getClient().migrateData(request, options)

package/src/exports.ts

@@ -1,13 +1,19 @@
 export { DhtNode, DhtNodeEvents, DhtNodeOptions } from './dht/DhtNode'
 export { ListeningRpcCommunicator } from './transport/ListeningRpcCommunicator'
-export { Simulator, LatencyType } from './connection/Simulator/Simulator'
-export { SimulatorTransport } from './connection/Simulator/SimulatorTransport'
-export { getRandomRegion, getRegionDelayMatrix } from './connection/Simulator/pings'
+export { RoutingRpcCommunicator } from './transport/RoutingRpcCommunicator'
+export { Simulator, LatencyType } from './connection/simulator/Simulator'
+export { SimulatorTransport } from './connection/simulator/SimulatorTransport'
+export { getRandomRegion, getRegionDelayMatrix } from './connection/simulator/pings'
 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 { DefaultConnectorFacade } from './connection/ConnectorFacade'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
-export { Remote } from './dht/contact/Remote'
+export { Remote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/Remote'
 export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
-export { IceServer } from './connection/WebRTC/WebRtcConnectorRpcLocal'
+export { IceServer } from './connection/webrtc/WebrtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'
+export { ClientWebsocket } from './connection/websocket/ClientWebsocket'
+export { ManagedConnection } from './connection/ManagedConnection'
+export { ConnectionType } from './connection/IConnection'
+export { PeerID } from './helpers/PeerID'

package/src/helpers/Connectivity.ts

@@ -0,0 +1,19 @@
+import { ConnectionType } from '../connection/IConnection'
+import { ConnectivityMethod, NodeType, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { isPrivateIPv4 } from './AddressTools'
+
+export const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod): boolean => {
+    const hasPrivateAddress = ((websocketServer.host === 'localhost') || isPrivateIPv4(websocketServer.host))
+    return websocketServer.tls || hasPrivateAddress
+}
+
+export const expectedConnectionType = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): ConnectionType => {
+    if (remotePeerDescriptor.websocket 
+        && (localPeerDescriptor.type !== NodeType.BROWSER || canOpenConnectionFromBrowser(remotePeerDescriptor.websocket))) {
+        return ConnectionType.WEBSOCKET_CLIENT
+    } else if (localPeerDescriptor.websocket 
+        && (remotePeerDescriptor.type !== NodeType.BROWSER || canOpenConnectionFromBrowser(localPeerDescriptor.websocket))) {
+        return ConnectionType.WEBSOCKET_SERVER
+    }
+    return ConnectionType.WEBRTC
+}

package/src/helpers/errors.ts

@@ -33,13 +33,13 @@ class Err extends Error {
 
 export class ConnectionFailed extends Err { constructor( message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTION_FAILED, message, originalError) } }
 export class CouldNotRoute extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_ROUTE, message, originalError) } }
-export class WebSocketServerStartError extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.STARTING_WEBSOCKET_SERVER_FAILED, message, originalError) } }
-export class WebSocketConnectionRequestRejected extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.WEBSOCKET_CONNECTION_REQUEST_REJECTED, message, originalError) } }
+export class WebsocketServerStartError extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.STARTING_WEBSOCKET_SERVER_FAILED, message, originalError) } }
+export class WebsocketConnectionRequestRejected extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.WEBSOCKET_CONNECTION_REQUEST_REJECTED, message, originalError) } }
 export class CouldNotStart extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_START, message, originalError) } }
 export class CouldNotStop extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_STOP, message, originalError) } }
 export class CannotConnectToSelf extends Err { constructor(message?: string, originalError?: Error | string) {super(ErrorCode.CANNOT_CONNECT_TO_SELF, message, originalError) } }
 export class NotImplemented extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.NOT_IMPLEMENTED, message, originalError) } }
-export class IllegalRTCPeerConnectionState extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.ILLEGAL_RTC_PEER_CONNECTION_STATE, message, originalError) } }
+export class IllegalRtcPeerConnectionState extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.ILLEGAL_RTC_PEER_CONNECTION_STATE, message, originalError) } }
 export class IllegalArguments extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.ILLEGAL_ARGUMENTS, message, originalError) } }
 export class ConnectivityResponseTimeout extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTIVITY_RESPONSE_NOT_RECEIVED_BEFORE_TIMEOUT, message, originalError) } }
 export class ConnectionLocker extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTION_LOCKER, message, originalError) } }

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -1,3 +1,4 @@
+import { binaryToHex } from '@streamr/utils'
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey } from './PeerID'
 
@@ -5,6 +6,11 @@ export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID
     return PeerID.fromValue(peerDescriptor.kademliaId)
 }
 
+// TODO could move getNodeIdFromPeerDescriptor (and NodeID) from trackerless-network
+export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): string => {
+    return binaryToHex(peerDescriptor.kademliaId)
+}
+
 export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey => {
     return PeerID.fromValue(peerDescriptor.kademliaId).toKey()
 }