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

package/src/connection/simulator/SimulatorConnection.ts

@@ -1,137 +0,0 @@
-import { ConnectionType, IConnection } from '../IConnection'
-import { Simulator } from './Simulator'
-import { Message, PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { Connection } from '../Connection'
-import { Logger } from '@streamr/utils'
-import { protoToString } from '../../helpers/protoToString'
-import { toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-export class SimulatorConnection extends Connection implements IConnection {
-
-    private stopped = false
-    public localPeerDescriptor: PeerDescriptor
-    private targetPeerDescriptor: PeerDescriptor
-    private simulator: Simulator
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        targetPeerDescriptor: PeerDescriptor,
-        connectionType: ConnectionType,
-        simulator: Simulator
-    ) {
-        super(connectionType)
-
-        this.localPeerDescriptor = localPeerDescriptor
-        this.setPeerDescriptor(targetPeerDescriptor)
-        this.targetPeerDescriptor = targetPeerDescriptor
-        this.connectionType = connectionType
-        this.simulator = simulator
-
-        this.send = this.send.bind(this)
-        this.close = this.close.bind(this)
-        this.connect = this.connect.bind(this)
-        this.handleIncomingData = this.handleIncomingData.bind(this)
-        this.handleIncomingDisconnection = this.handleIncomingDisconnection.bind(this)
-        this.destroy = this.destroy.bind(this)
-        this.doDisconnect = this.doDisconnect.bind(this)
-    }
-
-    public send(data: Uint8Array): void {
-        logger.trace('send()')
-        if (!this.stopped) {
-
-            this.simulator.send(this, data)
-
-        } else {
-            const localNodeId = toNodeId(this.localPeerDescriptor)
-            const targetNodeId = toNodeId(this.targetPeerDescriptor)
-            logger.error(localNodeId + ', ' + targetNodeId + 'tried to send() on a stopped connection')
-        }
-    }
-
-    public async close(gracefulLeave: boolean): Promise<void> {
-        const localNodeId = toNodeId(this.localPeerDescriptor)
-        const targetNodeId = toNodeId(this.targetPeerDescriptor)
-
-        logger.trace(localNodeId + ', ' + targetNodeId + ' close()')
-        if (!this.stopped) {
-            logger.trace(localNodeId + ', ' + targetNodeId + ' close() not stopped')
-            this.stopped = true
-
-            try {
-                logger.trace(localNodeId + ', ' + targetNodeId + ' close() calling simulator.disconnect()')
-                this.simulator.close(this)
-                logger.trace(localNodeId + ', ' + targetNodeId + ' close() simulator.disconnect returned')
-            } catch (e) {
-                logger.trace(localNodeId + ', ' + targetNodeId + 'close aborted' + e)
-            } finally {
-                logger.trace(localNodeId + ', ' + targetNodeId + ' calling this.doDisconnect')
-                this.doDisconnect(gracefulLeave)
-            }
-
-        } else {
-            logger.trace(localNodeId + ', ' + targetNodeId + ' close() tried to close a stopped connection')
-        }
-    }
-
-    public connect(): void {
-        if (!this.stopped) {
-            logger.trace('connect() called')
-
-            this.simulator.connect(this, this.targetPeerDescriptor, (error?: string) => {
-                if (error !== undefined) {
-                    logger.trace(error)
-                    this.doDisconnect(false)
-                } else {
-                    this.emit('connected')
-                }
-            })
-        } else {
-            logger.trace('tried to connect() a stopped connection')
-        }
-    }
-
-    public handleIncomingData(data: Uint8Array): void {
-        if (!this.stopped) {
-            logger.trace('handleIncomingData() ' + protoToString(Message.fromBinary(data), Message))
-            this.emit('data', data)
-        } else {
-            logger.trace('tried to call handleIncomingData() a stopped connection')
-        }
-    }
-
-    public handleIncomingDisconnection(): void {
-        if (!this.stopped) {
-            const localNodeId = toNodeId(this.localPeerDescriptor)
-            logger.trace(localNodeId + ' handleIncomingDisconnection()')
-            this.stopped = true
-            this.doDisconnect(false)
-        } else {
-            logger.trace('tried to call handleIncomingDisconnection() a stopped connection')
-        }
-    }
-
-    public destroy(): void {
-        const localNodeId = toNodeId(this.localPeerDescriptor)
-        if (!this.stopped) {
-            logger.trace(localNodeId + ' destroy()')
-            this.removeAllListeners()
-            this.close(false).catch((_e) => { })
-        } else {
-            logger.trace(localNodeId + ' tried to call destroy() a stopped connection')
-        }
-    }
-
-    private doDisconnect(gracefulLeave: boolean) {
-        const localNodeId = toNodeId(this.localPeerDescriptor)
-        const targetNodeId = toNodeId(this.targetPeerDescriptor)
-        logger.trace(localNodeId + ' doDisconnect()')
-        this.stopped = true
-
-        logger.trace(localNodeId + ', ' + targetNodeId + ' doDisconnect emitting')
-
-        this.emit('disconnected', gracefulLeave)
-    }
-}

package/src/connection/simulator/SimulatorConnector.ts

@@ -1,98 +0,0 @@
-import { ConnectionType } from '../IConnection'
-
-import {
-    HandshakeError,
-    PeerDescriptor,
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { Logger } from '@streamr/utils'
-import { Simulator } from './Simulator'
-import { SimulatorConnection } from './SimulatorConnection'
-import { DhtAddress, toNodeId } from '../../identifiers'
-import { acceptHandshake, createIncomingHandshaker, createOutgoingHandshaker, rejectHandshake } from '../Handshaker'
-import { PendingConnection } from '../PendingConnection'
-
-const logger = new Logger(module)
-
-export class SimulatorConnector {
-
-    private connectingConnections: Map<DhtAddress, PendingConnection> = new Map()
-    private stopped = false
-    private localPeerDescriptor: PeerDescriptor
-    private simulator: Simulator
-    private onNewConnection: (connection: PendingConnection) => boolean
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        simulator: Simulator,
-        onNewConnection: (connection: PendingConnection) => boolean,
-    ) {
-        this.localPeerDescriptor = localPeerDescriptor
-        this.simulator = simulator
-        this.onNewConnection = onNewConnection
-    }
-
-    public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
-        logger.trace('connect() ' + toNodeId(targetPeerDescriptor))
-        const nodeId = toNodeId(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(nodeId)
-        if (existingConnection) {
-            return existingConnection
-        }
-
-        const connection = new SimulatorConnection(this.localPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
-
-        const pendingConnection = new PendingConnection(targetPeerDescriptor)
-        createOutgoingHandshaker(this.localPeerDescriptor, pendingConnection, connection, targetPeerDescriptor)
-        this.connectingConnections.set(nodeId, pendingConnection)
-        const delFunc = () => {
-            this.connectingConnections.delete(nodeId)
-            connection.off('disconnected', delFunc)
-            pendingConnection.off('connected', delFunc)
-            pendingConnection.off('disconnected', delFunc)
-        }
-        connection.once('disconnected', delFunc)
-        pendingConnection.once('connected', delFunc)
-        pendingConnection.once('disconnected', delFunc)
-        
-        connection.connect()
-        return pendingConnection
-    }
-
-    public getPeerDescriptor(): PeerDescriptor {
-        return this.localPeerDescriptor
-    }
-
-    public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        // connection is incoming, so remotePeerDescriptor is localPeerDescriptor
-        const remotePeerDescriptor = sourceConnection.localPeerDescriptor
-        const remoteNodeId = toNodeId(sourceConnection.localPeerDescriptor)
-        logger.trace(remoteNodeId + ' incoming connection, stopped: ' + this.stopped)
-        if (this.stopped) {
-            return
-        }
-        const connection = new SimulatorConnection(this.localPeerDescriptor, remotePeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
-        
-        const pendingConnection = new PendingConnection(remotePeerDescriptor)
-        const handshaker = createIncomingHandshaker(this.localPeerDescriptor, pendingConnection, connection)
-        logger.trace('connected')
-
-        handshaker.once('handshakeRequest', () => {
-            logger.trace(remoteNodeId + ' incoming handshake request')
-
-            if (this.onNewConnection(pendingConnection)) {
-                logger.trace(remoteNodeId + ' calling acceptHandshake')
-                acceptHandshake(handshaker, pendingConnection, connection)
-            } else {
-                rejectHandshake(pendingConnection, connection, handshaker, HandshakeError.DUPLICATE_CONNECTION)
-            }
-        })
-
-        this.simulator.accept(sourceConnection, connection)
-    }
-
-    public async stop(): Promise<void> {
-        this.stopped = true
-        const conns = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(conns.map(async (conn) => conn.close(false)))
-    }
-}

package/src/connection/simulator/SimulatorTransport.ts

@@ -1,15 +0,0 @@
-import { MetricsContext } from '@streamr/utils'
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { ConnectionManager } from '../ConnectionManager'
-import { Simulator } from './Simulator'
-import { SimulatorConnectorFacade } from '../ConnectorFacade'
-
-export class SimulatorTransport extends ConnectionManager {
-    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
-        super({
-            createConnectorFacade: () => new SimulatorConnectorFacade(localPeerDescriptor, simulator),
-            metricsContext: new MetricsContext(),
-            allowIncomingPrivateConnections: false
-        })
-    }
-}

package/src/connection/simulator/pings.ts

@@ -1,42 +0,0 @@
-/* eslint-disable max-len, @typescript-eslint/prefer-for-of */
-
-// This file contains a 16x16 matrix of ping times measured between
-// amazon regions. Converted to typescript from the file pings.csv
-// in order to make loading into browser easier.
-
-export enum RegionIndex { eu_central_1, eu_west_1, eu_west_2, eu_west_3, eu_north_1, us_east_1, us_east_2, us_west_1, us_west_2, ca_central_1, ap_south_1, ap_northeast_2, ap_southeast_1, ap_southeast_2, ap_northeast_1, sa_east_1 }
-
-export const regionPingMatrix = [
-    [0.325, 23.163, 12.942, 8.923, 20.699, 89.208, 99.98, 150.077, 139.224, 90.454, 117.0, 226.823, 154.592, 286.753, 222.719, 205.563],
-    [24.911, 0.195, 10.022, 18.544, 39.802, 66.161, 93.877, 136.271, 127.362, 73.733, 122.187, 229.064, 177.256, 254.277, 200.207, 186.817],
-    [12.879, 9.994, 0.167, 8.626, 31.896, 74.663, 85.231, 136.185, 125.328, 77.811, 111.29, 236.34, 164.357, 262.577, 207.745, 187.383],
-    [9.007, 16.823, 8.761, 0.191, 28.449, 81.969, 92.599, 140.961, 132.269, 85.444, 107.421, 243.981, 167.17, 279.322, 214.088, 197.986],
-    [20.661, 40.0, 31.176, 27.645, 0.137, 104.171, 115.704, 165.01, 155.741, 107.635, 136.75, 267.321, 173.951, 292.266, 238.492, 216.048],
-    [89.076, 67.701, 75.414, 81.598, 104.866, 0.284, 11.501, 61.662, 78.612, 14.115, 186.697, 174.546, 210.93, 196.071, 145.622, 114.919],
-    [100.018, 93.968, 85.06, 92.582, 115.719, 11.514, 0.184, 51.668, 48.447, 25.808, 195.433, 160.031, 197.27, 186.913, 133.115, 127.954],
-    [148.544, 137.18, 136.137, 141.333, 164.73, 60.257, 50.886, 0.197, 21.509, 77.668, 229.32, 134.858, 174.472, 137.329, 107.566, 175.944],
-    [137.885, 128.304, 125.316, 132.271, 155.726, 63.376, 48.457, 20.743, 0.293, 59.645, 218.285, 126.988, 162.72, 138.599, 100.203, 174.612],
-    [90.494, 78.203, 77.998, 84.348, 109.549, 14.136, 25.917, 77.323, 59.692, 0.163, 187.854, 169.253, 206.944, 195.467, 141.054, 126.962],
-    [120.19, 119.978, 112.023, 107.434, 139.361, 185.043, 195.679, 233.008, 216.025, 186.888, 0.177, 130.21, 56.019, 145.643, 128.57, 298.98],
-    [226.296, 229.187, 237.024, 243.839, 266.919, 174.727, 160.066, 136.623, 124.799, 169.854, 129.131, 0.189, 81.065, 139.967, 33.24, 284.578],
-    [154.691, 178.279, 170.997, 154.261, 173.776, 211.511, 197.551, 173.735, 162.834, 206.659, 56.964, 68.853, 0.215, 91.601, 69.684, 323.146],
-    [289.784, 253.234, 261.752, 277.504, 292.125, 198.099, 185.709, 136.413, 138.613, 194.986, 142.484, 147.706, 91.615, 0.156, 114.518, 311.12],
-    [223.926, 201.084, 210.133, 216.779, 237.762, 145.336, 132.887, 108.26, 98.057, 142.613, 122.716, 33.185, 68.547, 114.901, 0.162, 257.403],
-    [205.555, 178.082, 186.533, 195.774, 216.701, 117.089, 128.001, 175.761, 176.018, 125.551, 303.904, 285.782, 323.15, 309.618, 255.904, 0.262]
-]
-
-export function getRegionDelayMatrix(): Array<Array<number>> {
-    const ret = []
-    for (let i = 0; i < regionPingMatrix.length; i++) {
-        const row = []
-        for (let j = 0; j < regionPingMatrix[i].length; j++) {
-            row.push(regionPingMatrix[i][j] / 2)
-        }
-        ret.push(row)
-    }
-    return ret
-}
-
-export function getRandomRegion(): number {
-    return Math.floor(Math.random() * 15)
-}

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -1,242 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { WebrtcConnectionEvents, IWebrtcConnection, RtcDescription } from './IWebrtcConnection'
-import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
-import { Logger } from '@streamr/utils'
-import { EARLY_TIMEOUT, IceServer } from './WebrtcConnector'
-import { createRandomConnectionId } from '../Connection'
-
-enum DisconnectedRtcPeerConnectionStateEnum {
-    DISCONNECTED = 'disconnected',
-    FAILED = 'failed',
-    CLOSED = 'closed',
-}
-
-const logger = new Logger(module)
-
-type Events = WebrtcConnectionEvents & ConnectionEvents
-
-interface Params {
-    iceServers?: IceServer[]
-}
-
-export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrtcConnection, IConnection {
-
-    public connectionId: ConnectionID
-    public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
-    // We need to keep track of connection state ourselves because
-    // RTCPeerConnection.connectionState is not supported on Firefox
-    private lastState: RTCPeerConnectionState = 'connecting'
-    private readonly iceServers: IceServer[]
-    private peerConnection?: RTCPeerConnection
-    private dataChannel?: RTCDataChannel
-    private makingOffer = false
-    private isOffering = false
-    private closed = false
-    private earlyTimeout: NodeJS.Timeout
-
-    constructor(params: Params) {
-        super()
-        this.connectionId = createRandomConnectionId()
-        this.iceServers = params.iceServers ?? []
-        this.earlyTimeout = setTimeout(() => {
-            this.doClose(false, 'timed out due to remote descriptor not being set')
-        }, EARLY_TIMEOUT)
-    }
-
-    public start(isOffering: boolean): void {
-        this.isOffering = isOffering
-        const urls: RTCIceServer[] = this.iceServers.map(({ url, port, username, password }) => ({
-            urls: `${url}:${port}`,
-            username,
-            credential: password
-        }))
-        this.peerConnection = new RTCPeerConnection({ iceServers: urls })
-
-        this.peerConnection.onicecandidate = (event) => {
-            if ((event.candidate !== null) && (event.candidate.sdpMid !== null)) {
-                this.emit('localCandidate', event.candidate.candidate, event.candidate.sdpMid)
-            }
-        }
-
-        this.peerConnection.onicegatheringstatechange = () => {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            logger.trace(`conn.onGatheringStateChange: ${this.peerConnection?.iceGatheringState}`)
-        }
-
-        this.peerConnection.onconnectionstatechange = () => this.onStateChange()
-
-        if (isOffering) {
-            this.peerConnection.onnegotiationneeded = async () => {
-                if (this.peerConnection !== undefined) {
-                    this.makingOffer = true
-                    try {
-                        await this.peerConnection.setLocalDescription()
-                    } catch (err) {
-                        logger.warn('Failed to set local description', { err })
-                    }
-                    if (this.peerConnection.localDescription !== null) {
-                        this.emit('localDescription', this.peerConnection.localDescription?.sdp, this.peerConnection.localDescription?.type)
-                    }
-                }
-                this.makingOffer = false
-            }
-
-            const dataChannel = this.peerConnection.createDataChannel('streamrDataChannel')
-            this.setupDataChannel(dataChannel)
-        } else {
-            this.peerConnection.ondatachannel = (event) => {
-                this.setupDataChannel(event.channel)
-            }
-        }
-    }
-
-    public async setRemoteDescription(description: string, type: string): Promise<void> {
-        const offerCollision = (type.toLowerCase() === RtcDescription.OFFER) && (this.makingOffer || (this.peerConnection === undefined) ||
-            this.peerConnection.signalingState != 'stable')
-
-        const ignoreOffer = this.isOffering && offerCollision
-        if (ignoreOffer) {
-            return
-        }
-        try {
-            await this.peerConnection?.setRemoteDescription({ sdp: description, type: type.toLowerCase() as RTCSdpType })
-            clearTimeout(this.earlyTimeout)
-        } catch (err) {
-            logger.warn('Failed to set remote description', { err })
-        }
-
-        if ((type.toLowerCase() === RtcDescription.OFFER) && (this.peerConnection !== undefined)) {
-            try {
-                await this.peerConnection.setLocalDescription()
-            } catch (err) {
-                logger.warn('Failed to set local description', { err })
-            }
-            if (this.peerConnection.localDescription !== null) {
-                this.emit('localDescription', this.peerConnection.localDescription.sdp, this.peerConnection.localDescription.type)
-            }
-        }
-    }
-
-    public addRemoteCandidate(candidate: string, mid: string): void {
-        this.peerConnection?.addIceCandidate({ candidate: candidate, sdpMid: mid })
-            .catch((err) => {
-                logger.warn('Failed to add ICE candidate', { err })
-            })
-    }
-
-    public isOpen(): boolean {
-        return this.lastState === 'connected'
-    }
-
-    // IConnection implementation
-    
-    public async close(gracefulLeave: boolean, reason?: string): Promise<void> {
-        this.doClose(gracefulLeave, reason)
-    }
-    
-    private doClose(gracefulLeave: boolean, reason?: string): void {
-        if (!this.closed) {
-            this.closed = true
-            this.lastState = 'closed'
-            clearTimeout(this.earlyTimeout)
-
-            this.stopListening()
-            this.emit('disconnected', gracefulLeave, undefined, reason)
-            
-            this.removeAllListeners()
-
-            if (this.dataChannel !== undefined) {
-                try {
-                    this.dataChannel.close()
-                } catch (err) {
-                    logger.warn('Failed to close data channel', { err })
-                }
-            }
-
-            this.dataChannel = undefined
-
-            if (this.peerConnection !== undefined) {
-                try {
-                    this.peerConnection.close()
-                } catch (err) {
-                    logger.warn('Failed to close connection', { err })
-                }
-            }
-            this.peerConnection = undefined
-            
-        }
-    }
-
-    public destroy(): void {
-        this.removeAllListeners()
-        this.doClose(false)
-    }
-
-    public send(data: Uint8Array): void {
-        if (this.lastState === 'connected') {
-            this.dataChannel?.send(data as Buffer)
-        } else {
-            logger.warn('Tried to send on a connection with last state ' + this.lastState)
-        }
-    }
-
-    private setupDataChannel(dataChannel: RTCDataChannel): void {
-        this.dataChannel = dataChannel
-        this.dataChannel.binaryType = 'arraybuffer'
-
-        dataChannel.onopen = () => {
-            logger.trace('dc.onOpen')
-            this.onDataChannelOpen()
-        }
-
-        dataChannel.onclose = () => {
-            logger.trace('dc.onClosed')
-            this.doClose(false)
-        }
-
-        dataChannel.onerror = (err) => {
-            logger.warn('Data channel error', { err })
-        }
-
-        dataChannel.onmessage = (msg) => {
-            logger.trace('dc.onmessage')
-            this.emit('data', new Uint8Array(msg.data))
-        }
-    }
-
-    private stopListening() {
-        if (this.dataChannel !== undefined) {
-            this.dataChannel.onopen = null
-            this.dataChannel.onclose = null
-            this.dataChannel.onerror = null
-            this.dataChannel.onbufferedamountlow = null
-            this.dataChannel.onmessage = null
-        }
-
-        if (this.peerConnection !== undefined) {
-            this.peerConnection.onconnectionstatechange = null
-            this.peerConnection.onicecandidate = null
-            this.peerConnection.onicegatheringstatechange = null
-            this.peerConnection.onnegotiationneeded = null
-            this.peerConnection.ondatachannel = null
-        }
-    }
-
-    private onDataChannelOpen(): void {
-        this.lastState = 'connected'
-        this.emit('connected')
-    }
-
-    private onStateChange(): void {
-        if (this.peerConnection!.connectionState === DisconnectedRtcPeerConnectionStateEnum.CLOSED
-            || this.peerConnection!.connectionState === DisconnectedRtcPeerConnectionStateEnum.DISCONNECTED
-            || this.peerConnection!.connectionState === DisconnectedRtcPeerConnectionStateEnum.FAILED
-        ) {
-            this.doClose(false)
-        }
-    }
-
-    public setConnectionId(connectionId: ConnectionID): void {
-        this.connectionId = connectionId
-    }
-}

package/src/connection/webrtc/IWebrtcConnection.ts

@@ -1,24 +0,0 @@
-export interface WebrtcConnectionEvents {
-    localDescription: (description: string, type: string) => void
-    localCandidate: (candidate: string, mid: string) => void
-}
-
-export enum RtcDescription {
-    OFFER = 'offer',
-    ANSWER = 'answer'
-}
-
-export interface IWebrtcConnection {
-    start(isOffering: boolean): void
-
-    on(event: 'localDescription', listener: (description: string, type: string) => void): this
-    on(event: 'localCandidate', listener: (candidate: string, mid: string) => void): this
-    once(event: 'localDescription', listener: (description: string, type: string) => void): this
-    once(event: 'localCandidate', listener: (candidate: string, mid: string) => void): this
-    off(event: 'localDescription', listener: (description: string, type: string) => void): this 
-    off(event: 'localCandidate', listener: (candidate: string, mid: string) => void): this
-   
-    setRemoteDescription(description: string, type: string): Promise<void>
-    addRemoteCandidate(candidate: string, mid: string): void
-    isOpen(): boolean
-}