@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/src/connection/websocket/WebsocketConnector.ts

@@ -16,7 +16,7 @@ import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/Dht
 import { Logger, binaryToHex, wait } from '@streamr/utils'
 import { ManagedConnection } from '../ManagedConnection'
 import { WebsocketServer } from './WebsocketServer'
-import { ConnectivityChecker } from '../ConnectivityChecker'
+import { sendConnectivityRequest } from '../connectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { ServerWebsocket } from './ServerWebsocket'
@@ -29,6 +29,9 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { expectedConnectionType } from '../../helpers/Connectivity'
 import { WebsocketServerStartError } from '../../helpers/errors'
 import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
+import { attachConnectivityRequestHandler } from '../connectivityRequestHandler'
+import * as Err from '../../helpers/errors'
+
 const logger = new Logger(module)
 
 export type Action = 'connectivityRequest' | 'connectivityProbe'
@@ -41,7 +44,6 @@ const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
 export interface WebsocketConnectorConfig {
     transport: ITransport
-    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     onNewConnection: (connection: ManagedConnection) => boolean
     portRange?: PortRange
     maxMessageSize?: number
@@ -59,7 +61,6 @@ export class WebsocketConnector {
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly websocketServer?: WebsocketServer
-    private connectivityChecker?: ConnectivityChecker
     private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
     private onNewConnection: (connection: ManagedConnection) => boolean
     private host?: string
@@ -77,7 +78,7 @@ export class WebsocketConnector {
 
     constructor(config: WebsocketConnectorConfig) {
         this.websocketServer = config.portRange ? new WebsocketServer({
-            portRange: config.portRange!,
+            portRange: config.portRange,
             tlsCertificate: config.tlsCertificate,
             maxMessageSize: config.maxMessageSize,
             enableTls: config.serverEnableTls
@@ -98,8 +99,18 @@ export class WebsocketConnector {
 
     private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
         const rpcLocal = new WebsocketConnectorRpcLocal({
-            canConnect: (peerDescriptor: PeerDescriptor) => config.canConnect(peerDescriptor),
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
+            hasConnection: (targetPeerDescriptor: PeerDescriptor): boolean => {
+                const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
+                if (this.connectingConnections.has(peerKey)
+                    || this.connectingConnections.has(peerKey)
+                    || this.ongoingConnectRequests.has(peerKey)
+                ) {
+                    return true
+                } else {
+                    return false
+                }
+            },
             onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
             abortSignal: this.abortController.signal
         })
@@ -107,7 +118,7 @@ export class WebsocketConnector {
             WebsocketConnectionRequest,
             WebsocketConnectionResponse,
             'requestConnection',
-            async (req: WebsocketConnectionRequest, context: ServerCallContext) => {
+            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> => {
                 if (!this.abortController.signal.aborted) {
                     return rpcLocal.requestConnection(req, context)
                 } else {
@@ -134,13 +145,12 @@ export class WebsocketConnector {
             updateCertificate: (certificate: string, privateKey: string) => this.websocketServer!.updateCertificate(certificate, privateKey)
         })
         logger.trace(`AutoCertifying subdomain...`)
-        await this.autoCertifierClient!.start()
+        await this.autoCertifierClient.start()
     }
 
     private setHost(hostName: string): void {
         logger.trace(`Setting host name to ${hostName}`)
         this.host = hostName
-        this.connectivityChecker!.setHost(hostName)
     }
 
     public async start(): Promise<void> {
@@ -151,7 +161,7 @@ export class WebsocketConnector {
                 const action = query?.action as (Action | undefined)
                 logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.getRemoteAddress() })
                 if (action === 'connectivityRequest') {
-                    this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
+                    attachConnectivityRequestHandler(serverSocket)
                 } else if (action === 'connectivityProbe') {
                     // no-op
                 } else {
@@ -160,7 +170,6 @@ export class WebsocketConnector {
             })
             const port = await this.websocketServer.start()
             this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.serverEnableTls, this.host)
         }
     }
 
@@ -189,12 +198,22 @@ export class WebsocketConnector {
                         return preconfiguredConnectivityResponse
                     } else {
                         // Do real connectivity checking
-                        return await this.connectivityChecker!.sendConnectivityRequest(entryPoint, selfSigned)
+                        const connectivityRequest = {
+                            port: this.selectedPort!,
+                            host: this.host,
+                            tls: this.serverEnableTls,
+                            selfSigned
+                        }
+                        if (!this.abortController.signal.aborted) {
+                            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 ${binaryToHex(entryPoint.kademliaId)} `
+                    const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.nodeId)} `
                         + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
                     logger.error(error, { error: err })
                     await wait(2000)
@@ -257,7 +276,14 @@ export class WebsocketConnector {
                 targetPeerDescriptor,
                 toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
-            remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
+            remoteConnector.requestConnection().then((_response: WebsocketConnectionResponse) => {
+                logger.trace('Sent WebsocketConnectionRequest request to peer', { targetPeerDescriptor })
+                return
+            }, (err) => {
+                logger.debug('Failed to send WebsocketConnectionRequest request to peer of failed to get the response ', {
+                    error: err, targetPeerDescriptor
+                })
+            })
         })
         const managedConnection = new ManagedConnection(
             this.localPeerDescriptor!,
@@ -265,7 +291,7 @@ export class WebsocketConnector {
             undefined,
             undefined,
             targetPeerDescriptor
-        )        
+        )
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
         this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
@@ -273,7 +299,7 @@ export class WebsocketConnector {
     }
 
     private onServerSocketHandshakeRequest(
-        sourcePeerDescriptor: PeerDescriptor, 
+        sourcePeerDescriptor: PeerDescriptor,
         serverWebsocket: IConnection,
         targetPeerDescriptor?: PeerDescriptor
     ) {
@@ -282,12 +308,8 @@ export class WebsocketConnector {
         if (this.ongoingConnectRequests.has(peerId.toKey())) {
             const ongoingConnectRequest = this.ongoingConnectRequests.get(peerId.toKey())!
             ongoingConnectRequest.attachImplementation(serverWebsocket)
-            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
-                ongoingConnectRequest.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
-            } else {
-                ongoingConnectRequest.acceptHandshake()
-                this.ongoingConnectRequests.delete(peerId.toKey())
-            }
+            ongoingConnectRequest.acceptHandshake()
+            this.ongoingConnectRequests.delete(peerId.toKey())
         } else {
             const managedConnection = new ManagedConnection(
                 this.localPeerDescriptor!,
@@ -322,7 +344,6 @@ export class WebsocketConnector {
 
         const attempts = Array.from(this.connectingConnections.values())
         await Promise.allSettled(attempts.map((conn) => conn.close(false)))
-        this.connectivityChecker?.destroy()
         await this.websocketServer?.stop()
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -9,8 +9,8 @@ import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ManagedConnection } from '../ManagedConnection'
 
 interface WebsocketConnectorRpcLocalConfig {
-    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
+    hasConnection: (targetPeerDescriptor: PeerDescriptor) => boolean
     onNewConnection: (connection: ManagedConnection) => boolean
     abortSignal: AbortSignal
 }
@@ -25,17 +25,15 @@ export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
 
     public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.config.canConnect(senderPeerDescriptor)) {
-            setImmediate(() => {
-                if (this.config.abortSignal.aborted) {
-                    return
-                }
+        setImmediate(() => {
+            if (this.config.abortSignal.aborted) {
+                return
+            }
+            if (!this.config.hasConnection(senderPeerDescriptor)) {
                 const connection = this.config.connect(senderPeerDescriptor)
                 this.config.onNewConnection(connection)
-            })
-            return { accepted: true }
-        } else {
-            return { accepted: false }
-        }
+            }
+        })
+        return { accepted: true }
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -1,17 +1,17 @@
 import {
     PeerDescriptor,
-    WebsocketConnectionRequest
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
 } 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'
 
 const logger = new Logger(module)
 
-export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcClient> {
+export class WebsocketConnectorRpcRemote extends RpcRemote<IWebsocketConnectorRpcClient> {
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
@@ -21,19 +21,10 @@ export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcCl
         super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
     }
 
-    async requestConnection(ip: string, port: number): Promise<boolean> {
+    async requestConnection(): Promise<WebsocketConnectionResponse> {
         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

@@ -101,11 +101,17 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                     return
                 }
                 
-                const connection = request.accept(undefined, request.origin)
-                
-                logger.trace('IConnection accepted.')
+                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 ServerWebsocket(connection, request.resourceURL))
+                if (connection) {
+                    this.emit('connected', new ServerWebsocket(connection, request.resourceURL))
+                }
             })
             this.httpServer.once('error', (err: Error) => {
                 reject(new WebsocketServerStartError('Starting Websocket server failed', err))
@@ -137,9 +143,18 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         this.removeAllListeners()
         return new Promise((resolve, _reject) => {
             this.wsServer?.shutDown()
-            this.httpServer?.close(() => {
+            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()
         })
     }