@streamr/dht 100.0.0-testnet-three.6 → 100.1.0

package/src/connection/websocket/WebsocketConnector.ts

@@ -1,4 +1,4 @@
-import { ClientWebsocket } from './ClientWebsocket'
+import { WebsocketClientConnection } from './NodeWebsocketClientConnection'
 import { IConnection, ConnectionType } from '../IConnection'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
@@ -17,10 +17,10 @@ import { ManagedConnection } from '../ManagedConnection'
 import { WebsocketServer } from './WebsocketServer'
 import { sendConnectivityRequest } from '../connectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
-import { ServerWebsocket } from './ServerWebsocket'
+import { WebsocketServerConnection } from './WebsocketServerConnection'
 import { Handshaker } from '../Handshaker'
-import { ParsedUrlQuery } from 'querystring'
-import { range, sample } from 'lodash'
+import queryString from 'querystring'
+import { shuffle } from 'lodash'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { expectedConnectionType } from '../../helpers/Connectivity'
 import { WebsocketServerStartError } from '../../helpers/errors'
@@ -29,8 +29,7 @@ import { DISABLE_CONNECTIVITY_PROBE, attachConnectivityRequestHandler } from '..
 import * as Err from '../../helpers/errors'
 import { Empty } from '../../proto/google/protobuf/empty'
 import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { version as localVersion } from '../../../package.json'
-import { isCompatibleVersion } from '../../helpers/versionCompatibility'
+import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../../helpers/version'
 
 const logger = new Logger(module)
 
@@ -143,10 +142,10 @@ export class WebsocketConnector {
     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() })
+                const serverSocket = connection as unknown as WebsocketServerConnection
+                const query = queryString.parse(serverSocket.resourceURL.query as string ?? '')
+                const action = query.action as (Action | undefined)
+                logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.remoteIpAddress })
                 if (action === 'connectivityRequest') {
                     attachConnectivityRequestHandler(serverSocket)
                 } else if (action === 'connectivityProbe') {
@@ -175,7 +174,7 @@ export class WebsocketConnector {
                 host: '127.0.0.1',
                 natType: NatType.UNKNOWN,
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: localVersion
+                version: LOCAL_PROTOCOL_VERSION
             }
         }
         if (!this.config.entrypoints || this.config.entrypoints.length === 0) {
@@ -190,11 +189,12 @@ export class WebsocketConnector {
                 },
                 // TODO: Resolve the given host name or or use as is if IP was given. 
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: localVersion
+                version: LOCAL_PROTOCOL_VERSION
             }
         }
