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

package/src/connection/websocket/WebsocketConnector.ts

@@ -0,0 +1,328 @@
+import { ClientWebsocket } from './ClientWebsocket'
+import { IConnection, ConnectionType } from '../IConnection'
+import { ITransport } from '../../transport/ITransport'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { WebsocketConnectorRpcLocal } from './WebsocketConnectorRpcLocal'
+import { WebsocketConnectorRpcRemote } from './WebsocketConnectorRpcRemote'
+import {
+    ConnectivityMethod,
+    ConnectivityResponse,
+    HandshakeError,
+    PeerDescriptor,
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { Logger, binaryToHex, wait } from '@streamr/utils'
+import { ManagedConnection } from '../ManagedConnection'
+import { WebsocketServer } from './WebsocketServer'
+import { ConnectivityChecker } from '../ConnectivityChecker'
+import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
+import { PeerIDKey } from '../../helpers/PeerID'
+import { ServerWebsocket } from './ServerWebsocket'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { Handshaker } from '../Handshaker'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { ParsedUrlQuery } from 'querystring'
+import { range, sample } from 'lodash'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { expectedConnectionType } from '../../helpers/Connectivity'
+import { WebsocketServerStartError } from '../../helpers/errors'
+import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
+const logger = new Logger(module)
+
+export type Action = 'connectivityRequest' | 'connectivityProbe'
+
+export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod, action?: Action): string => {
+    return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port + ((action !== undefined) ? '?action=' + action : '')
+}
+
+const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
+
+export interface WebsocketConnectorConfig {
+    transport: ITransport
+    canConnect: (peerDescriptor: PeerDescriptor) => boolean
+    onNewConnection: (connection: ManagedConnection) => boolean
+    portRange?: PortRange
+    maxMessageSize?: number
+    host?: string
+    entrypoints?: PeerDescriptor[]
+    tlsCertificate?: TlsCertificate
+    autoCertifierTransport: ITransport
+    autoCertifierUrl: string
+    autoCertifierConfigFile: string
+    serverEnableTls: boolean
+}
+
+export class WebsocketConnector {
+
+    private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+    private readonly websocketServer?: WebsocketServer
+    private connectivityChecker?: ConnectivityChecker
+    private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
+    private onNewConnection: (connection: ManagedConnection) => boolean
+    private host?: string
+    private readonly entrypoints?: PeerDescriptor[]
+    private readonly tlsCertificate?: TlsCertificate
+    private readonly autoCertifierTransport: ITransport
+    private readonly autoCertifierUrl: string
+    private readonly autoCertifierConfigFile: string
+    private readonly serverEnableTls: boolean
+    private autoCertifierClient?: AutoCertifierClientFacade
+    private selectedPort?: number
+    private localPeerDescriptor?: PeerDescriptor
+    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private abortController = new AbortController()
+
+    constructor(config: WebsocketConnectorConfig) {
+        this.websocketServer = config.portRange ? new WebsocketServer({
+            portRange: config.portRange!,
+            tlsCertificate: config.tlsCertificate,
+            maxMessageSize: config.maxMessageSize,
+            enableTls: config.serverEnableTls
+        }) : undefined
+        this.onNewConnection = config.onNewConnection
+        this.host = config.host
+        this.entrypoints = config.entrypoints
+        this.tlsCertificate = config.tlsCertificate
+        this.autoCertifierTransport = config.autoCertifierTransport
+        this.autoCertifierUrl = config.autoCertifierUrl
+        this.autoCertifierConfigFile = config.autoCertifierConfigFile
+        this.serverEnableTls = config.serverEnableTls
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebsocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
+            rpcRequestTimeout: 15000
+        })
+        this.registerLocalRpcMethods(config)
+    }
+
+    private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
+        const rpcLocal = new WebsocketConnectorRpcLocal({
+            canConnect: (peerDescriptor: PeerDescriptor) => config.canConnect(peerDescriptor),
+            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
+            onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
+            abortSignal: this.abortController.signal
+        })
+        this.rpcCommunicator.registerRpcMethod(
+            WebsocketConnectionRequest,
+            WebsocketConnectionResponse,
+            'requestConnection',
+            async (req: WebsocketConnectionRequest, context: ServerCallContext) => {
+                if (!this.abortController.signal.aborted) {
+                    return rpcLocal.requestConnection(req, context)
+                } else {
+                    return { accepted: false }
+                }
+            }
+        )
+    }
+
+    private attachHandshaker(connection: IConnection) {
+        const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
+        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor?: PeerDescriptor) => {
+            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, remotePeerDescriptor)
+        })
+    }
+
+    public async autoCertify(): Promise<void> {
+        this.autoCertifierClient = new AutoCertifierClientFacade({
+            configFile: this.autoCertifierConfigFile,
+            transport: this.autoCertifierTransport,
+            url: this.autoCertifierUrl,
+            wsServerPort: this.selectedPort!,
+            setHost: (hostName: string) => this.setHost(hostName),
+            updateCertificate: (certificate: string, privateKey: string) => this.websocketServer!.updateCertificate(certificate, privateKey)
+        })
+        logger.trace(`AutoCertifying subdomain...`)
+        await this.autoCertifierClient!.start()
+    }
+
+    private setHost(hostName: string): void {
+        logger.trace(`Setting host name to ${hostName}`)
+        this.host = hostName
+        this.connectivityChecker!.setHost(hostName)
+    }
+
+    public async start(): Promise<void> {
+        if (!this.abortController.signal.aborted && this.websocketServer) {
+            this.websocketServer.on('connected', (connection: IConnection) => {
+                const serverSocket = connection as unknown as ServerWebsocket
+                const query = serverSocket.resourceURL.query as unknown as (ParsedUrlQuery | null)
+                const action = query?.action as (Action | undefined)
+                logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.getRemoteAddress() })
+                if (action === 'connectivityRequest') {
+                    this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
+                } else if (action === 'connectivityProbe') {
+                    // no-op
+                } else {
+                    this.attachHandshaker(connection)
+                }
+            })
+            const port = await this.websocketServer.start()
+            this.selectedPort = port
+            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.serverEnableTls, this.host)
+        }
+    }
+
+    public async checkConnectivity(selfSigned: boolean): Promise<ConnectivityResponse> {
+        // TODO: this could throw if the server is not running
+        const noServerConnectivityResponse: ConnectivityResponse = {
+            host: '127.0.0.1',
+            natType: NatType.UNKNOWN
+        }
+        if (this.abortController.signal.aborted) {
+            return noServerConnectivityResponse
+        }
+        for (const reattempt of range(ENTRY_POINT_CONNECTION_ATTEMPTS)) {
+            const entryPoint = sample(this.entrypoints)!
+            try {
+                if (!this.websocketServer) {
+                    return noServerConnectivityResponse
+                } else {
+                    if (!this.entrypoints || this.entrypoints.length === 0) {
+                        // return connectivity info given in config
+                        const preconfiguredConnectivityResponse: ConnectivityResponse = {
+                            host: this.host!,
+                            natType: NatType.OPEN_INTERNET,
+                            websocket: { host: this.host!, port: this.selectedPort!, tls: this.tlsCertificate !== undefined }
+                        }
+                        return preconfiguredConnectivityResponse
+                    } else {
+                        // Do real connectivity checking
+                        return await this.connectivityChecker!.sendConnectivityRequest(entryPoint, selfSigned)
+                    }
+                }
+            } catch (err) {
+                if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
+                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.kademliaId)} `
+                        + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
+                    logger.error(error, { error: err })
+                    await wait(2000)
+                }
+            }
+        }
+        throw new WebsocketServerStartError(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
+    }
+
+    public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
+        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
+        return (connectionType === ConnectionType.WEBSOCKET_CLIENT || connectionType === ConnectionType.WEBSOCKET_SERVER)
+    }
+
+    public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.connectingConnections.get(peerKey)
+        if (existingConnection) {
+            return existingConnection
+        }
+
+        if (this.localPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
+            return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
+        } else {
+            const socket = new ClientWebsocket()
+
+            const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
+
+            const managedConnection = new ManagedConnection(
+                this.localPeerDescriptor!,
+                ConnectionType.WEBSOCKET_CLIENT,
+                socket,
+                undefined,
+                targetPeerDescriptor
+            )
+            managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
+
+            this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+
+            const delFunc = () => {
+                if (this.connectingConnections.has(peerKey)) {
+                    this.connectingConnections.delete(peerKey)
+                }
+                socket.off('disconnected', delFunc)
+                managedConnection.off('handshakeCompleted', delFunc)
+            }
+            socket.on('disconnected', delFunc)
+            managedConnection.on('handshakeCompleted', delFunc)
+
+            socket.connect(url)
+
+            return managedConnection
+        }
+    }
+
+    private requestConnectionFromPeer(localPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+        setImmediate(() => {
+            const remoteConnector = new WebsocketConnectorRpcRemote(
+                localPeerDescriptor,
+                targetPeerDescriptor,
+                toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+            )
+            remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
+        })
+        const managedConnection = new ManagedConnection(
+            this.localPeerDescriptor!,
+            ConnectionType.WEBSOCKET_SERVER,
+            undefined,
+            undefined,
+            targetPeerDescriptor
+        )        
+        managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
+        this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+        return managedConnection
+    }
+
+    private onServerSocketHandshakeRequest(
+        sourcePeerDescriptor: PeerDescriptor, 
+        serverWebsocket: IConnection,
+        targetPeerDescriptor?: PeerDescriptor
+    ) {
+        const peerId = peerIdFromPeerDescriptor(sourcePeerDescriptor)
+
+        if (this.ongoingConnectRequests.has(peerId.toKey())) {
+            const ongoingConnectRequest = this.ongoingConnectRequests.get(peerId.toKey())!
+            ongoingConnectRequest.attachImplementation(serverWebsocket)
+            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                ongoingConnectRequest.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
+            } else {
+                ongoingConnectRequest.acceptHandshake()
+                this.ongoingConnectRequests.delete(peerId.toKey())
+            }
+        } else {
+            const managedConnection = new ManagedConnection(
+                this.localPeerDescriptor!,
+                ConnectionType.WEBSOCKET_SERVER,
+                undefined,
+                serverWebsocket,
+                targetPeerDescriptor
+            )
+
+            managedConnection.setRemotePeerDescriptor(sourcePeerDescriptor)
+
+            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                managedConnection.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
+            } else if (this.onNewConnection(managedConnection)) {
+                managedConnection.acceptHandshake()
+            } else {
+                managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)
+            }
+        }
+    }
+
+    public setLocalPeerDescriptor(localPeerDescriptor: PeerDescriptor): void {
+        this.localPeerDescriptor = localPeerDescriptor
+    }
+
+    public async destroy(): Promise<void> {
+        this.abortController.abort()
+        this.rpcCommunicator.destroy()
+
+        const requests = Array.from(this.ongoingConnectRequests.values())
+        await Promise.allSettled(requests.map((conn) => conn.close(false)))
+
+        const attempts = Array.from(this.connectingConnections.values())
+        await Promise.allSettled(attempts.map((conn) => conn.close(false)))
+        this.connectivityChecker?.destroy()
+        await this.websocketServer?.stop()
+    }
+}

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -0,0 +1,41 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import {
+    PeerDescriptor,
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { IWebsocketConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
+import { ManagedConnection } from '../ManagedConnection'
+
+interface WebsocketConnectorRpcLocalConfig {
+    canConnect: (peerDescriptor: PeerDescriptor) => boolean
+    connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
+    onNewConnection: (connection: ManagedConnection) => boolean
+    abortSignal: AbortSignal
+}
+
+export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
+
+    private readonly config: WebsocketConnectorRpcLocalConfig
+
+    constructor(config: WebsocketConnectorRpcLocalConfig) {
+        this.config = config
+    }
+
+    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        if (this.config.canConnect(senderPeerDescriptor)) {
+            setImmediate(() => {
+                if (this.config.abortSignal.aborted) {
+                    return
+                }
+                const connection = this.config.connect(senderPeerDescriptor)
+                this.config.onNewConnection(connection)
+            })
+            return { accepted: true }
+        } else {
+            return { accepted: false }
+        }
+    }
+}

package/src/connection/{WebSocket/WebSocketConnectorRpcRemote.ts → websocket/WebsocketConnectorRpcRemote.ts}

@@ -1,44 +1,38 @@
 import {
     PeerDescriptor,
-    WebSocketConnectionRequest
+    WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebSocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IWebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Remote } from '../../dht/contact/Remote'
 
 const logger = new Logger(module)
 
-export class WebSocketConnectorRpcRemote extends Remote<IWebSocketConnectorRpcClient> {
+export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcClient> {
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebSocketConnectorRpcClient>
+        client: ProtoRpcClient<IWebsocketConnectorRpcClient>
     ) {
         super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
     }
 
     async requestConnection(ip: string, port: number): Promise<boolean> {
-        logger.trace(`Requesting WebSocket connection from ${keyFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
-        const request: WebSocketConnectionRequest = {
+        logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
+        const request: WebsocketConnectionRequest = {
             ip,
             port
         }
         const options = this.formDhtRpcOptions()
         try {
             const res = await this.getClient().requestConnection(request, options)
-            
-            if (res.reason) {
-                logger.debug('WebSocketConnectionRequest Rejected', {
-                    stack: new Err.WebSocketConnectionRequestRejected(res.reason).stack
-                })
-            }
             return res.accepted
         } catch (err) {
-            logger.debug(new Err.WebSocketConnectionRequestRejected('WebSocketConnectionRequest rejected', err).stack!)
+            logger.debug(new Err.WebsocketConnectionRequestRejected('WebsocketConnectionRequest rejected', err).stack!)
             return false
         }
     }

package/src/connection/{WebSocket/WebSocketServer.ts → websocket/WebsocketServer.ts}

@@ -2,16 +2,15 @@ import { createServer as createHttpServer, Server as HttpServer, IncomingMessage
 import { createServer as createHttpsServer, Server as HttpsServer } from 'https'
 import EventEmitter from 'eventemitter3'
 import { server as WsServer } from 'websocket'
-import { ServerWebSocket } from './ServerWebSocket'
-import {
-    ConnectionSourceEvents
-} from '../IConnectionSource'
-
+import { ServerWebsocket } from './ServerWebsocket'
+import { ConnectionSourceEvents } from '../IConnectionSource'
 import { Logger, asAbortable } from '@streamr/utils'
-import { WebSocketServerStartError } from '../../helpers/errors'
+import { createSelfSignedCertificate } from '@streamr/autocertifier-client' 
+import { WebsocketServerStartError } from '../../helpers/errors'
 import { PortRange, TlsCertificate } from '../ConnectionManager'
 import { range } from 'lodash'
 import fs from 'fs'
+import { UUID } from '../../helpers/UUID'
 
 const logger = new Logger(module)
 
@@ -22,24 +21,27 @@ const logger = new Logger(module)
 
 declare class NodeJsWsServer extends WsServer { }
 
-interface WebSocketServerConfig {
+interface WebsocketServerConfig {
     portRange: PortRange
+    enableTls: boolean
     tlsCertificate?: TlsCertificate
     maxMessageSize?: number
 }
 
-export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
+export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
 
     private httpServer?: HttpServer | HttpsServer
     private wsServer?: WsServer
     private readonly abortController = new AbortController()
     private readonly portRange: PortRange
     private readonly tlsCertificate?: TlsCertificate
+    private readonly enableTls: boolean
     private readonly maxMessageSize: number
 
-    constructor(config: WebSocketServerConfig) {
+    constructor(config: WebsocketServerConfig) {
         super()
         this.portRange = config.portRange
+        this.enableTls = config.enableTls
         this.tlsCertificate = config.tlsCertificate
         this.maxMessageSize = config.maxMessageSize ?? 1048576
     }
@@ -48,33 +50,42 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
         const ports = range(this.portRange.min, this.portRange.max + 1)
         for (const port of ports) {
             try {
-                await asAbortable(this.startServer(port, this.tlsCertificate), this.abortController.signal)
+                await asAbortable(this.startServer(port, this.enableTls), this.abortController.signal)
                 return port
             } catch (err) {
                 if (err.originalError?.code === 'EADDRINUSE') {
                     logger.debug(`failed to start WebSocket server on port: ${port} reattempting on next port`)
                 } else {
-                    throw new WebSocketServerStartError(err)
+                    throw new WebsocketServerStartError(err)
                 }
             }
         }
-        throw new WebSocketServerStartError(`Failed to start WebSocket server on any port in range: ${this.portRange.min}-${this.portRange.min}`)
+        throw new WebsocketServerStartError(`Failed to start WebSocket server on any port in range: ${this.portRange.min}-${this.portRange.min}`)
     }
 
-    private startServer(port: number, tlsCertificate?: TlsCertificate): Promise<void> {
+    // If tlsCertificate has been given the tls boolean is ignored
+    // TODO: could be simplified?
+    private startServer(port: number, tls: boolean): Promise<void> {
         const requestListener = (request: IncomingMessage, response: ServerResponse<IncomingMessage>) => {
             logger.trace('Received request for ' + request.url)
             response.writeHead(404)
             response.end()
         }
         return new Promise((resolve, reject) => {
-            this.httpServer = tlsCertificate ? 
-                createHttpsServer({
-                    key: fs.readFileSync(tlsCertificate.privateKeyFileName),
-                    cert: fs.readFileSync(tlsCertificate.certFileName)
+            if (this.tlsCertificate) {
+                this.httpServer = createHttpsServer({
+                    key: fs.readFileSync(this.tlsCertificate.privateKeyFileName),
+                    cert: fs.readFileSync(this.tlsCertificate.certFileName)
+                }, requestListener)
+            } else if (!tls) {
+                this.httpServer = createHttpServer(requestListener)
+            } else {
+                const certificate = createSelfSignedCertificate('streamr-self-signed-' + new UUID().toString(), 1000)
+                this.httpServer = createHttpsServer({
+                    key: certificate.serverKey,
+                    cert: certificate.serverCert
                 }, requestListener)
-                : 
-                createHttpServer(requestListener)
+            }
 
             function originIsAllowed() {
                 return true
@@ -94,10 +105,10 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
                 
                 logger.trace('IConnection accepted.')
 
-                this.emit('connected', new ServerWebSocket(connection, request.resourceURL))
+                this.emit('connected', new ServerWebsocket(connection, request.resourceURL))
             })
             this.httpServer.once('error', (err: Error) => {
-                reject(new WebSocketServerStartError('Starting Websocket server failed', err))
+                reject(new WebsocketServerStartError('Starting Websocket server failed', err))
             })
 
             this.httpServer.once('listening', () => {
@@ -109,11 +120,18 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
                 // Listen only to IPv4 network interfaces, default value listens to IPv6 as well
                 this.httpServer.listen(port, '0.0.0.0')
             } catch (e) {
-                reject(new WebSocketServerStartError('Websocket server threw an exception', e))
+                reject(new WebsocketServerStartError('Websocket server threw an exception', e))
             }
         })
     }
 
+    public updateCertificate(cert: string, key: string): void {
+        (this.httpServer! as HttpsServer).setSecureContext({
+            cert,
+            key
+        })
+    }
+
     public stop(): Promise<void> {
         this.abortController.abort()
         this.removeAllListeners()