@streamr/dht 100.0.0-pretestnet.0 → 100.0.0-pretestnet.3

package/src/connection/{WebSocket/ServerWebSocket.ts → websocket/ServerWebsocket.ts}

@@ -2,8 +2,8 @@ import EventEmitter from 'eventemitter3'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { connection as WsConnection } from 'websocket'
 import { Logger } from '@streamr/utils'
-import { DisconnectionType } from '../../transport/ITransport'
 import { Url } from 'url'
+import { GOING_AWAY } from './ClientWebsocket'
 
 const logger = new Logger(module)
 
@@ -18,7 +18,7 @@ enum MessageType {
     BINARY = 'binary'
 }
 
-export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
 
     public readonly connectionId: ConnectionID
     public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
@@ -33,40 +33,34 @@ export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements I
         this.connectionId = new ConnectionID()
 
         socket.on('message', (message) => {
-            if (!this.stopped) {
-                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))
-                }
+            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))
             }
         })
         socket.on('close', (reasonCode, description) => {
-            if (!this.stopped) {
-                logger.trace(' Peer ' + socket.remoteAddress + ' disconnected.')
-                this.doDisconnect('OTHER', reasonCode, description)
-            }
+            logger.trace('Peer ' + socket.remoteAddress + ' disconnected.')            
+            this.doDisconnect(reasonCode, description)
         })
 
         socket.on('error', (error) => {
-            if (!this.stopped) {
-                this.emit('error', error.name)
-            }
+            this.emit('error', error.name)
         })
 
         this.socket = socket
     }
 
-    private doDisconnect(disconnectionType: DisconnectionType, reasonCode: number, description: string): void {
+    private doDisconnect(reasonCode: number, description: string): void {
         this.stopped = true
         this.socket?.removeAllListeners()
         this.socket = undefined
-
-        this.emit('disconnected', disconnectionType, reasonCode, description)
+        const gracefulLeave = reasonCode === GOING_AWAY
+        this.emit('disconnected', gracefulLeave, reasonCode, description)
     }
 
     public send(data: Uint8Array): void {
@@ -80,16 +74,16 @@ export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements I
                 this.socket.sendBytes(Buffer.from(data))
             }
         } else {
-            logger.error('Tried to call send() on a stopped socket')
+            logger.debug('Tried to call send() on a stopped socket')
         }
 
     }
 
-    public async close(): Promise<void> {
+    public async close(gracefulLeave: boolean): Promise<void> {
         if (!this.stopped) {
-            this.socket?.close()
+            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
         } else {
-            logger.error('Tried to close a stopped connection')
+            logger.debug('Tried to close a stopped connection')
         }
     }
 
@@ -103,7 +97,7 @@ export class ServerWebSocket extends EventEmitter<ConnectionEvents> implements I
             }
             this.stopped = true
         } else {
-            logger.error('Tried to destroy() a stopped connection')
+            logger.debug('Tried to destroy() a stopped connection')
         }
     }
 

package/src/connection/{WebSocket/WebSocketConnectorRpcLocal.ts → websocket/WebsocketConnector.ts}

@@ -1,112 +1,150 @@
-import { ClientWebSocket } from './ClientWebSocket'
+import { ClientWebsocket } from './ClientWebsocket'
 import { IConnection, ConnectionType } from '../IConnection'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { WebSocketConnectorRpcRemote } from './WebSocketConnectorRpcRemote'
+import { WebsocketConnectorRpcLocal } from './WebsocketConnectorRpcLocal'
+import { WebsocketConnectorRpcRemote } from './WebsocketConnectorRpcRemote'
 import {
     ConnectivityMethod,
     ConnectivityResponse,
-    NodeType,
     PeerDescriptor,
-    WebSocketConnectionRequest,
-    WebSocketConnectionResponse
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { WebSocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger, binaryToHex, wait } from '@streamr/utils'
-import { IWebSocketConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { ManagedConnection } from '../ManagedConnection'
-import { WebSocketServer } from './WebSocketServer'
+import { WebsocketServer } from './WebsocketServer'
 import { ConnectivityChecker } from '../ConnectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { PeerIDKey } from '../../helpers/PeerID'
-import { ServerWebSocket } from './ServerWebSocket'
+import { ServerWebsocket } from './ServerWebsocket'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Handshaker } from '../Handshaker'
 import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ParsedUrlQuery } from 'querystring'
 import { range, sample } from 'lodash'
-import { isPrivateIPv4 } from '../../helpers/AddressTools'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-
+import { expectedConnectionType } from '../../helpers/Connectivity'
+import { WebsocketServerStartError } from '../../helpers/errors'
+import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
 const logger = new Logger(module)
 
-export const connectivityMethodToWebSocketUrl = (ws: ConnectivityMethod): string => {
+export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod): string => {
     return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port
 }
 
