@streamr/dht 0.0.1-tatum.5 → 0.0.1-tatum.7

package/src/connection/ConnectivityChecker.ts

@@ -21,7 +21,7 @@ const logger = new Logger(module)
 export enum ConnectionMode { REQUEST = 'connectivityRequest', PROBE = 'connectivityProbe' }
 export class ConnectivityChecker {
 
-    private static readonly CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivitychecker'
+    private static readonly CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivity-checker'
     private static readonly CONNECTIVITY_CHECKER_TIMEOUT = 5000
     private destroyed = false
     private readonly webSocketPort: number
@@ -49,7 +49,7 @@ export class ConnectivityChecker {
                 mode: ConnectionMode.REQUEST
             })
         } catch (e) {
-            throw new Err.ConnectionFailed('Failed to connect to the entrypoints', e)
+            throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${connectivityMethodToWebSocketUrl(entryPoint.websocket!)}`, e)
         }
         // send connectivity request
         const connectivityRequestMessage: ConnectivityRequest = { port: this.webSocketPort, host: this.host, tls: this.tls }
@@ -72,6 +72,7 @@ export class ConnectivityChecker {
                     try {
                         const message: Message = Message.fromBinary(bytes)
                         if (message.body.oneofKind === 'connectivityResponse') {
+                            logger.trace('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
                             const connectivityResponseMessage = message.body.connectivityResponse
                             outgoingConnection!.off('data', listener)
                             clearTimeout(timeoutId)
@@ -88,9 +89,8 @@ export class ConnectivityChecker {
         }
         try {
             const retPromise = responseAwaiter()
-            logger.trace('trying to send connectivity request')
             outgoingConnection.send(Message.toBinary(msg))
-            logger.debug('connectivity request sent: ' + JSON.stringify(Message.toJson(msg)))
+            logger.trace('ConnectivityRequest sent: ' + JSON.stringify(Message.toJson(msg)))
             return await retPromise
         } catch (e) {
             logger.error('error getting connectivityresponse')
@@ -104,7 +104,7 @@ export class ConnectivityChecker {
             try {
                 const message = Message.fromBinary(data)
                 if (message.body.oneofKind === 'connectivityRequest') {
-                    logger.trace('received connectivity request')
+                    logger.trace('ConnectivityRequest received: ' + JSON.stringify(Message.toJson(message)))
                     this.handleIncomingConnectivityRequest(connectionToListenTo, message.body.connectivityRequest).then(() => {
                         logger.trace('handleIncomingConnectivityRequest ok')
                         return
@@ -130,12 +130,14 @@ export class ConnectivityChecker {
         let connectivityResponseMessage: ConnectivityResponse | undefined
         const host = connectivityRequest.host ?? connection.getRemoteAddress()
         try {
+            const wsServerInfo = {
+                host,
+                port: connectivityRequest.port,
+                tls: connectivityRequest.tls
+            }
+            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebSocketUrl(wsServerInfo)}`)
             outgoingConnection = await this.connectAsync({
-                wsServerInfo: {
-                    host,
-                    port: connectivityRequest.port,
-                    tls: connectivityRequest.tls
-                },
+                wsServerInfo,
                 mode: ConnectionMode.PROBE
             })
         } catch (err) {
@@ -148,7 +150,7 @@ export class ConnectivityChecker {
         }
         if (outgoingConnection) {
             outgoingConnection.close('OTHER')
-            logger.trace('Connectivity test produced positive result, communicating reply to the requester')
+            logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
             connectivityResponseMessage = {
                 openInternet: true,
                 host,
@@ -165,6 +167,7 @@ export class ConnectivityChecker {
             }
         }
         connection.send(Message.toBinary(msg))
+        logger.trace('ConnectivityResponse sent: ' + JSON.stringify(Message.toJson(msg)))
     }
 
     // eslint-disable-next-line class-methods-use-this

package/src/connection/ConnectorFacade.ts

@@ -0,0 +1,143 @@
+import { Logger } from '@streamr/utils'
+import {
+    ConnectivityResponse,
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { ITransport } from '../transport/ITransport'
+import { ConnectionManager, PortRange, TlsCertificate } from './ConnectionManager'
+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'
+
+export interface ConnectorFacade {
+    createConnection: (peerDescriptor: PeerDescriptor) => ManagedConnection
+    getOwnPeerDescriptor: () => PeerDescriptor | undefined
+    start: (
+        onIncomingConnection: (connection: ManagedConnection) => boolean,
+        canConnect: (peerDescriptor: PeerDescriptor) => boolean
+    ) => Promise<void>
+    stop: () => Promise<void>
+}
+
+const logger = new Logger(module)
+
+export interface DefaultConnectorFacadeConfig {
+    transport: ITransport
+    websocketHost?: string
+    websocketPortRange?: PortRange
+    entryPoints?: PeerDescriptor[]
+    iceServers?: IceServer[]
+    webrtcAllowPrivateAddresses?: boolean
+    webrtcDatachannelBufferThresholdLow?: number
+    webrtcDatachannelBufferThresholdHigh?: number
+    webrtcNewConnectionTimeout?: number
+    externalIp?: string
+    webrtcPortRange?: PortRange
+    maxMessageSize?: number
+    tlsCertificate?: TlsCertificate
+    createOwnPeerDescriptor: (connectivityResponse: ConnectivityResponse) => PeerDescriptor
+}
+
+export class DefaultConnectorFacade implements ConnectorFacade {
+
+    private readonly config: DefaultConnectorFacadeConfig
+    private ownPeerDescriptor?: PeerDescriptor
+    private webSocketConnector?: WebSocketConnector
+    private webrtcConnector?: WebRtcConnector
+
+    constructor(config: DefaultConnectorFacadeConfig) {
+        this.config = config
+    }
+
+    async start(
+        onIncomingConnection: (connection: ManagedConnection) => boolean,
+        canConnect: (peerDescriptor: PeerDescriptor) => boolean
+    ): Promise<void> {
+        logger.trace(`Creating WebSocketConnector`)
+        this.webSocketConnector = new WebSocketConnector({
+            protocolVersion: ConnectionManager.PROTOCOL_VERSION,
+            transport: this.config.transport!,
+            // TODO should we use canConnect also for WebRtcConnector? (NET-1142)
+            canConnect: (peerDescriptor: PeerDescriptor) => canConnect(peerDescriptor),
+            onIncomingConnection,
+            portRange: this.config.websocketPortRange,
+            host: this.config.websocketHost,
+            entrypoints: this.config.entryPoints,
+            tlsCertificate: this.config.tlsCertificate,
+            maxMessageSize: this.config.maxMessageSize
+        })
+        logger.trace(`Creating WebRTCConnector`)
+        this.webrtcConnector = new WebRtcConnector({
+            transport: this.config.transport!,
+            protocolVersion: ConnectionManager.PROTOCOL_VERSION,
+            iceServers: this.config.iceServers,
+            allowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
+            bufferThresholdLow: this.config.webrtcDatachannelBufferThresholdLow,
+            bufferThresholdHigh: this.config.webrtcDatachannelBufferThresholdHigh,
+            connectionTimeout: this.config.webrtcNewConnectionTimeout,
+            externalIp: this.config.externalIp,
+            portRange: this.config.webrtcPortRange,
+            maxMessageSize: this.config.maxMessageSize
+        }, onIncomingConnection)
+        await this.webSocketConnector.start()
+        const connectivityResponse = await this.webSocketConnector.checkConnectivity()
+        const ownPeerDescriptor = this.config.createOwnPeerDescriptor(connectivityResponse)
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.webSocketConnector.setOwnPeerDescriptor(ownPeerDescriptor)
+        this.webrtcConnector.setOwnPeerDescriptor(ownPeerDescriptor)
+    }
+
+    createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
+        if (this.webSocketConnector!.isPossibleToFormConnection(peerDescriptor)) {
+            return this.webSocketConnector!.connect(peerDescriptor)
+        } else {
+            return this.webrtcConnector!.connect(peerDescriptor)
+        }
+    }
+
+    getOwnPeerDescriptor(): PeerDescriptor | undefined {
+        return this.ownPeerDescriptor
+    }
+
+    async stop(): Promise<void> {
+        await this.webSocketConnector!.destroy()
+        await this.webrtcConnector!.stop()
+    }
+}
+
+export class SimulatorConnectorFacade implements ConnectorFacade {
+
+    private readonly ownPeerDescriptor: PeerDescriptor
+    private simulatorConnector?: SimulatorConnector
+    private simulator: Simulator
+
+    constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.simulator = simulator
+    }
+
+    async start(onIncomingConnection: (connection: ManagedConnection) => boolean): Promise<void> {
+        logger.trace(`Creating SimulatorConnector`)
+        this.simulatorConnector = new SimulatorConnector(
+            ConnectionManager.PROTOCOL_VERSION,
+            this.ownPeerDescriptor,
+            this.simulator,
+            onIncomingConnection
+        )
+        this.simulator.addConnector(this.simulatorConnector)
+    }
+
+    createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
+        return this.simulatorConnector!.connect(peerDescriptor)
+    }
+
+    getOwnPeerDescriptor(): PeerDescriptor {
+        return this.ownPeerDescriptor
+    }
+
+    async stop(): Promise<void> {
+        await this.simulatorConnector!.stop()
+    }
+}

