@streamr/dht 100.2.5-beta.0 → 101.0.0-beta.0

package/src/connection/websocket/WebsocketClientConnector.ts

@@ -0,0 +1,119 @@
+import { WebsocketClientConnection } from './NodeWebsocketClientConnection'
+import { ConnectionType } from '../IConnection'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { WebsocketClientConnectorRpcLocal } from './WebsocketClientConnectorRpcLocal'
+import {
+    ConnectivityMethod,
+    PeerDescriptor,
+    WebsocketConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { WebsocketServer } from './WebsocketServer'
+import { createOutgoingHandshaker } from '../Handshaker'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { expectedConnectionType } from '../../helpers/Connectivity'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { GeoIpLocator } from '@streamr/geoip-location'
+import { PendingConnection } from '../PendingConnection'
+
+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 : '')
+}
+
+export interface WebsocketClientConnectorOptions {
+    onNewConnection: (connection: PendingConnection) => boolean
+    hasConnection: (nodeId: DhtAddress) => boolean
+    rpcCommunicator: ListeningRpcCommunicator
+}
+
+export class WebsocketClientConnector {
+
+    public static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
+    private readonly websocketServer?: WebsocketServer
+    private geoIpLocator?: GeoIpLocator
+
+    private localPeerDescriptor?: PeerDescriptor
+    private connectingConnections: Map<DhtAddress, PendingConnection> = new Map()
+    private abortController = new AbortController()
+    private readonly options: WebsocketClientConnectorOptions
+
+    constructor(options: WebsocketClientConnectorOptions) {
+        this.options = options
+        
+        this.registerLocalRpcMethods()
+    }
+
+    private registerLocalRpcMethods() {
+        const rpcLocal = new WebsocketClientConnectorRpcLocal({
+            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
+            hasConnection: (nodeId: DhtAddress): boolean => (this.connectingConnections.has(nodeId)
+                || this.options.hasConnection(nodeId))
+            ,
+            onNewConnection: (connection: PendingConnection) => this.options.onNewConnection(connection),
+            abortSignal: this.abortController.signal
+        })
+        this.options.rpcCommunicator.registerRpcNotification(
+            WebsocketConnectionRequest,
+            'requestConnection',
+            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> => {
+                if (!this.abortController.signal.aborted) {
+                    return rpcLocal.requestConnection(req, context)
+                } else {
+                    return {}
+                }
+            }
+        )
+    }
+
+    public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
+        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
+        return connectionType === ConnectionType.WEBSOCKET_CLIENT
+    }
+
+    public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.connectingConnections.get(nodeId)
+        if (existingConnection) {
+            return existingConnection
+        }
+        const socket = new WebsocketClientConnection()
+
+        const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
+
+        const pendingConnection = new PendingConnection(targetPeerDescriptor)
+        createOutgoingHandshaker(this.localPeerDescriptor!, pendingConnection, socket, targetPeerDescriptor)
+        this.connectingConnections.set(nodeId, pendingConnection)
+
+        const delFunc = () => {
+            if (this.connectingConnections.has(nodeId)) {
+                this.connectingConnections.delete(nodeId)
+            }
+            socket.off('disconnected', delFunc)
+            pendingConnection.off('disconnected', delFunc)
+            pendingConnection.off('connected', delFunc)
+        }
+        socket.on('disconnected', delFunc)
+        pendingConnection.on('disconnected', delFunc)
+        pendingConnection.on('connected', delFunc)
+
+        socket.connect(url, false)
+
+        return pendingConnection
+    }
+    
+    public setLocalPeerDescriptor(peerDescriptor: PeerDescriptor): void {
+        this.localPeerDescriptor = peerDescriptor
+    }
+
+    public async destroy(): Promise<void> {
+        this.abortController.abort()
+
+        const requests = Array.from(this.connectingConnections.values())
+        await Promise.allSettled(requests.map((conn) => conn.close(true)))
+
+        await this.websocketServer?.stop()
+        await this.geoIpLocator?.stop()
+    }
+}

package/src/connection/websocket/WebsocketClientConnectorRpcLocal.ts

