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

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -1,82 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_ID = 'stream'
-const NUM_OF_NODES = 16
-const NUM_OF_NODES_PER_KBUCKET = 8
-const WEBSOCKET_PORT_RANGE = { min: 62200, max: 62200 + NUM_OF_NODES }
-
-describe('Layer1 Scale', () => {
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 43225, tls: false }
-    })
-    let layer0Nodes: DhtNode[]
-    let layer1Nodes: DhtNode[]
-    let epLayer0Node: DhtNode
-    let epLayer1Node: DhtNode
-
-    beforeEach(async () => {
-        epLayer0Node = new DhtNode({
-            peerDescriptor: epPeerDescriptor,
-            websocketServerEnableTls: false
-        })
-        await epLayer0Node.start()
-        await epLayer0Node.joinDht([epPeerDescriptor])
-
-        epLayer1Node = new DhtNode({ 
-            transport: epLayer0Node,
-            connectionsView: epLayer0Node.getConnectionsView(),
-            peerDescriptor: epPeerDescriptor,
-            serviceId: STREAM_ID
-        })
-        await epLayer1Node.start()
-        await epLayer1Node.joinDht([epPeerDescriptor])
-
-        layer0Nodes = []
-        layer1Nodes = []
-
-        for (let i = 0; i < NUM_OF_NODES; i++) {
-            const node = new DhtNode({ 
-                websocketPortRange: WEBSOCKET_PORT_RANGE,
-                entryPoints: [epPeerDescriptor],
-                websocketServerEnableTls: false,
-                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
-            })
-            await node.start()
-            layer0Nodes.push(node)
-            const layer1 = new DhtNode({
-                transport: node,
-                connectionsView: node.getConnectionsView(),
-                entryPoints: [epPeerDescriptor],
-                peerDescriptor: node.getLocalPeerDescriptor(),
-                serviceId: STREAM_ID,
-                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
-            })
-            await layer1.start()
-            layer1Nodes.push(layer1)
-        }
-
-        await Promise.all(layer0Nodes.map((node) => node.joinDht([epPeerDescriptor])))
-
-        await Promise.all(layer1Nodes.map((node) => node.joinDht([epPeerDescriptor])))
-
-    }, 120000)
-
-    afterEach(async () => {
-        await Promise.all(layer1Nodes.map((node) => node.stop()))
-        await Promise.all(layer0Nodes.map((node) => node.stop()))
-        await epLayer0Node.stop()
-        await epLayer1Node.stop()
-    }, 15000)
-
-    // TODO: fix flaky test in NET-1021
-    it('bucket sizes', async () => {
-        layer0Nodes.forEach((node) => {
-            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
-        })
-        layer1Nodes.forEach((node ) => {
-            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
-        })
-    })
-})

package/test/end-to-end/Layer1-Scale-Webrtc.test.ts

@@ -1,76 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockPeerDescriptor } from '../utils/utils'
-
-const STREAM_ID = 'stream'
-const NUM_OF_NODES = 16
-const NUM_OF_NODES_PER_KBUCKET = 8
-
-describe('Layer1 Scale', () => {
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 43228, tls: false }
-    })
-    let layer0Nodes: DhtNode[]
-    let layer1Nodes: DhtNode[]
-    let epLayer0Node: DhtNode
-    let epLayer1Node: DhtNode
-
-    beforeEach(async () => {
-        epLayer0Node = new DhtNode({
-            peerDescriptor: epPeerDescriptor,
-            websocketServerEnableTls: false
-        })
-        await epLayer0Node.start()
-        await epLayer0Node.joinDht([epPeerDescriptor])
-
-        epLayer1Node = new DhtNode({
-            transport: epLayer0Node,
-            connectionsView: epLayer0Node.getConnectionsView(),
-            peerDescriptor: epPeerDescriptor,
-            serviceId: STREAM_ID
-        })
-        await epLayer1Node.start()
-        await epLayer1Node.joinDht([epPeerDescriptor])
-
-        layer0Nodes = []
-        layer1Nodes = []
-
-        for (let i = 1; i < NUM_OF_NODES; i++) {
-            const node = new DhtNode({ 
-                entryPoints: [epPeerDescriptor],
-                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
-            })
-            await node.start()
-            layer0Nodes.push(node)
-            const layer1 = new DhtNode({
-                transport: node,
-                connectionsView: node.getConnectionsView(),
-                entryPoints: [epPeerDescriptor],
-                peerDescriptor: node.getLocalPeerDescriptor(),
-                serviceId: STREAM_ID,
-                rpcRequestTimeout: 5000,
-                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
-            })
-            await layer1.start()
-            layer1Nodes.push(layer1)
-        }
-        await Promise.all(layer0Nodes.map((node) => node.joinDht([epPeerDescriptor])))
-        await Promise.all(layer1Nodes.map((node) => node.joinDht([epPeerDescriptor])))
-    }, 120000)
-
-    afterEach(async () => {
-        await Promise.all(layer1Nodes.map((node) => node.stop()))
-        await Promise.all(layer0Nodes.map((node) => node.stop()))
-        await epLayer0Node.stop()
-        await epLayer1Node.stop()
-    }, 15000)
-
-    it('bucket sizes', async () => {
-        layer0Nodes.forEach((node) => {
-            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
-        })
-        layer1Nodes.forEach((node) => {
-            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
-        })
-    })
-})

