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

package/src/connection/{WebSocket/WebSocketConnectorRpcLocal.ts → websocket/WebsocketConnector.ts}

@@ -1,112 +1,150 @@
-import { ClientWebSocket } from './ClientWebSocket'
+import { ClientWebsocket } from './ClientWebsocket'
 import { IConnection, ConnectionType } from '../IConnection'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { WebSocketConnectorRpcRemote } from './WebSocketConnectorRpcRemote'
+import { WebsocketConnectorRpcLocal } from './WebsocketConnectorRpcLocal'
+import { WebsocketConnectorRpcRemote } from './WebsocketConnectorRpcRemote'
 import {
     ConnectivityMethod,
     ConnectivityResponse,
-    NodeType,
     PeerDescriptor,
-    WebSocketConnectionRequest,
-    WebSocketConnectionResponse
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { WebSocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger, binaryToHex, wait } from '@streamr/utils'
-import { IWebSocketConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { ManagedConnection } from '../ManagedConnection'
-import { WebSocketServer } from './WebSocketServer'
+import { WebsocketServer } from './WebsocketServer'
 import { ConnectivityChecker } from '../ConnectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { PeerIDKey } from '../../helpers/PeerID'
-import { ServerWebSocket } from './ServerWebSocket'
+import { ServerWebsocket } from './ServerWebsocket'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Handshaker } from '../Handshaker'
 import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ParsedUrlQuery } from 'querystring'
 import { range, sample } from 'lodash'
-import { isPrivateIPv4 } from '../../helpers/AddressTools'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-
+import { expectedConnectionType } from '../../helpers/Connectivity'
+import { WebsocketServerStartError } from '../../helpers/errors'
+import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
 const logger = new Logger(module)
 
-export const connectivityMethodToWebSocketUrl = (ws: ConnectivityMethod): string => {
+export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod): string => {
     return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port
 }
 
-const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod) => {
-    const hasPrivateAddress = ((websocketServer.host === 'localhost') || isPrivateIPv4(websocketServer.host))
-    return websocketServer.tls || hasPrivateAddress
-}
-
 const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
