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

package/src/connection/ConnectorFacade.ts

@@ -6,23 +6,25 @@ import {
 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'
+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
+    getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
         onIncomingConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean
+        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
+        autoCertifierTransport: ITransport
     ) => Promise<void>
     stop: () => Promise<void>
 }
 
 const logger = new Logger(module)
 
+// TODO: Wrap component specific configs to their own objects.
 export interface DefaultConnectorFacadeConfig {
     transport: ITransport
     websocketHost?: string
@@ -37,15 +39,18 @@ export interface DefaultConnectorFacadeConfig {
     webrtcPortRange?: PortRange
     maxMessageSize?: number
     tlsCertificate?: TlsCertificate
-    createOwnPeerDescriptor: (connectivityResponse: ConnectivityResponse) => PeerDescriptor
+    websocketServerEnableTls?: boolean
+    autoCertifierUrl?: string
+    autoCertifierConfigFile?: string
+    createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => PeerDescriptor
 }
 
 export class DefaultConnectorFacade implements ConnectorFacade {
 
     private readonly config: DefaultConnectorFacadeConfig
-    private ownPeerDescriptor?: PeerDescriptor
-    private webSocketConnector?: WebSocketConnectorRpcLocal
-    private webrtcConnector?: WebRtcConnectorRpcLocal
+    private localPeerDescriptor?: PeerDescriptor
+    private websocketConnector?: WebsocketConnector
+    private webrtcConnector?: WebrtcConnector
 
     constructor(config: DefaultConnectorFacadeConfig) {
         this.config = config
@@ -53,22 +58,28 @@ export class DefaultConnectorFacade implements ConnectorFacade {
 
     async start(
         onIncomingConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean
+        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
+        autoCertifierTransport: ITransport
     ): Promise<void> {
-        logger.trace(`Creating WebSocketConnector`)
-        this.webSocketConnector = new WebSocketConnectorRpcLocal({
+        logger.trace(`Creating WebsocketConnectorRpcLocal`)
+        const webSocketConnectorConfig = {
             transport: this.config.transport!,
-            // TODO should we use canConnect also for WebRtcConnector? (NET-1142)
+            // 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,
+            serverEnableTls: this.config.websocketServerEnableTls!,
+            autoCertifierUrl: this.config.autoCertifierUrl!,
+            autoCertifierConfigFile: this.config.autoCertifierConfigFile!,
+            autoCertifierTransport,
             maxMessageSize: this.config.maxMessageSize
-        })
-        logger.trace(`Creating WebRTCConnector`)
-        this.webrtcConnector = new WebRtcConnectorRpcLocal({
+        }
+        this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
+        logger.trace(`Creating WebRtcConnectorRpcLocal`)
+        this.webrtcConnector = new WebrtcConnector({
             transport: this.config.transport!,
             iceServers: this.config.iceServers,
             allowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
@@ -79,47 +90,76 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             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)
+        await this.websocketConnector.start()
+        // TODO: generate a PeerDescriptor in a single function. Requires changes to the createOwnPeerDescriptor
+        // function in the config. Currently it's given by the DhtNode and it sets the PeerDescriptor for the
+        // DhtNode in each call. 
+        // LocalPeerDescriptor could be stored in one place and passed from there to the connectors
+        const temporarilySelfSigned = (!this.config.tlsCertificate && this.config.websocketServerEnableTls === true)
+        const connectivityResponse = await this.websocketConnector.checkConnectivity(temporarilySelfSigned)
+        let localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        this.localPeerDescriptor = localPeerDescriptor
+        this.websocketConnector.setLocalPeerDescriptor(localPeerDescriptor)
+        if (localPeerDescriptor.websocket && !this.config.tlsCertificate && this.config.websocketServerEnableTls) {
+            try {
+                await this.websocketConnector!.autoCertify()
+                const connectivityResponse = await this.websocketConnector!.checkConnectivity(false)
+                localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+                this.localPeerDescriptor = localPeerDescriptor
+                if (localPeerDescriptor.websocket === undefined) {
+                    logger.warn('ConnectivityCheck failed after autocertification, websocket server connectivity disabled')
+                }
+                this.websocketConnector!.setLocalPeerDescriptor(localPeerDescriptor)
+            } catch (err) {
+                logger.warn('Failed to autocertify, disabling websocket server TLS')
+                await this.websocketConnector.destroy()
+                this.websocketConnector = new WebsocketConnector({
+                    ...webSocketConnectorConfig,
+                    serverEnableTls: false,
+                })
+                await this.websocketConnector.start()
+                const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
+                localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+                this.localPeerDescriptor = localPeerDescriptor
+                this.websocketConnector.setLocalPeerDescriptor(localPeerDescriptor)
+            }
+        }
+        this.webrtcConnector.setLocalPeerDescriptor(localPeerDescriptor)
     }
 
     createConnection(peerDescriptor: PeerDescriptor): ManagedConnection {
-        if (this.webSocketConnector!.isPossibleToFormConnection(peerDescriptor)) {
-            return this.webSocketConnector!.connect(peerDescriptor)
+        if (this.websocketConnector!.isPossibleToFormConnection(peerDescriptor)) {
+            return this.websocketConnector!.connect(peerDescriptor)
         } else {
             return this.webrtcConnector!.connect(peerDescriptor)
         }
     }
 
-    getOwnPeerDescriptor(): PeerDescriptor | undefined {
-        return this.ownPeerDescriptor
+    getLocalPeerDescriptor(): PeerDescriptor | undefined {
+        return this.localPeerDescriptor
     }
 
     async stop(): Promise<void> {
-        await this.webSocketConnector!.destroy()
+        await this.websocketConnector!.destroy()
         await this.webrtcConnector!.stop()
     }
 }
 
 export class SimulatorConnectorFacade implements ConnectorFacade {
 
-    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly localPeerDescriptor: PeerDescriptor
     private simulatorConnector?: SimulatorConnector
     private simulator: Simulator
 
-    constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
-        this.ownPeerDescriptor = ownPeerDescriptor
+    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
+        this.localPeerDescriptor = localPeerDescriptor
         this.simulator = simulator
     }
 
     async start(onIncomingConnection: (connection: ManagedConnection) => boolean): Promise<void> {
         logger.trace(`Creating SimulatorConnector`)
         this.simulatorConnector = new SimulatorConnector(
-            this.ownPeerDescriptor,
+            this.localPeerDescriptor,
             this.simulator,
             onIncomingConnection
         )
@@ -130,8 +170,8 @@ export class SimulatorConnectorFacade implements ConnectorFacade {
         return this.simulatorConnector!.connect(peerDescriptor)
     }
 
-    getOwnPeerDescriptor(): PeerDescriptor {
-        return this.ownPeerDescriptor
+    getLocalPeerDescriptor(): PeerDescriptor {
+        return this.localPeerDescriptor
     }
 
     async stop(): Promise<void> {

package/src/connection/Handshaker.ts

@@ -15,20 +15,20 @@ interface HandshakerEvents {
 export class Handshaker extends EventEmitter<HandshakerEvents> {
 
     private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
-    private ownPeerDescriptor: PeerDescriptor
+    private localPeerDescriptor: PeerDescriptor
     private connection: IConnection
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         connection: IConnection
     ) {
         super()
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.connection = connection
-        this.connection.on('data', this.onData)
+        this.connection.on('data', (data: Uint8Array) => this.onData(data))
     }
 
-    private onData = (data: Uint8Array) => {
+    private onData(data: Uint8Array) {
         try {
             const message = Message.fromBinary(data)
             if (message.body.oneofKind === 'handshakeRequest') {
@@ -53,8 +53,8 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
 
     public sendHandshakeRequest(): void {
         const outgoingHandshake: HandshakeRequest = {
-            sourceId: this.ownPeerDescriptor.kademliaId,
-            peerDescriptor: this.ownPeerDescriptor
+            sourceId: this.localPeerDescriptor.kademliaId,
+            peerDescriptor: this.localPeerDescriptor
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -71,8 +71,8 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
 
     public sendHandshakeResponse(error?: string): void {
         const outgoingHandshakeResponse: HandshakeResponse = {
-            sourceId: this.ownPeerDescriptor.kademliaId,
-            peerDescriptor: this.ownPeerDescriptor
+            sourceId: this.localPeerDescriptor.kademliaId,
+            peerDescriptor: this.localPeerDescriptor
         }
         if (error) {
             outgoingHandshakeResponse.responseError = error

package/src/connection/IConnection.ts

@@ -1,10 +1,9 @@
 import { UUID } from '../helpers/UUID'
-import { DisconnectionType } from '../transport/ITransport'
 
 export interface ConnectionEvents {
     data: (bytes: Uint8Array) => void
     connected: () => void
-    disconnected: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void 
+    disconnected: (gracefulLeave: boolean, code?: number, reason?: string) => void 
     error: (name: string) => void
 }
 
@@ -29,19 +28,19 @@ export interface IConnection {
     on(event: 'data', listener: (bytes: Uint8Array) => void): this
     on(event: 'error', listener: (name: string) => void): this
     on(event: 'connected', listener: () => void): this
-    on(event: 'disconnected', listener: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void): this
+    on(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): this
     
     once(event: 'data', listener: (bytes: Uint8Array) => void): this
     once(event: 'error', listener: (name: string) => void): this
     once(event: 'connected', listener: () => void): this
-    once(event: 'disconnected', listener: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void): this
+    once(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): this
 
     off(event: 'data', listener: (bytes: Uint8Array) => void): void
     off(event: 'error', listener: (name: string) => void): void
     off(event: 'connected', listener: () => void): void
-    off(event: 'disconnected', listener: (disconnectionType: DisconnectionType, code?: number, reason?: string) => void): void
+    off(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): void
     
     send(data: Uint8Array): void
-    close(disconnectionType: DisconnectionType): Promise<void>
+    close(gracefulLeave: boolean): Promise<void>
     destroy(): void
 }

package/src/connection/ManagedConnection.ts

@@ -6,7 +6,6 @@ import { Logger, raceEvents3, runAndRaceEvents3, RunAndRaceEventsReturnType } fr
 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 {
@@ -44,12 +43,12 @@ export class ManagedConnection extends EventEmitter<Events> {
     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,
@@ -58,7 +57,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         this.send = this.send.bind(this)
 
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.outgoingConnection = outgoingConnection
         this.incomingConnection = incomingConnection
         this.connectionType = connectionType
@@ -72,7 +71,7 @@ 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)
@@ -95,7 +94,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         } else {
             if (incomingConnection) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, incomingConnection)
+                this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
                 this.handshaker.on('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
                     this.setPeerDescriptor(peerDescriptor)
                     this.emit('handshakeRequest', peerDescriptor)
@@ -165,7 +164,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         return this.peerDescriptor
     }
 
-    private onHandshakeCompleted = (peerDescriptor: PeerDescriptor) => {
+    private onHandshakeCompleted(peerDescriptor: PeerDescriptor) {
         this.lastUsed = Date.now()
 
         this.setPeerDescriptor(peerDescriptor)
@@ -186,7 +185,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 {
@@ -207,13 +206,13 @@ export class ManagedConnection extends EventEmitter<Events> {
         impl.on('disconnected', this.onDisconnected)
     }
 
-    private onDisconnected(disconnectionType: DisconnectionType): void {
-        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' onDisconnected() ' + disconnectionType)
+    private onDisconnected(gracefulLeave: boolean): void {
+        logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' onDisconnected() ' + gracefulLeave)
         if (this.bufferSentbyOtherConnection) {
             return
         }
         this.emit('internal_disconnected')
-        this.doDisconnect(disconnectionType)
+        this.doDisconnect(gracefulLeave)
     }
 
     async send(data: Uint8Array, doNotConnect = false): Promise<void> {
@@ -246,14 +245,14 @@ export class ManagedConnection extends EventEmitter<Events> {
 
             if (result.winnerName === 'internal_disconnected') {
                 this.doNotEmitDisconnected = false
-                this.doDisconnect('OTHER')
+                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('OTHER')
+                    this.doDisconnect(false)
                 } else {
                     let result2: RunAndRaceEventsReturnType<Events>
 
@@ -268,7 +267,7 @@ export class ManagedConnection extends EventEmitter<Events> {
                     if (result2.winnerName === 'bufferSentByOtherConnection') {
                         logger.trace('bufferSentByOtherConnection received')
                         this.doNotEmitDisconnected = false
-                        this.doDisconnect('OTHER')
+                        this.doDisconnect(false)
                     } else if (result2.winnerName === 'closing') {
                         logger.trace('bufferSentByOtherConnection not received, instead received a closing event')
                     } else if (result2.winnerName === 'disconnected') {
@@ -305,7 +304,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()
@@ -322,18 +321,18 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.handshaker!.sendHandshakeResponse(errorMessage)
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType) {
+    private doDisconnect(gracefulLeave: boolean) {
         logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' doDisconnect() emitting')
 
         if (!this.doNotEmitDisconnected) {
             logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' emitting disconnected')
-            this.emit('disconnected', disconnectionType)
+            this.emit('disconnected', gracefulLeave)
         } else {
             logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' not emitting disconnected because doNotEmitDisconnected flag is set')
         }
     }
 
-    public async close(disconnectionType: DisconnectionType): Promise<void> {
+    public async close(gracefulLeave: boolean): Promise<void> {
         if (this.replacedByOtherConnection) {
             logger.trace('close() called on replaced connection')
         }
@@ -341,13 +340,13 @@ export class ManagedConnection extends EventEmitter<Events> {
         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.doDisconnect(gracefulLeave)
         }
     }
 

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

@@ -1,25 +1,25 @@
 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)
     }
 
-    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,7 +4,6 @@ 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'
 
 const logger = new Logger(module)
@@ -12,19 +11,19 @@ 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,36 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            logger.error(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.error(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(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(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
 
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', '
                 + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' close() not stopped')
             this.stopped = true
 
             try {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() calling simulator.disconnect()')
                 this.simulator.close(this)
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' close() simulator.disconnect returned')
             } catch (e) {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     'close aborted' + e)
             } finally {
-                logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+                logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                     ' calling this.doDisconnect')
-                this.doDisconnect(disconnectionType)
+                this.doDisconnect(gracefulLeave)
             }
 
         } else {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', ' + keyFromPeerDescriptor(this.targetPeerDescriptor) +
                 ' close() tried to close a stopped connection')
         }
     }
@@ -87,7 +86,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 +108,9 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' handleIncomingDisconnection()')
+            logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ' handleIncomingDisconnection()')
             this.stopped = true
-            this.doDisconnect('OTHER')
+            this.doDisconnect(false)
         } else {
             logger.trace('tried to call handleIncomingDisconnection() a stopped connection')
         }
@@ -119,22 +118,22 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public destroy(): void {
         if (!this.stopped) {
-            logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ' destroy()')
+            logger.trace(keyFromPeerDescriptor(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(keyFromPeerDescriptor(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(keyFromPeerDescriptor(this.localPeerDescriptor) + ' doDisconnect()')
         this.stopped = true
 
-        logger.trace(keyFromPeerDescriptor(this.ownPeerDescriptor) + ', '
+        logger.trace(keyFromPeerDescriptor(this.localPeerDescriptor) + ', '
             + keyFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
 
-        this.emit('disconnected', disconnectionType)
+        this.emit('disconnected', gracefulLeave)
 
     }
 }