@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/connection/WebRTC/RemoteWebrtcConnector.ts

@@ -1,93 +0,0 @@
-import {
-    IceCandidate,
-    PeerDescriptor,
-    RtcAnswer,
-    RtcOffer,
-    WebRtcConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebRtcConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { Logger } from '@streamr/utils'
-
-const logger = new Logger(module)
-
-export class RemoteWebrtcConnector {
-
-    private peerDescriptor: PeerDescriptor
-    private client: ProtoRpcClient<IWebRtcConnectorServiceClient>
-
-    constructor(peerDescriptor: PeerDescriptor, client: ProtoRpcClient<IWebRtcConnectorServiceClient>) {
-        this.peerDescriptor = peerDescriptor
-        this.client = client
-    }
-
-    requestConnection(sourceDescriptor: PeerDescriptor, connectionId: string): void {
-        const request: WebRtcConnectionRequest = {
-            target: this.peerDescriptor,
-            requester: sourceDescriptor,
-            connectionId
-        }
-        const options: DhtRpcOptions = {
-            sourceDescriptor: sourceDescriptor,
-            targetDescriptor: this.peerDescriptor,
-            notification: true
-        }
-
-        this.client.requestConnection(request, options).catch((_e) => {
-            logger.trace('Failed to send requestConnection')
-        })
-    }
-
-    sendRtcOffer(sourceDescriptor: PeerDescriptor, description: string, connectionId: string): void {
-        const request: RtcOffer = {
-            target: this.peerDescriptor,
-            requester: sourceDescriptor,
-            connectionId,
-            description
-        }
-        const options: DhtRpcOptions = {
-            sourceDescriptor: sourceDescriptor,
-            targetDescriptor: this.peerDescriptor,
-        }
-
-        this.client.rtcOffer(request, options).catch((_e) => {
-            logger.trace('Failed to send rtcOffer')
-        })
-    }
-
-    sendRtcAnswer(sourceDescriptor: PeerDescriptor, description: string, connectionId: string): void {
-        const request: RtcAnswer = {
-            target: this.peerDescriptor,
-            requester: sourceDescriptor,
-            connectionId,
-            description
-        }
-        const options: DhtRpcOptions = {
-            sourceDescriptor: sourceDescriptor,
-            targetDescriptor: this.peerDescriptor,
-        }
-
-        this.client.rtcAnswer(request, options).catch((_e) => {
-            logger.trace('Failed to send rtcAnswer')
-        })
-    }
-
-    sendIceCandidate(sourceDescriptor: PeerDescriptor, candidate: string, mid: string, connectionId: string): void {
-        const request: IceCandidate = {
-            target: this.peerDescriptor,
-            requester: sourceDescriptor,
-            connectionId,
-            mid,
-            candidate
-        }
-        const options: DhtRpcOptions = {
-            sourceDescriptor: sourceDescriptor,
-            targetDescriptor: this.peerDescriptor,
-        }
-        this.client.iceCandidate(request, options).catch((_e) => {
-            logger.trace('Failed to send iceCandidate')
-        })
-    }
-}
-

package/src/connection/WebSocket/RemoteWebSocketConnector.ts

@@ -1,49 +0,0 @@
-import {
-    PeerDescriptor,
-    WebSocketConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebSocketConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
-import { Logger } from '@streamr/utils'
-import * as Err from '../../helpers/errors'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
-
-const logger = new Logger(module)
-
-export class RemoteWebSocketConnector {
-
-    private peerDescriptor: PeerDescriptor
-    private client: ProtoRpcClient<IWebSocketConnectorServiceClient>
-
-    constructor(peerDescriptor: PeerDescriptor, client: ProtoRpcClient<IWebSocketConnectorServiceClient>) {
-        this.peerDescriptor = peerDescriptor
-        this.client = client
-    }
-
-    async requestConnection(sourceDescriptor: PeerDescriptor, ip: string, port: number): Promise<boolean> {
-        logger.trace(`Requesting WebSocket connection from ${this.peerDescriptor.kademliaId.toString()}`)
-        const request: WebSocketConnectionRequest = {
-            target: this.peerDescriptor,
-            requester: sourceDescriptor,
-            ip,
-            port
-        }
-        const options: DhtRpcOptions = {
-            sourceDescriptor: sourceDescriptor,
-            targetDescriptor: this.peerDescriptor 
-        }
-        try {
-            const res = await this.client.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!)
-            return false
-        }
-    }
-}

package/src/helpers/browser/isBrowser.ts

@@ -1 +0,0 @@
-export const isNodeJS = (): boolean => false

package/src/helpers/browser/isNodeJS.ts

@@ -1 +0,0 @@
-export const isNodeJS = (): boolean => true

package/test/integration/DhtWithMockConnectionLatencies.test.ts

@@ -1,46 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode } from '../utils/utils'
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
-
-describe('Mock connection Dht joining with latencies', () => {
-    let entryPoint: DhtNode
-    let nodes: DhtNode[]
-    let simulator: Simulator
-    let entrypointDescriptor: PeerDescriptor
-    
-    beforeEach(async () => {
-        nodes = []
-        simulator = new Simulator(LatencyType.RANDOM)
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: '0'
-        }
-        for (let i = 1; i < 100; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator)
-            nodes.push(node)
-        }
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map((node) => node.stop())
-        ])
-        simulator.stop()
-    })
-
-    it('Happy path', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
-        nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 2)
-            expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(node.getK() - 2)
-        })
-        expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK() - 2)
-    }, 60 * 1000)
-})

package/test/integration/DhtWithMockConnections.test.ts

@@ -1,46 +0,0 @@
-import { Simulator } from '../../src/connection/Simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode } from '../utils/utils'
-
-describe('Mock IConnection DHT Joining', () => {
-    let entryPoint: DhtNode
-    let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
-    let simulator: Simulator
-
-    beforeEach(async () => {
-        nodes = []
-        simulator = new Simulator()
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: '0'
-        }
-        for (let i = 1; i < 100; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator)
-            nodes.push(node)
-        }
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map(async (node) => node.stop())
-        ])
-        simulator.stop()
-    })
-
-    it('Happy path', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
-        nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 2)
-            expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(node.getK() - 2)
-        })
-        expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK() - 2)
-    }, 60000)
-})

package/test/integration/DhtWithRealConnectionLatencies.test.ts

@@ -1,47 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockConnectionDhtNode } from '../utils/utils'
-import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { getRandomRegion } from '../../src/connection/Simulator/pings'
-
-describe('Mock connection Dht joining with real latencies', () => {
-    let entryPoint: DhtNode
-    let nodes: DhtNode[]
-    let simulator: Simulator
-    let entrypointDescriptor: PeerDescriptor
-    
-    beforeEach(async () => {
-        nodes = []
-        simulator = new Simulator(LatencyType.REAL)
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            region: getRandomRegion()
-        }
-        for (let i = 1; i < 100; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator)
-            nodes.push(node)
-        }
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map((node) => node.stop())
-        ])
-        simulator.stop()
-    })
-
-    it('Happy path', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
-        nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 3)
-            expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(node.getK() - 3)
-        })
-        expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK())
-    }, 60 * 1000)
-})