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

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()