@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/src/connection/WebRTC/WebRtcConnectorRpcLocal.ts

@@ -1,335 +0,0 @@
-import {
-    IceCandidate,
-    PeerDescriptor,
-    RtcAnswer,
-    RtcOffer, WebRtcConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { ITransport } from '../../transport/ITransport'
-import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { NodeWebRtcConnection } from './NodeWebRtcConnection'
-import { WebRtcConnectorRpcRemote } from './WebRtcConnectorRpcRemote'
-import { WebRtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { PeerIDKey } from '../../helpers/PeerID'
-import { ManagedWebRtcConnection } from '../ManagedWebRtcConnection'
-import { Logger } from '@streamr/utils'
-import * as Err from '../../helpers/errors'
-import { IWebRtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { ManagedConnection } from '../ManagedConnection'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import {
-    areEqualPeerDescriptors,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
-} from '../../helpers/peerIdFromPeerDescriptor'
-import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
-import { PortRange } from '../ConnectionManager'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-
-const logger = new Logger(module)
-
-export const replaceInternalIpWithExternalIp = (candidate: string, ip: string): string => {
-    const parsed = candidate.split(' ')
-    const type = parsed[7]
-    if (type === 'host') {
-        parsed[4] = ip
-    }
-    return parsed.join(' ')
-}
-
-export interface WebRtcConnectorRpcLocalConfig {
-    transport: ITransport
-    iceServers?: IceServer[]
-    allowPrivateAddresses?: boolean
-    bufferThresholdLow?: number
-    bufferThresholdHigh?: number
-    maxMessageSize?: number
-    connectionTimeout?: number
-    externalIp?: string
-    portRange?: PortRange
-}
-
-export interface IceServer {
-    url: string
-    port: number
-    username?: string
-    password?: string
-    tcp?: boolean
-}
-
-export class WebRtcConnectorRpcLocal implements IWebRtcConnectorRpc {
-
-    private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
-    private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly ongoingConnectAttempts: Map<PeerIDKey, ManagedWebRtcConnection> = new Map()
-    private ownPeerDescriptor?: PeerDescriptor
-    private stopped = false
-    private iceServers: IceServer[]
-    private allowPrivateAddresses: boolean
-    private config: WebRtcConnectorRpcLocalConfig
-    private onIncomingConnection: (connection: ManagedConnection) => boolean
-
-    constructor(
-        config: WebRtcConnectorRpcLocalConfig,
-        onIncomingConnection: (connection: ManagedConnection) => boolean
-    ) {
-        this.config = config
-        this.iceServers = config.iceServers || []
-        this.allowPrivateAddresses = config.allowPrivateAddresses || true
-        this.onIncomingConnection = onIncomingConnection
-
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnectorRpcLocal.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
-            rpcRequestTimeout: 15000
-        })
-        this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
-            (req: RtcOffer, context: ServerCallContext) => this.rtcOffer(req, context))
-        this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
-            (req: RtcAnswer, context: ServerCallContext) => this.rtcAnswer(req, context))
-        this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
-            (req: IceCandidate, context: ServerCallContext) => this.iceCandidate(req, context))
-        this.rpcCommunicator.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection',
-            (req: WebRtcConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context))
-    }
-
-    connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        if (areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
-            throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
-        }
-
-        logger.trace(`Opening WebRTC connection to ${keyFromPeerDescriptor(targetPeerDescriptor)}`)
-
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.ongoingConnectAttempts.get(peerKey)
-        if (existingConnection) {
-            return existingConnection
-        }
-
-        const connection = new NodeWebRtcConnection({
-            remotePeerDescriptor: targetPeerDescriptor,
-            iceServers: this.iceServers,
-            bufferThresholdLow: this.config.bufferThresholdLow,
-            bufferThresholdHigh: this.config.bufferThresholdHigh,
-            connectingTimeout: this.config.connectionTimeout,
-            portRange: this.config.portRange
-        })
-
-        const offering = this.isOffering(targetPeerDescriptor)
-        let managedConnection: ManagedWebRtcConnection
-
-        if (offering) {
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, connection)
-        } else {
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, undefined, connection)
-        }
-
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
-
-        this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
-
-        const delFunc = () => {
-            if (this.ongoingConnectAttempts.has(peerKey)) {
-                this.ongoingConnectAttempts.delete(peerKey)
-            }
-            connection.off('disconnected', delFunc)
-            managedConnection.off('handshakeCompleted', delFunc)
-        }
-        connection.on('disconnected', delFunc)
-        managedConnection.on('handshakeCompleted', delFunc)
-
-        const remoteConnector = new WebRtcConnectorRpcRemote(
-            this.ownPeerDescriptor!,
-            targetPeerDescriptor,
-            toProtoRpcClient(new WebRtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-        )
-
-        connection.on('localCandidate', (candidate: string, mid: string) => {
-            if (this.config.externalIp) {
-                candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
-                logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
-            }
-            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId.toString())
-        })
-
-        if (offering) {
-            connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcOffer(description, connection.connectionId.toString())
-            })
-        } else {
-            connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(description, connection.connectionId.toString())
-            })
-        }
-
-        connection.start(offering)
-
-        if (!offering) {
-            remoteConnector.requestConnection(connection.connectionId.toString())
-        }
-
-        return managedConnection
-    }
-
-    setOwnPeerDescriptor(peerDescriptor: PeerDescriptor): void {
-        this.ownPeerDescriptor = peerDescriptor
-    }
-
-    private isIceCandidateAllowed(candidate: string): boolean {
-        if (!this.allowPrivateAddresses) {
-            const address = getAddressFromIceCandidate(candidate)
-            if (address && isPrivateIPv4(address)) {
-                return false
-            }
-        }
-        return true
-    }
-
-    private onRtcOffer(
-        remotePeer: PeerDescriptor,
-        targetPeer: PeerDescriptor,
-        description: string,
-        connectionId: string
-    ): void {
-        if (this.stopped || !areEqualPeerDescriptors(targetPeer, this.ownPeerDescriptor!)) {
-            return
-        }
-        const peerKey = keyFromPeerDescriptor(remotePeer)
-        let managedConnection = this.ongoingConnectAttempts.get(peerKey)
-        let connection = managedConnection?.getWebRtcConnection()
-
-        if (!managedConnection) {
-            connection = new NodeWebRtcConnection({ remotePeerDescriptor: remotePeer })
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, undefined, connection)
-
-            managedConnection.setPeerDescriptor(remotePeer)
-
-            this.ongoingConnectAttempts.set(peerKey, managedConnection)
-            this.onIncomingConnection(managedConnection)
-
-            const remoteConnector = new WebRtcConnectorRpcRemote(
-                this.ownPeerDescriptor!,
-                remotePeer,
-                toProtoRpcClient(new WebRtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-            )
-
-            connection.on('localCandidate', (candidate: string, mid: string) => {
-                remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId.toString())
-            })
-
-            connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(description, connection!.connectionId.toString())
-            })
-
-            connection.start(false)
-
-        }
-
-        // Always use offerers connectionId
-        connection!.setConnectionId(connectionId)
-        connection!.setRemoteDescription(description, 'offer')
-
-        managedConnection.on('handshakeRequest', () => {
-            if (this.ongoingConnectAttempts.has(peerKey)) {
-                this.ongoingConnectAttempts.delete(peerKey)
-            }
-            managedConnection!.acceptHandshake()
-        })
-    }
-
-    private onRtcAnswer(
-        remotePeerDescriptor: PeerDescriptor,
-        targetPeerDescriptor: PeerDescriptor,
-        description: string,
-        connectionId: string
-    ): void {
-        if (this.stopped || !areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
-            return
-        }
-        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.ongoingConnectAttempts.get(peerKey)?.getWebRtcConnection()
-        if (!connection) {
-            return
-        } else if (connection.connectionId.toString() !== connectionId) {
-            logger.trace(`Ignoring RTC answer due to connectionId mismatch`)
-            return
-        }
-        connection.setRemoteDescription(description, 'answer')
-    }
-
-    private onConnectionRequest(targetPeerDescriptor: PeerDescriptor): void {
-        if (this.stopped || this.ongoingConnectAttempts.has(keyFromPeerDescriptor(targetPeerDescriptor))) {
-            return
-        }
-        const managedConnection = this.connect(targetPeerDescriptor)
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
-
-        this.onIncomingConnection(managedConnection)
-    }
-    private onRemoteCandidate(
-        remotePeerDescriptor: PeerDescriptor,
-        targetPeerDescriptor: PeerDescriptor,
-        candidate: string,
-        mid: string,
-        connectionId: string
-    ): void {
-        if (this.stopped || !areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
-            return
-        }
-        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.ongoingConnectAttempts.get(peerKey)?.getWebRtcConnection()
-
-        if (!connection) {
-            return
-        } else if (connection.connectionId.toString() !== connectionId) {
-            logger.trace(`Ignoring remote candidate due to connectionId mismatch`)
-            return
-        } else if (this.isIceCandidateAllowed(candidate)) {
-            connection.addRemoteCandidate(candidate, mid)
-        }
-    }
-
-    public async stop(): Promise<void> {
-        logger.trace('stop()')
-        this.stopped = true
-
-        const attempts = Array.from(this.ongoingConnectAttempts.values())
-        await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
-
-        this.rpcCommunicator.destroy()
-    }
-
-    public isOffering(targetPeerDescriptor: PeerDescriptor): boolean {
-        const myId = peerIdFromPeerDescriptor(this.ownPeerDescriptor!)
-        const theirId = peerIdFromPeerDescriptor(targetPeerDescriptor)
-        return myId.hasSmallerHashThan(theirId)
-    }
-
-    // IWebRTCConnector implementation
-    // TODO should we read connectionId from WebRtcConnectionRequest (or remove the field)?
-    async requestConnection(_request: WebRtcConnectionRequest, context: ServerCallContext): Promise<Empty> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        this.onConnectionRequest(senderPeerDescriptor)
-        return {}
-    }
-
-    async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
-        this.onRtcOffer(senderPeerDescriptor, receiverPeerDescriptor, request.description, request.connectionId)
-        return {}
-    }
-
-    async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
-        this.onRtcAnswer(senderPeerDescriptor, receiverPeerDescriptor, request.description, request.connectionId)
-        return {}
-    }
-
-    async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
-        this.onRemoteCandidate(senderPeerDescriptor, receiverPeerDescriptor, request.candidate, request.mid, request.connectionId)
-        return {}
-    }
-}

