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

package/src/connection/ManagedConnection.ts

@@ -1,69 +1,78 @@
 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 { DisconnectionType } from '../transport/ITransport'
-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
-    private ownPeerDescriptor: PeerDescriptor
+    private localPeerDescriptor: PeerDescriptor
     protected outgoingConnection?: IConnection
     protected incomingConnection?: IConnection
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         connectionType: ConnectionType,
         outgoingConnection?: IConnection,
         incomingConnection?: IConnection,
+        targetPeerDescriptor?: PeerDescriptor
     ) {
         super()
 
-        this.send = this.send.bind(this)
-
-        this.ownPeerDescriptor = ownPeerDescriptor
+        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)
@@ -72,33 +81,37 @@ export class ManagedConnection extends EventEmitter<Events> {
         }
 
         if (outgoingConnection) {
-            this.handshaker = new Handshaker(this.ownPeerDescriptor, 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)
 
         } else {
             if (incomingConnection) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, incomingConnection)
-                this.handshaker.on('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
-                    this.setPeerDescriptor(peerDescriptor)
-                    this.emit('handshakeRequest', peerDescriptor)
+                this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
+                this.handshaker.on('handshakeRequest', (sourcePeerDescriptor: PeerDescriptor, targetPeerDescriptor?: PeerDescriptor) => {
+                    this.setRemotePeerDescriptor(sourcePeerDescriptor)
+                    this.emit('handshakeRequest', sourcePeerDescriptor, targetPeerDescriptor)
                 })
 
                 incomingConnection.on('disconnected', this.onDisconnected)
@@ -150,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) => {
+    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,8 +199,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         impl.on('data', (bytes: Uint8Array) => {
             this.lastUsed = Date.now()
-            if (this.listenerCount('managedData') < 1) {
-
+            if (this.listenerCount('managedData') === 0) {
                 this.inputBuffer.push(bytes)
             } else {
                 this.emit('managedData', bytes, this.getPeerDescriptor()!)
@@ -203,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(disconnectionType: DisconnectionType): void {
-        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' onDisconnected() ' + disconnectionType)
+    private onDisconnected(gracefulLeave: boolean): void {
+        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' onDisconnected() ' + gracefulLeave)
         if (this.bufferSentbyOtherConnection) {
             return
         }
-        this.emit('internal_disconnected')
-        this.doDisconnect(disconnectionType)
+        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()
 
@@ -232,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('OTHER')
-            } 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('OTHER')
-                } 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('OTHER')
-                    } 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
         }
     }
 
@@ -292,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')
     }
 
@@ -305,7 +287,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         // This happens when connectionRequest has been made and answered
         if (this.implementation) {
             if (!this.handshaker) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.implementation)
+                this.handshaker = new Handshaker(this.localPeerDescriptor, this.implementation)
             }
 
             this.handshaker.sendHandshakeResponse()
@@ -315,44 +297,37 @@ export class ManagedConnection extends EventEmitter<Events> {
             this.attachImplementation(this.incomingConnection!)
         }
 
