@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/src/connection/connectivityChecker.ts

@@ -1,108 +0,0 @@
-import { Logger, RunAndRaceEventsReturnType, runAndRaceEvents3 } from '@streamr/utils'
-import { v4 } from 'uuid'
-import * as Err from '../helpers/errors'
-import {
-    ConnectivityRequest, ConnectivityResponse,
-    Message, PeerDescriptor
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { ConnectionEvents, IConnection } from './IConnection'
-import { WebsocketClientConnection } from './websocket/NodeWebsocketClientConnection'
-import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketClientConnector'
-import { isMaybeSupportedProtocolVersion } from '../helpers/version'
-
-const logger = new Logger(module)
-
-// TODO use options option or named constant?
-export const connectAsync = async ({ url, allowSelfSignedCertificate, timeoutMs = 1000 }:
-    { url: string, allowSelfSignedCertificate: boolean, timeoutMs?: number }
-): Promise<IConnection> => {
-    const socket = new WebsocketClientConnection()
-    let result: RunAndRaceEventsReturnType<ConnectionEvents>
-    try {
-        result = await runAndRaceEvents3<ConnectionEvents>([
-            () => { socket.connect(url, allowSelfSignedCertificate) }],
-        socket, ['connected', 'error'],
-        timeoutMs)
-    } catch {
-        throw new Err.ConnectionFailed('WebSocket connection timed out')
-    }
-    if (result.winnerName === 'error') {
-        throw new Err.ConnectionFailed('Could not open WebSocket connection')
-    }
-    return socket
-}
-
-export const CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivity-checker'
-const CONNECTIVITY_CHECKER_TIMEOUT = 5000
-
-export const sendConnectivityRequest = async (
-    request: ConnectivityRequest,
-    entryPoint: PeerDescriptor
-): Promise<ConnectivityResponse> => {
-    let outgoingConnection: IConnection
-    const wsServerInfo = {
-        host: entryPoint.websocket!.host, 
-        port: entryPoint.websocket!.port,
-        tls: entryPoint.websocket!.tls,
-    }
-    const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityRequest')
-    logger.debug(`Attempting connectivity check with entrypoint ${url}`)
-    try {
-        outgoingConnection = await connectAsync({
-            url,
-            allowSelfSignedCertificate: request.allowSelfSignedCertificate
-        })
-    } catch (e) {
-        throw new Err.ConnectionFailed(`Failed to connect to entrypoint for connectivity check: ${url}`, e)
-    }
-    // send connectivity request
-    const msg: Message = {
-        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-        messageId: v4(),
-        body: {
-            oneofKind: 'connectivityRequest',
-            connectivityRequest: request
-        }
-    }
-    const responseAwaiter = () => {
-        return new Promise((resolve: (res: ConnectivityResponse) => void, reject) => {
-            const timeoutId = setTimeout(() => {
-                // TODO should we have some handling for this floating promise?
-                outgoingConnection.close(false)
-                reject(new Err.ConnectivityResponseTimeout('timeout'))
-            }, CONNECTIVITY_CHECKER_TIMEOUT)
-            const listener = (bytes: Uint8Array) => {
-                // TODO should we have some handling for this floating promise?
-                outgoingConnection.close(false)
-                try {
-                    const message: Message = Message.fromBinary(bytes)
-                    if (message.body.oneofKind === 'connectivityResponse') {
-                        logger.debug('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
-                        const connectivityResponseMessage = message.body.connectivityResponse
-                        const remoteProtocolVersion = connectivityResponseMessage.protocolVersion
-                        outgoingConnection!.off('data', listener)
-                        clearTimeout(timeoutId)
-                        if (isMaybeSupportedProtocolVersion(remoteProtocolVersion)) {
-                            resolve(connectivityResponseMessage)
-                        } else {
-                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                            reject(`Unsupported version: ${remoteProtocolVersion}`)
-                        }
-                    }
-                } catch (err) {
-                    logger.trace('Could not parse message', { err })
-                }
-            }
-            outgoingConnection!.on('data', listener)
-        })
-    }
-    try {
-        const retPromise = responseAwaiter()
-        outgoingConnection.send(Message.toBinary(msg))
-        logger.trace('ConnectivityRequest sent: ' + JSON.stringify(Message.toJson(msg)))
-        return await retPromise
-    } catch (e) {
-        logger.error('error getting connectivityresponse')
-        throw e
-    }
-}

package/src/connection/connectivityRequestHandler.ts

@@ -1,116 +0,0 @@
-import { ipv4ToNumber, Logger } from '@streamr/utils'
-import { v4 } from 'uuid'
-import {
-    ConnectivityRequest,
-    ConnectivityResponse,
-    Message
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { NatType } from './ConnectionManager'
-import { CONNECTIVITY_CHECKER_SERVICE_ID, connectAsync } from './connectivityChecker'
-import { IConnection } from './IConnection'
-import { WebsocketServerConnection } from './websocket/WebsocketServerConnection'
-import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketClientConnector'
-import { LOCAL_PROTOCOL_VERSION } from '../helpers/version'
-import { GeoIpLocator } from '@streamr/geoip-location'
-
-export const DISABLE_CONNECTIVITY_PROBE = 0
-
-const logger = new Logger(module)
-
-export const attachConnectivityRequestHandler = (connectionToListenTo: WebsocketServerConnection, geoIpLocator?: GeoIpLocator): void => {
-    connectionToListenTo.on('data', async (data: Uint8Array) => {
-        logger.trace('server received data')
-        try {
-            const message = Message.fromBinary(data)
-            if (message.body.oneofKind === 'connectivityRequest') {
-                logger.trace('ConnectivityRequest received: ' + JSON.stringify(Message.toJson(message)))
-                try {
-                    await handleIncomingConnectivityRequest(connectionToListenTo,
-                        message.body.connectivityRequest, geoIpLocator)
-                    logger.trace('handleIncomingConnectivityRequest ok')
-                } catch (err1) {
-                    logger.error('handleIncomingConnectivityRequest', { err: err1 })
-                }
-            }
-        } catch (err2) {
-            logger.trace('Could not parse message', { err: err2 })
-        }
-    })
-}
-
-const handleIncomingConnectivityRequest = async (
-    connection: WebsocketServerConnection,
-    connectivityRequest: ConnectivityRequest,
-    geoIpLocator?: GeoIpLocator
-): Promise<void> => {
-    const host = connectivityRequest.host ?? connection.getRemoteIpAddress()
-    const ipAddress = connection.getRemoteIpAddress()
-    let connectivityResponse: ConnectivityResponse
-    if (connectivityRequest.port !== DISABLE_CONNECTIVITY_PROBE) {
-        connectivityResponse = await connectivityProbe(connectivityRequest, ipAddress, host)
-    } else {
-        logger.trace('ConnectivityRequest port is 0, replying without connectivityProbe')
-        connectivityResponse = {
-            host,
-            natType: NatType.UNKNOWN,
-            ipAddress: ipv4ToNumber(ipAddress),
-            protocolVersion: LOCAL_PROTOCOL_VERSION
-        }
-    }
-    if (geoIpLocator !== undefined) {
-        const location = geoIpLocator.lookup(ipAddress)
-        if (location !== undefined) {
-            connectivityResponse.latitude = location.latitude
-            connectivityResponse.longitude = location.longitude
-        }
-    }
-    const msg: Message = {
-        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-        messageId: v4(),
-        body: {
-            oneofKind: 'connectivityResponse',
-            connectivityResponse
-        }
-    }
-    connection.send(Message.toBinary(msg))
-    logger.trace('ConnectivityResponse sent: ' + JSON.stringify(Message.toJson(msg)))
-}
-
-const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAddress: string, host: string): Promise<ConnectivityResponse> => {
-    let outgoingConnection: IConnection | undefined
-    let connectivityResponseMessage: ConnectivityResponse
-    try {
-        const wsServerInfo = {
-            host,
-            port: connectivityRequest.port,
-            tls: connectivityRequest.tls
-        }
-        const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityProbe')
-        logger.trace(`Attempting Connectivity Check to ${url}`)
-        outgoingConnection = await connectAsync({
-            url,
-            allowSelfSignedCertificate: connectivityRequest.allowSelfSignedCertificate
-        })
-        logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
-        connectivityResponseMessage = {
-            host,
-            natType: NatType.OPEN_INTERNET,
-            websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls },
-            ipAddress: ipv4ToNumber(ipAddress),
-            protocolVersion: LOCAL_PROTOCOL_VERSION
-        }
-    } catch (err) {
-        logger.debug('error', { err })
-        connectivityResponseMessage = {
-            host,
-            natType: NatType.UNKNOWN,
-            ipAddress: ipv4ToNumber(ipAddress),
-            protocolVersion: LOCAL_PROTOCOL_VERSION
-        }
-    }
-    if (outgoingConnection) {
-        // TODO should we have some handling for this floating promise?
-        outgoingConnection.close(false)
-    }
-    return connectivityResponseMessage
-}

package/src/connection/simulator/Simulator.ts

@@ -1,369 +0,0 @@
-/* eslint-disable @typescript-eslint/parameter-properties */
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { SimulatorConnector } from './SimulatorConnector'
-import { SimulatorConnection } from './SimulatorConnection'
-import { ConnectionID } from '../IConnection'
-import { Logger } from '@streamr/utils'
-import { getRegionDelayMatrix } from './pings'
-import Heap from 'heap'
-import { debugVars } from '../../helpers/debugHelpers'
-import { DhtAddress, toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-export enum LatencyType { NONE = 'NONE', RANDOM = 'RANDOM', REAL = 'REAL', FIXED = 'FIXED' }
-
-// One-way 'pipe' of messages
-
-class Association {
-    public sourceConnection: SimulatorConnection
-    public destinationConnection?: SimulatorConnection
-    private lastOperationAt: number = 0
-    private closing = false
-
-    constructor(sourceConnection: SimulatorConnection,
-        destinationConnection?: SimulatorConnection,
-        public connectedCallback?: (error?: string) => void
-    ) {
-        this.sourceConnection = sourceConnection
-        this.destinationConnection = destinationConnection
-    }
-
-    public setDestinationConnection(connection: SimulatorConnection) {
-        this.destinationConnection = connection
-    }
-
-    public getLastOperationAt(): number {
-        return this.lastOperationAt
-    }
-
-    public setLastOperationAt(executionTime: number): void {
-        this.lastOperationAt = executionTime
-    }
-
-    public setClosing(): void {
-        this.closing = true
-    }
-
-    public isClosing(): boolean {
-        return this.closing
-    }
-}
-
-class SimulatorOperation {
-    private static objectCounter = 0
-    public objectId = 0
-
-    constructor(
-        public executionTime: number,
-        public association: Association
-    ) {
-        this.objectId = SimulatorOperation.objectCounter
-        SimulatorOperation.objectCounter++
-    }
-}
-
-class ConnectOperation extends SimulatorOperation {
-    constructor(
-        executionTime: number,
-        association: Association,
-        public sourceConnection: SimulatorConnection,
-        public targetDescriptor: PeerDescriptor) {
-
-        super(executionTime, association)
-    }
-}
-
-class SendOperation extends SimulatorOperation {
-    constructor(
-        executionTime: number,
-        association: Association,
-        public data: Uint8Array
-    ) {
-        super(executionTime, association)
-    }
-}
-
-class CloseOperation extends SimulatorOperation {
-}
-
-export class Simulator {
-    private stopped = false
-    private connectors: Map<DhtAddress, SimulatorConnector> = new Map()
-    private latencyTable?: number[][]
-    private associations: Map<ConnectionID, Association> = new Map()
-
-    private latencyType: LatencyType
-    private fixedLatency?: number
-
-    private loopCounter = 0
-    private MAX_LOOPS = 1000
-
-    private operationQueue: Heap<SimulatorOperation> = new Heap<SimulatorOperation>((a: SimulatorOperation, b: SimulatorOperation) => {
-        if ((a.executionTime - b.executionTime) === 0) {
-            return (a.objectId - b.objectId)
-        } else {
-            return (a.executionTime - b.executionTime)
-        }
-    })
-
-    private simulatorTimeout?: NodeJS.Timeout
-
-    constructor(latencyType: LatencyType = LatencyType.NONE, fixedLatency?: number) {
-        this.latencyType = latencyType
-        this.fixedLatency = fixedLatency
-
-        if (this.latencyType === LatencyType.REAL) {
-            this.latencyTable = getRegionDelayMatrix()
-        }
-
-        if ((this.latencyType === LatencyType.FIXED) && (this.fixedLatency === undefined)) {
-            throw new Error('LatencyType.FIXED requires the desired latency to be given as second parameter')
-        }
-
-        this.generateExecutionTime = this.generateExecutionTime.bind(this)
-        this.getLatency = this.getLatency.bind(this)
-        this.executeCloseOperation = this.executeCloseOperation.bind(this)
-        this.executeConnectOperation = this.executeConnectOperation.bind(this)
-        this.executeSendOperation = this.executeSendOperation.bind(this)
-        this.executeQueuedOperations = this.executeQueuedOperations.bind(this)
-        this.accept = this.accept.bind(this)
-        this.send = this.send.bind(this)
-        this.close = this.close.bind(this)
-        this.scheduleNextTimeout = this.scheduleNextTimeout.bind(this)
-        this.scheduleOperation = this.scheduleOperation.bind(this)
-    }
-
-    private generateExecutionTime(association: Association, sourceRegion: number | undefined, targetRegion: number | undefined): number {
-        let executionTime = Date.now() + this.getLatency(sourceRegion, targetRegion)
-        if (association.getLastOperationAt() > executionTime) {
-            executionTime = association.getLastOperationAt()
-        }
-
-        return executionTime
-    }
-
-    private getLatency(sourceRegion: number | undefined, targetRegion: number | undefined): number {
-        let latency: number = 0
-
-        if (this.latencyType === LatencyType.FIXED) {
-            latency = this.fixedLatency!
-        }
-
-        if (this.latencyType === LatencyType.REAL) {
-
-            if (sourceRegion === undefined || targetRegion === undefined || sourceRegion > 15 || targetRegion > 15) {
-                logger.error('invalid region index given to Simulator')
-                throw new Error('invalid region index given to Simulator')
-            }
-
-            latency = this.latencyTable![sourceRegion][targetRegion]
-        }
-        if (this.latencyType === LatencyType.RANDOM) {
-            latency = Math.random() * (250 - 5) + 5
-        }
-
-        return latency
-    }
-
-    public accept(sourceConnection: SimulatorConnection, targetConnection: SimulatorConnection): void {
-
-        const sourceAssociation = this.associations.get(sourceConnection.connectionId)
-
-        if (!sourceAssociation) {
-            logger.error('source association not found in accept()')
-            return
-        }
-        sourceAssociation.setDestinationConnection(targetConnection)
-
-        const targetAssociation = new Association(targetConnection, sourceConnection)
-        this.associations.set(targetConnection.connectionId, targetAssociation)
-
-        sourceAssociation.connectedCallback!()
-    }
-
-    public addConnector(connector: SimulatorConnector): void {
-        this.connectors.set(toNodeId(connector.getPeerDescriptor()), connector)
-    }
-
-    private executeConnectOperation(operation: ConnectOperation): void {
-        const target = this.connectors.get(toNodeId(operation.targetDescriptor))
-
-        if (!target) {
-            logger.error('Target connector not found when executing connect operation')
-            operation.association.connectedCallback!('Target connector not found')
-            return
-        }
-
-        target.handleIncomingConnection(operation.sourceConnection)
-    }
-
-    private executeCloseOperation(operation: CloseOperation): void {
-
-        if (this.stopped) {
-            return
-        }
-
-        const target = operation.association.destinationConnection
-
-        let counterAssociation: Association | undefined
-
-        if (target) {
-            counterAssociation = this.associations.get(target.connectionId)
-        }
-
-        if (!target || !counterAssociation) {
-            this.associations.delete(operation.association.sourceConnection.connectionId)
-
-        } else if (!counterAssociation.isClosing()) {
-            target.handleIncomingDisconnection()
-            this.close(target)
-        } else {
-            // this is the 'ack' of the CloseOperation to the original closer
-            this.associations.delete(target.connectionId)
-            this.associations.delete(operation.association.sourceConnection.connectionId)
-        }
-    }
-
-    private executeSendOperation(operation: SendOperation): void {
-
-        if (this.stopped) {
-            return
-        }
-
-        const target = operation.association.destinationConnection
-        target!.handleIncomingData(operation.data)
-
-    }
-
-    private executeQueuedOperations(): void {
-        const currentTime = Date.now()
-        while (this.operationQueue.size() > 0
-            && this.operationQueue.peek()!.executionTime <= currentTime) {
-            const operation = this.operationQueue.pop()
-
-            if (operation instanceof ConnectOperation) {
-                this.executeConnectOperation(operation)
-            } else if (operation instanceof CloseOperation) {
-                this.executeCloseOperation(operation)
-            } else if (operation instanceof SendOperation) {
-                this.executeSendOperation(operation)
-            } else {
-                logger.error('Unknown SimulatorOperation')
-            }
-
-            this.loopCounter++
-            if (this.loopCounter >= this.MAX_LOOPS) {
-                this.loopCounter = 0
-                setTimeout(() => this.executeQueuedOperations(), 0)
-                return
-            }
-        }
-
-        this.scheduleNextTimeout()
-    }
-
-    private scheduleNextTimeout(): void {
-        if (this.simulatorTimeout) {
-            clearTimeout(this.simulatorTimeout)
-            this.simulatorTimeout = undefined
-        }
-
-        const currentTime = Date.now()
-
-        const firstOperation = this.operationQueue.peek()
-
-        if (!firstOperation) {
-            return
-        }
-
-        const firstOperationTime = firstOperation.executionTime
-        const timeDifference = firstOperationTime - currentTime
-
-        this.simulatorTimeout = setTimeout(this.executeQueuedOperations, timeDifference)
-    }
-
-    private scheduleOperation(operation: SimulatorOperation) {
-        this.operationQueue.push(operation)
-        this.scheduleNextTimeout()
-    }
-
-    public connect(sourceConnection: SimulatorConnection, targetDescriptor: PeerDescriptor, connectedCallback: (error?: string) => void): void {
-
-        if (this.stopped) {
-            logger.error('connect() called on a stopped simulator ' + (new Error().stack))
-            return
-        }
-        debugVars.simulatorHeapSize = this.operationQueue.size()
-
-        const association = new Association(sourceConnection, undefined, connectedCallback)
-        this.associations.set(sourceConnection.connectionId, association)
-
-        const executionTime = this.generateExecutionTime(association, sourceConnection.localPeerDescriptor.region, targetDescriptor.region)
-        association.setLastOperationAt(executionTime)
-
-        const operation = new ConnectOperation(executionTime, association,
-            sourceConnection, targetDescriptor)
-
-        this.scheduleOperation(operation)
-    }
-
-    public close(sourceConnection: SimulatorConnection): void {
-
-        if (this.stopped) {
-            return
-        }
-
-        const association = this.associations.get(sourceConnection.connectionId)
-        if (!association) {
-            return
-        }
-
-        association.setClosing()
-
-        const executionTime = this.generateExecutionTime(association,
-            sourceConnection.localPeerDescriptor.region,
-            sourceConnection.getPeerDescriptor()?.region)
-        association.setLastOperationAt(executionTime)
-
-        const operation = new CloseOperation(executionTime, association)
-
-        this.scheduleOperation(operation)
-    }
-
-    public send(sourceConnection: SimulatorConnection, data: Uint8Array): void {
-
-        if (this.stopped) {
-            return
-        }
-
-        const association = this.associations.get(sourceConnection.connectionId)
-        if (!association) {
-            return
-        }
-
-        if (association.isClosing()) {
-            logger.trace('Tried to call send() on a closing association')
-            return
-        }
-
-        const executionTime = this.generateExecutionTime(association,
-            sourceConnection.localPeerDescriptor.region,
-            association.destinationConnection!.localPeerDescriptor.region)
-
-        association.setLastOperationAt(executionTime)
-
-        const operation = new SendOperation(executionTime, association, data)
-
-        this.scheduleOperation(operation)
-    }
-
-    public stop(): void {
-        this.stopped = true
-        logger.info(this.associations.size + ' associations in the beginning of stop()')
-
-        if (this.simulatorTimeout) {
-            clearTimeout(this.simulatorTimeout)
-        }
-    }
-}