package/src/connection/ManagedConnection.ts

@@ -7,6 +7,7 @@ import EventEmitter from 'eventemitter3'
 import { PeerIDKey } from '../helpers/PeerID'
 import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { DisconnectionType } from '../transport/ITransport'
+import { keyOrUnknownFromPeerDescriptor } from './ConnectionManager'
 
 export interface ManagedConnectionEvents {
     managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void
@@ -23,8 +24,6 @@ const logger = new Logger(module)
 export type Events = ManagedConnectionEvents & ConnectionEvents
 export class ManagedConnection extends EventEmitter<Events> {
 
-    private static objectCounter = 0
-    public objectId = 0
     private implementation?: IConnection
 
     private outputBuffer: Uint8Array[] = []
@@ -58,8 +57,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         incomingConnection?: IConnection,
     ) {
         super()
-        this.objectId = ManagedConnection.objectCounter
-        ManagedConnection.objectCounter++
 
         this.send = this.send.bind(this)
 
@@ -72,7 +69,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         this.onDisconnected = this.onDisconnected.bind(this)
 
-        logger.trace('creating ManagedConnection of type: ' + connectionType + ' objectId: ' + this.objectId)
+        logger.trace('creating ManagedConnection of type: ' + connectionType)
         if (incomingConnection && outgoingConnection) {
             throw new Err.IllegalArguments('Managed connection constructor only accepts either an incoming connection OR a outgoing connection')
         }
@@ -81,15 +78,14 @@ export class ManagedConnection extends EventEmitter<Events> {
             this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, outgoingConnection)
 
             this.handshaker.once('handshakeFailed', (errorMessage) => {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName + ' handshakeFailed: ' + errorMessage)
+                logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' handshakeFailed: ' + errorMessage)
                 this.emit('handshakeFailed')
             })
 
             this.handshaker.on('handshakeCompleted', (peerDescriptor: PeerDescriptor) => {
-                logger.trace('handshake completed for outgoing connection ' + this.ownPeerDescriptor.nodeName +
-                    ', ' + this.peerDescriptor?.nodeName + ' objectid: ' + this.objectId
+                logger.trace('handshake completed for outgoing connection '
+                    + ', ' + keyOrUnknownFromPeerDescriptor(this.peerDescriptor) 
                     + ' outputBuffer.length: ' + this.outputBuffer.length)
-
                 this.attachImplementation(outgoingConnection)
                 this.onHandshakeCompleted(peerDescriptor)
             })
@@ -124,7 +120,7 @@ export class ManagedConnection extends EventEmitter<Events> {
     ): this {
         if (event === 'managedData' && this.listenerCount('managedData') === 0) {
             while (this.inputBuffer.length > 0) {
-                logger.trace('emptying inputBuffer objectId: ' + this.objectId)
+                logger.trace('emptying inputBuffer')
                 const data = this.inputBuffer.shift()!
                 fn(data, this.getPeerDescriptor())
             }
@@ -142,7 +138,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         if (event === 'managedData' && this.listenerCount('managedData') === 0) {
             if (this.inputBuffer.length > 0) {
                 while (this.inputBuffer.length > 0) {
-                    logger.trace('emptying inputBuffer objectId: ' + this.objectId)
+                    logger.trace('emptying inputBuffer')
                     const data = this.inputBuffer.shift()!
                     fn(data, this.getPeerDescriptor())
                 }
@@ -179,17 +175,16 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.handshakeCompleted = true
 
         while (this.outputBuffer.length > 0) {
-            logger.trace('emptying outputBuffer objectId: ' + this.objectId)
-
+            logger.trace('emptying outputBuffer')
             this.implementation!.send(this.outputBuffer.shift()!)
         }
 
-        logger.trace('emitting handshake_completed, objectId: ' + this.objectId)
+        logger.trace('emitting handshake_completed')
         this.emit('handshakeCompleted', peerDescriptor)
     }
 
-    public attachImplementation(impl: IConnection, _peerDescriptor?: PeerDescriptor): void {
-        logger.trace('attachImplementation() objectId: ' + this.objectId)
+    public attachImplementation(impl: IConnection): void {
+        logger.trace('attachImplementation()')
         this.implementation = impl
 
         impl.on('data', (bytes: Uint8Array) => {
@@ -215,8 +210,8 @@ export class ManagedConnection extends EventEmitter<Events> {
         impl.on('disconnected', this.onDisconnected)
     }
 
-    private onDisconnected(disconnectionType: DisconnectionType, _code?: number, _reason?: string): void {
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName + ' onDisconnected() ' + disconnectionType)
+    private onDisconnected(disconnectionType: DisconnectionType): void {
+        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' onDisconnected() ' + disconnectionType)
         if (this.bufferSentbyOtherConnection) {
             return
         }
@@ -238,7 +233,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         } else if (this.implementation) {
             this.implementation.send(data)
         } else {
-            logger.trace('adding data to outputBuffer objectId: ' + this.objectId)
+            logger.trace('adding data to outputBuffer')
 
             let result: RunAndRaceEventsReturnType<Events>
 
@@ -248,7 +243,7 @@ export class ManagedConnection extends EventEmitter<Events> {
                 result = await runAndRaceEvents3<Events>([() => { this.outputBuffer.push(data) }], this, ['handshakeCompleted', 'handshakeFailed',
                     'bufferSentByOtherConnection', 'closing', 'internal_disconnected'], 15000)
             } catch (e) {
-                logger.debug(`Connection from ${this.ownPeerDescriptor.nodeName} to ${this.peerDescriptor?.nodeName} timed out`)
+                logger.debug(`Connection to ${keyOrUnknownFromPeerDescriptor(this.peerDescriptor)} timed out`)
                 throw e
             }
 
@@ -256,7 +251,7 @@ export class ManagedConnection extends EventEmitter<Events> {
                 this.doNotEmitDisconnected = false
                 this.doDisconnect('OTHER')
             } else if (result.winnerName === 'handshakeFailed') {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName + ' handshakeFailed received')
+                logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' handshakeFailed received')
 
                 if (this.bufferSentbyOtherConnection) {
                     logger.trace('bufferSentByOtherConnection already true')
@@ -269,8 +264,8 @@ export class ManagedConnection extends EventEmitter<Events> {
                         result2 = await raceEvents3<Events>(this,
                             ['bufferSentByOtherConnection', 'closing', 'disconnected'], 15000)
                     } catch (ex) {
-                        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName +
-                            ' Exception from raceEvents3 while waiting bufferSentByOtherConnection or closing ' + ex)
+                        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor)
+                            + ' Exception from raceEvents3 while waiting bufferSentByOtherConnection or closing ' + ex)
                         throw ex
                     }
                     if (result2.winnerName === 'bufferSentByOtherConnection') {
@@ -294,13 +289,13 @@ export class ManagedConnection extends EventEmitter<Events> {
         if (this.implementation) {
             this.implementation.send(data)
         } else {
-            logger.trace('adding data to outputBuffer objectId: ' + this.objectId)
+            logger.trace('adding data to outputBuffer')
             this.outputBuffer.push(data)
         }
     }
 
     public reportBufferSentByOtherConnection(): void {
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName + ' reportBufferSentByOtherConnection')
+        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' reportBufferSentByOtherConnection')
         if (this.handshaker) {
             this.handshaker.removeAllListeners()
         }
@@ -309,11 +304,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.emit('bufferSentByOtherConnection')
     }
 
-    public reportBufferSendingByOtherConnectionFailed(): void {
-        logger.trace('reportBufferSendingByOtherConnectionFailed')
-        this.doDisconnect('OTHER')
-    }
-
     public acceptHandshake(): void {
         // This happens when connectionRequest has been made and answered
         if (this.implementation) {
@@ -336,14 +326,13 @@ export class ManagedConnection extends EventEmitter<Events> {
     }
 
     private doDisconnect(disconnectionType: DisconnectionType) {
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName + ' doDisconnect() emitting')
+        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' doDisconnect() emitting')
 
         if (!this.doNotEmitDisconnected) {
-            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName + ' emitting disconnected')
+            logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' emitting disconnected')
             this.emit('disconnected', disconnectionType)
         } else {
-            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + this.peerDescriptor?.nodeName +
-                ' not emitting disconnected because doNotEmitDisconnected flag is set')
+            logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' not emitting disconnected because doNotEmitDisconnected flag is set')
         }
     }
 

