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

package/protos/DhtRpc.proto

@@ -196,14 +196,18 @@ message ConnectivityResponse {
 }
 
 message HandshakeRequest {
-  bytes sourceId = 1;
-  PeerDescriptor peerDescriptor = 2;
+  PeerDescriptor sourcePeerDescriptor = 1;
+  optional PeerDescriptor targetPeerDescriptor = 2;
 }
 
 message HandshakeResponse {
-  bytes sourceId = 1;
-  PeerDescriptor peerDescriptor = 2;
-  optional string responseError = 3;
+  PeerDescriptor sourcePeerDescriptor = 1;
+  optional HandshakeError error = 2;
+}
+
+enum HandshakeError {
+  DUPLICATE_CONNECTION = 0;
+  INVALID_TARGET_PEER_DESCRIPTOR = 1;
 }
 
 // Wraps all messages

package/src/connection/ConnectionLockRpcLocal.ts

@@ -17,7 +17,7 @@ import {
 import { IConnectionLockRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { PeerIDKey } from '../helpers/PeerID'
-import { keyOrUnknownFromPeerDescriptor } from './ConnectionManager'
+import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
 import { LockID } from './ConnectionLockHandler'
 
 interface ConnectionLockRpcLocalConfig {
@@ -62,7 +62,7 @@ export class ConnectionLockRpcLocal implements IConnectionLockRpc {
 
     async gracefulDisconnect(disconnectNotice: DisconnectNotice, context: ServerCallContext): Promise<Empty> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        logger.trace(keyOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice')
+        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice')
 
         if (disconnectNotice.disconnectMode === DisconnectMode.LEAVING) {
             this.config.closeConnection(senderPeerDescriptor, true, 'graceful leave notified')

package/src/connection/ConnectionLockRpcRemote.ts

@@ -2,9 +2,8 @@ import { Logger } from '@streamr/utils'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { IConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { LockRequest, UnlockRequest, PeerDescriptor, DisconnectNotice, DisconnectMode } from '../proto/packages/dht/protos/DhtRpc'
-
 import * as Err from '../helpers/errors'
-import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Remote } from '../dht/contact/Remote'
 import { LockID } from './ConnectionLockHandler'
 
@@ -21,7 +20,7 @@ export class ConnectionLockRpcRemote extends Remote<IConnectionLockRpcClient> {
     }
 
     public async lockRequest(lockId: LockID): Promise<boolean> {
-        logger.trace(`Requesting locked connection to ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting locked connection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: LockRequest = {
             lockId
         }
@@ -36,7 +35,7 @@ export class ConnectionLockRpcRemote extends Remote<IConnectionLockRpcClient> {
     }
 
     public unlockRequest(lockId: LockID): void {
-        logger.trace(`Requesting connection to be unlocked from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting connection to be unlocked from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: UnlockRequest = {
             lockId
         }
@@ -49,7 +48,7 @@ export class ConnectionLockRpcRemote extends Remote<IConnectionLockRpcClient> {
     }
 
     public async gracefulDisconnect(disconnectMode: DisconnectMode): Promise<void> {
-        logger.trace(`Notifying a graceful disconnect to ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Notifying a graceful disconnect to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: DisconnectNotice = {
             disconnectMode
         }

package/src/connection/ConnectionManager.ts

@@ -8,6 +8,7 @@ import { PeerIDKey } from '../helpers/PeerID'
 import * as Err from '../helpers/errors'
 import {
     areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../helpers/peerIdFromPeerDescriptor'
@@ -66,10 +67,6 @@ enum ConnectionManagerState {
     STOPPED = 'stopped'
 }
 
-interface ConnectionManagerEvents {
-    newConnection: (connection: ManagedConnection) => void
-}
-
 export interface ConnectionLocker {
     lockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void
     unlockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void
@@ -87,8 +84,6 @@ export interface TlsCertificate {
     certFileName: string
 }
 
-export type Events = TransportEvents & ConnectionManagerEvents
-
 const INTERNAL_SERVICE_ID = 'system/connection-manager'
 
 // Form an string representation from a peer description which can be undefined. This output 
@@ -100,15 +95,15 @@ 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 keyOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => { 
+export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => { 
     if (peerDescriptor !== undefined) {
-        return keyFromPeerDescriptor(peerDescriptor)
+        return getNodeIdFromPeerDescriptor(peerDescriptor)
     } else {
         return 'unknown'
     }
 }
 
-export class ConnectionManager extends EventEmitter<Events> implements ITransport, ConnectionLocker {
+export class ConnectionManager extends EventEmitter<TransportEvents> implements ITransport, ConnectionLocker {
 
     private config: ConnectionManagerConfig
     private readonly metricsContext: MetricsContext
@@ -126,7 +121,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         this.config = config
         this.onData = this.onData.bind(this)
         this.send = this.send.bind(this)
-        this.onIncomingConnection = this.onIncomingConnection.bind(this)
+        this.onNewConnection = this.onNewConnection.bind(this)
         this.metricsContext = this.config.metricsContext ?? new MetricsContext()
         this.metrics = {
             sendMessagesPerSecond: new RateMetric(),
@@ -165,14 +160,14 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         const disconnectionCandidates = new SortedContactList<Contact>(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 100000)
         this.connections.forEach((connection) => {
             if (!this.locks.isLocked(connection.peerIdKey) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
-                logger.trace('disconnecting in timeout interval: ' + keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
+                logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
                 disconnectionCandidates.addContact(new Contact(connection.getPeerDescriptor()!))
             }
         })
         const sortedCandidates = disconnectionCandidates.getAllContacts()
         const targetNum = this.connections.size - maxConnections
         for (let i = 0; i < sortedCandidates.length && i < targetNum; i++) {
-            logger.trace('garbageCollecting ' + keyFromPeerDescriptor(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor()))
+            logger.trace('garbageCollecting ' + getNodeIdFromPeerDescriptor(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor()))
             this.gracefullyDisconnectAsync(sortedCandidates[sortedCandidates.length - 1 - i].getPeerDescriptor(),
                 DisconnectMode.NORMAL).catch((_e) => { })
         }
@@ -185,7 +180,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         this.state = ConnectionManagerState.RUNNING
         logger.trace(`Starting ConnectionManager...`)
         await this.connectorFacade.start(
-            (connection: ManagedConnection) => this.onIncomingConnection(connection),
+            (connection: ManagedConnection) => this.onNewConnection(connection),
             (peerDescriptor: PeerDescriptor) => this.canConnect(peerDescriptor),
             this
         )
@@ -259,7 +254,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new Err.CannotConnectToSelf('Cannot send to self')
         }
-        logger.trace(`Sending message to: ${keyFromPeerDescriptor(peerDescriptor)}`)
+        logger.trace(`Sending message to: ${getNodeIdFromPeerDescriptor(peerDescriptor)}`)
         message = {
             ...message,
             sourceDescriptor: this.getLocalPeerDescriptor()
@@ -268,7 +263,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         let connection = this.connections.get(peerIdKey)
         if (!connection && !doNotConnect) {
             connection = this.connectorFacade.createConnection(peerDescriptor)
-            this.onIncomingConnection(connection)
+            this.onNewConnection(connection)
         } else if (!connection) {
             throw new Err.SendFailed('No connection to target, doNotConnect flag is true')
         }
@@ -328,7 +323,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             return
         }
         if (this.duplicateMessageDetector.isMostLikelyDuplicate(message.messageId)) {
-            logger.trace('handleMessage filtered duplicate ' + keyFromPeerDescriptor(message.sourceDescriptor!) 
+            logger.trace('handleMessage filtered duplicate ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!) 
                 + ' ' + message.serviceId + ' ' + message.messageId)
             return
         }
@@ -336,7 +331,8 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         if (message.serviceId === INTERNAL_SERVICE_ID) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + keyFromPeerDescriptor(message.sourceDescriptor!) + ' ' + message.serviceId + ' ' + message.messageId)
+            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!) 
+                + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
     }
@@ -366,47 +362,46 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
     private onConnected(connection: ManagedConnection) {
         const peerDescriptor = connection.getPeerDescriptor()!
         this.emit('connected', peerDescriptor)
-        logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' onConnected() ' + connection.connectionType)
+        logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' onConnected() ' + connection.connectionType)
         this.onConnectionCountChange()
     }
 
     private onDisconnected(connection: ManagedConnection, gracefulLeave: boolean) {
-        logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
+        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(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
+            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
                 + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave)
             this.emit('disconnected', connection.getPeerDescriptor()!, gracefulLeave)
             this.onConnectionCountChange()
         } else {
-            logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
+            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
                 + ' onDisconnected() did nothing, no such connection in connectionManager')
             if (storedConnection) {
-                logger.trace(keyOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
+                logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
                 + ' connectionIds do not match ' + storedConnection.connectionId + ' ' + connection.connectionId)
             }
         }
 
     }
 
-    private onIncomingConnection(connection: ManagedConnection): boolean {
+    private onNewConnection(connection: ManagedConnection): boolean {
         if (this.state === ConnectionManagerState.STOPPED) {
             return false
         }
-        logger.trace('onIncomingConnection()')
+        logger.trace('onNewConnection()')
         connection.offeredAsIncoming = true
-        if (!this.acceptIncomingConnection(connection)) {
+        if (!this.acceptNewConnection(connection)) {
             return false
         }
         connection.on('managedData', this.onData)
         connection.on('disconnected', (gracefulLeave: boolean) => {
             this.onDisconnected(connection, gracefulLeave)
         })
-        this.emit('newConnection', connection)
         if (connection.isHandshakeCompleted()) {
             this.onConnected(connection)
         } else {
@@ -417,17 +412,17 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         return true
     }
 
-    private acceptIncomingConnection(newConnection: ManagedConnection): boolean {
-        logger.trace(keyFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' acceptIncomingConnection()')
+    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(keyOrUnknownFromPeerDescriptor(newConnection.getPeerDescriptor())
+                logger.trace(getNodeIdOrUnknownFromPeerDescriptor(newConnection.getPeerDescriptor())
                     + ' acceptIncomingConnection() replace current connection')
                 // replace the current connection
                 const oldConnection = this.connections.get(newPeerID.toKey())!
-                logger.trace('replaced: ' + keyFromPeerDescriptor(newConnection.getPeerDescriptor()!))
+                logger.trace('replaced: ' + getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!))
                 const buffer = oldConnection.stealOutputBuffer()
                 
                 for (const data of buffer) {
@@ -437,19 +432,18 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
                 oldConnection.reportBufferSentByOtherConnection()
                 oldConnection.replacedByOtherConnection = true
             } else {
-                newConnection.rejectedAsIncoming = true
                 return false
             }
         }
 
-        logger.trace(keyFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' added to connections at acceptIncomingConnection')
+        logger.trace(getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' added to connections at acceptIncomingConnection')
         this.connections.set(peerIdKey, newConnection)
 
         return true
     }
 
     private async closeConnection(peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string): Promise<void> {
-        logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() ' + reason)
+        logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() ' + reason)
         const id = keyFromPeerDescriptor(peerDescriptor)
         this.locks.clearAllLocks(id)
         if (this.connections.has(id)) {
@@ -457,7 +451,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             await connectionToClose.close(gracefulLeave)
 
         } else {
-            logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() this.connections did not have the id')
+            logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() this.connections did not have the id')
             this.emit('disconnected', peerDescriptor, false)
         }
     }
@@ -546,7 +540,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
     }
 
     private async doGracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
-        logger.trace(keyFromPeerDescriptor(targetDescriptor) + ' gracefullyDisconnectAsync()')
+        logger.trace(getNodeIdFromPeerDescriptor(targetDescriptor) + ' gracefullyDisconnectAsync()')
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
@@ -555,7 +549,7 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         try {
             await rpcRemote.gracefulDisconnect(disconnectMode)
         } catch (ex) {
-            logger.trace(keyFromPeerDescriptor(targetDescriptor) + ' remote.gracefulDisconnect() failed' + ex)
+            logger.trace(getNodeIdFromPeerDescriptor(targetDescriptor) + ' remote.gracefulDisconnect() failed' + ex)
         }
     }
 

package/src/connection/ConnectivityChecker.ts

@@ -1,5 +1,4 @@
 import {
-    ConnectivityMethod,
     ConnectivityRequest, ConnectivityResponse,
     Message, MessageType, PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
@@ -18,7 +17,6 @@ const logger = new Logger(module)
 // checks. This is attached to all ServerWebsockets to listen to
 // ConnectivityRequest messages. 
 
-export enum ConnectionMode { REQUEST = 'connectivityRequest', PROBE = 'connectivityProbe' }
 export class ConnectivityChecker {
 
     private static readonly CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivity-checker'
@@ -39,18 +37,19 @@ export class ConnectivityChecker {
             throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
         }
         let outgoingConnection: IConnection
+        const wsServerInfo = {
+            host: entryPoint.websocket!.host, 
+            port: entryPoint.websocket!.port,
+            tls: entryPoint.websocket!.tls,
+        }
+        const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityRequest')
         try {
             outgoingConnection = await this.connectAsync({
-                wsServerInfo: {
-                    host: entryPoint.websocket!.host, 
-                    port: entryPoint.websocket!.port,
-                    tls: entryPoint.websocket!.tls,
-                },
-                mode: ConnectionMode.REQUEST,
+                url,
                 selfSigned
             })
         } catch (e) {
-            throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`, e)
+            throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${url}`, e)
         }
         // send connectivity request
         const connectivityRequestMessage: ConnectivityRequest = { port: this.websocketPort, host: this.host, tls: this.tls, selfSigned }
@@ -140,10 +139,10 @@ export class ConnectivityChecker {
                 port: connectivityRequest.port,
                 tls: connectivityRequest.tls
             }
-            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebsocketUrl(wsServerInfo)}`)
+            const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityProbe')
+            logger.trace(`Attempting Connectivity Check to ${url}`)
             outgoingConnection = await this.connectAsync({
-                wsServerInfo,
-                mode: ConnectionMode.PROBE,
+                url,
                 selfSigned: connectivityRequest.selfSigned
             })
         } catch (err) {
@@ -175,11 +174,10 @@ export class ConnectivityChecker {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    private async connectAsync({ wsServerInfo, mode, selfSigned, timeoutMs = 1000, }:
-        { wsServerInfo: ConnectivityMethod, mode: ConnectionMode, selfSigned: boolean, timeoutMs?: number }
+    private async connectAsync({ url, selfSigned, timeoutMs = 1000, }:
+        { url: string, selfSigned: boolean, timeoutMs?: number }
     ): Promise<IConnection> {
         const socket = new ClientWebsocket()
-        const url = `${connectivityMethodToWebsocketUrl(wsServerInfo)}?${mode}=true`
         let result: RunAndRaceEventsReturnType<ConnectionEvents>
         try {
             result = await runAndRaceEvents3<ConnectionEvents>([

package/src/connection/ConnectorFacade.ts

@@ -9,13 +9,13 @@ import { ManagedConnection } from './ManagedConnection'
 import { Simulator } from './simulator/Simulator'
 import { SimulatorConnector } from './simulator/SimulatorConnector'
 import { IceServer, WebrtcConnector } from './webrtc/WebrtcConnector'
-import { WebsocketConnector } from './websocket/WebsocketConnector'
+import { WebsocketConnector, WebsocketConnectorConfig } from './websocket/WebsocketConnector'
 
 export interface ConnectorFacade {
     createConnection: (peerDescriptor: PeerDescriptor) => ManagedConnection
     getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
-        onIncomingConnection: (connection: ManagedConnection) => boolean,
+        onNewConnection: (connection: ManagedConnection) => boolean,
         canConnect: (peerDescriptor: PeerDescriptor) => boolean,
         autoCertifierTransport: ITransport
     ) => Promise<void>
@@ -57,7 +57,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
     }
 
     async start(
-        onIncomingConnection: (connection: ManagedConnection) => boolean,
+        onNewConnection: (connection: ManagedConnection) => boolean,
         canConnect: (peerDescriptor: PeerDescriptor) => boolean,
         autoCertifierTransport: ITransport
     ): Promise<void> {
@@ -66,7 +66,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             transport: this.config.transport!,
             // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
             canConnect: (peerDescriptor: PeerDescriptor) => canConnect(peerDescriptor),
-            onIncomingConnection,
+            onNewConnection,
             portRange: this.config.websocketPortRange,
             host: this.config.websocketHost,
             entrypoints: this.config.entryPoints,
@@ -89,7 +89,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             externalIp: this.config.externalIp,
             portRange: this.config.webrtcPortRange,
             maxMessageSize: this.config.maxMessageSize
-        }, onIncomingConnection)
+        }, onNewConnection)
         await this.websocketConnector.start()
         // TODO: generate a PeerDescriptor in a single function. Requires changes to the createOwnPeerDescriptor
         // function in the config. Currently it's given by the DhtNode and it sets the PeerDescriptor for the
@@ -97,34 +97,45 @@ export class DefaultConnectorFacade implements ConnectorFacade {
         // LocalPeerDescriptor could be stored in one place and passed from there to the connectors
         const temporarilySelfSigned = (!this.config.tlsCertificate && this.config.websocketServerEnableTls === true)
         const connectivityResponse = await this.websocketConnector.checkConnectivity(temporarilySelfSigned)
-        let localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
-        this.localPeerDescriptor = localPeerDescriptor
-        this.websocketConnector.setLocalPeerDescriptor(localPeerDescriptor)
+        const localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        this.setLocalPeerDescriptor(localPeerDescriptor)
         if (localPeerDescriptor.websocket && !this.config.tlsCertificate && this.config.websocketServerEnableTls) {
             try {
                 await this.websocketConnector!.autoCertify()
                 const connectivityResponse = await this.websocketConnector!.checkConnectivity(false)
-                localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
-                this.localPeerDescriptor = localPeerDescriptor
-                if (localPeerDescriptor.websocket === undefined) {
-                    logger.warn('ConnectivityCheck failed after autocertification, websocket server connectivity disabled')
+                const autocertifiedLocalPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+                if (autocertifiedLocalPeerDescriptor.websocket !== undefined) {
+                    this.setLocalPeerDescriptor(autocertifiedLocalPeerDescriptor)
+                } else {
+                    logger.warn('Connectivity check failed after auto-certification, disabling WebSocket server TLS')
+                    await this.restartWebsocketConnector({
+                        ...webSocketConnectorConfig,
+                        serverEnableTls: false
+                    })
                 }
-                this.websocketConnector!.setLocalPeerDescriptor(localPeerDescriptor)
             } catch (err) {
-                logger.warn('Failed to autocertify, disabling websocket server TLS')
-                await this.websocketConnector.destroy()
-                this.websocketConnector = new WebsocketConnector({
+                logger.warn('Failed to auto-certify, disabling WebSocket server TLS')
+                await this.restartWebsocketConnector({
                     ...webSocketConnectorConfig,
-                    serverEnableTls: false,
+                    serverEnableTls: false
                 })
-                await this.websocketConnector.start()
-                const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
-                localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
-                this.localPeerDescriptor = localPeerDescriptor
-                this.websocketConnector.setLocalPeerDescriptor(localPeerDescriptor)
             }
         }
-        this.webrtcConnector.setLocalPeerDescriptor(localPeerDescriptor)
+    }
+
+    private setLocalPeerDescriptor(peerDescriptor: PeerDescriptor) {
+        this.localPeerDescriptor = peerDescriptor
+        this.websocketConnector!.setLocalPeerDescriptor(peerDescriptor)
+        this.webrtcConnector!.setLocalPeerDescriptor(peerDescriptor)
+    }
+    
+    async restartWebsocketConnector(webSocketConnectorConfig: WebsocketConnectorConfig): Promise<void> {
+        await this.websocketConnector!.destroy()
+        this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
+        await this.websocketConnector.start()
+        const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
+        const localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        this.setLocalPeerDescriptor(localPeerDescriptor)
     }
 
     createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
@@ -156,12 +167,12 @@ export class SimulatorConnectorFacade implements ConnectorFacade {
         this.simulator = simulator
     }
 
-    async start(onIncomingConnection: (connection: ManagedConnection) => boolean): Promise<void> {
+    async start(onNewConnection: (connection: ManagedConnection) => boolean): Promise<void> {
         logger.trace(`Creating SimulatorConnector`)
         this.simulatorConnector = new SimulatorConnector(
             this.localPeerDescriptor,
             this.simulator,
-            onIncomingConnection
+            onNewConnection
         )
         this.simulator.addConnector(this.simulatorConnector)
     }

package/src/connection/Handshaker.ts

@@ -1,15 +1,15 @@
 import { Logger } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { v4 } from 'uuid'
-import { Message, HandshakeRequest, HandshakeResponse, MessageType, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Message, HandshakeRequest, HandshakeResponse, MessageType, PeerDescriptor, HandshakeError } from '../proto/packages/dht/protos/DhtRpc'
 import { IConnection } from './IConnection'
 
 const logger = new Logger(module)
 
 interface HandshakerEvents {
-    handshakeRequest: (peerDescriptor: PeerDescriptor) => void
-    handshakeCompleted: (peerDescriptor: PeerDescriptor) => void
-    handshakeFailed: (reason?: string) => void
+    handshakeRequest: (source: PeerDescriptor, target?: PeerDescriptor) => void
+    handshakeCompleted: (remote: PeerDescriptor) => void
+    handshakeFailed: (error?: HandshakeError) => void
 }
 
 export class Handshaker extends EventEmitter<HandshakerEvents> {
@@ -34,15 +34,15 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
             if (message.body.oneofKind === 'handshakeRequest') {
                 logger.trace('handshake request received')
                 const handshake = message.body.handshakeRequest
-                this.emit('handshakeRequest', handshake.peerDescriptor!)
+                this.emit('handshakeRequest', handshake.sourcePeerDescriptor!, handshake.targetPeerDescriptor)
             }
             if (message.body.oneofKind === 'handshakeResponse') {
                 logger.trace('handshake response received')
                 const handshake = message.body.handshakeResponse
-                if (handshake.responseError) {
-                    this.emit('handshakeFailed', handshake.responseError)
+                if (handshake.error !== undefined) {
+                    this.emit('handshakeFailed', handshake.error)
                 } else {
-                    this.emit('handshakeCompleted', handshake.peerDescriptor!)
+                    this.emit('handshakeCompleted', handshake.sourcePeerDescriptor!)
                 }
             }
         } catch (err) {
@@ -51,10 +51,10 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         
     }
 
-    public sendHandshakeRequest(): void {
+    public sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void {
         const outgoingHandshake: HandshakeRequest = {
-            sourceId: this.localPeerDescriptor.kademliaId,
-            peerDescriptor: this.localPeerDescriptor
+            sourcePeerDescriptor: this.localPeerDescriptor,
+            targetPeerDescriptor: remotePeerDescriptor
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -69,13 +69,10 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         logger.trace('handshake request sent')
     }
 
-    public sendHandshakeResponse(error?: string): void {
+    public sendHandshakeResponse(error?: HandshakeError): void {
         const outgoingHandshakeResponse: HandshakeResponse = {
-            sourceId: this.localPeerDescriptor.kademliaId,
-            peerDescriptor: this.localPeerDescriptor
-        }
-        if (error) {
-            outgoingHandshakeResponse.responseError = error
+            sourcePeerDescriptor: this.localPeerDescriptor,
+            error
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -87,6 +84,6 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
             }
         }
         this.connection.send(Message.toBinary(msg))
-        logger.trace('handshake request sent')
+        logger.trace('handshake response sent')
     }
 }