@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/src/connection/ConnectionManager.ts

@@ -1,31 +1,19 @@
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { CountMetric, LevelMetric, Logger, Metric, MetricsContext, MetricsDefinition, RateMetric, waitForEvent3 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
-import { Contact } from '../dht/contact/Contact'
 import { SortedContactList } from '../dht/contact/SortedContactList'
 import { DuplicateDetector } from '../dht/routing/DuplicateDetector'
-import { PeerIDKey } from '../helpers/PeerID'
 import * as Err from '../helpers/errors'
-import {
-    areEqualPeerDescriptors,
-    getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
-} from '../helpers/peerIdFromPeerDescriptor'
-import { protoToString } from '../helpers/protoToString'
 import {
     DisconnectMode,
     DisconnectNotice,
-    DisconnectNoticeResponse,
     LockRequest,
     LockResponse,
     Message,
-    MessageType,
     PeerDescriptor,
     UnlockRequest
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
-import { ITransport, TransportEvents } from '../transport/ITransport'
+import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../transport/ITransport'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
 import { ConnectionLockHandler, LockID } from './ConnectionLockHandler'
 import { ConnectorFacade } from './ConnectorFacade'
@@ -34,6 +22,8 @@ import { ConnectionLockRpcRemote } from './ConnectionLockRpcRemote'
 import { WEBRTC_CLEANUP } from './webrtc/NodeWebrtcConnection'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ConnectionLockRpcLocal } from './ConnectionLockRpcLocal'
+import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { getOfferer } from '../helpers/offering'
 
 export interface ConnectionManagerConfig {
     maxConnections?: number
@@ -55,9 +45,6 @@ interface ConnectionManagerMetrics extends MetricsDefinition {
     connectionTotalFailureCount: Metric
 }
 
-// TODO move this type identifiers.ts and use also in other classes (and rename to ServiceID)
-type ServiceId = string
-
 const logger = new Logger(module)
 
 enum ConnectionManagerState {
@@ -68,10 +55,10 @@ enum ConnectionManagerState {
 }
 
 export interface ConnectionLocker {
-    lockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void
-    unlockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void
-    weakLockConnection(targetDescriptor: PeerDescriptor): void
-    weakUnlockConnection(targetDescriptor: PeerDescriptor): void
+    lockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void
+    unlockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void
+    weakLockConnection(nodeId: DhtAddress, lockId: LockID): void
+    weakUnlockConnection(nodeId: DhtAddress, lockId: LockID): void
 }
 
 export interface PortRange {
@@ -95,7 +82,7 @@ const INTERNAL_SERVICE_ID = 'system/connection-manager'
 // - if we create stricter types for incoming messages (message.sourceDescriptor or
 //   disconnectNotice.peerDescriptor)
 // - if ManagedConnection#peerDescriptor is never undefined
-export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => { 
+export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => {
     if (peerDescriptor !== undefined) {
         return getNodeIdFromPeerDescriptor(peerDescriptor)
     } else {
@@ -107,10 +94,11 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
 
     private config: ConnectionManagerConfig
     private readonly metricsContext: MetricsContext
-    private readonly duplicateMessageDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
+    // TODO use config option or named constant?
+    private readonly duplicateMessageDetector: DuplicateDetector = new DuplicateDetector(10000)
     private readonly metrics: ConnectionManagerMetrics
     private locks = new ConnectionLockHandler()
-    private connections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private connections: Map<DhtAddress, ManagedConnection> = new Map()
     private readonly connectorFacade: ConnectorFacade
     private rpcCommunicator?: RoutingRpcCommunicator
     private disconnectorIntervalRef?: NodeJS.Timeout
@@ -135,12 +123,13 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         this.connectorFacade = this.config.createConnectorFacade()
         this.send = this.send.bind(this)
         this.rpcCommunicator = new RoutingRpcCommunicator(INTERNAL_SERVICE_ID, this.send, {
-            rpcRequestTimeout: 10000
+            rpcRequestTimeout: 10000  // TODO use config option or named constant?
         })
         const lockRpcLocal = new ConnectionLockRpcLocal({
-            addRemoteLocked: (id: PeerIDKey, serviceId: string) => this.locks.addRemoteLocked(id, serviceId),
-            removeRemoteLocked: (id: PeerIDKey, serviceId: string) => this.locks.removeRemoteLocked(id, serviceId),
+            addRemoteLocked: (id: DhtAddress, lockId: LockID) => this.locks.addRemoteLocked(id, lockId),
+            removeRemoteLocked: (id: DhtAddress, lockId: LockID) => this.locks.removeRemoteLocked(id, lockId),
             closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => {
+                // TODO should we have some handling for this floating promise?
                 this.closeConnection(peerDescriptor, gracefulLeave, reason)
             },
             getLocalPeerDescriptor: () => this.getLocalPeerDescriptor()
@@ -149,7 +138,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             (req: LockRequest, context: ServerCallContext) => lockRpcLocal.lockRequest(req, context))
         this.rpcCommunicator.registerRpcNotification(UnlockRequest, 'unlockRequest',
             (req: UnlockRequest, context: ServerCallContext) => lockRpcLocal.unlockRequest(req, context))
-        this.rpcCommunicator.registerRpcMethod(DisconnectNotice, DisconnectNoticeResponse, 'gracefulDisconnect',
+        this.rpcCommunicator.registerRpcNotification(DisconnectNotice, 'gracefulDisconnect',
             (req: DisconnectNotice, context: ServerCallContext) => lockRpcLocal.gracefulDisconnect(req, context))
     }
 
@@ -157,19 +146,31 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.connections.size <= maxConnections) {
             return
         }
-        const disconnectionCandidates = new SortedContactList<Contact>(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 100000)
-        this.connections.forEach((connection) => {
-            if (!this.locks.isLocked(connection.peerIdKey) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
+        const disconnectionCandidates = new SortedContactList<ManagedConnection>({
+            referenceId: getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 
+            maxSize: 100000,  // TODO use config option or named constant?
+            allowToContainReferenceId: false,
+            emitEvents: false
+        })
+        this.connections.forEach((connection, key) => {
+            // TODO: Investigate why multiple invalid WS client connections to the same
+            // server with a different nodeId can remain in the this.connections map.
+            // Seems to only happen if the ConnectionManager acting as client is not running a WS server itself.
+            if (connection.getPeerDescriptor() !== undefined && !this.hasConnection(getNodeIdFromPeerDescriptor(connection.getPeerDescriptor()!))) {
+                logger.trace(`Attempting to disconnect a hanging connection to ${getNodeIdFromPeerDescriptor(connection.getPeerDescriptor()!)}`)
+                connection.close(false).catch(() => {})
+                this.connections.delete(key)
+            } else if (!this.locks.isLocked(connection.getNodeId()) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
                 logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
-                disconnectionCandidates.addContact(new Contact(connection.getPeerDescriptor()!))
+                disconnectionCandidates.addContact(connection)
             }
         })
         const sortedCandidates = disconnectionCandidates.getAllContacts()
         const targetNum = this.connections.size - maxConnections
         for (let i = 0; i < sortedCandidates.length && i < targetNum; i++) {
-            logger.trace('garbageCollecting ' + getNodeIdFromPeerDescriptor(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor()))
-            this.gracefullyDisconnectAsync(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor(),
-                DisconnectMode.NORMAL).catch((_e) => { })
+            const peerDescriptor = sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor()!
+            logger.trace('garbageCollecting ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+            this.gracefullyDisconnectAsync(peerDescriptor, DisconnectMode.NORMAL).catch((_e) => { })
         }
     }
 
@@ -181,7 +182,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         logger.trace(`Starting ConnectionManager...`)
         await this.connectorFacade.start(
             (connection: ManagedConnection) => this.onNewConnection(connection),
-            (peerDescriptor: PeerDescriptor) => this.canConnect(peerDescriptor),
+            (nodeId: DhtAddress) => this.hasConnection(nodeId),
             this
         )
         // Garbage collection of connections
@@ -189,7 +190,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             logger.trace('disconnectorInterval')
             const LAST_USED_LIMIT = 20000
             this.garbageCollectConnections(this.config.maxConnections ?? 80, LAST_USED_LIMIT)
-        }, 5000)
+        }, 5000)  // TODO use config option or named constant?
     }
 
     public async stop(): Promise<void> {
@@ -212,7 +213,9 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
                 }
             } else {
                 logger.trace('handshake of connection not completed, force-closing')
+                // TODO use config option or named constant?
                 const eventReceived = waitForEvent3<ManagedConnectionEvents>(peer, 'disconnected', 2000)
+                // TODO should we have some handling for this floating promise?
                 peer.close(true)
                 try {
                     await eventReceived
@@ -234,96 +237,88 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         WEBRTC_CLEANUP.cleanUp()
     }
 
-    public getNumberOfLocalLockedConnections(): number {
-        return this.locks.getNumberOfLocalLockedConnections()
+    public getLocalLockedConnectionCount(): number {
+        return this.locks.getLocalLockedConnectionCount()
     }
 
-    public getNumberOfRemoteLockedConnections(): number {
-        return this.locks.getNumberOfRemoteLockedConnections()
+    public getRemoteLockedConnectionCount(): number {
+        return this.locks.getRemoteLockedConnectionCount()
     }
 
-    public getNumberOfWeakLockedConnections(): number {
-        return this.locks.getNumberOfWeakLockedConnections()
+    public getWeakLockedConnectionCount(): number {
+        return this.locks.getWeakLockedConnectionCount()
     }
 
-    public async send(message: Message, doNotConnect = false, doNotMindStopped = false): Promise<void> {
-        if (this.state === ConnectionManagerState.STOPPED && !doNotMindStopped) {
+    public async send(message: Message, opts: SendOptions = DEFAULT_SEND_OPTIONS): Promise<void> {
+        if ((this.state === ConnectionManagerState.STOPPED || this.state === ConnectionManagerState.STOPPING) && !opts.sendIfStopped) {
             return
         }
         const peerDescriptor = message.targetDescriptor!
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new Err.CannotConnectToSelf('Cannot send to self')
         }
-        logger.trace(`Sending message to: ${getNodeIdFromPeerDescriptor(peerDescriptor)}`)
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        logger.trace(`Sending message to: ${nodeId}`)
         message = {
             ...message,
             sourceDescriptor: this.getLocalPeerDescriptor()
         }
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        let connection = this.connections.get(peerIdKey)
-        if (!connection && !doNotConnect) {
+        let connection = this.connections.get(nodeId)
+        if (!connection && opts.connect) {
             connection = this.connectorFacade.createConnection(peerDescriptor)
             this.onNewConnection(connection)
         } else if (!connection) {
-            throw new Err.SendFailed('No connection to target, doNotConnect flag is true')
+            throw new Err.SendFailed('No connection to target, connect flag is false')
         }
         const binary = Message.toBinary(message)
         this.metrics.sendBytesPerSecond.record(binary.byteLength)
         this.metrics.sendMessagesPerSecond.record(1)
-        return connection.send(binary, doNotConnect)
+        return connection.send(binary, opts.connect)
     }
 
-    private isConnectionToSelf(peerDescriptor: PeerDescriptor): boolean { 
+    private isConnectionToSelf(peerDescriptor: PeerDescriptor): boolean {
         return areEqualPeerDescriptors(peerDescriptor, this.getLocalPeerDescriptor()) || this.isOwnWebsocketServer(peerDescriptor)
     }
 
     private isOwnWebsocketServer(peerDescriptor: PeerDescriptor): boolean {
         const localPeerDescriptor = this.getLocalPeerDescriptor()
         if ((peerDescriptor.websocket !== undefined) && (localPeerDescriptor.websocket !== undefined)) {
-            return ((peerDescriptor.websocket.port === localPeerDescriptor.websocket.port) 
+            return ((peerDescriptor.websocket.port === localPeerDescriptor.websocket.port)
                 && (peerDescriptor.websocket.host === localPeerDescriptor.websocket.host))
         } else {
             return false
         }
     }
 
-    public getConnection(peerDescriptor: PeerDescriptor): ManagedConnection | undefined {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.connections.get(peerIdKey)
+    public getConnection(nodeId: DhtAddress): ManagedConnection | undefined {
+        return this.connections.get(nodeId)
     }
 
     public getLocalPeerDescriptor(): PeerDescriptor {
         return this.connectorFacade.getLocalPeerDescriptor()!
     }
 
-    public hasConnection(peerDescriptor: PeerDescriptor): boolean {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.connections.has(peerIdKey)
-    }
-
-    public hasLocalLockedConnection(peerDescriptor: PeerDescriptor): boolean {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.locks.isLocalLocked(peerIdKey)
+    public hasConnection(nodeId: DhtAddress): boolean {
+        return this.connections.has(nodeId)
     }
 
-    public hasRemoteLockedConnection(peerDescriptor: PeerDescriptor): boolean {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.locks.isRemoteLocked(peerIdKey)
+    public hasLocalLockedConnection(nodeId: DhtAddress): boolean {
+        return this.locks.isLocalLocked(nodeId)
     }
 
-    private canConnect(peerDescriptor: PeerDescriptor): boolean {
-        // Perhaps the connection's state should be checked here
-        return !this.hasConnection(peerDescriptor) // TODO: Add port range check
+    public hasRemoteLockedConnection(nodeId: DhtAddress): boolean {
+        return this.locks.isRemoteLocked(nodeId)
     }
 
-    public handleMessage(message: Message): void {
-        logger.trace('Received message of type ' + message.messageType)
-        if (message.messageType !== MessageType.RPC) {
-            logger.trace('Filtered out non-RPC message of type ' + message.messageType)
+    private handleMessage(message: Message): void {
+        const messageType = message.body.oneofKind
+        logger.trace('Received message of type ' + messageType)
+        if (messageType !== 'rpcMessage') {
+            logger.trace('Filtered out non-RPC message of type ' + messageType)
             return
         }
         if (this.duplicateMessageDetector.isMostLikelyDuplicate(message.messageId)) {
-            logger.trace('handleMessage filtered duplicate ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!) 
+            logger.trace('handleMessage filtered duplicate ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             return
         }
@@ -331,12 +326,20 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (message.serviceId === INTERNAL_SERVICE_ID) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!) 
+            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
     }
 
+    public handleIncomingMessage(message: Message): boolean {
+        if (message.serviceId === INTERNAL_SERVICE_ID) {
+            this.rpcCommunicator?.handleMessageFromPeer(message)
+            return true
+        }
+        return false
+    }
+
     private onData(data: Uint8Array, peerDescriptor: PeerDescriptor): void {
         if (this.state === ConnectionManagerState.STOPPED) {
             return
@@ -346,7 +349,6 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         let message: Message | undefined
         try {
             message = Message.fromBinary(data)
-            logger.trace(`received protojson: ${protoToString(message, Message)}`)
         } catch (e) {
             logger.debug(`Parsing incoming data into Message failed: ${e}`)
             return
@@ -367,26 +369,21 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private onDisconnected(connection: ManagedConnection, gracefulLeave: boolean) {
-        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
-
-        const peerIdKey = keyFromPeerDescriptor(connection.getPeerDescriptor()!)
-        const storedConnection = this.connections.get(peerIdKey)
-        if (storedConnection && storedConnection.connectionId.equals(connection.connectionId)) {
-            this.locks.clearAllLocks(peerIdKey)
-            this.connections.delete(peerIdKey)
-            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
-                + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave)
+        const nodeId = getNodeIdFromPeerDescriptor(connection.getPeerDescriptor()!)
+        logger.trace(nodeId + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
+        const storedConnection = this.connections.get(nodeId)
+        if (storedConnection && (storedConnection.connectionId === connection.connectionId)) {
+            this.locks.clearAllLocks(nodeId)
+            this.connections.delete(nodeId)
+            logger.trace(nodeId + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave)
             this.emit('disconnected', connection.getPeerDescriptor()!, gracefulLeave)
             this.onConnectionCountChange()
         } else {
-            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
-                + ' onDisconnected() did nothing, no such connection in connectionManager')
+            logger.trace(nodeId + ' onDisconnected() did nothing, no such connection in connectionManager')
             if (storedConnection) {
-                logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
-                + ' connectionIds do not match ' + storedConnection.connectionId + ' ' + connection.connectionId)
+                logger.trace(nodeId + ' connectionIds do not match ' + storedConnection.connectionId + ' ' + connection.connectionId.toString())
             }
         }
-
     }
 
     private onNewConnection(connection: ManagedConnection): boolean {
@@ -394,7 +391,6 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return false
         }
         logger.trace('onNewConnection()')
-        connection.offeredAsIncoming = true
         if (!this.acceptNewConnection(connection)) {
             return false
         }
@@ -413,22 +409,20 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private acceptNewConnection(newConnection: ManagedConnection): boolean {
-        logger.trace(getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' acceptIncomingConnection()')
-        const newPeerID = peerIdFromPeerDescriptor(newConnection.getPeerDescriptor()!)
-        const peerIdKey = keyFromPeerDescriptor(newConnection.getPeerDescriptor()!)
-        if (this.connections.has(peerIdKey)) {
-            if (newPeerID.hasSmallerHashThan(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
-                logger.trace(getNodeIdOrUnknownFromPeerDescriptor(newConnection.getPeerDescriptor())
-                    + ' acceptIncomingConnection() replace current connection')
+        const nodeId = getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!)
+        logger.trace(nodeId + ' acceptIncomingConnection()')
+        if (this.connections.has(nodeId)) {
+            if (getOfferer(getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), nodeId) === 'remote') {
+                logger.trace(nodeId + ' acceptIncomingConnection() replace current connection')
                 // replace the current connection
-                const oldConnection = this.connections.get(newPeerID.toKey())!
-                logger.trace('replaced: ' + getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!))
+                const oldConnection = this.connections.get(nodeId)!
+                logger.trace('replaced: ' + nodeId)
                 const buffer = oldConnection.stealOutputBuffer()
-                
+
                 for (const data of buffer) {
                     newConnection.sendNoWait(data)
                 }
-                
+
                 oldConnection.reportBufferSentByOtherConnection()
                 oldConnection.replacedByOtherConnection = true
             } else {
@@ -436,22 +430,22 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             }
         }
 
-        logger.trace(getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' added to connections at acceptIncomingConnection')
-        this.connections.set(peerIdKey, newConnection)
+        logger.trace(nodeId + ' added to connections at acceptIncomingConnection')
+        this.connections.set(nodeId, newConnection)
 
         return true
     }
 
     private async closeConnection(peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string): Promise<void> {
-        logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() ' + reason)
-        const id = keyFromPeerDescriptor(peerDescriptor)
-        this.locks.clearAllLocks(id)
-        if (this.connections.has(id)) {
-            const connectionToClose = this.connections.get(id)!
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        logger.trace(nodeId + ' ' + 'closeConnection() ' + reason)
+        this.locks.clearAllLocks(nodeId)
+        if (this.connections.has(nodeId)) {
+            const connectionToClose = this.connections.get(nodeId)!
             await connectionToClose.close(gracefulLeave)
 
         } else {
-            logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() this.connections did not have the id')
+            logger.trace(nodeId + ' ' + 'closeConnection() this.connections did not have the id')
             this.emit('disconnected', peerDescriptor, false)
         }
     }
@@ -460,13 +454,14 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
-            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
         )
-        this.locks.addLocalLocked(peerIdKey, lockId)
+        this.locks.addLocalLocked(nodeId, lockId)
         rpcRemote.lockRequest(lockId)
             .then((_accepted) => logger.trace('LockRequest successful'))
             .catch((err) => { logger.debug(err) })
@@ -476,38 +471,36 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.removeLocalLocked(peerIdKey, lockId)
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        this.locks.removeLocalLocked(nodeId, lockId)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
-            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
         )
-        if (this.connections.has(peerIdKey)) {
+        if (this.connections.has(nodeId)) {
             rpcRemote.unlockRequest(lockId)
         }
     }
 
-    public weakLockConnection(targetDescriptor: PeerDescriptor): void {
-        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
+    public weakLockConnection(nodeId: DhtAddress, lockId: LockID): void {
+        if (this.state === ConnectionManagerState.STOPPED || (nodeId === getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.addWeakLocked(peerIdKey)
+        this.locks.addWeakLocked(nodeId, lockId)
     }
 
-    public weakUnlockConnection(targetDescriptor: PeerDescriptor): void {
-        if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
+    public weakUnlockConnection(nodeId: DhtAddress, lockId: LockID): void {
+        if (this.state === ConnectionManagerState.STOPPED || (nodeId === getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.removeWeakLocked(peerIdKey)
-
+        this.locks.removeWeakLocked(nodeId, lockId)
     }
 
     private async gracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
 
-        const connection = this.connections.get(peerIdFromPeerDescriptor(targetDescriptor).toKey())
+        const connection = this.connections.get(getNodeIdFromPeerDescriptor(targetDescriptor))
 
         if (!connection) {
             logger.debug('gracefullyDisconnectedAsync() tried on a non-existing connection')
@@ -515,6 +508,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         }
 
         const promise = new Promise<void>((resolve, _reject) => {
+            // TODO use config option or named constant?
             // eslint-disable-next-line promise/catch-or-return
             waitForEvent3<ManagedConnectionEvents>(connection, 'disconnected', 2000).then(() => {
                 logger.trace('disconnected event received in gracefullyDisconnectAsync()')
@@ -522,6 +516,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             })
                 .catch((e) => {
                     logger.trace('force-closing connection after timeout ' + e)
+                    // TODO should we have some handling for this floating promise?
                     connection.close(true)
                 })
                 .finally(() => {
@@ -530,30 +525,29 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
                 })
         })
 
-        this.doGracefullyDisconnectAsync(targetDescriptor, disconnectMode)
-            .then(() => { return })
-            .catch((e) => {
-                logger.error(e)
-            })
-
-        await promise
+        await Promise.all([
+            promise,
+            this.doGracefullyDisconnectAsync(targetDescriptor, disconnectMode)
+        ])
     }
 
     private async doGracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
-        logger.trace(getNodeIdFromPeerDescriptor(targetDescriptor) + ' gracefullyDisconnectAsync()')
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        logger.trace(nodeId + ' gracefullyDisconnectAsync()')
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
-            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
         )
         try {
             await rpcRemote.gracefulDisconnect(disconnectMode)
         } catch (ex) {
-            logger.trace(getNodeIdFromPeerDescriptor(targetDescriptor) + ' remote.gracefulDisconnect() failed' + ex)
+            logger.trace(nodeId + ' remote.gracefulDisconnect() failed' + ex)
         }
     }
 
-    public getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+    public getConnections(): PeerDescriptor[] {
         return Array.from(this.connections.values())
             .filter((managedConnection: ManagedConnection) => managedConnection.isHandshakeCompleted())
             .map((managedConnection: ManagedConnection) => managedConnection.getPeerDescriptor()!)

package/src/connection/ConnectorFacade.ts

@@ -10,13 +10,14 @@ import { Simulator } from './simulator/Simulator'
 import { SimulatorConnector } from './simulator/SimulatorConnector'
 import { IceServer, WebrtcConnector } from './webrtc/WebrtcConnector'
 import { WebsocketConnector, WebsocketConnectorConfig } from './websocket/WebsocketConnector'
+import { DhtAddress } from '../identifiers'
 
 export interface ConnectorFacade {
     createConnection: (peerDescriptor: PeerDescriptor) => ManagedConnection
     getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
         onNewConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
+        hasConnection: (nodeId: DhtAddress) => boolean,
         autoCertifierTransport: ITransport
     ) => Promise<void>
     stop: () => Promise<void>
@@ -39,6 +40,7 @@ export interface DefaultConnectorFacadeConfig {
     webrtcPortRange?: PortRange
     maxMessageSize?: number
     tlsCertificate?: TlsCertificate
+    // TODO explicit default value for "websocketServerEnableTls" or make it required
     websocketServerEnableTls?: boolean
     autoCertifierUrl?: string
     autoCertifierConfigFile?: string
@@ -51,22 +53,21 @@ export class DefaultConnectorFacade implements ConnectorFacade {
     private localPeerDescriptor?: PeerDescriptor
     private websocketConnector?: WebsocketConnector
     private webrtcConnector?: WebrtcConnector
-
     constructor(config: DefaultConnectorFacadeConfig) {
         this.config = config
     }
 
     async start(
         onNewConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
+        hasConnection: (nodeId: DhtAddress) => boolean,
         autoCertifierTransport: ITransport
     ): Promise<void> {
         logger.trace(`Creating WebsocketConnectorRpcLocal`)
         const webSocketConnectorConfig = {
-            transport: this.config.transport!,
+            transport: this.config.transport,
             // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
-            canConnect: (peerDescriptor: PeerDescriptor) => canConnect(peerDescriptor),
             onNewConnection,
+            hasConnection,
             portRange: this.config.websocketPortRange,
             host: this.config.websocketHost,
             entrypoints: this.config.entryPoints,
@@ -80,7 +81,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
         this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
         logger.trace(`Creating WebRtcConnectorRpcLocal`)
         this.webrtcConnector = new WebrtcConnector({
-            transport: this.config.transport!,
+            transport: this.config.transport,
             iceServers: this.config.iceServers,
             allowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
             bufferThresholdLow: this.config.webrtcDatachannelBufferThresholdLow,
@@ -101,8 +102,8 @@ export class DefaultConnectorFacade implements ConnectorFacade {
         this.setLocalPeerDescriptor(localPeerDescriptor)
         if (localPeerDescriptor.websocket && !this.config.tlsCertificate && this.config.websocketServerEnableTls) {
             try {
-                await this.websocketConnector!.autoCertify()
-                const connectivityResponse = await this.websocketConnector!.checkConnectivity(false)
+                await this.websocketConnector.autoCertify()
+                const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
                 const autocertifiedLocalPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
                 if (autocertifiedLocalPeerDescriptor.websocket !== undefined) {
                     this.setLocalPeerDescriptor(autocertifiedLocalPeerDescriptor)
@@ -114,7 +115,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
                     })
                 }
             } catch (err) {
-                logger.warn('Failed to auto-certify, disabling WebSocket server TLS')
+                logger.warn('Failed to auto-certify, disabling WebSocket server TLS', { error: err })
                 await this.restartWebsocketConnector({
                     ...webSocketConnectorConfig,
                     serverEnableTls: false