package/src/connection/WebSocket/WebSocketConnectorRpcLocal.ts

@@ -1,295 +0,0 @@
-import { ClientWebSocket } from './ClientWebSocket'
-import { IConnection, ConnectionType } from '../IConnection'
-import { ITransport } from '../../transport/ITransport'
-import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { WebSocketConnectorRpcRemote } from './WebSocketConnectorRpcRemote'
-import {
-    ConnectivityMethod,
-    ConnectivityResponse,
-    NodeType,
-    PeerDescriptor,
-    WebSocketConnectionRequest,
-    WebSocketConnectionResponse
-} from '../../proto/packages/dht/protos/DhtRpc'
-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 { ConnectivityChecker } from '../ConnectivityChecker'
-import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
-import { PeerIDKey } from '../../helpers/PeerID'
-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'
-
-const logger = new Logger(module)
-
-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 {
-    transport: ITransport
-    canConnect: (peerDescriptor: PeerDescriptor, _ip: string, port: number) => boolean
-    onIncomingConnection: (connection: ManagedConnection) => boolean
-    portRange?: PortRange
-    maxMessageSize?: number
-    host?: string
-    entrypoints?: PeerDescriptor[]
-    tlsCertificate?: TlsCertificate
-}
-
-export class WebSocketConnectorRpcLocal implements IWebSocketConnectorRpc {
-
-    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 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 selectedPort?: number
-    private ownPeerDescriptor?: PeerDescriptor
-    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
-    private destroyed = false
-
-    constructor(config: WebSocketConnectorRpcLocalConfig) {
-        this.webSocketServer = config.portRange ? new WebSocketServer({
-            portRange: config.portRange!,
-            tlsCertificate: config.tlsCertificate,
-            maxMessageSize: config.maxMessageSize
-        }) : 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, {
-            rpcRequestTimeout: 15000
-        })
-
-        this.rpcCommunicator.registerRpcMethod(
-            WebSocketConnectionRequest,
-            WebSocketConnectionResponse,
-            'requestConnection',
-            (req: WebSocketConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context)
-        )
-    }
-
-    private attachHandshaker(connection: IConnection) {
-        const handshaker = new Handshaker(this.ownPeerDescriptor!, connection)
-        handshaker.once('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
-            this.onServerSocketHandshakeRequest(peerDescriptor, connection)
-        })
-    }
-
-    public async start(): Promise<void> {
-        if (!this.destroyed && this.webSocketServer) {
-            this.webSocketServer.on('connected', (connection: IConnection) => {
-
-                const serverSocket = connection as unknown as ServerWebSocket
-                if (serverSocket.resourceURL &&
-                    serverSocket.resourceURL.query) {
-                    const query = serverSocket.resourceURL.query as unknown as ParsedUrlQuery
-                    if (query.connectivityRequest) {
-                        logger.trace('Received connectivity request connection from ' + serverSocket.getRemoteAddress())
-                        this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
-                    } else if (query.connectivityProbe) {
-                        logger.trace('Received connectivity probe connection from ' + serverSocket.getRemoteAddress())
-                    } else {
-                        this.attachHandshaker(connection)
-                    }
-                } else {
-                    this.attachHandshaker(connection)
-                }
-            })
-            const port = await this.webSocketServer.start()
-            this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.tlsCertificate !== undefined, this.host)
-        }
-    }
-
-    public async checkConnectivity(): 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) {
-            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
-                    return noServerConnectivityResponse
-                } else {
-                    if (!this.entrypoints || this.entrypoints.length < 1) {
-                        // 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)
-                    }
-                }
-            } 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!)}`
-                    logger.error(error, { error: err })
-                    await wait(2000)
-                }
-            }
-        }
-        throw Error(`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
-        }
-    }
-
-    public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(peerKey)
-        if (existingConnection) {
-            return existingConnection
-        }
-
-        if (this.ownPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
-            return this.requestConnectionFromPeer(this.ownPeerDescriptor!, targetPeerDescriptor)
-        } else {
-            const socket = new ClientWebSocket()
-
-            const url = connectivityMethodToWebSocketUrl(targetPeerDescriptor.websocket!)
-
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
-            managedConnection.setPeerDescriptor(targetPeerDescriptor)
-
-            this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
-
-            const delFunc = () => {
-                if (this.connectingConnections.has(peerKey)) {
-                    this.connectingConnections.delete(peerKey)
-                }
-                socket.off('disconnected', delFunc)
-                managedConnection.off('handshakeCompleted', delFunc)
-            }
-            socket.on('disconnected', delFunc)
-            managedConnection.on('handshakeCompleted', delFunc)
-
-            socket.connect(url)
-
-            return managedConnection
-        }
-    }
-
-    private requestConnectionFromPeer(ownPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        setImmediate(() => {
-            const remoteConnector = new WebSocketConnectorRpcRemote(
-                ownPeerDescriptor,
-                targetPeerDescriptor,
-                toProtoRpcClient(new WebSocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-            )
-            remoteConnector.requestConnection(ownPeerDescriptor.websocket!.host, ownPeerDescriptor.websocket!.port)
-        })
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, 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) => {
-
-        const peerId = peerIdFromPeerDescriptor(peerDescriptor)
-
-        if (this.ongoingConnectRequests.has(peerId.toKey())) {
-            const ongoingConnectReguest = this.ongoingConnectRequests.get(peerId.toKey())!
-            ongoingConnectReguest.attachImplementation(serverWebSocket)
-            ongoingConnectReguest.acceptHandshake()
-            this.ongoingConnectRequests.delete(peerId.toKey())
-        } else {
-            const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebSocket)
-
-            managedConnection.setPeerDescriptor(peerDescriptor)
-
-            if (this.onIncomingConnection(managedConnection)) {
-                managedConnection.acceptHandshake()
-            } else {
-                managedConnection.rejectHandshake('Duplicate connection')
-                managedConnection.destroy()
-            }
-        }
-    }
-
-    public setOwnPeerDescriptor(ownPeerDescriptor: PeerDescriptor): void {
-        this.ownPeerDescriptor = ownPeerDescriptor
-    }
-
-    public async destroy(): Promise<void> {
-        this.destroyed = true
-        this.rpcCommunicator.destroy()
-
-        const requests = Array.from(this.ongoingConnectRequests.values())
-        await Promise.allSettled(requests.map((conn) => conn.close('OTHER')))
-
-        const attempts = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
-        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
-        }
-    }
-}

