@streamr/dht 0.0.1-tatum.0

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

@@ -0,0 +1,98 @@
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerID } from '../../src/helpers/PeerID'
+import { ConnectionType } from '../../src/connection/IConnection'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import EventEmitter from 'events'
+import { waitForEvent } from '@streamr/utils'
+
+describe('Layer0 with WebRTC connections', () => {
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('entrypoint').value,
+        nodeName: 'entrypoint',
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 10029 }
+    }
+    let epDhtNode: DhtNode
+    let node1: DhtNode
+    let node2: DhtNode
+    let node3: DhtNode
+    let node4: DhtNode
+
+    beforeEach(async () => {
+
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, nodeName: 'entrypoint', numberOfNodesPerKBucket: 8 })
+        await epDhtNode.start()
+
+        await epDhtNode.joinDht([epPeerDescriptor])
+
+        node1 = new DhtNode({ peerIdString: 'Peer0', nodeName: 'Peer0', entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ peerIdString: 'Peer1', nodeName: 'Peer1', entryPoints: [epPeerDescriptor] })
+        node3 = new DhtNode({ peerIdString: 'Peer2', nodeName: 'Peer2', entryPoints: [epPeerDescriptor] })
+        node4 = new DhtNode({ peerIdString: 'Peer3', nodeName: 'Peer3', entryPoints: [epPeerDescriptor] })
+
+        await Promise.all([
+            node1.start(),
+            node2.start(),
+            node3.start(),
+            node4.start()
+        ])
+
+        await epDhtNode.joinDht([epPeerDescriptor])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            node1.stop(),
+            node2.stop(),
+            node3.stop(),
+            node4.stop()
+        ])
+        await epDhtNode.stop()
+    })
+
+    class Peer0Listener extends EventEmitter {
+        private nodeToListen: DhtNode
+        constructor(nodeToListen: DhtNode) {
+            super()
+            this.nodeToListen = nodeToListen
+            this.nodeToListen.on('connected', (peer: PeerDescriptor) => {
+                if (PeerID.fromValue(peer.kademliaId).equals(PeerID.fromString('Peer0'))) {
+                    this.emit('peer0connected')
+                }
+            })
+        }
+    }
+
+    it('Happy path two peers', async () => {
+
+        await Promise.all([waitForEvent(new Peer0Listener(node2), 'peer0connected', 20000),
+            node2.joinDht([epPeerDescriptor]),
+            node1.joinDht([epPeerDescriptor])
+        ])
+
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getPeerDescriptor())!.connectionType)
+            .toEqual(ConnectionType.WEBRTC)
+        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getPeerDescriptor())!.connectionType)
+            .toEqual(ConnectionType.WEBRTC)
+
+    }, 60000)
+
+    it('Happy path simultaneous joins', async () => {
+        await Promise.all([
+            node1.joinDht([epPeerDescriptor]),
+            node2.joinDht([epPeerDescriptor]),
+            node3.joinDht([epPeerDescriptor]),
+            node4.joinDht([epPeerDescriptor])
+        ])
+
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getPeerDescriptor())!.connectionType)
+            .toEqual(ConnectionType.WEBRTC)
+        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getPeerDescriptor())!.connectionType)
+            .toEqual(ConnectionType.WEBRTC)
+    })
+})

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