@@ -0,0 +1,39 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import {
+    PeerDescriptor,
+    WebsocketConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { IWebsocketClientConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress } from '../../identifiers'
+import { PendingConnection } from '../PendingConnection'
+
+interface WebsocketClientConnectorRpcLocalOptions {
+    connect: (targetPeerDescriptor: PeerDescriptor) => PendingConnection
+    hasConnection: (nodeId: DhtAddress) => boolean
+    onNewConnection: (connection: PendingConnection) => boolean
+    abortSignal: AbortSignal
+}
+
+export class WebsocketClientConnectorRpcLocal implements IWebsocketClientConnectorRpc {
+
+    private readonly options: WebsocketClientConnectorRpcLocalOptions
+
+    constructor(options: WebsocketClientConnectorRpcLocalOptions) {
+        this.options = options
+    }
+
+    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> {
+        if (this.options.abortSignal.aborted) {
+            return {}
+        }
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        if (!this.options.hasConnection(getNodeIdFromPeerDescriptor(senderPeerDescriptor))) {
+            const connection = this.options.connect(senderPeerDescriptor)
+            this.options.onNewConnection(connection)
+        }
+        return {}
+    }
+}

package/src/connection/websocket/{WebsocketConnectorRpcRemote.ts → WebsocketClientConnectorRpcRemote.ts}

@@ -3,12 +3,12 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
-import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketClientConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
-export class WebsocketConnectorRpcRemote extends RpcRemote<WebsocketConnectorRpcClient> {
+export class WebsocketClientConnectorRpcRemote extends RpcRemote<WebsocketClientConnectorRpcClient> {
 
     async requestConnection(): Promise<void> {
         logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)

package/src/connection/websocket/WebsocketServer.ts

@@ -3,7 +3,6 @@ import { createServer as createHttpsServer, Server as HttpsServer } from 'https'
 import EventEmitter from 'eventemitter3'
 import WebSocket from 'ws'
 import { WebsocketServerConnection } from './WebsocketServerConnection'
-import { ConnectionSourceEvents } from '../IConnectionSource'
 import { Logger, asAbortable } from '@streamr/utils'
 import { createSelfSignedCertificate } from '@streamr/autocertifier-client' 
 import { WebsocketServerStartError } from '../../helpers/errors'
@@ -12,33 +11,38 @@ import { range } from 'lodash'
 import fs from 'fs'
 import { v4 as uuid } from 'uuid'
 import { parse } from 'url'
+import { IConnection } from '../IConnection'
 
 const logger = new Logger(module)
 
-interface WebsocketServerConfig {
+interface WebsocketServerOptions {
     portRange: PortRange
     enableTls: boolean
     tlsCertificate?: TlsCertificate
     maxMessageSize?: number
 }
 
-export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
+interface Events {
+    connected: ((connection: IConnection) => void) 
+}
+
+export class WebsocketServer extends EventEmitter<Events> {
 
     private httpServer?: HttpServer | HttpsServer
     private wsServer?: WebSocket.Server
     private readonly abortController = new AbortController()
-    private readonly config: WebsocketServerConfig
+    private readonly options: WebsocketServerOptions
 
-    constructor(config: WebsocketServerConfig) {
+    constructor(options: WebsocketServerOptions) {
         super()
-        this.config = config
+        this.options = options
     }
 
     public async start(): Promise<number> {
-        const ports = range(this.config.portRange.min, this.config.portRange.max + 1)
+        const ports = range(this.options.portRange.min, this.options.portRange.max + 1)
         for (const port of ports) {
             try {
-                await asAbortable(this.startServer(port, this.config.enableTls), this.abortController.signal)
+                await asAbortable(this.startServer(port, this.options.enableTls), this.abortController.signal)
                 return port
             } catch (err) {
                 if (err.originalError?.code === 'EADDRINUSE') {
@@ -49,7 +53,7 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
             }
         }
         throw new WebsocketServerStartError(
-            `Failed to start WebSocket server on any port in range: ${this.config.portRange.min}-${this.config.portRange.min}`
+            `Failed to start WebSocket server on any port in range: ${this.options.portRange.min}-${this.options.portRange.min}`
         )
     }
 
@@ -62,15 +66,15 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
             response.end()
         }
         return new Promise((resolve, reject) => {
-            if (this.config.tlsCertificate) {
+            if (this.options.tlsCertificate) {
                 this.httpServer = createHttpsServer({
-                    key: fs.readFileSync(this.config.tlsCertificate.privateKeyFileName),
-                    cert: fs.readFileSync(this.config.tlsCertificate.certFileName)
+                    key: fs.readFileSync(this.options.tlsCertificate.privateKeyFileName),
+                    cert: fs.readFileSync(this.options.tlsCertificate.certFileName)
                 }, requestListener)
             } else if (!tls) {
                 this.httpServer = createHttpServer(requestListener)
             } else {
-                // TODO use config option or named constant?
+                // TODO use options option or named constant?
                 const certificate = createSelfSignedCertificate('streamr-self-signed-' + uuid(), 1000)
                 this.httpServer = createHttpsServer({
                     key: certificate.serverKey,
@@ -151,7 +155,7 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
     }
 
     private createWsServer(): WebSocket.Server {
-        const maxPayload = this.config.maxMessageSize ?? 1048576
+        const maxPayload = this.options.maxMessageSize ?? 1048576
         return this.wsServer = new WebSocket.Server({
             noServer: true,
             maxPayload