-        this.onHandshakeCompleted(this.peerDescriptor!)
-    }
-
-    public rejectHandshake(errorMessage: string): void {
-        this.handshaker!.sendHandshakeResponse(errorMessage)
+        this.onHandshakeCompleted(this.remotePeerDescriptor!)
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType) {
-        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' doDisconnect() emitting')
-
-        if (!this.doNotEmitDisconnected) {
-            logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' emitting disconnected')
-            this.emit('disconnected', disconnectionType)
-        } 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(disconnectionType: DisconnectionType): Promise<void> {
+    public async close(gracefulLeave: boolean): Promise<void> {
         if (this.replacedByOtherConnection) {
             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(disconnectionType)
+            await this.implementation?.close(gracefulLeave)
         } else if (this.outgoingConnection) {
-            await this.outgoingConnection?.close(disconnectionType)
+            await this.outgoingConnection?.close(gracefulLeave)
         } else if (this.incomingConnection) {
-            await this.incomingConnection?.close(disconnectionType)
+            await this.incomingConnection?.close(gracefulLeave)
         } else {
-            this.doDisconnect(disconnectionType)
+            this.emit('disconnected', gracefulLeave)
         }
     }
 
     public destroy(): void {
         this.closing = true
+        
         this.emit('closing')
         if (!this.stopped) {
             this.stopped = true

package/src/connection/{ManagedWebRtcConnection.ts → ManagedWebrtcConnection.ts}

@@ -1,25 +1,27 @@
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { ConnectionType } from './IConnection'
 import { ManagedConnection } from './ManagedConnection'
-import { NodeWebRtcConnection } from './WebRTC/NodeWebRtcConnection'
+import { NodeWebrtcConnection } from './webrtc/NodeWebrtcConnection'
 
-export class ManagedWebRtcConnection extends ManagedConnection {
+export class ManagedWebrtcConnection extends ManagedConnection {
 
-    constructor(ownPeerDescriptor: PeerDescriptor,
-        connectingConnection?: NodeWebRtcConnection,
-        connectedConnection?: NodeWebRtcConnection) {
+    constructor(localPeerDescriptor: PeerDescriptor,
+        connectingConnection?: NodeWebrtcConnection,
+        connectedConnection?: NodeWebrtcConnection
+    ) {
         super(
-            ownPeerDescriptor,
+            localPeerDescriptor,
             ConnectionType.WEBRTC,
             connectingConnection,
-            connectedConnection)
+            connectedConnection
+        )
     }
 
-    public getWebRtcConnection(): NodeWebRtcConnection {
+    public getWebrtcConnection(): NodeWebrtcConnection {
         if (this.outgoingConnection) {
-            return this.outgoingConnection as unknown as NodeWebRtcConnection
+            return this.outgoingConnection as unknown as NodeWebrtcConnection
         } else {
-            return this.incomingConnection as unknown as NodeWebRtcConnection
+            return this.incomingConnection as unknown as NodeWebrtcConnection
         }
     }
 }

package/src/connection/{Simulator → simulator}/Simulator.ts

@@ -333,7 +333,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         const association = new Association(sourceConnection, undefined, connectedCallback)
         this.associations.set(sourceConnection.connectionId, association)
 
-        const executionTime = this.generateExecutionTime(association, sourceConnection.ownPeerDescriptor.region, targetDescriptor.region)
+        const executionTime = this.generateExecutionTime(association, sourceConnection.localPeerDescriptor.region, targetDescriptor.region)
         association.setLastOperationAt(executionTime)
 
         const operation = new ConnectOperation(executionTime, association,
@@ -356,7 +356,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         association.setClosing()
 
         const executionTime = this.generateExecutionTime(association,
-            sourceConnection.ownPeerDescriptor.region,
+            sourceConnection.localPeerDescriptor.region,
             sourceConnection.getPeerDescriptor()?.region)
         association.setLastOperationAt(executionTime)
 
@@ -382,8 +382,8 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         }
 
         const executionTime = this.generateExecutionTime(association,
-            sourceConnection.ownPeerDescriptor.region,
-            association.destinationConnection!.ownPeerDescriptor.region)
+            sourceConnection.localPeerDescriptor.region,
+            association.destinationConnection!.localPeerDescriptor.region)
 
         association.setLastOperationAt(executionTime)
 

package/src/connection/{Simulator → simulator}/SimulatorConnection.ts

@@ -4,27 +4,26 @@ import { Message, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Connection } from '../Connection'
 import { Logger } from '@streamr/utils'
 import { protoToString } from '../../helpers/protoToString'
-import { DisconnectionType } from '../../transport/ITransport'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
 export class SimulatorConnection extends Connection implements IConnection {
 
     private stopped = false
-    public ownPeerDescriptor: PeerDescriptor
+    public localPeerDescriptor: PeerDescriptor
     private targetPeerDescriptor: PeerDescriptor
     private simulator: Simulator
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         targetPeerDescriptor: PeerDescriptor,
         connectionType: ConnectionType,
         simulator: Simulator
     ) {
         super(connectionType)
 
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.setPeerDescriptor(targetPeerDescriptor)
         this.targetPeerDescriptor = targetPeerDescriptor
         this.connectionType = connectionType
@@ -46,36 +45,37 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            logger.error(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.error(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                 'tried to send() on a stopped connection')
         }
     }
 
-    public async close(disconnectionType: DisconnectionType): Promise<void> {
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
+    public async close(gracefulLeave: boolean): Promise<void> {
+        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+            + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
 
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
-                + 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.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() calling simulator.disconnect()')
                 this.simulator.close(this)
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() simulator.disconnect returned')
             } catch (e) {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     'close aborted' + e)
             } finally {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' calling this.doDisconnect')
-                this.doDisconnect(disconnectionType)
+                this.doDisconnect(gracefulLeave)
             }
 
         } else {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
                 ' close() tried to close a stopped connection')
         }
     }
@@ -87,7 +87,7 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.connect(this, this.targetPeerDescriptor, (error?: string) => {
                 if (error) {
                     logger.trace(error)
-                    this.doDisconnect('OTHER')
+                    this.doDisconnect(false)
                 } else {
                     this.emit('connected')
                 }
@@ -109,9 +109,9 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' handleIncomingDisconnection()')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' handleIncomingDisconnection()')
             this.stopped = true
-            this.doDisconnect('OTHER')
+            this.doDisconnect(false)
         } else {
             logger.trace('tried to call handleIncomingDisconnection() a stopped connection')
         }
@@ -119,22 +119,22 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public destroy(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' destroy()')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' destroy()')
             this.removeAllListeners()
-            this.close('OTHER').catch((_e) => { })
+            this.close(false).catch((_e) => { })
         } else {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' tried to call destroy() a stopped connection')
+            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' tried to call destroy() a stopped connection')
         }
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType) {
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' doDisconnect()')
+    private doDisconnect(gracefulLeave: boolean) {
+        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' doDisconnect()')
         this.stopped = true
 
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
-            + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
+        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', '
+            + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
 
-        this.emit('disconnected', disconnectionType)
+        this.emit('disconnected', gracefulLeave)
 
     }
 }