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

package/src/connection/ConnectivityChecker.ts

@@ -10,7 +10,7 @@ import { ClientWebSocket } from './WebSocket/ClientWebSocket'
 import { v4 } from 'uuid'
 import { NatType } from './ConnectionManager'
 import { ServerWebSocket } from './WebSocket/ServerWebSocket'
-import { connectivityMethodToWebSocketUrl } from './WebSocket/WebSocketConnector'
+import { connectivityMethodToWebSocketUrl } from './WebSocket/WebSocketConnectorRpcLocal'
 
 const logger = new Logger(module)
 
@@ -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,140 @@
+import { Logger } from '@streamr/utils'
+import {
+    ConnectivityResponse,
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { ITransport } from '../transport/ITransport'
+import { PortRange, TlsCertificate } from './ConnectionManager'
+import { ManagedConnection } from './ManagedConnection'
+import { Simulator } from './Simulator/Simulator'
+import { SimulatorConnector } from './Simulator/SimulatorConnector'
+import { IceServer, WebRtcConnectorRpcLocal } from './WebRTC/WebRtcConnectorRpcLocal'
+import { WebSocketConnectorRpcLocal } from './WebSocket/WebSocketConnectorRpcLocal'
+
+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?: WebSocketConnectorRpcLocal
+    private webrtcConnector?: WebRtcConnectorRpcLocal
+
+    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 WebSocketConnectorRpcLocal({
+            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 WebRtcConnectorRpcLocal({
+            transport: this.config.transport!,
+            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(
+            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/Handshaker.ts

@@ -16,17 +16,14 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
 
     private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
     private ownPeerDescriptor: PeerDescriptor
-    private protocolVersion: string
     private connection: IConnection
 
     constructor(
         ownPeerDescriptor: PeerDescriptor,
-        protocolVersion: string, 
         connection: IConnection
     ) {
         super()
         this.ownPeerDescriptor = ownPeerDescriptor
-        this.protocolVersion = protocolVersion
         this.connection = connection
         this.connection.on('data', this.onData)
     }
@@ -57,7 +54,6 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     public sendHandshakeRequest(): void {
         const outgoingHandshake: HandshakeRequest = {
             sourceId: this.ownPeerDescriptor.kademliaId,
-            protocolVersion: this.protocolVersion,
             peerDescriptor: this.ownPeerDescriptor
         }
         const msg: Message = {
@@ -76,7 +72,6 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     public sendHandshakeResponse(error?: string): void {
         const outgoingHandshakeResponse: HandshakeResponse = {
             sourceId: this.ownPeerDescriptor.kademliaId,
-            protocolVersion: this.protocolVersion,
             peerDescriptor: this.ownPeerDescriptor
         }
         if (error) {

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[] = []
@@ -46,25 +45,20 @@ export class ManagedConnection extends EventEmitter<Events> {
     private closing = false
     public replacedByOtherConnection = false
     private ownPeerDescriptor: PeerDescriptor
-    private protocolVersion: string
     protected outgoingConnection?: IConnection
     protected incomingConnection?: IConnection
 
     constructor(
         ownPeerDescriptor: PeerDescriptor,
-        protocolVersion: string,
         connectionType: ConnectionType,
         outgoingConnection?: IConnection,
         incomingConnection?: IConnection,
     ) {
         super()
-        this.objectId = ManagedConnection.objectCounter
-        ManagedConnection.objectCounter++
 
         this.send = this.send.bind(this)
 
         this.ownPeerDescriptor = ownPeerDescriptor
-        this.protocolVersion = protocolVersion
         this.outgoingConnection = outgoingConnection
         this.incomingConnection = incomingConnection
         this.connectionType = connectionType
@@ -72,24 +66,23 @@ 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')
         }
 
         if (outgoingConnection) {
-            this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, outgoingConnection)
+            this.handshaker = new Handshaker(this.ownPeerDescriptor, 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)
             })
@@ -102,7 +95,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         } else {
             if (incomingConnection) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, incomingConnection)
+                this.handshaker = new Handshaker(this.ownPeerDescriptor, incomingConnection)
                 this.handshaker.on('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
                     this.setPeerDescriptor(peerDescriptor)
                     this.emit('handshakeRequest', peerDescriptor)
@@ -124,7 +117,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 +135,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 +172,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 +207,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 +230,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 +240,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 +248,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 +261,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 +286,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,16 +301,11 @@ 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) {
             if (!this.handshaker) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, this.implementation)
+                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.implementation)
             }
 
             this.handshaker.sendHandshakeResponse()
@@ -336,14 +323,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/ManagedWebRtcConnection.ts

@@ -6,12 +6,10 @@ import { NodeWebRtcConnection } from './WebRTC/NodeWebRtcConnection'
 export class ManagedWebRtcConnection extends ManagedConnection {
 
     constructor(ownPeerDescriptor: PeerDescriptor,
-        protocolVersion: string,
         connectingConnection?: NodeWebRtcConnection,
         connectedConnection?: NodeWebRtcConnection) {
         super(
             ownPeerDescriptor,
-            protocolVersion,
             ConnectionType.WEBRTC,
             connectingConnection,
             connectedConnection)

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)