@@ -0,0 +1,69 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+
+describe('Layer1 Scale', () => {
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('0').value,
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 43228 },
+        nodeName: 'entrypoint'
+    }
+
+    const STREAM_ID = 'stream'
+
+    const NUM_OF_NODES = 16
+
+    let layer0Nodes: DhtNode[]
+
+    let layer1Nodes: DhtNode[]
+
+    let epLayer0Node: DhtNode
+    let epLayer1Node: DhtNode
+
+    beforeEach(async () => {
+        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        await epLayer0Node.start()
+        await epLayer0Node.joinDht([epPeerDescriptor])
+
+        epLayer1Node = new DhtNode({ transportLayer: epLayer0Node, 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({ peerIdString: `node-${i}`, nodeName: `${i}`, entryPoints: [epPeerDescriptor] })
+            await node.start()
+            layer0Nodes.push(node)
+            const layer1 = new DhtNode({
+                transportLayer: node,
+                entryPoints: [epPeerDescriptor],
+                peerDescriptor: node.getPeerDescriptor(),
+                serviceId: STREAM_ID,
+                rpcRequestTimeout: 5000
+            })
+            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.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 1)
+        })
+        layer1Nodes.forEach((node) => {
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() / 2)
+        })
+    })
+})

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

@@ -0,0 +1,73 @@
+import { DhtNode } from '../../src/dht/DhtNode'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerID } from '../../src/helpers/PeerID'
+
+describe('Layer1 Scale', () => {
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('entrypoint').value,
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 43225 },
+        nodeName: 'entrypoint'
+    }
+
+    const STREAM_ID = 'stream'
+
+    const NUM_OF_NODES = 16
+
+    let layer0Nodes: DhtNode[]
+
+    let layer1Nodes: DhtNode[]
+
+    let epLayer0Node: DhtNode
+    let epLayer1Node: DhtNode
+
+    beforeEach(async () => {
+        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor, nodeName: 'entrypoint' })
+        await epLayer0Node.start()
+        await epLayer0Node.joinDht([epPeerDescriptor])
+
+        epLayer1Node = new DhtNode({ transportLayer: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID, nodeName: 'entrypoint' })
+        await epLayer1Node.start()
+        await epLayer1Node.joinDht([epPeerDescriptor])
+
+        layer0Nodes = []
+        layer1Nodes = []
+
+        for (let i = 0; i < NUM_OF_NODES; i++) {
+            const node = new DhtNode({ peerIdString: `node-${i}`, nodeName: `${i}`, webSocketPort: 62200 + i, entryPoints: [epPeerDescriptor] })
+            await node.start()
+            layer0Nodes.push(node)
+            const layer1 = new DhtNode({
+                nodeName: `${i}`,
+                transportLayer: node,
+                entryPoints: [epPeerDescriptor],
+                peerDescriptor: node.getPeerDescriptor(),
+                serviceId: STREAM_ID
+            })
+            await layer1.start()
+            layer1Nodes.push(layer1)
+        }
+
+        await Promise.all(layer0Nodes.map((node) => node.joinDht([epPeerDescriptor])))
+
+        await Promise.all(layer1Nodes.map((node) => node.joinDht([epPeerDescriptor])))
+
+    }, 60000)
+
+    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.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 1)
+        })
+        layer1Nodes.forEach((node ) => {
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() / 2)
+        })
+    })
+})

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

@@ -0,0 +1,62 @@
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { PeerID } from '../../src/helpers/PeerID'
+import { waitForCondition } from '@streamr/utils'
+import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+
+describe('WebSocket IConnection Requests', () => {
+    const epPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('3').value,
+        type: NodeType.NODEJS,
+        websocket: { ip: '127.0.0.1', port: 10021 }
+    }
+    let epDhtNode: DhtNode
+    let node1: DhtNode
+    let node2: DhtNode
+
+    beforeEach(async () => {
+
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor })
+        await epDhtNode.start()
+
+        await epDhtNode.joinDht([epPeerDescriptor])
+
+        node1 = new DhtNode({ peerIdString: '2', nodeName: 'node1', webSocketPort: 10022, entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ peerIdString: '1', nodeName: 'node2', entryPoints: [epPeerDescriptor] })
+        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 (isSamePeerDescriptor(peerDescriptor, node2.getPeerDescriptor())) {
+                connected1 = true
+            }
+        })
+        node2.on('connected', (peerDescriptor: PeerDescriptor) => {
+            if (isSamePeerDescriptor(peerDescriptor, node1.getPeerDescriptor())) {
+                connected2 = true
+            }
+        })
+
+        await node2.joinDht([epPeerDescriptor])
+        await node1.joinDht([epPeerDescriptor])
+
+        await waitForCondition(() => { return (connected1 && connected2) })
+
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getPeerDescriptor())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getPeerDescriptor())).toEqual(true)
+
+    }, 10000)
+})

