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

package/test/benchmark/RecursiveFind.test.ts

@@ -5,7 +5,8 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { PeerID, peerIdFromPeerDescriptor } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
 
@@ -31,19 +32,18 @@ describe('Recursive find correctness', () => {
 
         nodes = []
         const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined, entryPointId)
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
 
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
 
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined, nodeId)
+            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined)
             nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
@@ -70,7 +70,7 @@ describe('Recursive find correctness', () => {
         debugVars['waiting'] = false
         logger.info('waiting over')
 
-        nodes.forEach((node) => logger.info(node.getPeerDescriptor().nodeName + ': connections:' +
+        nodes.forEach((node) => logger.info(keyFromPeerDescriptor(node.getPeerDescriptor()) + ': connections:' +
             node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
             + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
             + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()

package/test/end-to-end/Layer0-Layer1.test.ts

@@ -1,6 +1,6 @@
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('Layer0-Layer1', () => {
     const epPeerDescriptor: PeerDescriptor = {
@@ -35,11 +35,11 @@ describe('Layer0-Layer1', () => {
         await node1.start()
         await node2.start()
 
-        stream1Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID1 })
-        stream1Node2 = new DhtNode({ transportLayer: node1, serviceId: STREAM_ID1 })
+        stream1Node1 = new DhtNode({ transport: epDhtNode, serviceId: STREAM_ID1 })
+        stream1Node2 = new DhtNode({ transport: node1, serviceId: STREAM_ID1 })
 
-        stream2Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID2 })
-        stream2Node2 = new DhtNode({ transportLayer: node2, serviceId: STREAM_ID2 })
+        stream2Node1 = new DhtNode({ transport: epDhtNode, serviceId: STREAM_ID2 })
+        stream2Node2 = new DhtNode({ transport: node2, serviceId: STREAM_ID2 })
 
         await Promise.all([
             stream1Node1.start(),
@@ -81,9 +81,9 @@ describe('Layer0-Layer1', () => {
         expect(stream2Node1.getClosestContacts()).toHaveLength(1)
         expect(stream2Node2.getClosestContacts()).toHaveLength(1)
 
-        expect(isSamePeerDescriptor(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
-        expect(isSamePeerDescriptor(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
-        expect(isSamePeerDescriptor(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
-        expect(isSamePeerDescriptor(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
     })
 })

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

@@ -54,31 +54,31 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer1EntryPoint = new DhtNode({
             peerId: binaryToHex(entrypointDescriptor.kademliaId),
-            transportLayer: layer0EntryPoint,
+            transport: layer0EntryPoint,
             serviceId: 'layer1'
         })
 
         layer1Node1 = new DhtNode({
             peerId: layer0Node1Id,
-            transportLayer: layer0Node1,
+            transport: layer0Node1,
             serviceId: 'layer1'
         })
 
         layer1Node2 = new DhtNode({
             peerId: layer0Node2Id,
-            transportLayer: layer0Node2,
+            transport: layer0Node2,
             serviceId: 'layer1'
         })
 
         layer1Node3 = new DhtNode({
             peerId: layer0Node3Id,
-            transportLayer: layer0Node3,
+            transport: layer0Node3,
             serviceId: 'layer1'
         })
 
         layer1Node4 = new DhtNode({
             peerId: layer0Node4Id,
-            transportLayer: layer0Node4,
+            transport: layer0Node4,
             serviceId: 'layer1'
         })
 

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

@@ -8,7 +8,6 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 describe('Layer0 with WebRTC connections', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('entrypoint').value,
-        nodeName: 'entrypoint',
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 10029, tls: false }
     }
@@ -20,15 +19,15 @@ describe('Layer0 with WebRTC connections', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, nodeName: 'entrypoint', numberOfNodesPerKBucket: 8 })
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 8 })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ nodeName: 'Peer0', entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ nodeName: 'Peer1', entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ nodeName: 'Peer2', entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ nodeName: 'Peer3', entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node3 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node4 = new DhtNode({ entryPoints: [epPeerDescriptor] })
 
         await Promise.all([
             node1.start(),

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

@@ -2,12 +2,13 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 
+const NUM_OF_NODES_PER_KBUCKET = 8
+
 describe('Layer1 Scale', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('0').value,
         type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43228, tls: false },
-        nodeName: 'entrypoint'
+        websocket: { host: '127.0.0.1', port: 43228, tls: false }
     }
 
     const STREAM_ID = 'stream'
@@ -26,7 +27,7 @@ describe('Layer1 Scale', () => {
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
-        epLayer1Node = new DhtNode({ transportLayer: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
+        epLayer1Node = new DhtNode({ transport: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
         await epLayer1Node.start()
         await epLayer1Node.joinDht([epPeerDescriptor])
 
@@ -34,15 +35,19 @@ describe('Layer1 Scale', () => {
         layer1Nodes = []
 
         for (let i = 1; i < NUM_OF_NODES; i++) {
-            const node = new DhtNode({ nodeName: `${i}`, entryPoints: [epPeerDescriptor] })
+            const node = new DhtNode({ 
+                entryPoints: [epPeerDescriptor],
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
+            })
             await node.start()
             layer0Nodes.push(node)
             const layer1 = new DhtNode({
-                transportLayer: node,
+                transport: node,
                 entryPoints: [epPeerDescriptor],
                 peerDescriptor: node.getPeerDescriptor(),
                 serviceId: STREAM_ID,
-                rpcRequestTimeout: 5000
+                rpcRequestTimeout: 5000,
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
             await layer1.start()
             layer1Nodes.push(layer1)
@@ -60,10 +65,10 @@ describe('Layer1 Scale', () => {
 
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 1)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() / 2)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -2,12 +2,13 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 
+const NUM_OF_NODES_PER_KBUCKET = 8
+
 describe('Layer1 Scale', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('entrypoint').value,
         type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43225, tls: false },
-        nodeName: 'entrypoint'
+        websocket: { host: '127.0.0.1', port: 43225, tls: false }
     }
 
     const STREAM_ID = 'stream'
@@ -24,11 +25,11 @@ describe('Layer1 Scale', () => {
     const websocketPortRange = { min: 62200, max: 62200 + NUM_OF_NODES }
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor, nodeName: 'entrypoint' })
+        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
-        epLayer1Node = new DhtNode({ transportLayer: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID, nodeName: 'entrypoint' })
+        epLayer1Node = new DhtNode({ transport: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
         await epLayer1Node.start()
         await epLayer1Node.joinDht([epPeerDescriptor])
 
@@ -36,15 +37,19 @@ describe('Layer1 Scale', () => {
         layer1Nodes = []
 
         for (let i = 0; i < NUM_OF_NODES; i++) {
-            const node = new DhtNode({ nodeName: `${i}`, websocketPortRange, entryPoints: [epPeerDescriptor] })
+            const node = new DhtNode({ 
+                websocketPortRange, 
+                entryPoints: [epPeerDescriptor],
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
+            })
             await node.start()
             layer0Nodes.push(node)
             const layer1 = new DhtNode({
-                nodeName: `${i}`,
-                transportLayer: node,
+                transport: node,
                 entryPoints: [epPeerDescriptor],
                 peerDescriptor: node.getPeerDescriptor(),
-                serviceId: STREAM_ID
+                serviceId: STREAM_ID,
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
             await layer1.start()
             layer1Nodes.push(layer1)
@@ -66,10 +71,10 @@ describe('Layer1 Scale', () => {
     // TODO: fix flaky test in NET-1021
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 1)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node ) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() / 2)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -3,7 +3,7 @@ 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'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('WebSocket IConnection Requests', () => {
     const epPeerDescriptor: PeerDescriptor = {
@@ -22,8 +22,8 @@ describe('WebSocket IConnection Requests', () => {
 
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ nodeName: 'node1', websocketPortRange: { min: 10022, max: 10022 }, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ nodeName: 'node2', entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ websocketPortRange: { min: 10022, max: 10022 }, entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
         await node1.start()
         await node2.start()
     })
@@ -40,12 +40,12 @@ describe('WebSocket IConnection Requests', () => {
         let connected2 = false
 
         node1.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (isSamePeerDescriptor(peerDescriptor, node2.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node2.getPeerDescriptor())) {
                 connected1 = true
             }
         })
         node2.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (isSamePeerDescriptor(peerDescriptor, node1.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node1.getPeerDescriptor())) {
                 connected2 = true
             }
         })

package/test/integration/ConnectionLocking.test.ts

@@ -1,20 +1,30 @@
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { waitForCondition } from '@streamr/utils'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { ITransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
-import { SimulatorTransport } from '../../src/exports'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            transport,
+            createOwnPeerDescriptor: () => ownPeerDescriptor
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 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
     }
 
@@ -29,17 +39,13 @@ describe('Connection Locking', () => {
     beforeEach(async () => {
         simulator = new Simulator()
         mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
+        await mockConnectorTransport1.start()
         mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
-
-        connectionManager1 = new ConnectionManager({
-            transportLayer: mockConnectorTransport1
-        })
-
-        connectionManager2 = new ConnectionManager({
-            transportLayer: mockConnectorTransport2
-        })
-        await connectionManager1.start(() => mockPeerDescriptor1)
-        await connectionManager2.start(() => mockPeerDescriptor2)
+        await mockConnectorTransport2.start()
+        connectionManager1 = createConnectionManager(mockPeerDescriptor1, mockConnectorTransport1)
+        connectionManager2 = createConnectionManager(mockPeerDescriptor2, mockConnectorTransport2)
+        await connectionManager1.start()
+        await connectionManager2.start()
     })
 
     afterEach(async () => {
@@ -68,7 +74,7 @@ describe('Connection Locking', () => {
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock2')),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
         expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
@@ -97,7 +103,7 @@ describe('Connection Locking', () => {
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock2')),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
 
@@ -125,10 +131,10 @@ describe('Connection Locking', () => {
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
         await waitForCondition(() =>
-            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2, 'testLock1')
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2, 'testLock1')
-            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock1')
-            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1, 'testLock1')
+            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
+            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
+            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
+            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
         )
         
         expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(true)
@@ -150,12 +156,12 @@ describe('Connection Locking', () => {
         await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
         
         await waitForCondition(() =>
-            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2, 'testLock1')
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2, 'testLock1')
+            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
+            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
         )
         await waitForCondition(() =>
-            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock1')
-            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1, 'testLock1')
+            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
+            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
         )
         await waitForCondition(() => !connectionManager2.hasConnection(mockPeerDescriptor1))
         await waitForCondition(() => !connectionManager1.hasConnection(mockPeerDescriptor2))