-const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod) => {
-    const hasPrivateAddress = ((websocketServer.host === 'localhost') || isPrivateIPv4(websocketServer.host))
-    return websocketServer.tls || hasPrivateAddress
-}
-
 const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
-interface WebSocketConnectorRpcLocalConfig {
+interface WebsocketConnectorConfig {
     transport: ITransport
-    canConnect: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
+    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     onIncomingConnection: (connection: ManagedConnection) => boolean
     portRange?: PortRange
     maxMessageSize?: number
     host?: string
     entrypoints?: PeerDescriptor[]
     tlsCertificate?: TlsCertificate
+    autoCertifierTransport: ITransport
+    autoCertifierUrl: string
+    autoCertifierConfigFile: string
+    serverEnableTls: boolean
 }
 
-export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
+export class WebsocketConnector {
 
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly canConnectFunction: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
-    private readonly webSocketServer?: WebSocketServer
+    private readonly websocketServer?: WebsocketServer
     private connectivityChecker?: ConnectivityChecker
     private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
     private onIncomingConnection: (connection: ManagedConnection) => boolean
     private host?: string
     private readonly entrypoints?: PeerDescriptor[]
     private readonly tlsCertificate?: TlsCertificate
+    private readonly autoCertifierTransport: ITransport
+    private readonly autoCertifierUrl: string
+    private readonly autoCertifierConfigFile: string
+    private readonly serverEnableTls: boolean
+    private autoCertifierClient?: AutoCertifierClientFacade
     private selectedPort?: number
-    private ownPeerDescriptor?: PeerDescriptor
+    private localPeerDescriptor?: PeerDescriptor
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
-    private destroyed = false
+    private abortController = new AbortController()
 
-    constructor(config: WebSocketConnectorRpcLocalConfig) {
-        this.webSocketServer = config.portRange ? new WebSocketServer({
+    constructor(config: WebsocketConnectorConfig) {
+        this.websocketServer = config.portRange ? new WebsocketServer({
             portRange: config.portRange!,
             tlsCertificate: config.tlsCertificate,
-            maxMessageSize: config.maxMessageSize
+            maxMessageSize: config.maxMessageSize,
+            enableTls: config.serverEnableTls
         }) : undefined
         this.onIncomingConnection = config.onIncomingConnection
         this.host = config.host
         this.entrypoints = config.entrypoints
         this.tlsCertificate = config.tlsCertificate
-
-        this.canConnectFunction = config.canConnect.bind(this)
-
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebSocketConnectorRpcLocal.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
+        this.autoCertifierTransport = config.autoCertifierTransport
+        this.autoCertifierUrl = config.autoCertifierUrl
+        this.autoCertifierConfigFile = config.autoCertifierConfigFile
+        this.serverEnableTls = config.serverEnableTls
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebsocketConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
+        this.registerLocalRpcMethods(config)
+    }
 
+    private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
+        const rpcLocal = new WebsocketConnectorRpcLocal({
+            canConnect: (peerDescriptor: PeerDescriptor) => config.canConnect(peerDescriptor),
+            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
+            onIncomingConnection: (connection: ManagedConnection) => config.onIncomingConnection(connection),
+            abortSignal: this.abortController.signal
+        })
         this.rpcCommunicator.registerRpcMethod(
-            WebSocketConnectionRequest,
-            WebSocketConnectionResponse,
+            WebsocketConnectionRequest,
+            WebsocketConnectionResponse,
             'requestConnection',
-            (req: WebSocketConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context)
+            async (req: WebsocketConnectionRequest, context: ServerCallContext) => {
+                if (!this.abortController.signal.aborted) {
+                    return rpcLocal.requestConnection(req, context)
+                } else {
+                    return { accepted: false }
+                }
+            }
         )
     }
 
     private attachHandshaker(connection: IConnection) {
-        const handshaker = new Handshaker(this.ownPeerDescriptor!, connection)
+        const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
         handshaker.once('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
             this.onServerSocketHandshakeRequest(peerDescriptor, connection)
         })
     }
 
+    public async autoCertify(): Promise<void> {
+        this.autoCertifierClient = new AutoCertifierClientFacade({
+            configFile: this.autoCertifierConfigFile,
+            transport: this.autoCertifierTransport,
+            url: this.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.connectivityChecker!.setHost(hostName)
+    }
+
     public async start(): Promise<void> {
-        if (!this.destroyed && this.webSocketServer) {
-            this.webSocketServer.on('connected', (connection: IConnection) => {
+        if (!this.abortController.signal.aborted && this.websocketServer) {
+            this.websocketServer.on('connected', (connection: IConnection) => {
 
-                const serverSocket = connection as unknown as ServerWebSocket
+                const serverSocket = connection as unknown as ServerWebsocket
                 if (serverSocket.resourceURL &&
                     serverSocket.resourceURL.query) {
                     const query = serverSocket.resourceURL.query as unknown as ParsedUrlQuery
@@ -122,63 +160,55 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
                     this.attachHandshaker(connection)
                 }
             })
-            const port = await this.webSocketServer.start()
+            const port = await this.websocketServer.start()
             this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.tlsCertificate !== undefined, this.host)
+            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.serverEnableTls, this.host)
         }
     }
 
-    public async checkConnectivity(): Promise<ConnectivityResponse> {
+    public async checkConnectivity(selfSigned: boolean): Promise<ConnectivityResponse> {
         // TODO: this could throw if the server is not running
         const noServerConnectivityResponse: ConnectivityResponse = {
-            openInternet: false,
             host: '127.0.0.1',
             natType: NatType.UNKNOWN
         }
-        if (this.destroyed) {
+        if (this.abortController.signal.aborted) {
             return noServerConnectivityResponse
         }
         for (const reattempt of range(ENTRY_POINT_CONNECTION_ATTEMPTS)) {
             const entryPoint = sample(this.entrypoints)!
             try {
-                if (!this.webSocketServer) {
-                    // If no websocket server, return openInternet: false
+                if (!this.websocketServer) {
                     return noServerConnectivityResponse
                 } else {
-                    if (!this.entrypoints || this.entrypoints.length < 1) {
+                    if (!this.entrypoints || this.entrypoints.length === 0) {
                         // return connectivity info given in config
                         const preconfiguredConnectivityResponse: ConnectivityResponse = {
-                            openInternet: true,
                             host: this.host!,
                             natType: NatType.OPEN_INTERNET,
                             websocket: { host: this.host!, port: this.selectedPort!, tls: this.tlsCertificate !== undefined }
                         }
                         return preconfiguredConnectivityResponse
                     } else {
-                        // Do real connectivity checking
-                        return await this.connectivityChecker!.sendConnectivityRequest(entryPoint)
+                        // Do real connectivity checking     
+                        return await this.connectivityChecker!.sendConnectivityRequest(entryPoint, selfSigned)
                     }
                 }
             } catch (err) {
                 if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
                     const error = `Failed to connect to entrypoint with id ${binaryToHex(entryPoint.kademliaId)} `
-                        + `and URL ${connectivityMethodToWebSocketUrl(entryPoint.websocket!)}`
+                        + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
                     logger.error(error, { error: err })
                     await wait(2000)
                 }
             }
         }
-        throw Error(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
+        throw new WebsocketServerStartError(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
     }
 
     public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
-        if (this.ownPeerDescriptor!.websocket !== undefined) {
-            return (targetPeerDescriptor.type !== NodeType.BROWSER) || canOpenConnectionFromBrowser(this.ownPeerDescriptor!.websocket)
-        } else if (targetPeerDescriptor.websocket !== undefined) {
-            return (this.ownPeerDescriptor!.type !== NodeType.BROWSER) || canOpenConnectionFromBrowser(targetPeerDescriptor.websocket)
-        } else {
-            return false
-        }
+        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
+        return (connectionType === ConnectionType.WEBSOCKET_CLIENT || connectionType === ConnectionType.WEBSOCKET_SERVER)
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
@@ -188,14 +218,14 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
             return existingConnection
         }
 
-        if (this.ownPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
-            return this.requestConnectionFromPeer(this.ownPeerDescriptor!, targetPeerDescriptor)
+        if (this.localPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
+            return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
         } else {
-            const socket = new ClientWebSocket()
+            const socket = new ClientWebsocket()
 
-            const url = connectivityMethodToWebSocketUrl(targetPeerDescriptor.websocket!)
+            const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
 
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
+            const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
             managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
             this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
@@ -216,33 +246,33 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
         }
     }
 
-    private requestConnectionFromPeer(ownPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+    private requestConnectionFromPeer(localPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
         setImmediate(() => {
-            const remoteConnector = new WebSocketConnectorRpcRemote(
-                ownPeerDescriptor,
+            const remoteConnector = new WebsocketConnectorRpcRemote(
+                localPeerDescriptor,
                 targetPeerDescriptor,
-                toProtoRpcClient(new WebSocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
-            remoteConnector.requestConnection(ownPeerDescriptor.websocket!.host, ownPeerDescriptor.websocket!.port)
+            remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
         })
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER)
+        const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER)
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
         this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
         return managedConnection
     }
 
-    private onServerSocketHandshakeRequest = (peerDescriptor: PeerDescriptor, serverWebSocket: IConnection) => {
+    private onServerSocketHandshakeRequest(peerDescriptor: PeerDescriptor, serverWebsocket: IConnection) {
 
         const peerId = peerIdFromPeerDescriptor(peerDescriptor)
 
         if (this.ongoingConnectRequests.has(peerId.toKey())) {
             const ongoingConnectReguest = this.ongoingConnectRequests.get(peerId.toKey())!
-            ongoingConnectReguest.attachImplementation(serverWebSocket)
+            ongoingConnectReguest.attachImplementation(serverWebsocket)
             ongoingConnectReguest.acceptHandshake()
             this.ongoingConnectRequests.delete(peerId.toKey())
         } else {
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebSocket)
+            const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebsocket)
 
             managedConnection.setPeerDescriptor(peerDescriptor)
 
@@ -255,41 +285,20 @@ export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
         }
     }
 
-    public setOwnPeerDescriptor(ownPeerDescriptor: PeerDescriptor): void {
-        this.ownPeerDescriptor = ownPeerDescriptor
+    public setLocalPeerDescriptor(localPeerDescriptor: PeerDescriptor): void {
+        this.localPeerDescriptor = localPeerDescriptor
     }
 
     public async destroy(): Promise<void> {
-        this.destroyed = true
-        this.rpcCommunicator.stop()
+        this.abortController.abort()
+        this.rpcCommunicator.destroy()
 
         const requests = Array.from(this.ongoingConnectRequests.values())
-        await Promise.allSettled(requests.map((conn) => conn.close('OTHER')))
+        await Promise.allSettled(requests.map((conn) => conn.close(false)))
 
         const attempts = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
+        await Promise.allSettled(attempts.map((conn) => conn.close(false)))
         this.connectivityChecker?.destroy()
-        await this.webSocketServer?.stop()
-    }
-
-    // IWebSocketConnectorRpc implementation
-    public async requestConnection(request: WebSocketConnectionRequest, context: ServerCallContext): Promise<WebSocketConnectionResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (!this.destroyed && this.canConnectFunction(senderPeerDescriptor, request.ip, request.port)) {
-            setImmediate(() => {
-                if (this.destroyed) {
-                    return
-                }
-                const connection = this.connect(senderPeerDescriptor)
-                this.onIncomingConnection(connection)
-            })
-            const res: WebSocketConnectionResponse = {
-                accepted: true
-            }
-            return res
-        }
-        return {
-            accepted: false
-        }
+        await this.websocketServer?.stop()
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -0,0 +1,41 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import {
+    PeerDescriptor,
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
+} 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'
+
+interface WebsocketConnectorRpcLocalConfig {
+    canConnect: (peerDescriptor: PeerDescriptor) => boolean
+    connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
+    onIncomingConnection: (connection: ManagedConnection) => boolean
+    abortSignal: AbortSignal
+}
+
+export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
+
+    private readonly config: WebsocketConnectorRpcLocalConfig
+
+    constructor(config: WebsocketConnectorRpcLocalConfig) {
+        this.config = config
+    }
+
+    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
+                }
+                const connection = this.config.connect(senderPeerDescriptor)
+                this.config.onIncomingConnection(connection)
+            })
+            return { accepted: true }
+        } else {
+            return { accepted: false }
+        }
+    }
+}

package/src/connection/{WebSocket/WebSocketConnectorRpcRemote.ts → websocket/WebsocketConnectorRpcRemote.ts}

@@ -1,8 +1,8 @@
 import {
     PeerDescriptor,
-    WebSocketConnectionRequest
+    WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebSocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+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'
@@ -11,34 +11,28 @@ import { Remote } from '../../dht/contact/Remote'
 
 const logger = new Logger(module)
 
-export class WebSocketConnectorRpcRemote extends Remote<IWebSocketConnectorRpcClient> {
+export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcClient> {
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebSocketConnectorRpcClient>
+        client: ProtoRpcClient<IWebsocketConnectorRpcClient>
     ) {
         super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
     }
 
     async requestConnection(ip: string, port: number): Promise<boolean> {
         logger.trace(`Requesting WebSocket connection from ${keyFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
-        const request: WebSocketConnectionRequest = {
+        const request: WebsocketConnectionRequest = {
             ip,
             port
         }
         const options = this.formDhtRpcOptions()
         try {
             const res = await this.getClient().requestConnection(request, options)
-            
-            if (res.reason) {
-                logger.debug('WebSocketConnectionRequest Rejected', {
-                    stack: new Err.WebSocketConnectionRequestRejected(res.reason).stack
-                })
-            }
             return res.accepted
         } catch (err) {
-            logger.debug(new Err.WebSocketConnectionRequestRejected('WebSocketConnectionRequest rejected', err).stack!)
+            logger.debug(new Err.WebsocketConnectionRequestRejected('WebsocketConnectionRequest rejected', err).stack!)
             return false
         }
     }