package/src/connection/RemoteConnectionLocker.ts

@@ -5,6 +5,7 @@ import { LockRequest, UnlockRequest, PeerDescriptor, DisconnectNotice, Disconnec
 import { DhtRpcOptions } from '../rpc-protocol/DhtRpcOptions'
 
 import * as Err from '../helpers/errors'
+import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -27,7 +28,7 @@ export class RemoteConnectionLocker {
     }
 
     public async lockRequest(serviceId: string): Promise<boolean> {
-        logger.trace(`Requesting locked connection to ${this.targetPeerDescriptor.kademliaId.toString()}`)
+        logger.trace(`Requesting locked connection to ${keyFromPeerDescriptor(this.targetPeerDescriptor)}`)
         const request: LockRequest = {
             peerDescriptor: this.ownPeerDescriptor,
             protocolVersion: this.protocolVersion,
@@ -47,7 +48,7 @@ export class RemoteConnectionLocker {
     }
 
     public unlockRequest(serviceId: string): void {
-        logger.trace(`Requesting connection to be unlocked from ${this.targetPeerDescriptor.kademliaId.toString()}`)
+        logger.trace(`Requesting connection to be unlocked from ${keyFromPeerDescriptor(this.targetPeerDescriptor)}`)
         const request: UnlockRequest = {
             peerDescriptor: this.ownPeerDescriptor,
             protocolVersion: this.protocolVersion,
@@ -66,7 +67,7 @@ export class RemoteConnectionLocker {
     }
 
     public async gracefulDisconnect(disconnecMode: DisconnectMode): Promise<void> {
-        logger.trace(`Notifying a graceful disconnect to ${this.targetPeerDescriptor.nodeName} from ${this.ownPeerDescriptor.nodeName}`)
+        logger.trace(`Notifying a graceful disconnect to ${keyFromPeerDescriptor(this.targetPeerDescriptor)}`)
         const request: DisconnectNotice = {
             peerDescriptor: this.ownPeerDescriptor,
             protocolVersion: this.protocolVersion,

package/src/connection/Simulator/Simulator.ts

@@ -110,7 +110,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     private fixedLatency?: number
 
     private loopCounter = 0
-    private operationCounter = 0
     private MAX_LOOPS = 1000
 
     private operationQueue: Heap<SimulatorOperation> = new Heap<SimulatorOperation>((a: SimulatorOperation, b: SimulatorOperation) => {
@@ -273,8 +272,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
             && this.operationQueue.peek()!.executionTime <= currentTime) {
             const operation = this.operationQueue.pop()
 
-            this.operationCounter++
-
             if (operation instanceof ConnectOperation) {
                 this.executeConnectOperation(operation)
             } else if (operation instanceof CloseOperation) {
@@ -296,10 +293,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         this.scheduleNextTimeout()
     }
 
-    public getOperationCounter(): number {
-        return this.operationCounter
-    }
-
     private scheduleNextTimeout(): void {
         if (this.simulatorTimeout) {
             clearTimeout(this.simulatorTimeout)

package/src/connection/Simulator/SimulatorConnection.ts

@@ -5,6 +5,7 @@ import { Connection } from '../Connection'
 import { Logger } from '@streamr/utils'
 import { protoToString } from '../../helpers/protoToString'
 import { DisconnectionType } from '../../transport/ITransport'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -45,35 +46,36 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            logger.error(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+            logger.error(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                 'tried to send() on a stopped connection')
         }
     }
 
     public async close(disconnectionType: DisconnectionType): Promise<void> {
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) + ' close()')
+        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
 
         if (!this.stopped) {
-            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) + ' close() not stopped')
+            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
+                + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close() not stopped')
             this.stopped = true
 
             try {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() calling simulator.disconnect()')
                 this.simulator.close(this)
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() simulator.disconnect returned')
             } catch (e) {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     'close aborted' + e)
             } finally {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' calling this.doDisconnect')
                 this.doDisconnect(disconnectionType)
             }
 
         } else {
-            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) +
+            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                 ' close() tried to close a stopped connection')
         }
     }
@@ -107,7 +109,7 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            logger.trace(this.ownPeerDescriptor.nodeName + ' handleIncomingDisconnection()')
+            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' handleIncomingDisconnection()')
             this.stopped = true
             this.doDisconnect('OTHER')
         } else {
@@ -117,19 +119,20 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public destroy(): void {
         if (!this.stopped) {
-            logger.trace(this.ownPeerDescriptor.nodeName + ' destroy()')
+            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' destroy()')
             this.removeAllListeners()
             this.close('OTHER').catch((_e) => { })
         } else {
-            logger.trace(this.ownPeerDescriptor.nodeName + ' tried to call destroy() a stopped connection')
+            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' tried to call destroy() a stopped connection')
         }
     }
 
     private doDisconnect(disconnectionType: DisconnectionType) {
-        logger.trace(this.ownPeerDescriptor.nodeName + ' doDisconnect()')
+        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' doDisconnect()')
         this.stopped = true
 
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + (this.targetPeerDescriptor.nodeName!) + ' doDisconnect emitting')
+        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
+            + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
 
         this.emit('disconnected', disconnectionType)
 