package/test/end-to-end/RecoveryFromFailedAutoCertification.test.ts

@@ -1,52 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import os from 'os'
-
-describe('Failed autocertification', () => {
-    
-    let entryPoint: DhtNode
-    let failedAutocertificationNode: DhtNode
-    let node: DhtNode
-    let entryPointPeerDescriptor: PeerDescriptor
-
-    beforeEach(async () => {
-        entryPoint = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 11112, max: 11112 }, websocketServerEnableTls: false })
-        await entryPoint.start()
-        entryPointPeerDescriptor = entryPoint.getLocalPeerDescriptor()
-        await entryPoint.joinDht([entryPointPeerDescriptor])
-        
-        failedAutocertificationNode = new DhtNode({ 
-            websocketPortRange: { min: 11113, max: 11113 },
-            websocketHost: '127.0.0.1',
-            entryPoints: [entryPointPeerDescriptor],
-            websocketServerEnableTls: true,
-            autoCertifierConfigFile: os.tmpdir() + '/failedAutoCertificationConfigFile.json',
-            autoCertifierUrl: 'http://127.0.0.1:44444'
-        })
-
-        node = new DhtNode({
-            websocketPortRange: { min: 11114, max: 11114 },
-            websocketHost: '127.0.0.1',
-            entryPoints: [entryPointPeerDescriptor],
-            websocketServerEnableTls: false
-        })
-    
-        await node.start()
-        await node.joinDht([entryPointPeerDescriptor])
-    })
-
-    afterEach(async () => {
-        await failedAutocertificationNode.stop()
-        await entryPoint.stop()
-        await node.stop()
-    })
-
-    it('failed auto certification should default to no tls', async () => {
-        await failedAutocertificationNode.start()
-        const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
-        expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
-        await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
-        expect(failedAutocertificationNode.getNeighborCount()).toEqual(2)
-    })
-
-})

package/test/end-to-end/WebsocketConnectionRequest.test.ts

@@ -1,69 +0,0 @@
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { waitForCondition } from '@streamr/utils'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { areEqualPeerDescriptors } from '../../src/identifiers'
-
-describe('Websocket IConnection Requests', () => {
-
-    const epPeerDescriptor = createMockPeerDescriptor({
-        websocket: { host: '127.0.0.1', port: 10021, tls: false }
-    })
-    let epDhtNode: DhtNode
-    let node1: DhtNode
-    let node2: DhtNode
-
-    beforeEach(async () => {
-
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
-        await epDhtNode.start()
-
-        await epDhtNode.joinDht([epPeerDescriptor])
-
-        node1 = new DhtNode({ 
-            websocketPortRange: { min: 10022, max: 10022 },
-            entryPoints: [epPeerDescriptor],
-            websocketServerEnableTls: false
-        })
-        node2 = new DhtNode({ 
-            entryPoints: [epPeerDescriptor],
-            websocketServerEnableTls: false
-        })
-
-        await node1.start()
-        await node2.start()
-    })
-
-    afterEach(async () => {
-        await epDhtNode.stop()
-        await node1.stop()
-        await node2.stop()
-    })
-
-    it('Happy Path', async () => {
-
-        let connected1 = false
-        let connected2 = false
-
-        node1.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (areEqualPeerDescriptors(peerDescriptor, node2.getLocalPeerDescriptor())) {
-                connected1 = true
-            }
-        })
-        node2.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (areEqualPeerDescriptors(peerDescriptor, node1.getLocalPeerDescriptor())) {
-                connected2 = true
-            }
-        })
-
-        await node2.joinDht([epPeerDescriptor])
-        await node1.joinDht([epPeerDescriptor])
-
-        await waitForCondition(() => { return (connected1 && connected2) })
-
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getNodeId())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getNodeId())).toEqual(true)
-
-    }, 10000)
-})

