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

package/src/connection/ManagedConnection.ts

@@ -1,45 +1,55 @@
 import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from './IConnection'
 import * as Err from '../helpers/errors'
 import { Handshaker } from './Handshaker'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
-import { Logger, raceEvents3, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
+import { HandshakeError, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Logger, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { PeerIDKey } from '../helpers/PeerID'
 import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
-import { keyOrUnknownFromPeerDescriptor } from './ConnectionManager'
+import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
 
 export interface ManagedConnectionEvents {
     managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void
-    handshakeRequest: (peerDescriptor: PeerDescriptor) => void
+    handshakeRequest: (source: PeerDescriptor, target?: PeerDescriptor) => void
     handshakeCompleted: (peerDescriptor: PeerDescriptor) => void
     handshakeFailed: () => void
     bufferSentByOtherConnection: () => void
     closing: () => void
-    internal_disconnected: () => void
+}
+
+interface OutpuBufferEvents {
+    bufferSent: () => void
+    bufferSendingFailed: () => void
+}
+
+interface OutpuBufferEvents {
+    bufferSent: () => void
+    bufferSendingFailed: () => void
 }
 
 const logger = new Logger(module)
 
 export type Events = ManagedConnectionEvents & ConnectionEvents
+
 export class ManagedConnection extends EventEmitter<Events> {
 
     private implementation?: IConnection
 
+    private outputBufferEmitter = new EventEmitter<OutpuBufferEvents>()
     private outputBuffer: Uint8Array[] = []
+
     private inputBuffer: Uint8Array[] = []
 
     public connectionId: ConnectionID
-    private peerDescriptor?: PeerDescriptor
+    private remotePeerDescriptor?: PeerDescriptor
     public connectionType: ConnectionType
 
     private handshaker?: Handshaker
     private handshakeCompleted = false
-    private doNotEmitDisconnected = false
 
     private lastUsed: number = Date.now()
     private stopped = false
     public offeredAsIncoming = false
-    public rejectedAsIncoming = false
     private bufferSentbyOtherConnection = false
     private closing = false
     public replacedByOtherConnection = false
@@ -52,17 +62,17 @@ export class ManagedConnection extends EventEmitter<Events> {
         connectionType: ConnectionType,
         outgoingConnection?: IConnection,
         incomingConnection?: IConnection,
+        targetPeerDescriptor?: PeerDescriptor
     ) {
         super()
 
-        this.send = this.send.bind(this)
-
         this.localPeerDescriptor = localPeerDescriptor
         this.outgoingConnection = outgoingConnection
         this.incomingConnection = incomingConnection
         this.connectionType = connectionType
         this.connectionId = new ConnectionID()
 
+        this.send = this.send.bind(this)
         this.onDisconnected = this.onDisconnected.bind(this)
 
         logger.trace('creating ManagedConnection of type: ' + connectionType)
@@ -73,21 +83,25 @@ export class ManagedConnection extends EventEmitter<Events> {
         if (outgoingConnection) {
             this.handshaker = new Handshaker(this.localPeerDescriptor, outgoingConnection)
 
-            this.handshaker.once('handshakeFailed', (errorMessage) => {
-                logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' handshakeFailed: ' + errorMessage)
-                this.emit('handshakeFailed')
+            this.handshaker.once('handshakeFailed', (error) => {
+                if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR) {
+                    this.close(false)
+                } else {
+                    logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' handshakeFailed: ' + error)
+                    this.emit('handshakeFailed')
+                }
             })
 
             this.handshaker.on('handshakeCompleted', (peerDescriptor: PeerDescriptor) => {
                 logger.trace('handshake completed for outgoing connection '
-                    + ', ' + keyOrUnknownFromPeerDescriptor(this.peerDescriptor) 
+                    + ', ' + getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) 
                     + ' outputBuffer.length: ' + this.outputBuffer.length)
                 this.attachImplementation(outgoingConnection)
                 this.onHandshakeCompleted(peerDescriptor)
             })
 
             outgoingConnection.once('connected', () => {
-                this.handshaker!.sendHandshakeRequest()
+                this.handshaker!.sendHandshakeRequest(targetPeerDescriptor)
                 this.emit('connected')
             })
             outgoingConnection.once('disconnected', this.onDisconnected)
@@ -95,9 +109,9 @@ export class ManagedConnection extends EventEmitter<Events> {
         } else {
             if (incomingConnection) {
                 this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
-                this.handshaker.on('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
-                    this.setPeerDescriptor(peerDescriptor)
-                    this.emit('handshakeRequest', peerDescriptor)
+                this.handshaker.on('handshakeRequest', (sourcePeerDescriptor: PeerDescriptor, targetPeerDescriptor?: PeerDescriptor) => {
+                    this.setRemotePeerDescriptor(sourcePeerDescriptor)
+                    this.emit('handshakeRequest', sourcePeerDescriptor, targetPeerDescriptor)
                 })
 
                 incomingConnection.on('disconnected', this.onDisconnected)
@@ -149,32 +163,32 @@ export class ManagedConnection extends EventEmitter<Events> {
     }
 
     public get peerIdKey(): PeerIDKey {
-        return keyFromPeerDescriptor(this.peerDescriptor!)
+        return keyFromPeerDescriptor(this.remotePeerDescriptor!)
     }
 
     public getLastUsed(): number {
         return this.lastUsed
     }
 
-    public setPeerDescriptor(peerDescriptor: PeerDescriptor): void {
-        this.peerDescriptor = peerDescriptor
+    public setRemotePeerDescriptor(peerDescriptor: PeerDescriptor): void {
+        this.remotePeerDescriptor = peerDescriptor
     }
 
     public getPeerDescriptor(): PeerDescriptor | undefined {
-        return this.peerDescriptor
+        return this.remotePeerDescriptor
     }
 
     private onHandshakeCompleted(peerDescriptor: PeerDescriptor) {
         this.lastUsed = Date.now()
 
-        this.setPeerDescriptor(peerDescriptor)
+        this.setRemotePeerDescriptor(peerDescriptor)
         this.handshakeCompleted = true
 
         while (this.outputBuffer.length > 0) {
             logger.trace('emptying outputBuffer')
             this.implementation!.send(this.outputBuffer.shift()!)
         }
-
+        this.outputBufferEmitter.emit('bufferSent')
         logger.trace('emitting handshake_completed')
         this.emit('handshakeCompleted', peerDescriptor)
     }
@@ -186,7 +200,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         impl.on('data', (bytes: Uint8Array) => {
             this.lastUsed = Date.now()
             if (this.listenerCount('managedData') === 0) {
-
                 this.inputBuffer.push(bytes)
             } else {
                 this.emit('managedData', bytes, this.getPeerDescriptor()!)
@@ -202,25 +215,26 @@ export class ManagedConnection extends EventEmitter<Events> {
             this.emit('connected')
         })
 
+        //ensure that we have subscribed to the event only once
         impl.off('disconnected', this.onDisconnected)
         impl.on('disconnected', this.onDisconnected)
     }
 
     private onDisconnected(gracefulLeave: boolean): void {
-        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' onDisconnected() ' + gracefulLeave)
+        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' onDisconnected() ' + gracefulLeave)
         if (this.bufferSentbyOtherConnection) {
             return
         }
-        this.emit('internal_disconnected')
-        this.doDisconnect(gracefulLeave)
+        this.outputBufferEmitter.emit('bufferSendingFailed')
+        this.emit('disconnected', gracefulLeave)
     }
 
     async send(data: Uint8Array, doNotConnect = false): Promise<void> {
         if (this.stopped) {
-            return
+            throw new Err.SendFailed('ManagedConnection is stopped')
         }
         if (this.closing) {
-            return
+            throw new Err.SendFailed('ManagedConnection is closing')
         }
         this.lastUsed = Date.now()
 
@@ -231,52 +245,20 @@ export class ManagedConnection extends EventEmitter<Events> {
         } else {
             logger.trace('adding data to outputBuffer')
 
-            let result: RunAndRaceEventsReturnType<Events>
-
-            this.doNotEmitDisconnected = true
+            let result: RunAndRaceEventsReturnType<OutpuBufferEvents>
 
             try {
-                result = await runAndRaceEvents3<Events>([() => { this.outputBuffer.push(data) }], this, ['handshakeCompleted', 'handshakeFailed',
-                    'bufferSentByOtherConnection', 'closing', 'internal_disconnected'], 15000)
+                result = await runAndRaceEvents3<OutpuBufferEvents>([() => { this.outputBuffer.push(data) }],
+                    this.outputBufferEmitter, ['bufferSent', 'bufferSendingFailed'], 15000)
             } catch (e) {
-                logger.debug(`Connection to ${keyOrUnknownFromPeerDescriptor(this.peerDescriptor)} timed out`)
-                throw e
+                logger.debug(`Connection to ${getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor)} timed out`)
+                throw new Err.SendFailed('Sending buffer timed out')
             }
 
-            if (result.winnerName === 'internal_disconnected') {
-                this.doNotEmitDisconnected = false
-                this.doDisconnect(false)
-            } else if (result.winnerName === 'handshakeFailed') {
-                logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' handshakeFailed received')
-
-                if (this.bufferSentbyOtherConnection) {
-                    logger.trace('bufferSentByOtherConnection already true')
-                    this.doNotEmitDisconnected = false
-                    this.doDisconnect(false)
-                } else {
-                    let result2: RunAndRaceEventsReturnType<Events>
-
-                    try {
-                        result2 = await raceEvents3<Events>(this,
-                            ['bufferSentByOtherConnection', 'closing', 'disconnected'], 15000)
-                    } catch (ex) {
-                        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor)
-                            + ' Exception from raceEvents3 while waiting bufferSentByOtherConnection or closing ' + ex)
-                        throw ex
-                    }
-                    if (result2.winnerName === 'bufferSentByOtherConnection') {
-                        logger.trace('bufferSentByOtherConnection received')
-                        this.doNotEmitDisconnected = false
-                        this.doDisconnect(false)
-                    } else if (result2.winnerName === 'closing') {
-                        logger.trace('bufferSentByOtherConnection not received, instead received a closing event')
-                    } else if (result2.winnerName === 'disconnected') {
-                        logger.trace('disconnected while in raceEvents3')
-                    }
-                }
-            } else {
-                this.doNotEmitDisconnected = false
+            if (result.winnerName === 'bufferSendingFailed') {
+                throw new Err.SendFailed('Sending buffer failed')
             }
+            // buffer was sent successfully, return normally
         }
     }
 
@@ -291,12 +273,13 @@ export class ManagedConnection extends EventEmitter<Events> {
     }
 
     public reportBufferSentByOtherConnection(): void {
-        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' reportBufferSentByOtherConnection')
+        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' reportBufferSentByOtherConnection')
         if (this.handshaker) {
             this.handshaker.removeAllListeners()
         }
         logger.trace('bufferSentByOtherConnection reported')
         this.bufferSentbyOtherConnection = true
+        this.outputBufferEmitter.emit('bufferSent')
         this.emit('bufferSentByOtherConnection')
     }
 
@@ -314,22 +297,12 @@ export class ManagedConnection extends EventEmitter<Events> {
             this.attachImplementation(this.incomingConnection!)
         }
 
-        this.onHandshakeCompleted(this.peerDescriptor!)
+        this.onHandshakeCompleted(this.remotePeerDescriptor!)
     }
 
-    public rejectHandshake(errorMessage: string): void {
-        this.handshaker!.sendHandshakeResponse(errorMessage)
-    }
-
-    private doDisconnect(gracefulLeave: boolean) {
-        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' doDisconnect() emitting')
-
-        if (!this.doNotEmitDisconnected) {
-            logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' emitting disconnected')
-            this.emit('disconnected', gracefulLeave)
-        } else {
-            logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' not emitting disconnected because doNotEmitDisconnected flag is set')
-        }
+    public rejectHandshake(error: HandshakeError): void {
+        this.handshaker!.sendHandshakeResponse(error)
+        this.destroy()
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
@@ -337,8 +310,10 @@ export class ManagedConnection extends EventEmitter<Events> {
             logger.trace('close() called on replaced connection')
         }
         this.closing = true
+        
+        this.outputBufferEmitter.emit('bufferSendingFailed')
         this.emit('closing')
-        this.doNotEmitDisconnected = false
+       
         if (this.implementation) {
             await this.implementation?.close(gracefulLeave)
         } else if (this.outgoingConnection) {
@@ -346,12 +321,13 @@ export class ManagedConnection extends EventEmitter<Events> {
         } else if (this.incomingConnection) {
             await this.incomingConnection?.close(gracefulLeave)
         } else {
-            this.doDisconnect(gracefulLeave)
+            this.emit('disconnected', gracefulLeave)
         }
     }
 
     public destroy(): void {
         this.closing = true
+        
         this.emit('closing')
         if (!this.stopped) {
             this.stopped = true

package/src/connection/ManagedWebrtcConnection.ts

@@ -7,12 +7,14 @@ export class ManagedWebrtcConnection extends ManagedConnection {
 
     constructor(localPeerDescriptor: PeerDescriptor,
         connectingConnection?: NodeWebrtcConnection,
-        connectedConnection?: NodeWebrtcConnection) {
+        connectedConnection?: NodeWebrtcConnection
+    ) {
         super(
             localPeerDescriptor,
             ConnectionType.WEBRTC,
             connectingConnection,
-            connectedConnection)
+            connectedConnection
+        )
     }
 
     public getWebrtcConnection(): NodeWebrtcConnection {

package/src/connection/simulator/SimulatorConnection.ts

@@ -4,7 +4,7 @@ import { Message, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Connection } from '../Connection'
 import { Logger } from '@streamr/utils'
 import { protoToString } from '../../helpers/protoToString'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -45,36 +45,37 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            logger.error(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.error(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                 'tried to send() on a stopped connection')
         }
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
-        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
+        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+            + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
 
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', '
-                + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close() not stopped')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', '
+                + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' close() not stopped')
             this.stopped = true
 
             try {
-                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() calling simulator.disconnect()')
                 this.simulator.close(this)
-                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() simulator.disconnect returned')
             } catch (e) {
-                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     'close aborted' + e)
             } finally {
-                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' calling this.doDisconnect')
                 this.doDisconnect(gracefulLeave)
             }
 
         } else {
-            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                 ' close() tried to close a stopped connection')
         }
     }