-interface WebSocketConnectorRpcLocalConfig {
+interface WebsocketConnectorConfig {
     transport: ITransport
-    canConnect: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
+    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     onIncomingConnection: (connection: ManagedConnection) => boolean
     portRange?: PortRange
     maxMessageSize?: number
     host?: string
     entrypoints?: PeerDescriptor[]
     tlsCertificate?: TlsCertificate
+    autoCertifierTransport: ITransport
+    autoCertifierUrl: string
+    autoCertifierConfigFile: string
+    serverEnableTls: boolean
 }
 
-export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
+export class WebsocketConnector {
 
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly canConnectFunction: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
-    private readonly webSocketServer?: WebSocketServer
+    private readonly websocketServer?: WebsocketServer
     private connectivityChecker?: ConnectivityChecker
     private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
     private onIncomingConnection: (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 ownPeerDescriptor?: PeerDescriptor
+    private localPeerDescriptor?: PeerDescriptor
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
-    private destroyed = false
+    private abortController = new AbortController()
 
-    constructor(config: WebSocketConnectorRpcLocalConfig) {
-        this.webSocketServer = config.portRange ? new WebSocketServer({
+    constructor(config: WebsocketConnectorConfig) {
+        this.websocketServer = config.portRange ? new WebsocketServer({
             portRange: config.portRange!,
             tlsCertificate: config.tlsCertificate,
-            maxMessageSize: config.maxMessageSize
+            maxMessageSize: config.maxMessageSize,
+            enableTls: config.serverEnableTls
         }) : undefined
         this.onIncomingConnection = config.onIncomingConnection
         this.host = config.host
         this.entrypoints = config.entrypoints
         this.tlsCertificate = config.tlsCertificate
-
-        this.canConnectFunction = config.canConnect.bind(this)
-
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebSocketConnectorRpcLocal.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
+        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),
+            onIncomingConnection: (connection: ManagedConnection) => config.onIncomingConnection(connection),
+            abortSignal: this.abortController.signal
+        })
         this.rpcCommunicator.registerRpcMethod(
-            WebSocketConnectionRequest,
-            WebSocketConnectionResponse,
+            WebsocketConnectionRequest,
+            WebsocketConnectionResponse,
             'requestConnection',
-            (req: WebSocketConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context)
+            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.ownPeerDescriptor!, connection)
+        const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
         handshaker.once('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
             this.onServerSocketHandshakeRequest(peerDescriptor, connection)
         })
     }
 
+    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.destroyed && this.webSocketServer) {
-            this.webSocketServer.on('connected', (connection: IConnection) => {
+        if (!this.abortController.signal.aborted && this.websocketServer) {
+            this.websocketServer.on('connected', (connection: IConnection) => {
 
-                const serverSocket = connection as unknown as ServerWebSocket
+                const serverSocket = connection as unknown as ServerWebsocket
                 if (serverSocket.resourceURL &&
                     serverSocket.resourceURL.query) {
                     const query = serverSocket.resourceURL.query as unknown as ParsedUrlQuery
@@ -122,63 +160,55 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
                     this.attachHandshaker(connection)
                 }
             })
-            const port = await this.webSocketServer.start()
+            const port = await this.websocketServer.start()
             this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.tlsCertificate !== undefined, this.host)
+            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.serverEnableTls, this.host)
         }
     }
 
-    public async checkConnectivity(): Promise<ConnectivityResponse> {
+    public async checkConnectivity(selfSigned: boolean): Promise<ConnectivityResponse> {
         // TODO: this could throw if the server is not running
         const noServerConnectivityResponse: ConnectivityResponse = {
-            openInternet: false,
             host: '127.0.0.1',
             natType: NatType.UNKNOWN
         }
-        if (this.destroyed) {
+        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) {
-                    // If no websocket server, return openInternet: false
+                if (!this.websocketServer) {
                     return noServerConnectivityResponse
                 } else {
-                    if (!this.entrypoints || this.entrypoints.length < 1) {
+                    if (!this.entrypoints || this.entrypoints.length === 0) {
                         // return connectivity info given in config
                         const preconfiguredConnectivityResponse: ConnectivityResponse = {
-                            openInternet: true,
                             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)
+                        // 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!)}`
+                        + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
                     logger.error(error, { error: err })
                     await wait(2000)
                 }
             }
         }
-        throw Error(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
+        throw new WebsocketServerStartError(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
     }
 
     public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
-        if (this.ownPeerDescriptor!.websocket !== undefined) {
-            return (targetPeerDescriptor.type !== NodeType.BROWSER) || canOpenConnectionFromBrowser(this.ownPeerDescriptor!.websocket)
-        } else if (targetPeerDescriptor.websocket !== undefined) {
-            return (this.ownPeerDescriptor!.type !== NodeType.BROWSER) || canOpenConnectionFromBrowser(targetPeerDescriptor.websocket)
-        } else {
-            return false
-        }
+        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
+        return (connectionType === ConnectionType.WEBSOCKET_CLIENT || connectionType === ConnectionType.WEBSOCKET_SERVER)
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
@@ -188,14 +218,14 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
             return existingConnection
         }
 
-        if (this.ownPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
-            return this.requestConnectionFromPeer(this.ownPeerDescriptor!, targetPeerDescriptor)
+        if (this.localPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
+            return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
         } else {
-            const socket = new ClientWebSocket()
+            const socket = new ClientWebsocket()
 
-            const url = connectivityMethodToWebSocketUrl(targetPeerDescriptor.websocket!)
+            const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
 
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
+            const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
             managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
             this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
@@ -216,33 +246,33 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
         }
     }
 
-    private requestConnectionFromPeer(ownPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+    private requestConnectionFromPeer(localPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
         setImmediate(() => {
-            const remoteConnector = new WebSocketConnectorRpcRemote(
-                ownPeerDescriptor,
+            const remoteConnector = new WebsocketConnectorRpcRemote(
+                localPeerDescriptor,
                 targetPeerDescriptor,
-                toProtoRpcClient(new WebSocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
-            remoteConnector.requestConnection(ownPeerDescriptor.websocket!.host, ownPeerDescriptor.websocket!.port)
+            remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
         })
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER)
+        const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER)
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
         this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
         return managedConnection
     }
 
-    private onServerSocketHandshakeRequest = (peerDescriptor: PeerDescriptor, serverWebSocket: IConnection) => {
+    private onServerSocketHandshakeRequest(peerDescriptor: PeerDescriptor, serverWebsocket: IConnection) {
 
         const peerId = peerIdFromPeerDescriptor(peerDescriptor)
 
         if (this.ongoingConnectRequests.has(peerId.toKey())) {
             const ongoingConnectReguest = this.ongoingConnectRequests.get(peerId.toKey())!
-            ongoingConnectReguest.attachImplementation(serverWebSocket)
+            ongoingConnectReguest.attachImplementation(serverWebsocket)
             ongoingConnectReguest.acceptHandshake()
             this.ongoingConnectRequests.delete(peerId.toKey())
         } else {
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebSocket)
+            const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebsocket)
 
             managedConnection.setPeerDescriptor(peerDescriptor)
 
@@ -255,41 +285,20 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
         }
     }
 
-    public setOwnPeerDescriptor(ownPeerDescriptor: PeerDescriptor): void {
-        this.ownPeerDescriptor = ownPeerDescriptor
+    public setLocalPeerDescriptor(localPeerDescriptor: PeerDescriptor): void {
+        this.localPeerDescriptor = localPeerDescriptor
     }
 
     public async destroy(): Promise<void> {
-        this.destroyed = true
+        this.abortController.abort()
         this.rpcCommunicator.destroy()
 
         const requests = Array.from(this.ongoingConnectRequests.values())
-        await Promise.allSettled(requests.map((conn) => conn.close('OTHER')))
+        await Promise.allSettled(requests.map((conn) => conn.close(false)))
 
         const attempts = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
+        await Promise.allSettled(attempts.map((conn) => conn.close(false)))
         this.connectivityChecker?.destroy()
-        await this.webSocketServer?.stop()
-    }
-
-    // IWebSocketConnectorRpc implementation
-    public async requestConnection(request: WebSocketConnectionRequest, context: ServerCallContext): Promise<WebSocketConnectionResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (!this.destroyed && this.canConnectFunction(senderPeerDescriptor, request.ip, request.port)) {
-            setImmediate(() => {
-                if (this.destroyed) {
-                    return
-                }
-                const connection = this.connect(senderPeerDescriptor)
-                this.onIncomingConnection(connection)
-            })
-            const res: WebSocketConnectionResponse = {
-                accepted: true
-            }
-            return res
-        }
-        return {
-            accepted: false
-        }
+        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
+    onIncomingConnection: (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.onIncomingConnection(connection)
+            })
+            return { accepted: true }
+        } else {
+            return { accepted: false }
+        }
+    }
+}

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

@@ -1,8 +1,8 @@
 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'
@@ -11,34 +11,28 @@ 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 = {
+        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()