package/test/end-to-end/memory-leak.test.ts

@@ -1,80 +0,0 @@
-import LeakDetector from 'jest-leak-detector'
-import { waitForCondition } from '@streamr/utils'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { Message } from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { toNodeId } from '../../src/identifiers'
-
-const MESSAGE_ID = 'mock-message-id'
-
-describe('memory leak', () => {
-
-    it('send message', async () => {
-        const entryPointDescriptor = createMockPeerDescriptor({
-            websocket: {
-                host: '127.0.0.1',
-                port: 11224,
-                tls: false
-            }
-        })
-        let entryPoint: DhtNode | undefined = new DhtNode({
-            nodeId: toNodeId(entryPointDescriptor),
-            websocketHost: entryPointDescriptor.websocket!.host,
-            websocketPortRange: {
-                min: entryPointDescriptor.websocket!.port,
-                max: entryPointDescriptor.websocket!.port
-            },
-            entryPoints: [entryPointDescriptor],
-            websocketServerEnableTls: false
-        })
-        await entryPoint.start()
-        await entryPoint.joinDht([entryPointDescriptor])
-        let sender: DhtNode | undefined = new DhtNode({ entryPoints: [entryPointDescriptor] })
-        let receiver: DhtNode | undefined = new DhtNode({ entryPoints: [entryPointDescriptor] })
-        await Promise.all([
-            (async () => {
-                await sender.start()
-                await sender.joinDht([entryPointDescriptor])
-            })(),
-            (async () => {
-                await receiver.start()
-                await receiver.joinDht([entryPointDescriptor])
-            })()
-        ])
-
-        let receivedMessage: Message | undefined = undefined
-        receiver.on('message', (msg: Message) => receivedMessage = msg)
-        const msg: Message = {
-            serviceId: 'mock-service-id',
-            targetDescriptor: receiver.getLocalPeerDescriptor(),
-            messageId: 'mock-message-id',
-            body: {
-                oneofKind: 'rpcMessage',
-                rpcMessage: RpcMessage.create()
-            }
-        }
-        await sender.send(msg)
-        await waitForCondition(() => receivedMessage !== undefined)
-        expect(receivedMessage!.messageId).toEqual(MESSAGE_ID)
-
-        await Promise.all([
-            entryPoint.stop(),
-            sender.stop(),
-            receiver.stop()
-        ])
-
-        const detector1 = new LeakDetector(entryPoint)
-        entryPoint = undefined
-        await detector1.isLeaking()
-        expect(await detector1.isLeaking()).toBe(false)
-
-        const detector2 = new LeakDetector(sender)
-        sender = undefined
-        expect(await detector2.isLeaking()).toBe(false)
-
-        const detector3 = new LeakDetector(receiver)
-        receiver = undefined
-        expect(await detector3.isLeaking()).toBe(false)
-    }, 10000)
-})

package/test/integration/ConnectionLocking.test.ts

