@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -1,16 +1,18 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     PeerDescriptor,
-    WebsocketConnectionRequest,
-    WebsocketConnectionResponse
+    WebsocketConnectionRequest
 } 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'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress } from '../../identifiers'
 
 interface WebsocketConnectorRpcLocalConfig {
-    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
+    hasConnection: (nodeId: DhtAddress) => boolean
     onNewConnection: (connection: ManagedConnection) => boolean
     abortSignal: AbortSignal
 }
@@ -23,19 +25,15 @@ export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
         this.config = config
     }
 
-    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> {
+    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> {
+        if (this.config.abortSignal.aborted) {
+            return {}
+        }
         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 }
+        if (!this.config.hasConnection(getNodeIdFromPeerDescriptor(senderPeerDescriptor))) {
+            const connection = this.config.connect(senderPeerDescriptor)
+            this.config.onNewConnection(connection)
         }
+        return {}
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -1,39 +1,19 @@
 import {
-    PeerDescriptor,
     WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-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 { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { Remote } from '../../dht/contact/Remote'
+import { RpcRemote } from '../../dht/contact/RpcRemote'
+import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
-export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcClient> {
+export class WebsocketConnectorRpcRemote extends RpcRemote<WebsocketConnectorRpcClient> {
 
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebsocketConnectorRpcClient>
-    ) {
-        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
-    }
-
-    async requestConnection(ip: string, port: number): Promise<boolean> {
+    async requestConnection(): Promise<void> {
         logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
-        const request: WebsocketConnectionRequest = {
-            ip,
-            port
-        }
+        const request: WebsocketConnectionRequest = {}
         const options = this.formDhtRpcOptions()
-        try {
-            const res = await this.getClient().requestConnection(request, options)
-            return res.accepted
-        } catch (err) {
-            logger.debug(new Err.WebsocketConnectionRequestRejected('WebsocketConnectionRequest rejected', err).stack!)
-            return false
-        }
+        return this.getClient().requestConnection(request, options)
     }
 }

package/src/connection/websocket/WebsocketServer.ts

@@ -1,8 +1,8 @@
 import { createServer as createHttpServer, Server as HttpServer, IncomingMessage, ServerResponse } from 'http'
 import { createServer as createHttpsServer, Server as HttpsServer } from 'https'
 import EventEmitter from 'eventemitter3'
-import { server as WsServer } from 'websocket'
-import { ServerWebsocket } from './ServerWebsocket'
+import WebSocket from 'ws'
+import { WebsocketServerConnection } from './WebsocketServerConnection'
 import { ConnectionSourceEvents } from '../IConnectionSource'
 import { Logger, asAbortable } from '@streamr/utils'
 import { createSelfSignedCertificate } from '@streamr/autocertifier-client' 
@@ -10,17 +10,11 @@ import { WebsocketServerStartError } from '../../helpers/errors'
 import { PortRange, TlsCertificate } from '../ConnectionManager'
 import { range } from 'lodash'
 import fs from 'fs'
-import { UUID } from '../../helpers/UUID'
+import { v4 as uuid } from 'uuid'
+import { parse } from 'url'
 
 const logger = new Logger(module)
 
-// NodeJsWsServer is declared as a global in test-browser Electron tests
-// in preload.js using "window.NodeJsWsServer = require('websocket').server".
-// This is done in order to use the real nodejs websocket server in tests
-// instead of a dummy polyfill.
-
-declare class NodeJsWsServer extends WsServer { }
-
 interface WebsocketServerConfig {
     portRange: PortRange
     enableTls: boolean
@@ -31,26 +25,20 @@ interface WebsocketServerConfig {
 export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
 
     private httpServer?: HttpServer | HttpsServer
-    private wsServer?: WsServer
+    private wsServer?: WebSocket.Server
     private readonly abortController = new AbortController()
-    private readonly portRange: PortRange
-    private readonly tlsCertificate?: TlsCertificate
-    private readonly enableTls: boolean
-    private readonly maxMessageSize: number
+    private readonly config: WebsocketServerConfig
 
     constructor(config: WebsocketServerConfig) {
         super()
-        this.portRange = config.portRange
-        this.enableTls = config.enableTls
-        this.tlsCertificate = config.tlsCertificate
-        this.maxMessageSize = config.maxMessageSize ?? 1048576
+        this.config = config
     }
 
     public async start(): Promise<number> {
-        const ports = range(this.portRange.min, this.portRange.max + 1)
+        const ports = range(this.config.portRange.min, this.config.portRange.max + 1)
         for (const port of ports) {
             try {
-                await asAbortable(this.startServer(port, this.enableTls), this.abortController.signal)
+                await asAbortable(this.startServer(port, this.config.enableTls), this.abortController.signal)
                 return port
             } catch (err) {
                 if (err.originalError?.code === 'EADDRINUSE') {
@@ -60,7 +48,9 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                 }
             }
         }
-        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.config.portRange.min}-${this.config.portRange.min}`
+        )
     }
 
     // If tlsCertificate has been given the tls boolean is ignored
@@ -72,15 +62,16 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
             response.end()
         }
         return new Promise((resolve, reject) => {
-            if (this.tlsCertificate) {
+            if (this.config.tlsCertificate) {
                 this.httpServer = createHttpsServer({
-                    key: fs.readFileSync(this.tlsCertificate.privateKeyFileName),
-                    cert: fs.readFileSync(this.tlsCertificate.certFileName)
+                    key: fs.readFileSync(this.config.tlsCertificate.privateKeyFileName),
+                    cert: fs.readFileSync(this.config.tlsCertificate.certFileName)
                 }, requestListener)
             } else if (!tls) {
                 this.httpServer = createHttpServer(requestListener)
             } else {
-                const certificate = createSelfSignedCertificate('streamr-self-signed-' + new UUID().toString(), 1000)
+                // TODO use config option or named constant?
+                const certificate = createSelfSignedCertificate('streamr-self-signed-' + uuid(), 1000)
                 this.httpServer = createHttpsServer({
                     key: certificate.serverKey,
                     cert: certificate.serverCert
@@ -91,22 +82,26 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                 return true
             }
 
-            this.wsServer = this.createWsServer(this.httpServer)
+            this.wsServer = this.createWsServer()
             
-            this.wsServer.on('request', (request) => {
+            this.wsServer.on('connection', (ws: WebSocket, request: IncomingMessage) => {
+                logger.trace(`New connection from ${request.socket.remoteAddress}`)
                 if (!originIsAllowed()) {
                     // Make sure we only accept requests from an allowed origin
-                    request.reject()
-                    logger.trace('IConnection from origin ' + request.origin + ' rejected.')
+                    ws.close()
+                    logger.trace('IConnection from origin ' + request.headers.origin + ' rejected.')
                     return
                 }
-                
-                const connection = request.accept(undefined, request.origin)
-                
-                logger.trace('IConnection accepted.')
+                this.emit('connected', new WebsocketServerConnection(ws, parse(request.url!), request.socket.remoteAddress!))
+            })
 
-                this.emit('connected', new ServerWebsocket(connection, request.resourceURL))
+            this.httpServer.on('upgrade', (request, socket, head) => {
+                logger.trace('Received upgrade request for ' + request.url)
+                this.wsServer!.handleUpgrade(request, socket, head, (ws: WebSocket) => {
+                    this.wsServer!.emit('connection', ws, request)
+                })
             })
+
             this.httpServer.once('error', (err: Error) => {
                 reject(new WebsocketServerStartError('Starting Websocket server failed', err))
             })
@@ -136,28 +131,30 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         this.abortController.abort()
         this.removeAllListeners()
         return new Promise((resolve, _reject) => {
-            this.wsServer?.shutDown()
-            this.httpServer?.close(() => {
+            this.wsServer!.close()
+            for (const ws of this.wsServer!.clients) {
+                ws.terminate()
+            }
+            this.httpServer?.once('close', () => {
+                // removeAllListeners is maybe not needed?
+                this.httpServer?.removeAllListeners()
                 resolve()
             })
+            this.httpServer?.close()
+            // the close method "Stops the server from accepting new connections and closes all 
+            // connections connected to this server which are not sending a request or waiting for a 
+            // response." (https://nodejs.org/api/http.html#serverclosecallback)
+            // i.e. we need to call closeAllConnections() to close the rest of the connections
+            // (in practice this closes the active websocket connections)
+            this.httpServer?.closeAllConnections()
         })
     }
 
-    private createWsServer(httpServer: HttpServer | HttpsServer): WsServer {
-        // Use the real nodejs WebSocket server in Electron tests
-
-        if (typeof NodeJsWsServer !== 'undefined') {
-            return new NodeJsWsServer({
-                httpServer,
-                autoAcceptConnections: false,
-                maxReceivedMessageSize: this.maxMessageSize
-            })
-        } else {
-            return this.wsServer = new WsServer({
-                httpServer,
-                autoAcceptConnections: false,
-                maxReceivedMessageSize: this.maxMessageSize
-            })
-        }
+    private createWsServer(): WebSocket.Server {
+        const maxPayload = this.config.maxMessageSize ?? 1048576
+        return this.wsServer = new WebSocket.Server({
+            noServer: true,
+            maxPayload
+        })
     }
 }

package/src/connection/websocket/WebsocketServerConnection.ts

@@ -0,0 +1,104 @@
+import EventEmitter from 'eventemitter3'
+import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
+import WebSocket from 'ws'
+import { Logger } from '@streamr/utils'
+import { Url } from 'url'
+import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
+import { createRandomConnectionId } from '../Connection'
+
+const logger = new Logger(module)
+
+export class WebsocketServerConnection extends EventEmitter<ConnectionEvents> implements IConnection {
+
+    public readonly connectionId: ConnectionID
+    public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
+    public readonly resourceURL: Url
+    public readonly remoteIpAddress: string
+    private socket?: WebSocket
+    private stopped = false
+
+    constructor(socket: WebSocket, resourceURL: Url, remoteAddress: string) {
+        super()
+
+        this.onMessage = this.onMessage.bind(this)
+        this.onClose = this.onClose.bind(this)
+        this.onError = this.onError.bind(this)
+
+        this.resourceURL = resourceURL
+        this.connectionId = createRandomConnectionId()
+        this.remoteIpAddress = remoteAddress
+
+        socket.on('message', this.onMessage)
+        socket.on('close', this.onClose)
+        socket.on('error', this.onError)
+
+        this.socket = socket
+    }
+
+    private onMessage(message: WebSocket.RawData, isBinary: boolean): void {
+        if (!isBinary) {
+            logger.trace('Received string Message')
+        } else {
+            logger.trace('Websocket server received Message')
+            this.emit('data', new Uint8Array(message as Buffer))
+        }
+    }
+
+    private onClose(reasonCode: number, description: string): void {
+        logger.trace('Peer ' + this.remoteIpAddress + ' disconnected.')
+        this.doDisconnect(reasonCode, description)
+    }
+
+    private onError(error: Error): void {
+        this.emit('error', error.name)
+    }
+
+    private stopListening(): void {
+        this.socket?.off('message', this.onMessage)
+        this.socket?.off('close', this.onClose)
+        this.socket?.off('error', this.onError)
+    }
+
+    private doDisconnect(reasonCode: number, description: string): void {
+        this.stopped = true
+        this.stopListening()
+        this.socket = undefined
+        const gracefulLeave = (reasonCode === GOING_AWAY) || (reasonCode === CUSTOM_GOING_AWAY)
+        this.emit('disconnected', gracefulLeave, reasonCode, description)
+    }
+
+    public send(data: Uint8Array): void {
+        // TODO: no need to check this.socket as it is always defined when stopped is false?
+        if (!this.stopped && this.socket) {
+            this.socket.send(data, { binary: true })
+        } else {
+            logger.debug('Tried to call send() on a stopped socket')
+        }
+
+    }
+
+    public async close(gracefulLeave: boolean): Promise<void> {
+        this.emit('disconnected', gracefulLeave, undefined, 'close() called')
+        this.removeAllListeners()
+        if (!this.stopped) {
+            this.socket?.close(gracefulLeave ? GOING_AWAY : undefined)
+        } else {
+            logger.debug('Tried to close a stopped connection')
+        }
+    }
+
+    // TODO could rename to "closeSilently?"
+    public destroy(): void {
+        if (!this.stopped) {
+            this.removeAllListeners()
+            if (this.socket) {
+                this.stopListening()
+                this.socket.close()
+                this.socket = undefined
+            }
+            this.stopped = true
+        } else {
+            logger.debug('Tried to destroy() a stopped connection')
+        }
+    }
+}