package/src/dht/registerExternalApiRpcMethods.ts

@@ -1,44 +0,0 @@
-import { DhtNode } from '../dht/DhtNode'
-import { ExternalStoreDataRequest, ExternalStoreDataResponse, FindDataRequest, FindDataResponse } from '../proto/packages/dht/protos/DhtRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-
-export const registerExternalApiRpcMethods = (thisNode: DhtNode): void => {
-    const rpcCommunicator = thisNode.getRpcCommunicator()
-    rpcCommunicator.registerRpcMethod(
-        FindDataRequest, 
-        FindDataResponse, 
-        'findData', 
-        (req: FindDataRequest, context: ServerCallContext) => findData(thisNode, req, context),
-        { timeout: 10000 }
-    )
-    rpcCommunicator.registerRpcMethod(
-        ExternalStoreDataRequest,
-        ExternalStoreDataResponse,
-        'externalStoreData',
-        (req: ExternalStoreDataRequest) => externalStoreData(thisNode, req),
-        { timeout: 10000 }
-    )
-}
-
-// IDHTRpcService method for external findRecursive calls
-const findData = async (thisNode: DhtNode, findDataRequest: FindDataRequest, context: ServerCallContext): Promise<FindDataResponse> => {
-    const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-    const result = await thisNode.startRecursiveFind(findDataRequest.kademliaId, true, senderPeerDescriptor)
-    if (result.dataEntries) {
-        return FindDataResponse.create({ dataEntries: result.dataEntries })
-    } else {
-        return FindDataResponse.create({ 
-            dataEntries: [],
-            error: 'Could not find data with the given key' 
-        })
-    }
-}
-
-// IDHTRpcService method for external storeData calls
-const externalStoreData = async (thisNode: DhtNode, request: ExternalStoreDataRequest): Promise<ExternalStoreDataResponse> => {
-    const result = await thisNode.storeDataToDht(request.key, request.data!)
-    return ExternalStoreDataResponse.create({
-        storers: result
-    })
-}