@@ -1,182 +0,0 @@
-import { MetricsContext, waitForCondition } from '@streamr/utils'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { ITransport } from '../../src/transport/ITransport'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
-import { createMockPeerDescriptor } from '../utils/utils'
-import { toNodeId } from '../../src/identifiers'
-
-const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
-    return new ConnectionManager({
-        createConnectorFacade: () => new DefaultConnectorFacade({
-            transport,
-            createLocalPeerDescriptor: async () => localPeerDescriptor
-        }),
-        metricsContext: new MetricsContext(),
-        allowIncomingPrivateConnections: true
-    })
-}
-
-describe('Connection Locking', () => {
-
-    const mockPeerDescriptor1 = createMockPeerDescriptor({
-        region: getRandomRegion()
-    })
-    const mockPeerDescriptor2 = createMockPeerDescriptor({
-        region: getRandomRegion()
-    })
-    let mockConnectorTransport1: ConnectionManager
-    let mockConnectorTransport2: ConnectionManager
-    let connectionManager1: ConnectionManager
-    let connectionManager2: ConnectionManager
-    let simulator: Simulator
-
-    beforeEach(async () => {
-        simulator = new Simulator(LatencyType.REAL)
-        mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
-        await mockConnectorTransport1.start()
-        mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
-        await mockConnectorTransport2.start()
-        connectionManager1 = createConnectionManager(mockPeerDescriptor1, mockConnectorTransport1)
-        connectionManager2 = createConnectionManager(mockPeerDescriptor2, mockConnectorTransport2)
-        await connectionManager1.start()
-        await connectionManager2.start()
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            mockConnectorTransport1.stop(),
-            mockConnectorTransport2.stop(),
-            connectionManager1.stop(),
-            connectionManager2.stop()
-        ])
-        simulator.stop()
-    })
-
-    it('can lock connections', async () => {
-        const nodeId1 = toNodeId(mockPeerDescriptor1)
-        const nodeId2 = toNodeId(mockPeerDescriptor2)
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
-        ])
-        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
-    })
-
-    it('Multiple services on the same peer', async () => {
-        const nodeId1 = toNodeId(mockPeerDescriptor1)
-        const nodeId2 = toNodeId(mockPeerDescriptor2)
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
-        ])
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
-        ])
-        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
-    })
-
-    it('can unlock connections', async () => {
-        const nodeId1 = toNodeId(mockPeerDescriptor1)
-        const nodeId2 = toNodeId(mockPeerDescriptor2)
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
-        ])
-        expect(connectionManager1.hasConnection(nodeId2))
-        expect(connectionManager2.hasLocalLockedConnection(nodeId2)).toEqual(false)
-        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
-
-        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock')
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
-        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
-        expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
-    })
-
-    it('unlocking multiple services', async () => {
-        const nodeId1 = toNodeId(mockPeerDescriptor1)
-        const nodeId2 = toNodeId(mockPeerDescriptor2)
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
-        ])
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
-        ])
-
-        expect(connectionManager1.hasConnection(nodeId2))
-        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(false)
-
-        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
-
-        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock2')
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
-        expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
-    })
-
-    it('maintains connection if both sides initially lock and then one end unlocks', async () => {
-        const nodeId1 = toNodeId(mockPeerDescriptor1)
-        const nodeId2 = toNodeId(mockPeerDescriptor2)
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
-            connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
-        ])
-
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2))
-        expect(connectionManager2.hasLocalLockedConnection(nodeId1))
-
-        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
-        await waitForCondition(() =>
-            connectionManager1.hasRemoteLockedConnection(nodeId2)
-            && !connectionManager1.hasLocalLockedConnection(nodeId2)
-            && !connectionManager2.hasRemoteLockedConnection(nodeId1)
-            && connectionManager2.hasLocalLockedConnection(nodeId1)
-        )
-        
-        expect(connectionManager2.hasConnection(nodeId1)).toEqual(true)
-        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
-    })
-
-    it('unlocks after graceful disconnect', async () => {
-        const nodeId1 = toNodeId(mockPeerDescriptor1)
-        const nodeId2 = toNodeId(mockPeerDescriptor2)
-        await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
-            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
-            connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
-        ])
-        expect(connectionManager1.hasConnection(nodeId2))
-        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
-        expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
-
-        //@ts-expect-error private field
-        await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
-        
-        await waitForCondition(() =>
-            !connectionManager1.hasRemoteLockedConnection(nodeId2)
-            && !connectionManager1.hasLocalLockedConnection(nodeId2)
-        )
-        await waitForCondition(() =>
-            !connectionManager2.hasRemoteLockedConnection(nodeId1)
-            && !connectionManager2.hasLocalLockedConnection(nodeId1)
-        )
-        await waitForCondition(() => !connectionManager2.hasConnection(nodeId1))
-        await waitForCondition(() => !connectionManager1.hasConnection(nodeId2))
-
-        expect(connectionManager1.hasConnection(nodeId2)).toEqual(false)
-        expect(connectionManager2.hasConnection(nodeId1)).toEqual(false)
-    }, 10000)
-})