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

package/src/connection/ConnectivityChecker.ts

@@ -6,16 +6,16 @@ import {
 import { ConnectionEvents, IConnection } from './IConnection'
 import { Logger, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
 import * as Err from '../helpers/errors'
-import { ClientWebSocket } from './WebSocket/ClientWebSocket'
+import { ClientWebsocket } from './websocket/ClientWebsocket'
 import { v4 } from 'uuid'
 import { NatType } from './ConnectionManager'
-import { ServerWebSocket } from './WebSocket/ServerWebSocket'
-import { connectivityMethodToWebSocketUrl } from './WebSocket/WebSocketConnectorRpcLocal'
+import { ServerWebsocket } from './websocket/ServerWebsocket'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
 
 const logger = new Logger(module)
 
 // Class for handling both client and server side of the connectivity
-// checks. This is attached to all ServerWebSockets to listen to
+// checks. This is attached to all ServerWebsockets to listen to
 // ConnectivityRequest messages. 
 
 export enum ConnectionMode { REQUEST = 'connectivityRequest', PROBE = 'connectivityProbe' }
@@ -24,17 +24,17 @@ export class 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
+    private readonly websocketPort: number
     private readonly tls: boolean 
-    private readonly host?: string
+    private host?: string
 
-    constructor(webSocketPort: number, tls: boolean, host?: string) {
-        this.webSocketPort = webSocketPort
+    constructor(websocketPort: number, tls: boolean, host?: string) {
+        this.websocketPort = websocketPort
         this.tls = tls
         this.host = host
     }
 
-    public async sendConnectivityRequest(entryPoint: PeerDescriptor): Promise<ConnectivityResponse> {
+    public async sendConnectivityRequest(entryPoint: PeerDescriptor, selfSigned: boolean): Promise<ConnectivityResponse> {
         if (this.destroyed) {
             throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
         }
@@ -46,13 +46,14 @@ export class ConnectivityChecker {
                     port: entryPoint.websocket!.port,
                     tls: entryPoint.websocket!.tls,
                 },
-                mode: ConnectionMode.REQUEST
+                mode: ConnectionMode.REQUEST,
+                selfSigned
             })
         } catch (e) {
-            throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${connectivityMethodToWebSocketUrl(entryPoint.websocket!)}`, 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 }
+        const connectivityRequestMessage: ConnectivityRequest = { port: this.websocketPort, host: this.host, tls: this.tls, selfSigned }
         const msg: Message = {
             serviceId: ConnectivityChecker.CONNECTIVITY_CHECKER_SERVICE_ID,
             messageType: MessageType.CONNECTIVITY_REQUEST, messageId: v4(),
@@ -64,11 +65,11 @@ export class ConnectivityChecker {
         const responseAwaiter = () => {
             return new Promise((resolve: (res: ConnectivityResponse) => void, reject) => {
                 const timeoutId = setTimeout(() => {
-                    outgoingConnection.close('OTHER')
+                    outgoingConnection.close(false)
                     reject(new Err.ConnectivityResponseTimeout('timeout'))
                 }, ConnectivityChecker.CONNECTIVITY_CHECKER_TIMEOUT)
                 const listener = (bytes: Uint8Array) => {
-                    outgoingConnection.close('OTHER')
+                    outgoingConnection.close(false)
                     try {
                         const message: Message = Message.fromBinary(bytes)
                         if (message.body.oneofKind === 'connectivityResponse') {
@@ -98,7 +99,11 @@ export class ConnectivityChecker {
         }
     }
 
-    public listenToIncomingConnectivityRequests(connectionToListenTo: ServerWebSocket): void {
+    public setHost(hostName: string): void {
+        this.host = hostName
+    }
+
+    public listenToIncomingConnectivityRequests(connectionToListenTo: ServerWebsocket): void {
         connectionToListenTo.on('data', (data: Uint8Array) => {
             logger.trace('server received data')
             try {
@@ -120,7 +125,7 @@ export class ConnectivityChecker {
     }
 
     private async handleIncomingConnectivityRequest(
-        connection: ServerWebSocket,
+        connection: ServerWebsocket,
         connectivityRequest: ConnectivityRequest
     ): Promise<void> {
         if (this.destroyed) {
@@ -135,24 +140,23 @@ export class ConnectivityChecker {
                 port: connectivityRequest.port,
                 tls: connectivityRequest.tls
             }
-            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebSocketUrl(wsServerInfo)}`)
+            logger.trace(`Attempting Connectivity Check to ${connectivityMethodToWebsocketUrl(wsServerInfo)}`)
             outgoingConnection = await this.connectAsync({
                 wsServerInfo,
-                mode: ConnectionMode.PROBE
+                mode: ConnectionMode.PROBE,
+                selfSigned: connectivityRequest.selfSigned
             })
         } catch (err) {
             logger.debug('error', { err })
             connectivityResponseMessage = {
-                openInternet: false,
                 host,
                 natType: NatType.UNKNOWN
             }
         }
         if (outgoingConnection) {
-            outgoingConnection.close('OTHER')
+            outgoingConnection.close(false)
             logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
             connectivityResponseMessage = {
-                openInternet: true,
                 host,
                 natType: NatType.OPEN_INTERNET,
                 websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls }
@@ -171,15 +175,15 @@ export class ConnectivityChecker {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    private async connectAsync({ wsServerInfo, mode, timeoutMs = 1000, }:
-        { wsServerInfo: ConnectivityMethod, mode: ConnectionMode, timeoutMs?: number }
+    private async connectAsync({ wsServerInfo, mode, selfSigned, timeoutMs = 1000, }:
+        { wsServerInfo: ConnectivityMethod, mode: ConnectionMode, selfSigned: boolean, timeoutMs?: number }
     ): Promise<IConnection> {
-        const socket = new ClientWebSocket()
-        const url = `${connectivityMethodToWebSocketUrl(wsServerInfo)}?${mode}=true`
+        const socket = new ClientWebsocket()
+        const url = `${connectivityMethodToWebsocketUrl(wsServerInfo)}?${mode}=true`
         let result: RunAndRaceEventsReturnType<ConnectionEvents>
         try {
             result = await runAndRaceEvents3<ConnectionEvents>([
-                () => { socket.connect(url) }],
+                () => { socket.connect(url, selfSigned) }],
             socket, ['connected', 'error'],
             timeoutMs)
         } catch (e) {

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)