-        for (const reattempt of range(ENTRY_POINT_CONNECTION_ATTEMPTS)) {
-            const entryPoint = sample(this.config.entrypoints)!
+        const shuffledEntrypoints = shuffle(this.config.entrypoints)
+        while (shuffledEntrypoints.length > 0 && !this.abortController.signal.aborted) {
+            const entryPoint = shuffledEntrypoints[0]
             try {
                 // Do real connectivity checking
                 const connectivityRequest = {
@@ -204,17 +204,16 @@ export class WebsocketConnector {
                     selfSigned
                 }
                 if (!this.abortController.signal.aborted) {
-                    return await sendConnectivityRequest(connectivityRequest, entryPoint, localVersion)
+                    return await sendConnectivityRequest(connectivityRequest, entryPoint)
                 } else {
                     throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
                 }
             } catch (err) {
-                if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
-                    const error = `Failed to connect to entrypoint with id ${getNodeIdFromPeerDescriptor(entryPoint)} `
-                        + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
-                    logger.error(error, { error: err })
-                    await wait(2000)
-                }
+                const error = `Failed to connect to entrypoint with id ${getNodeIdFromPeerDescriptor(entryPoint)} `
+                    + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
+                logger.error(error, { err })
+                shuffledEntrypoints.shift()
+                await wait(2000, this.abortController.signal)
             }
         }
         throw new WebsocketServerStartError(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
@@ -235,7 +234,7 @@ export class WebsocketConnector {
         if (this.localPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
             return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
         } else {
-            const socket = new ClientWebsocket()
+            const socket = new WebsocketClientConnection()
 
             const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
 
@@ -299,17 +298,17 @@ export class WebsocketConnector {
 
     private onServerSocketHandshakeRequest(
         sourcePeerDescriptor: PeerDescriptor,
-        serverWebsocket: IConnection,
-        sourceVersion: string,
+        websocketServerConnection: IConnection,
+        remoteVersion: string,
         targetPeerDescriptor?: PeerDescriptor
     ) {
         const nodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
         if (this.ongoingConnectRequests.has(nodeId)) {
             const ongoingConnectRequest = this.ongoingConnectRequests.get(nodeId)!
-            if (!isCompatibleVersion(sourceVersion, localVersion)) {
+            if (!isMaybeSupportedVersion(remoteVersion)) {
                 ongoingConnectRequest.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
             } else {
-                ongoingConnectRequest.attachImplementation(serverWebsocket)
+                ongoingConnectRequest.attachImplementation(websocketServerConnection)
                 ongoingConnectRequest.acceptHandshake()
             }
             this.ongoingConnectRequests.delete(nodeId)
@@ -318,11 +317,11 @@ export class WebsocketConnector {
                 this.localPeerDescriptor!,
                 ConnectionType.WEBSOCKET_SERVER,
                 undefined,
-                serverWebsocket,
+                websocketServerConnection,
                 targetPeerDescriptor
             )
             managedConnection.setRemotePeerDescriptor(sourcePeerDescriptor)
-            if (!isCompatibleVersion(sourceVersion, localVersion)) {
+            if (!isMaybeSupportedVersion(remoteVersion)) {
                 managedConnection.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
             } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 managedConnection.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)

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' 
@@ -11,16 +11,10 @@ import { PortRange, TlsCertificate } from '../ConnectionManager'
 import { range } from 'lodash'
 import fs from 'fs'
 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,7 +25,7 @@ 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 config: WebsocketServerConfig
 
@@ -88,28 +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
                 }
-                
-                let connection
-                try {
-                    connection = request.accept(undefined, request.origin)
-                    logger.trace('Connection accepted.', { remoteAddress: request.remoteAddress })
-                } catch (err) {
-                    logger.debug('Accepting websocket connection failed', { remoteAddress: request.remoteAddress, err })
-                }
+                this.emit('connected', new WebsocketServerConnection(ws, parse(request.url!), request.socket.remoteAddress!))
+            })
 
-                if (connection) {
-                    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))
             })
@@ -139,7 +131,10 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         this.abortController.abort()
         this.removeAllListeners()
         return new Promise((resolve, _reject) => {
-            this.wsServer?.shutDown()
+            this.wsServer!.close()
+            for (const ws of this.wsServer!.clients) {
+                ws.terminate()
+            }
             this.httpServer?.once('close', () => {
                 // removeAllListeners is maybe not needed?
                 this.httpServer?.removeAllListeners()
@@ -155,21 +150,11 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         })
     }
 
-    private createWsServer(httpServer: HttpServer | HttpsServer): WsServer {
-        const maxReceivedMessageSize = this.config.maxMessageSize ?? 1048576
-        // Use the real nodejs WebSocket server in Electron tests
-        if (typeof NodeJsWsServer !== 'undefined') {
-            return new NodeJsWsServer({
-                httpServer,
-                autoAcceptConnections: false,
-                maxReceivedMessageSize
-            })
-        } else {
-            return this.wsServer = new WsServer({
-                httpServer,
-                autoAcceptConnections: false,
-                maxReceivedMessageSize
-            })
-        }
+    private createWsServer(): WebSocket.Server {
+        const maxPayload = this.config.maxMessageSize ?? 1048576
+        return this.wsServer = new WebSocket.Server({
+            noServer: true,
+            maxPayload
+        })
     }
 }

package/src/connection/websocket/{ServerWebsocket.ts → WebsocketServerConnection.ts}

@@ -1,33 +1,23 @@
 import EventEmitter from 'eventemitter3'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
-import { Message, connection as WsConnection } from 'websocket'
+import WebSocket from 'ws'
 import { Logger } from '@streamr/utils'
 import { Url } from 'url'
-import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
+import { CUSTOM_GOING_AWAY, GOING_AWAY } from './AbstractWebsocketClientConnection'
 import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
 
-// NodeJsBuffer is global defined in preload.js of Karma
-// It is used to make Karma/Electron tests to use the NodeJS
-// implementation of Buffer instead of the browser polyfill
-
-declare let NodeJsBuffer: BufferConstructor
-
-enum MessageType {
-    UTF8 = 'utf8',
-    BINARY = 'binary'
-}
-
-export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export class WebsocketServerConnection extends EventEmitter<ConnectionEvents> implements IConnection {
 
     public readonly connectionId: ConnectionID
     public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
     public readonly resourceURL: Url
-    private socket?: WsConnection
+    public readonly remoteIpAddress: string
+    private socket?: WebSocket
     private stopped = false
 
-    constructor(socket: WsConnection, resourceURL: Url) {
+    constructor(socket: WebSocket, resourceURL: Url, remoteAddress: string) {
         super()
 
         this.onMessage = this.onMessage.bind(this)
@@ -36,6 +26,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
 
         this.resourceURL = resourceURL
         this.connectionId = createRandomConnectionId()
+        this.remoteIpAddress = remoteAddress
 
         socket.on('message', this.onMessage)
         socket.on('close', this.onClose)
@@ -44,20 +35,17 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.socket = socket
     }
 
-    private onMessage(message: Message): void {
-        logger.trace('ServerWebsocket::onMessage')
-        if (message.type === MessageType.UTF8) {
-            logger.debug('Received string Message: ' + message.utf8Data)
-        } else if (message.type === MessageType.BINARY) {
-            logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
-            this.emit('data',
-                new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
-                    message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
+    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.socket?.remoteAddress + ' disconnected.')
+        logger.trace('Peer ' + this.remoteIpAddress + ' disconnected.')
         this.doDisconnect(reasonCode, description)
     }
 
@@ -80,16 +68,9 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
     }
 
     public send(data: Uint8Array): void {
-        // If in an Karma / Electron test, use the NodeJS implementation
-        // of Buffer instead of the browser polyfill
-
         // TODO: no need to check this.socket as it is always defined when stopped is false?
         if (!this.stopped && this.socket) {
-            if (typeof NodeJsBuffer !== 'undefined') {
-                this.socket.sendBytes(NodeJsBuffer.from(data))
-            } else {
-                this.socket.sendBytes(Buffer.from(data))
-            }
+            this.socket.send(data, { binary: true })
         } else {
             logger.debug('Tried to call send() on a stopped socket')
         }
@@ -120,26 +101,4 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
             logger.debug('Tried to destroy() a stopped connection')
         }
     }
-
-    public getRemoteAddress(): string {
-        // TODO: no need to check this.socket as it is always defined when stopped is false?
-        if (!this.stopped && this.socket) {
-            return this.socket.remoteAddress
-        } else {
-            // TODO throw
-            logger.error('Tried to get the remoteAddress of a stopped connection')
-            return ''
-        }
-    }
-
-    public getRemoteIp(): string {
-        // TODO: no need to check this.socket as it is always defined when stopped is false?
-        if (!this.stopped && this.socket) {
-            return this.socket.socket.remoteAddress!
-        } else {
-            // TODO throw
-            logger.error('Tried to get the remoteAddress of a stopped connection')
-            return ''
-        }
-    }
 }