@@ -108,7 +109,7 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' handleIncomingDisconnection()')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' handleIncomingDisconnection()')
             this.stopped = true
             this.doDisconnect(false)
         } else {
@@ -118,20 +119,20 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public destroy(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' destroy()')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' destroy()')
             this.removeAllListeners()
             this.close(false).catch((_e) => { })
         } else {
-            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' tried to call destroy() a stopped connection')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' tried to call destroy() a stopped connection')
         }
     }
 
     private doDisconnect(gracefulLeave: boolean) {
-        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' doDisconnect()')
+        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' doDisconnect()')
         this.stopped = true
 
-        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', '
-            + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
+        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', '
+            + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
 
         this.emit('disconnected', gracefulLeave)
 

package/src/connection/simulator/SimulatorConnector.ts

@@ -1,6 +1,7 @@
 import { ConnectionType } from '../IConnection'
 
 import {
+    HandshakeError,
     PeerDescriptor,
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
@@ -8,7 +9,7 @@ import { ManagedConnection } from '../ManagedConnection'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { Simulator } from './Simulator'
 import { SimulatorConnection } from './SimulatorConnection'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -18,20 +19,20 @@ export class SimulatorConnector {
     private stopped = false
     private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
-    private onIncomingConnection: (connection: ManagedConnection) => boolean
+    private onNewConnection: (connection: ManagedConnection) => boolean
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
-        onIncomingConnection: (connection: ManagedConnection) => boolean
+        onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.simulator = simulator
-        this.onIncomingConnection = onIncomingConnection
+        this.onNewConnection = onNewConnection
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        logger.trace('connect() ' + keyFromPeerDescriptor(targetPeerDescriptor))
+        logger.trace('connect() ' + getNodeIdFromPeerDescriptor(targetPeerDescriptor))
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(peerKey)
         if (existingConnection) {
@@ -41,7 +42,7 @@ export class SimulatorConnector {
         const connection = new SimulatorConnection(this.localPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
 
         const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
         this.connectingConnections.set(peerKey, managedConnection)
         connection.once('disconnected', () => {
@@ -61,7 +62,7 @@ export class SimulatorConnector {
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        logger.trace(keyFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
+        logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
@@ -73,15 +74,13 @@ export class SimulatorConnector {
         logger.trace('connected')
 
         managedConnection.once('handshakeRequest', () => {
-            logger.trace(keyFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming handshake request')
-            logger.trace('incoming handshake request')
+            logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming handshake request')
 
-            if (this.onIncomingConnection(managedConnection)) {
-                logger.trace(keyFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' calling acceptHandshake')
+            if (this.onNewConnection(managedConnection)) {
+                logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' calling acceptHandshake')
                 managedConnection.acceptHandshake()
             } else {
-                managedConnection.rejectHandshake('Duplicate connection')
-                managedConnection.destroy()
+                managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)
             }
         })
 

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -2,7 +2,7 @@ import EventEmitter from 'eventemitter3'
 import { WebrtcConnectionEvents, IWebrtcConnection, RtcDescription } from './IWebrtcConnection'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { Logger } from '@streamr/utils'
-import { IceServer } from './WebrtcConnectorRpcLocal'
+import { IceServer } from './WebrtcConnector'
 
 const logger = new Logger(module)
 
@@ -20,7 +20,7 @@ interface Params {
 
 export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrtcConnection, IConnection {
 
-    public readonly connectionId: ConnectionID
+    public connectionId: ConnectionID
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
 
     // We need to keep track of connection state ourselves because

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -5,7 +5,7 @@ import EventEmitter from 'eventemitter3'
 import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
 import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { iceServerAsString } from './iceServerAsString'
 import { IceServer } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
@@ -80,9 +80,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     }
 
     public start(isOffering: boolean): void {
-        logger.trace(`Staring new connection for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
         const peerIdKey = keyFromPeerDescriptor(this.remotePeerDescriptor)
-        logger.trace(`Staring new connection for peer: ${peerIdKey} offering: ${isOffering}`)
+        logger.trace(`Starting new connection for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`, { isOffering })
         this.connection = new PeerConnection(peerIdKey, {
             iceServers: this.iceServers.map(iceServerAsString),
             maxMessageSize: this.maxMessageSize,
@@ -115,11 +114,11 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     public async setRemoteDescription(description: string, type: string): Promise<void> {
         if (this.connection) {
             try {
-                logger.trace(`Setting remote descriptor for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.trace(`Setting remote descriptor for peer: ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
                 this.connection.setRemoteDescription(description, type as DescriptionType)
                 this.remoteDescriptionSet = true
             } catch (err) {
-                logger.debug(`Failed to set remote descriptor for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.debug(`Failed to set remote descriptor for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
             }
         } else {
             this.doClose(false, `Tried to set description for non-existent connection`)
@@ -130,10 +129,10 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         if (this.connection) {
             if (this.remoteDescriptionSet) {
                 try {
-                    logger.trace(`Setting remote candidate for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    logger.trace(`Setting remote candidate for peer: ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
                     this.connection.addRemoteCandidate(candidate, mid)
                 } catch (err) {
-                    logger.debug(`Failed to set remote candidate for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    logger.debug(`Failed to set remote candidate for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
                 }
             } else {
                 // TODO: should queue candidates until remote description is set?
@@ -149,7 +148,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             try {
                 this.dataChannel!.sendMessageBinary(data as Buffer)
             } catch (err) {
-                logger.debug('Failed to send binary message to ' + keyFromPeerDescriptor(this.remotePeerDescriptor) + err)
+                logger.debug('Failed to send binary message to ' + getNodeIdFromPeerDescriptor(this.remotePeerDescriptor) + err)
             }
         }
     }
@@ -161,7 +160,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
             logger.trace(
-                `Closing Node WebRTC Connection to ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`
+                `Closing Node WebRTC Connection to ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`
                 + `${reason ? `, reason: ${reason}` : ''}`
             )
 
@@ -232,7 +231,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             clearTimeout(this.connectingTimeoutRef)
         }
         this.dataChannel = dataChannel
-        logger.trace(`DataChannel opened for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+        logger.trace(`DataChannel opened for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }