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

package/src/connection/websocket/{WebsocketConnector.ts → WebsocketServerConnector.ts}

@@ -1,48 +1,33 @@
-import { WebsocketClientConnection } from './NodeWebsocketClientConnection'
-import { IConnection, ConnectionType } from '../IConnection'
-import { ITransport } from '../../transport/ITransport'
+import { GeoIpLocator } from '@streamr/geoip-location'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { WebsocketConnectorRpcLocal } from './WebsocketConnectorRpcLocal'
-import { WebsocketConnectorRpcRemote } from './WebsocketConnectorRpcRemote'
-import {
-    ConnectivityMethod,
-    ConnectivityResponse,
-    HandshakeError,
-    PeerDescriptor,
-    WebsocketConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { ipv4ToNumber, Logger, wait } from '@streamr/utils'
-import { ManagedConnection } from '../ManagedConnection'
+import { Action, connectivityMethodToWebsocketUrl } from './WebsocketClientConnector'
 import { WebsocketServer } from './WebsocketServer'
-import { sendConnectivityRequest } from '../connectivityChecker'
+import { areEqualPeerDescriptors, DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
+import { ConnectivityResponse, HandshakeError, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
+import { ITransport } from '../../transport/ITransport'
+import { ipv4ToNumber, Logger, wait } from '@streamr/utils'
+import { attachConnectivityRequestHandler, DISABLE_CONNECTIVITY_PROBE } from '../connectivityRequestHandler'
 import { WebsocketServerConnection } from './WebsocketServerConnection'
-import { Handshaker } from '../Handshaker'
+import { ConnectionType, IConnection } from '../IConnection'
 import queryString from 'querystring'
+import { isMaybeSupportedVersion, LOCAL_PROTOCOL_VERSION } from '../../helpers/version'
 import { shuffle } from 'lodash'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { expectedConnectionType } from '../../helpers/Connectivity'
+import { sendConnectivityRequest } from '../connectivityChecker'
+import { acceptHandshake, Handshaker, rejectHandshake } from '../Handshaker'
+import { WebsocketClientConnectorRpcRemote } from './WebsocketClientConnectorRpcRemote'
+import { WebsocketClientConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { WebsocketServerStartError } from '../../helpers/errors'
-import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
-import { DISABLE_CONNECTIVITY_PROBE, attachConnectivityRequestHandler } from '../connectivityRequestHandler'
 import * as Err from '../../helpers/errors'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../../helpers/version'
-import { GeoIpLocator } from '@streamr/geoip-location'
+import { expectedConnectionType } from '../../helpers/Connectivity'
+import { PendingConnection } from '../PendingConnection'
 
 const logger = new Logger(module)
 
-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 WebsocketConnectorConfig {
-    transport: ITransport
-    onNewConnection: (connection: ManagedConnection) => boolean
+export interface WebsocketServerConnectorOptions {
+    onNewConnection: (connection: PendingConnection) => boolean
+    rpcCommunicator: ListeningRpcCommunicator
     hasConnection: (nodeId: DhtAddress) => boolean
     portRange?: PortRange
     maxMessageSize?: number
@@ -56,82 +41,34 @@ export interface WebsocketConnectorConfig {
     geoIpDatabaseFolder?: string
 }
 
-export class WebsocketConnector {
+// TODO: Could delFunc be removed here if the Handshaker event based clean up works correctly now?
+interface OngoingConnectionRequest {
+    delFunc: () => void
+    pendingConnection: PendingConnection
+}
+
+// TODO: Move server starting logic including autocertification and connectivity checking to WebsocketServer.ts?
+export class WebsocketServerConnector {
 
-    private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
-    private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly websocketServer?: WebsocketServer
     private geoIpLocator?: GeoIpLocator
-    private readonly ongoingConnectRequests: Map<DhtAddress, ManagedConnection> = new Map()
+    private readonly ongoingConnectRequests: Map<DhtAddress, OngoingConnectionRequest> = new Map()
     private host?: string
     private autoCertifierClient?: AutoCertifierClientFacade
     private selectedPort?: number
     private localPeerDescriptor?: PeerDescriptor
-    private connectingConnections: Map<DhtAddress, ManagedConnection> = new Map()
     private abortController = new AbortController()
-    private readonly config: WebsocketConnectorConfig
+    private readonly options: WebsocketServerConnectorOptions
 
-    constructor(config: WebsocketConnectorConfig) {
-        this.config = config
-        this.websocketServer = config.portRange ? new WebsocketServer({
-            portRange: config.portRange,
-            tlsCertificate: config.tlsCertificate,
-            maxMessageSize: config.maxMessageSize,
-            enableTls: config.serverEnableTls
+    constructor(options: WebsocketServerConnectorOptions) {
+        this.options = options
+        this.websocketServer = options.portRange ? new WebsocketServer({
+            portRange: options.portRange,
+            tlsCertificate: options.tlsCertificate,
+            maxMessageSize: options.maxMessageSize,
+            enableTls: options.serverEnableTls
         }) : undefined
-        this.host = config.host
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebsocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
-            rpcRequestTimeout: 15000  // TODO use config option or named constant?
-        })
-        this.registerLocalRpcMethods(config)
-    }
-
-    private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
-        const rpcLocal = new WebsocketConnectorRpcLocal({
-            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            hasConnection: (nodeId: DhtAddress): boolean => (this.connectingConnections.has(nodeId)
-                || this.ongoingConnectRequests.has(nodeId)
-                || config.hasConnection(nodeId))
-            ,
-            onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
-            abortSignal: this.abortController.signal
-        })
-        this.rpcCommunicator.registerRpcNotification(
-            WebsocketConnectionRequest,
-            'requestConnection',
-            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> => {
-                if (!this.abortController.signal.aborted) {
-                    return rpcLocal.requestConnection(req, context)
-                } else {
-                    return {}
-                }
-            }
-        )
-    }
-
-    private attachHandshaker(connection: IConnection) {
-        const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
-        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, sourceVersion: string, remotePeerDescriptor?: PeerDescriptor) => {
-            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, sourceVersion, remotePeerDescriptor)
-        })
-    }
-
-    public async autoCertify(): Promise<void> {
-        this.autoCertifierClient = new AutoCertifierClientFacade({
-            configFile: this.config.autoCertifierConfigFile,
-            transport: this.config.autoCertifierTransport,
-            url: this.config.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.host = options.host
     }
 
     public async start(): Promise<void> {
@@ -159,8 +96,8 @@ export class WebsocketConnector {
                 }
             })
             
-            if (this.config.geoIpDatabaseFolder) {
-                const geoIpLocator = new GeoIpLocator(this.config.geoIpDatabaseFolder)
+            if (this.options.geoIpDatabaseFolder) {
+                const geoIpLocator = new GeoIpLocator(this.options.geoIpDatabaseFolder)
                 try {
                     await geoIpLocator.start()
                     this.geoIpLocator = geoIpLocator
@@ -174,6 +111,48 @@ export class WebsocketConnector {
         }
     }
 
+    private attachHandshaker(connection: IConnection) {
+        // TODO: use createIncomingHandshaker here?
+        const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
+        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, sourceVersion: string, remotePeerDescriptor?: PeerDescriptor) => {
+            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, handshaker, sourceVersion, remotePeerDescriptor)
+        })
+    }
+
+    private onServerSocketHandshakeRequest(
+        sourcePeerDescriptor: PeerDescriptor,
+        websocketServerConnection: IConnection,
+        handshaker: Handshaker,
+        remoteVersion: string,
+        targetPeerDescriptor?: PeerDescriptor
+    ) {
+        const nodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
+        if (this.ongoingConnectRequests.has(nodeId)) {
+            const { pendingConnection, delFunc } = this.ongoingConnectRequests.get(nodeId)!
+            if (!isMaybeSupportedVersion(remoteVersion)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_VERSION)
+                delFunc()
+            } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
+                delFunc()  
+            } else {
+                acceptHandshake(handshaker, pendingConnection, websocketServerConnection)
+            }
+        } else {
+            const pendingConnection = new PendingConnection(sourcePeerDescriptor)
+            
+            if (!isMaybeSupportedVersion(remoteVersion)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_VERSION)  
+            } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)  
+            } else if (this.options.onNewConnection(pendingConnection)) {
+                acceptHandshake(handshaker, pendingConnection, websocketServerConnection)
+            } else {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.DUPLICATE_CONNECTION)
+            }
+        }
+    }
+
     public async checkConnectivity(allowSelfSignedCertificate: boolean): Promise<ConnectivityResponse> {
         // TODO: this could throw?
         if (this.abortController.signal.aborted) {
@@ -184,22 +163,22 @@ export class WebsocketConnector {
                 version: LOCAL_PROTOCOL_VERSION
             }
         }
-        if (!this.config.entrypoints || this.config.entrypoints.length === 0) {
-            // return connectivity info given in config
+        if (!this.options.entrypoints || this.options.entrypoints.length === 0) {
+            // return connectivity info given in options
             return {
                 host: this.host!,
                 natType: NatType.OPEN_INTERNET,
                 websocket: {
                     host: this.host!,
                     port: this.selectedPort!,
-                    tls: this.config.tlsCertificate !== undefined
+                    tls: this.options.tlsCertificate !== undefined
                 },
                 // TODO: Resolve the given host name or or use as is if IP was given. 
                 ipAddress: ipv4ToNumber('127.0.0.1'),
                 version: LOCAL_PROTOCOL_VERSION
             }
         }
-        const shuffledEntrypoints = shuffle(this.config.entrypoints)
+        const shuffledEntrypoints = shuffle(this.options.entrypoints)
         while (shuffledEntrypoints.length > 0 && !this.abortController.signal.aborted) {
             const entryPoint = shuffledEntrypoints[0]
             try {
@@ -207,7 +186,7 @@ export class WebsocketConnector {
                 const connectivityRequest = {
                     port: this.selectedPort ?? DISABLE_CONNECTIVITY_PROBE,
                     host: this.host,
-                    tls: this.websocketServer ? this.config.serverEnableTls : false,
+                    tls: this.websocketServer ? this.options.serverEnableTls : false,
                     allowSelfSignedCertificate
                 }
                 if (!this.abortController.signal.aborted) {
@@ -224,64 +203,44 @@ export class WebsocketConnector {
             }
         }
         throw new WebsocketServerStartError(
-            `Failed to connect to the entrypoints after ${this.config.entrypoints.length} attempts\n`
-            + `Attempted hosts: ${this.config.entrypoints.map((entry) => `${entry.websocket!.host}:${entry.websocket!.port}`).join(', ')}`
+            `Failed to connect to the entrypoints after ${this.options.entrypoints.length} attempts\n`
+            + `Attempted hosts: ${this.options.entrypoints.map((entry) => `${entry.websocket!.host}:${entry.websocket!.port}`).join(', ')}`
         )
     }
 
-    public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
-        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
-        return (connectionType === ConnectionType.WEBSOCKET_CLIENT || connectionType === ConnectionType.WEBSOCKET_SERVER)
+    public async autoCertify(): Promise<void> {
+        this.autoCertifierClient = new AutoCertifierClientFacade({
+            configFile: this.options.autoCertifierConfigFile,
+            transport: this.options.autoCertifierTransport,
+            url: this.options.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()
     }
 
-    public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(nodeId)
-        if (existingConnection) {
-            return existingConnection
-        }
-
-        if (this.localPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
-            return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
-        } else {
-            const socket = new WebsocketClientConnection()
-
-            const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
-
-            const managedConnection = new ManagedConnection(
-                this.localPeerDescriptor!,
-                ConnectionType.WEBSOCKET_CLIENT,
-                socket,
-                undefined,
-                targetPeerDescriptor
-            )
-            managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
-
-            this.connectingConnections.set(nodeId, managedConnection)
-
-            const delFunc = () => {
-                if (this.connectingConnections.has(nodeId)) {
-                    this.connectingConnections.delete(nodeId)
-                }
-                socket.off('disconnected', delFunc)
-                managedConnection.off('handshakeCompleted', delFunc)
-            }
-            socket.on('disconnected', delFunc)
-            managedConnection.on('handshakeCompleted', delFunc)
-
-            socket.connect(url, false)
+    private setHost(hostName: string): void {
+        logger.trace(`Setting host name to ${hostName}`)
+        this.host = hostName
+    }
 
-            return managedConnection
+    public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        if (this.ongoingConnectRequests.has(nodeId)) {
+            return this.ongoingConnectRequests.get(nodeId)!.pendingConnection
         }
+        return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
     }
 
-    private requestConnectionFromPeer(localPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+    private requestConnectionFromPeer(localPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): PendingConnection {
         setImmediate(() => {
-            const remoteConnector = new WebsocketConnectorRpcRemote(
+            const remoteConnector = new WebsocketClientConnectorRpcRemote(
                 localPeerDescriptor,
                 targetPeerDescriptor,
-                this.rpcCommunicator,
-                WebsocketConnectorRpcClient
+                this.options.rpcCommunicator,
+                WebsocketClientConnectorRpcClient
             )
             remoteConnector.requestConnection().then(() => {
                 logger.trace('Sent WebsocketConnectionRequest notification to peer', { targetPeerDescriptor })
@@ -291,57 +250,23 @@ export class WebsocketConnector {
                 })
             })
         })
-        const managedConnection = new ManagedConnection(
-            this.localPeerDescriptor!,
-            ConnectionType.WEBSOCKET_SERVER,
-            undefined,
-            undefined,
-            targetPeerDescriptor
-        )
+        const pendingConnection = new PendingConnection(targetPeerDescriptor)
         const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
-        managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(nodeId))
-        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
-        this.ongoingConnectRequests.set(nodeId, managedConnection)
-        return managedConnection
-    }
-
-    private onServerSocketHandshakeRequest(
-        sourcePeerDescriptor: PeerDescriptor,
-        websocketServerConnection: IConnection,
-        remoteVersion: string,
-        targetPeerDescriptor?: PeerDescriptor
-    ) {
-        const nodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
-        if (this.ongoingConnectRequests.has(nodeId)) {
-            const ongoingConnectRequest = this.ongoingConnectRequests.get(nodeId)!
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                ongoingConnectRequest.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
-            } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
-                ongoingConnectRequest.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
-            } else {
-                ongoingConnectRequest.attachImplementation(websocketServerConnection)
-                ongoingConnectRequest.acceptHandshake()
-            }
+        // TODO: can this leak?
+        const delFunc = () => {
+            pendingConnection.off('connected', delFunc)
+            pendingConnection.off('disconnected', delFunc)
             this.ongoingConnectRequests.delete(nodeId)
-        } else {
-            const managedConnection = new ManagedConnection(
-                this.localPeerDescriptor!,
-                ConnectionType.WEBSOCKET_SERVER,
-                undefined,
-                websocketServerConnection,
-                targetPeerDescriptor
-            )
-            managedConnection.setRemotePeerDescriptor(sourcePeerDescriptor)
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                managedConnection.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
-            } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
-                managedConnection.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
-            } else if (this.config.onNewConnection(managedConnection)) {
-                managedConnection.acceptHandshake()
-            } else {
-                managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)
-            }
         }
+        pendingConnection.on('connected', delFunc)
+        pendingConnection.on('disconnected', delFunc)
+        this.ongoingConnectRequests.set(nodeId, { pendingConnection, delFunc })
+        return pendingConnection
+    }
+
+    public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
+        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
+        return (connectionType === ConnectionType.WEBSOCKET_SERVER)
     }
 
     public setLocalPeerDescriptor(localPeerDescriptor: PeerDescriptor): void {
@@ -350,14 +275,12 @@ export class WebsocketConnector {
 
     public async destroy(): Promise<void> {
         this.abortController.abort()
-        this.rpcCommunicator.destroy()
 
         const requests = Array.from(this.ongoingConnectRequests.values())
-        await Promise.allSettled(requests.map((conn) => conn.close(false)))
+        await Promise.allSettled(requests.map((ongoingConnectRequest) => ongoingConnectRequest.pendingConnection.close(true)))
 
-        const attempts = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(attempts.map((conn) => conn.close(false)))
         await this.websocketServer?.stop()
         await this.geoIpLocator?.stop()
     }
+
 }