@streamr/dht 100.2.5-beta.1 → 101.0.0-beta.1

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -13,12 +13,6 @@ enum DisconnectedRtcPeerConnectionStateEnum {
 
 const logger = new Logger(module)
 
-export const WEBRTC_CLEANUP = new class {
-    // eslint-disable-next-line class-methods-use-this
-    cleanUp(): void {
-    }
-}
-
 type Events = WebrtcConnectionEvents & ConnectionEvents
 
 interface Params {

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -2,7 +2,7 @@ import { IWebrtcConnection, WebrtcConnectionEvents } from './IWebrtcConnection'
 import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import EventEmitter from 'eventemitter3'
-import { DataChannel, DescriptionType, PeerConnection, cleanup, initLogger } from 'node-datachannel'
+import { DataChannel, DescriptionType, PeerConnection, initLogger } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
 import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
 import { iceServerAsString } from './iceServerAsString'
@@ -13,18 +13,10 @@ import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
 
-export const WEBRTC_CLEANUP = new class {
-    // eslint-disable-next-line class-methods-use-this
-    cleanUp(): void {
-        cleanup()
-    }
-}
-
 export interface Params {
     remotePeerDescriptor: PeerDescriptor
     bufferThresholdHigh?: number
     bufferThresholdLow?: number
-    connectingTimeout?: number
     maxMessageSize?: number
     iceServers?: IceServer[]  // TODO make this parameter required (empty array is a good fallback which can be set by the caller if needed)
     portRange?: PortRange
@@ -55,16 +47,15 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     private dataChannel?: DataChannel
     private lastState: RtcPeerConnectionState = 'connecting'
     private remoteDescriptionSet = false
-    private connectingTimeoutRef?: NodeJS.Timeout
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
     private readonly iceServers: IceServer[]
     private readonly _bufferThresholdHigh: number // TODO: buffer handling must be implemented before production use (NET-938)
     private readonly bufferThresholdLow: number
-    private readonly connectingTimeout: number
     private readonly remotePeerDescriptor: PeerDescriptor
     private readonly portRange?: PortRange
     private readonly maxMessageSize?: number
     private closed = false
+    private offering?: boolean
 
     constructor(params: Params) {
         super()
@@ -73,7 +64,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         // eslint-disable-next-line no-underscore-dangle
         this._bufferThresholdHigh = params.bufferThresholdHigh ?? 2 ** 17
         this.bufferThresholdLow = params.bufferThresholdLow ?? 2 ** 15
-        this.connectingTimeout = params.connectingTimeout ?? 20000
         this.remotePeerDescriptor = params.remotePeerDescriptor
         this.maxMessageSize = params.maxMessageSize ?? 1048576
         this.portRange = params.portRange
@@ -81,6 +71,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
 
     public start(isOffering: boolean): void {
         const nodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+        this.offering = isOffering
         logger.trace(`Starting new connection for peer ${nodeId}`, { isOffering })
         this.connection = new PeerConnection(nodeId, {
             iceServers: this.iceServers.map(iceServerAsString),
@@ -89,11 +80,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             portRangeEnd: this.portRange?.max,
         })
 
-        this.connectingTimeoutRef = setTimeout(() => {
-            logger.trace('connectingTimeout, this.closed === ' + this.closed)
-            this.doClose(false)
-        }, this.connectingTimeout)
-
         this.connection.onStateChange((state: string) => this.onStateChange(state))
         this.connection.onGatheringStateChange(() => {})
 
@@ -169,10 +155,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             
             this.emit('disconnected', gracefulLeave, undefined, reason)
             this.removeAllListeners()
-            
-            if (this.connectingTimeoutRef) {
-                clearTimeout(this.connectingTimeoutRef)
-            }
 
             if (this.dataChannel) {
                 try {
@@ -226,9 +208,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     }
 
     private onDataChannelOpen(): void {
-        if (this.connectingTimeoutRef) {
-            clearTimeout(this.connectingTimeoutRef)
-        }
         logger.trace(`DataChannel opened for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }

package/src/connection/webrtc/WebrtcConnector.ts

@@ -1,4 +1,5 @@
 import {
+    HandshakeError,
     IceCandidate,
     PeerDescriptor,
     RtcAnswer,
@@ -9,15 +10,16 @@ import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicat
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { ManagedWebrtcConnection } from './ManagedWebrtcConnection'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
-import { ManagedConnection } from '../ManagedConnection'
 import { PortRange } from '../ConnectionManager'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { WebrtcConnectorRpcLocal } from './WebrtcConnectorRpcLocal'
 import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { getOfferer } from '../../helpers/offering'
+import { acceptHandshake, createIncomingHandshaker, createOutgoingHandshaker, rejectHandshake } from '../Handshaker'
+import { isMaybeSupportedVersion } from '../../helpers/version'
+import { PendingConnection } from '../PendingConnection'
 
 const logger = new Logger(module)
 
@@ -30,14 +32,14 @@ export const replaceInternalIpWithExternalIp = (candidate: string, ip: string):
     return parsed.join(' ')
 }
 
-export interface WebrtcConnectorConfig {
+export interface WebrtcConnectorOptions {
+    onNewConnection: (connection: PendingConnection) => boolean
     transport: ITransport
     iceServers?: IceServer[]
     allowPrivateAddresses?: boolean
     bufferThresholdLow?: number
     bufferThresholdHigh?: number
     maxMessageSize?: number
-    connectionTimeout?: number
     externalIp?: string
     portRange?: PortRange
 }
@@ -50,38 +52,37 @@ export interface IceServer {
     tcp?: boolean
 }
 
+export interface ConnectingConnection {
+    managedConnection: PendingConnection
+    connection: NodeWebrtcConnection
+}
+
 export class WebrtcConnector {
 
     private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly ongoingConnectAttempts: Map<DhtAddress, ManagedWebrtcConnection> = new Map()
+    private readonly ongoingConnectAttempts: Map<DhtAddress, ConnectingConnection> = new Map()
     private localPeerDescriptor?: PeerDescriptor
     private stopped = false
-    private config: WebrtcConnectorConfig
-
-    constructor(
-        config: WebrtcConnectorConfig,
-        onNewConnection: (connection: ManagedConnection) => boolean
-    ) {
-        this.config = config
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
-            rpcRequestTimeout: 15000  // TODO use config option or named constant?
+    private options: WebrtcConnectorOptions
+
+    constructor(options: WebrtcConnectorOptions) {
+        this.options = options
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, options.transport, {
+            rpcRequestTimeout: 15000  // TODO use options option or named constant?
         })
-        this.registerLocalRpcMethods(config, onNewConnection)
+        this.registerLocalRpcMethods(options)
     }
 
-    private registerLocalRpcMethods(
-        config: WebrtcConnectorConfig,
-        onNewConnection: (connection: ManagedConnection) => boolean
-    ) {
+    private registerLocalRpcMethods(options: WebrtcConnectorOptions) {
         const localRpc = new WebrtcConnectorRpcLocal({
-            createConnection: (targetPeerDescriptor: PeerDescriptor) => this.createConnection(targetPeerDescriptor),
-            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            onNewConnection,
+            connect: (targetPeerDescriptor: PeerDescriptor, doNotRequestConnection: boolean) => 
+                this.connect(targetPeerDescriptor, doNotRequestConnection),
+            onNewConnection: (connection: PendingConnection) => this.options.onNewConnection(connection),
             ongoingConnectAttempts: this.ongoingConnectAttempts,
             rpcCommunicator: this.rpcCommunicator,
             getLocalPeerDescriptor: () => this.localPeerDescriptor!,
-            allowPrivateAddresses: config.allowPrivateAddresses ?? true
+            allowPrivateAddresses: options.allowPrivateAddresses ?? true
         })
         this.rpcCommunicator.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection',
             async (_req: WebrtcConnectionRequest, context: ServerCallContext) => {
@@ -121,7 +122,7 @@ export class WebrtcConnector {
         )
     }
 
-    connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+    connect(targetPeerDescriptor: PeerDescriptor, doNotRequestConnection: boolean): PendingConnection {
         if (areEqualPeerDescriptors(targetPeerDescriptor, this.localPeerDescriptor!)) {
             throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
         }
@@ -131,7 +132,7 @@ export class WebrtcConnector {
         const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.ongoingConnectAttempts.get(nodeId)
         if (existingConnection) {
-            return existingConnection
+            return existingConnection.managedConnection
         }
 
         const connection = this.createConnection(targetPeerDescriptor)
@@ -139,68 +140,75 @@ export class WebrtcConnector {
         const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor!)
         const targetNodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
         const offering = (getOfferer(localNodeId, targetNodeId) === 'local')
-        let managedConnection: ManagedWebrtcConnection
-
-        if (offering) {
-            managedConnection = new ManagedWebrtcConnection(this.localPeerDescriptor!, connection)
-        } else {
-            managedConnection = new ManagedWebrtcConnection(this.localPeerDescriptor!, undefined, connection)
-        }
-
-        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
-
-        this.ongoingConnectAttempts.set(targetNodeId, managedConnection)
-
-        const delFunc = () => {
-            this.ongoingConnectAttempts.delete(nodeId)
-            connection.off('disconnected', delFunc)
-            managedConnection.off('handshakeCompleted', delFunc)
-        }
-        connection.on('disconnected', delFunc)
-        managedConnection.on('handshakeCompleted', delFunc)
-
+        let pendingConnection: PendingConnection
         const remoteConnector = new WebrtcConnectorRpcRemote(
             this.localPeerDescriptor!,
             targetPeerDescriptor,
             this.rpcCommunicator,
             WebrtcConnectorRpcClient
         )
-
-        connection.on('localCandidate', (candidate: string, mid: string) => {
-            if (this.config.externalIp !== undefined) {
-                candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
-                logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
-            }
-            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId)
-        })
-
+        const delFunc = () => {
+            this.ongoingConnectAttempts.delete(nodeId)
+            connection.off('disconnected', delFunc)
+            pendingConnection.off('disconnected', delFunc)
+            pendingConnection.off('connected', delFunc)
+        }
         if (offering) {
+            pendingConnection = new PendingConnection(targetPeerDescriptor)
+            createOutgoingHandshaker(this.localPeerDescriptor!, pendingConnection, connection, targetPeerDescriptor)
             connection.once('localDescription', (description: string) => {
+                logger.trace('Sending offer to remote peer')
                 remoteConnector.sendRtcOffer(description, connection.connectionId)
             })
         } else {
+            pendingConnection = new PendingConnection(targetPeerDescriptor)
+            const handshaker = createIncomingHandshaker(this.localPeerDescriptor!, pendingConnection, connection)
             connection.once('localDescription', (description: string) => {
                 remoteConnector.sendRtcAnswer(description, connection.connectionId)
             })
+            handshaker.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, remoteVersion: string) => {
+                if (!isMaybeSupportedVersion(remoteVersion)) {
+                    rejectHandshake(pendingConnection!, connection, handshaker, HandshakeError.UNSUPPORTED_VERSION)
+                } else {
+                    acceptHandshake(handshaker, pendingConnection, connection)
+                }
+                delFunc()
+            })
         }
 
+        this.ongoingConnectAttempts.set(targetNodeId, {
+            managedConnection: pendingConnection,
+            connection
+        })
+
+        connection.on('disconnected', delFunc)
+        pendingConnection.on('disconnected', delFunc)
+        pendingConnection.on('connected', delFunc)
+    
+        connection.on('localCandidate', (candidate: string, mid: string) => {
+            if (this.options.externalIp !== undefined) {
+                candidate = replaceInternalIpWithExternalIp(candidate, this.options.externalIp)
+                logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
+            }
+            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId)
+        })
+
         connection.start(offering)
 
-        if (!offering) {
+        if (!doNotRequestConnection && !offering) {
             remoteConnector.requestConnection()
         }
 
-        return managedConnection
+        return pendingConnection
     }
 
     private createConnection(targetPeerDescriptor: PeerDescriptor): NodeWebrtcConnection {
         return new NodeWebrtcConnection({
             remotePeerDescriptor: targetPeerDescriptor,
-            iceServers: this.config.iceServers,
-            bufferThresholdLow: this.config.bufferThresholdLow,
-            bufferThresholdHigh: this.config.bufferThresholdHigh,
-            connectingTimeout: this.config.connectionTimeout,
-            portRange: this.config.portRange
+            iceServers: this.options.iceServers,
+            bufferThresholdLow: this.options.bufferThresholdLow,
+            bufferThresholdHigh: this.options.bufferThresholdHigh,
+            portRange: this.options.portRange
             // TODO should we pass maxMessageSize?
         })
     }
@@ -214,7 +222,10 @@ export class WebrtcConnector {
         this.stopped = true
 
         const attempts = Array.from(this.ongoingConnectAttempts.values())
-        await Promise.allSettled(attempts.map((conn) => conn.close(false)))
+        await Promise.allSettled(attempts.map(async (conn) => {
+            conn.connection.destroy()
+            await conn.managedConnection.close(false)
+        }))
 
         this.rpcCommunicator.destroy()
     }

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -3,32 +3,27 @@ import { Logger } from '@streamr/utils'
 import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
 import { Empty } from '../../proto/google/protobuf/empty'
 import {
-    HandshakeError,
     IceCandidate,
     PeerDescriptor,
     RtcAnswer,
     RtcOffer
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { IWebrtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { ManagedConnection } from '../ManagedConnection'
-import { ManagedWebrtcConnection } from './ManagedWebrtcConnection'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
-import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { isMaybeSupportedVersion } from '../../helpers/version'
 import { ConnectionID } from '../IConnection'
+import { ConnectingConnection } from './WebrtcConnector'
+import { PendingConnection } from '../PendingConnection'
 
 const logger = new Logger(module)
 
-interface WebrtcConnectorRpcLocalConfig {
-    createConnection: (targetPeerDescriptor: PeerDescriptor) => NodeWebrtcConnection 
-    connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection 
-    onNewConnection: (connection: ManagedConnection) => boolean
+interface WebrtcConnectorRpcLocalOptions {
+    connect: (targetPeerDescriptor: PeerDescriptor, doNotRequestConnection: boolean) => PendingConnection 
+    onNewConnection: (connection: PendingConnection) => boolean
     // TODO pass accessor methods instead of passing a mutable entity
-    ongoingConnectAttempts: Map<DhtAddress, ManagedWebrtcConnection>
+    ongoingConnectAttempts: Map<DhtAddress, ConnectingConnection>
     rpcCommunicator: ListeningRpcCommunicator
     getLocalPeerDescriptor: () => PeerDescriptor
     allowPrivateAddresses: boolean
@@ -36,71 +31,46 @@ interface WebrtcConnectorRpcLocalConfig {
 
 export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
-    private readonly config: WebrtcConnectorRpcLocalConfig
+    private readonly options: WebrtcConnectorRpcLocalOptions
 
-    constructor(config: WebrtcConnectorRpcLocalConfig) {
-        this.config = config
+    constructor(options: WebrtcConnectorRpcLocalOptions) {
+        this.options = options
     }
 
     async requestConnection(context: ServerCallContext): Promise<Empty> {
         const targetPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.config.ongoingConnectAttempts.has(getNodeIdFromPeerDescriptor(targetPeerDescriptor))) {
+        if (this.options.ongoingConnectAttempts.has(getNodeIdFromPeerDescriptor(targetPeerDescriptor))) {
             return {}
         }
-        const managedConnection = this.config.connect(targetPeerDescriptor)
-        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
-        this.config.onNewConnection(managedConnection)
+        const pendingConnection = this.options.connect(targetPeerDescriptor, false)
+        this.options.onNewConnection(pendingConnection)
         return {}
     }
 
     async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
-        const remotePeer = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = getNodeIdFromPeerDescriptor(remotePeer)
-        let managedConnection = this.config.ongoingConnectAttempts.get(nodeId)
-        let connection = managedConnection?.getWebrtcConnection()
+        const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        let connection: NodeWebrtcConnection
+        let pendingConnection: PendingConnection
 
-        if (!managedConnection) {
-            connection = this.config.createConnection(remotePeer)
-            managedConnection = new ManagedWebrtcConnection(this.config.getLocalPeerDescriptor(), undefined, connection)
-            managedConnection.setRemotePeerDescriptor(remotePeer)
-            this.config.ongoingConnectAttempts.set(nodeId, managedConnection)
-            this.config.onNewConnection(managedConnection)
-            const remoteConnector = new WebrtcConnectorRpcRemote(
-                this.config.getLocalPeerDescriptor(),
-                remotePeer,
-                this.config.rpcCommunicator,
-                WebrtcConnectorRpcClient
-            )
-            connection.on('localCandidate', (candidate: string, mid: string) => {
-                remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId)
-            })
-            connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(description, connection!.connectionId)
-            })
-            connection.start(false)
+        if (!this.options.ongoingConnectAttempts.has(nodeId)) {
+            pendingConnection = this.options.connect(remotePeerDescriptor, true)
+            connection = this.options.ongoingConnectAttempts.get(nodeId)!.connection
+            this.options.onNewConnection(pendingConnection)
+        } else {
+            pendingConnection = this.options.ongoingConnectAttempts.get(nodeId)!.managedConnection
+            connection = this.options.ongoingConnectAttempts.get(nodeId)!.connection
         }
-
         // Always use offerers connectionId
         connection!.setConnectionId(request.connectionId as ConnectionID)
         connection!.setRemoteDescription(request.description, 'offer')
-
-        managedConnection.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, remoteVersion: string) => {
-            if (this.config.ongoingConnectAttempts.has(nodeId)) {
-                this.config.ongoingConnectAttempts.delete(nodeId)
-            }
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                managedConnection.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
-            } else {
-                managedConnection.acceptHandshake()
-            }
-        })
         return {}
     }
 
     async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.config.ongoingConnectAttempts.get(nodeId)?.getWebrtcConnection()
+        const connection = this.options.ongoingConnectAttempts.get(nodeId)?.connection
         if (!connection) {
             return {}
         } else if (connection.connectionId !== request.connectionId) {
@@ -114,7 +84,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
     async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.config.ongoingConnectAttempts.get(nodeId)?.getWebrtcConnection()
+        const connection = this.options.ongoingConnectAttempts.get(nodeId)?.connection
         if (!connection) {
             return {}
         } else if (connection.connectionId !== request.connectionId) {
@@ -127,7 +97,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
     }
 
     private isIceCandidateAllowed(candidate: string): boolean {
-        if (!this.config.allowPrivateAddresses) {
+        if (!this.options.allowPrivateAddresses) {
             const address = getAddressFromIceCandidate(candidate)
             if ((address !== undefined) && isPrivateIPv4(address)) {
                 return false

package/src/connection/websocket/AbstractWebsocketClientConnection.ts

@@ -44,7 +44,13 @@ export abstract class AbstractWebsocketClientConnection extends EventEmitter<Con
                 logger.trace(`Sending data with size ${data.byteLength}`)
                 this.socket?.send(data)
             } else {
-                logger.debug('Tried to send data on a non-open connection')
+                // Could this throw for faster feedback on RPC calls?
+                // Currently this log line is seen if a connection is closing but the disconnected event has not been emitted yet.
+                logger.debug('Tried to send data on a non-open connection', { 
+                    id: this.connectionId,
+                    readyState: this.socket!.readyState,
+                    destroyed: this.destroyed
+                })
             }
         } else {
             logger.debug('Tried to send() on stopped connection')
@@ -58,7 +64,7 @@ export abstract class AbstractWebsocketClientConnection extends EventEmitter<Con
             logger.trace(`Closing socket for connection ${this.connectionId}`)
             this.socket?.close(gracefulLeave ? CUSTOM_GOING_AWAY : undefined)
         } else {
-            logger.debug('Tried to close() a stopped connection')
+            logger.debug('Tried to close() a stopped connection', { id: this.connectionId })
         }
     }
 

package/src/connection/websocket/AutoCertifierClientFacade.ts

@@ -37,7 +37,7 @@ export interface IAutoCertifierClient {
     on(eventName: string, cb: (subdomain: CertifiedSubdomain) => void): void
 }
 
-interface AutoCertifierClientFacadeConfig {
+interface AutoCertifierClientFacadeOptions {
     url: string
     configFile: string
     transport: ITransport
@@ -55,24 +55,24 @@ export class AutoCertifierClientFacade {
 
     private autoCertifierClient: IAutoCertifierClient
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly config: AutoCertifierClientFacadeConfig
+    private readonly options: AutoCertifierClientFacadeOptions
 
-    constructor(config: AutoCertifierClientFacadeConfig) {
-        this.config = config
-        this.rpcCommunicator = new ListeningRpcCommunicator(AUTO_CERTIFIER_SERVICE_ID, config.transport)
-        this.autoCertifierClient = config.createClientFactory ? config.createClientFactory() 
+    constructor(options: AutoCertifierClientFacadeOptions) {
+        this.options = options
+        this.rpcCommunicator = new ListeningRpcCommunicator(AUTO_CERTIFIER_SERVICE_ID, options.transport)
+        this.autoCertifierClient = options.createClientFactory ? options.createClientFactory() 
             : defaultAutoCertifierClientFactory(
-                config.configFile,
-                config.url,
+                options.configFile,
+                options.url,
                 this.rpcCommunicator,
-                config.wsServerPort
+                options.wsServerPort
             )
     }
 
     async start(): Promise<void> {
         this.autoCertifierClient.on('updatedCertificate', (subdomain: CertifiedSubdomain) => {
-            this.config.setHost(subdomain.fqdn)
-            this.config.updateCertificate(subdomain.certificate, subdomain.privateKey)
+            this.options.setHost(subdomain.fqdn)
+            this.options.updateCertificate(subdomain.certificate, subdomain.privateKey)
             logger.trace(`Updated certificate`)
         })
         await Promise.all([

package/src/connection/websocket/NodeWebsocketClientConnection.ts

@@ -28,7 +28,7 @@ export class WebsocketClientConnection extends AbstractWebsocketClientConnection
                 }
             })
         } else {
-            logger.debug('Tried to connect() a stopped connection')
+            logger.debug('Tried to connect() a stopped connection', { id: this.connectionId })
         }
     }