package/test/integration/ConnectionLocking.test.ts

@@ -0,0 +1,166 @@
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { waitForCondition } from '@streamr/utils'
+import { PeerID } from '../../src/helpers/PeerID'
+import { SimulatorTransport } from '../../src/exports'
+
+describe('Connection Locking', () => {
+
+    const mockPeerDescriptor1: PeerDescriptor = {
+        kademliaId: PeerID.fromString('mock1').value,
+        nodeName: 'mock1',
+        type: NodeType.NODEJS
+    }
+    const mockPeerDescriptor2: PeerDescriptor = {
+        kademliaId: PeerID.fromString('mock2').value,
+        nodeName: 'mock2',
+        type: NodeType.NODEJS
+    }
+
+    let mockConnectorTransport1: ConnectionManager
+    let mockConnectorTransport2: ConnectionManager
+
+    let connectionManager1: ConnectionManager
+    let connectionManager2: ConnectionManager
+
+    let simulator: Simulator
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
+        mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
+
+        connectionManager1 = new ConnectionManager({
+            transportLayer: mockConnectorTransport1
+        })
+
+        connectionManager2 = new ConnectionManager({
+            transportLayer: mockConnectorTransport2
+        })
+        await connectionManager1.start(() => mockPeerDescriptor1)
+        await connectionManager2.start(() => mockPeerDescriptor2)
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            mockConnectorTransport1.stop(),
+            mockConnectorTransport2.stop(),
+            connectionManager1.stop(),
+            connectionManager2.stop()
+        ])
+        simulator.stop()
+    })
+
+    it('can lock connections', async () => {
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
+        ])
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+    })
+
+    it('Multiple services on the same peer', async () => {
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
+        ])
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock2')),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
+        ])
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+    })
+
+    it('can unlock connections', async () => {
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
+        ])
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
+        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
+        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+
+        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock')
+        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
+        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1) === false)
+        expect(connectionManager1.hasConnection(mockPeerDescriptor1)).toEqual(false)
+    })
+
+    it('unlocking multiple services', async () => {
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
+        ])
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock2')),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
+        ])
+
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
+        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)).toEqual(false)
+
+        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
+        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(true)
+
+        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock2')
+        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)).toEqual(false)
+        expect(connectionManager1.hasConnection(mockPeerDescriptor1)).toEqual(false)
+    })
+
+    it('maintains connection if both sides initially lock and then one end unlocks', async () => {
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
+            connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
+        ])
+
+        expect(connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2))
+        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1))
+
+        connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
+        await waitForCondition(() =>
+            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2, 'testLock1')
+            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2, 'testLock1')
+            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock1')
+            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1, 'testLock1')
+        )
+        
+        expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
+    })
+
+    it('unlocks after graceful disconnect', async () => {
+        await Promise.all([
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
+            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)),
+            connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
+            connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
+        ])
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2))
+        expect(connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)).toEqual(true)
+        expect(connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)).toEqual(true)
+
+        //@ts-expect-error private field
+        await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
+        
+        await waitForCondition(() =>
+            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2, 'testLock1')
+            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2, 'testLock1')
+        )
+        await waitForCondition(() =>
+            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock1')
+            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1, 'testLock1')
+        )
+        await waitForCondition(() => !connectionManager2.hasConnection(mockPeerDescriptor1))
+        await waitForCondition(() => !connectionManager1.hasConnection(mockPeerDescriptor2))
+
+        expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(false)
+        expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(false)
+    }, 10000)
+})