package/src/connection/Simulator/SimulatorConnector.ts

@@ -19,22 +19,22 @@ export class SimulatorConnector {
     private protocolVersion: string
     private ownPeerDescriptor: PeerDescriptor
     private simulator: Simulator
-    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
+    private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
         protocolVersion: string,
         ownPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
-        incomingConnectionCallback: (connection: ManagedConnection) => boolean
+        onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
         this.protocolVersion = protocolVersion
         this.ownPeerDescriptor = ownPeerDescriptor
         this.simulator = simulator
-        this.incomingConnectionCallback = incomingConnectionCallback
+        this.onIncomingConnection = onIncomingConnection
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        logger.trace('connect() ' + this.ownPeerDescriptor.nodeName + ',' + targetPeerDescriptor.nodeName)
+        logger.trace('connect() ' + keyFromPeerDescriptor(targetPeerDescriptor))
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(peerKey)
         if (existingConnection) {
@@ -65,8 +65,7 @@ export class SimulatorConnector {
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName +
-            ' incoming connection, stopped: ' + this.stopped)
+        logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
@@ -76,14 +75,14 @@ export class SimulatorConnector {
         const managedConnection = new ManagedConnection(this.ownPeerDescriptor, this.protocolVersion,
             ConnectionType.SIMULATOR_SERVER, undefined, connection)
 
-        logger.trace('connected, objectId: ' + managedConnection.objectId)
+        logger.trace('connected')
 
-        managedConnection.once('handshakeRequest', (_peerDescriptor: PeerDescriptor) => {
-            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName + ' incoming handshake request')
-            logger.trace('incoming handshake request objectId: ' + managedConnection.objectId)
+        managedConnection.once('handshakeRequest', () => {
+            logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming handshake request')
+            logger.trace('incoming handshake request')
 
-            if (this.incomingConnectionCallback(managedConnection)) {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName + ' calling acceptHandshake')
+            if (this.onIncomingConnection(managedConnection)) {
+                logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' calling acceptHandshake')
                 managedConnection.acceptHandshake()
             } else {
                 managedConnection.rejectHandshake('Duplicate connection')

package/src/connection/Simulator/SimulatorTransport.ts

@@ -1,9 +1,14 @@
+import { MetricsContext } from '@streamr/utils'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ConnectionManager } from '../ConnectionManager'
 import { Simulator } from './Simulator'
+import { SimulatorConnectorFacade } from '../ConnectorFacade'
 
 export class SimulatorTransport extends ConnectionManager {
     constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
-        super({ ownPeerDescriptor: ownPeerDescriptor, simulator, serviceIdPrefix: 'simulator/' })
+        super({
+            createConnectorFacade: () => new SimulatorConnectorFacade(ownPeerDescriptor, simulator),
+            metricsContext: new MetricsContext()
+        })
     }
 }