@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/test/integration/ReplicateData.test.ts

@@ -0,0 +1,106 @@
+/* eslint-disable no-console */
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { createMockConnectionDhtNode, waitNodesReadyForTesting } from '../utils/utils'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { DhtAddress, createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { sample } from 'lodash'
+import { DataEntry, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+const DATA = createMockDataEntry()
+const NUM_NODES = 100
+const MAX_CONNECTIONS = 80
+const K = 8
+const ENTRY_POINT_INDEX = 0
+
+const getDataEntries = (node: DhtNode): DataEntry[] => {
+    // @ts-expect-error private field
+    const store = node.localDataStore
+    return Array.from(store.values(getDhtAddressFromRaw(DATA.key)))
+}
+
+describe('Replicate data from node to node in DHT', () => {
+
+    let nodes: DhtNode[]
+    let entryPointDescriptor: PeerDescriptor
+    const simulator = new Simulator(LatencyType.FIXED, 20)
+
+    beforeEach(async () => {
+        const entryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress(), K, MAX_CONNECTIONS)
+        entryPointDescriptor = entryPoint.getLocalPeerDescriptor()
+        await entryPoint.joinDht([entryPointDescriptor])
+        nodes = []
+        nodes.push(entryPoint)
+        for (let i = 1; i < NUM_NODES; i++) {
+            const node = await createMockConnectionDhtNode(
+                simulator,
+                createRandomDhtAddress(),
+                K,
+                MAX_CONNECTIONS
+            )
+            nodes.push(node)
+        }
+    }, 60000)
+
+    afterEach(async () => {
+        await Promise.all(nodes.map(async (node) => await node.stop()))
+    }, 60000)
+
+    afterAll(async () => {
+        simulator.stop()
+    })
+
+    it('Data replicates to the closest node no matter where it is stored', async () => {
+        // calculate offline which node is closest to the data
+        const sortedList = new SortedContactList<DhtNode>({ 
+            referenceId: getDhtAddressFromRaw(DATA.key),
+            maxSize: 10000, 
+            allowToContainReferenceId: true, 
+            emitEvents: false 
+        })
+        nodes.forEach((node) => sortedList.addContact(node))
+
+        const closest = sortedList.getAllContacts()
+        const successfulStorers = await nodes[0].storeDataToDht(getDhtAddressFromRaw(DATA.key), DATA.data!)
+        expect(successfulStorers.length).toBe(1)
+
+        await Promise.all(
+            nodes.map(async (node, i) => {
+                if (i !== ENTRY_POINT_INDEX) {
+                    await node.joinDht([entryPointDescriptor])
+                }
+            })
+        )
+        await waitNodesReadyForTesting(nodes)
+
+        const data = getDataEntries(closest[0])
+        expect(data).toHaveLength(1)
+        expectEqualData(data[0], DATA)
+    }, 180000)
+
+    it('Data replicates to the other nodes when storers are stopped', async () => {
+        await Promise.all(
+            nodes.map(async (node, i) => {
+                if (i !== ENTRY_POINT_INDEX) {
+                    await node.joinDht([entryPointDescriptor])
+                }
+            })
+        )
+        await waitNodesReadyForTesting(nodes)
+
+        const randomIndex = Math.floor(Math.random() * nodes.length)
+        const storerDescriptors = await nodes[randomIndex].storeDataToDht(getDhtAddressFromRaw(DATA.key), DATA.data!)
+        const stoppedNodeIds: DhtAddress[] = []
+        await Promise.all(storerDescriptors.map(async (storerDescriptor) => {
+            const storer = nodes.find((n) => n.getNodeId() === getNodeIdFromPeerDescriptor(storerDescriptor))!
+            await storer.stop()
+            stoppedNodeIds.push(storer.getNodeId())
+        }))
+
+        const randomNonStoppedNode = sample(nodes.filter((n) => !stoppedNodeIds.includes(n.getNodeId())))!
+        const data = await randomNonStoppedNode.fetchDataFromDht(getDhtAddressFromRaw(DATA.key))
+        expect(data).toHaveLength(1)
+        expectEqualData(data[0], DATA)
+    }, 180000)
+})

package/test/integration/RouteMessage.test.ts

@@ -1,17 +1,20 @@
 import { DhtNode, Events as DhtNodeEvents } from '../../src/dht/DhtNode'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { v4 } from 'uuid'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { RoutingMode } from '../../src/dht/routing/RoutingSession'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
+const NUM_NODES = 30
+
 describe('Route Message With Mock Connections', () => {
+
     let entryPoint: DhtNode
     let sourceNode: DhtNode
     let destinationNode: DhtNode
@@ -19,29 +22,21 @@ describe('Route Message With Mock Connections', () => {
     let simulator: Simulator
     let entryPointDescriptor: PeerDescriptor
 
-    const entryPointId = '0'
-    const sourceId = 'eeeeeeeee'
-    const destinationId = '000000000'
-    const NUM_NODES = 30
-
-    const receiveMatrix: Array<Array<number>> = []
-
     beforeEach(async () => {
         routerNodes = []
         simulator = new Simulator()
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
+        entryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
 
         entryPointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
+            nodeId: getRawFromDhtAddress(entryPoint.getNodeId()),
             type: NodeType.NODEJS
         }
 
-        sourceNode = await createMockConnectionDhtNode(sourceId, simulator)
-        destinationNode = await createMockConnectionDhtNode(destinationId, simulator)
+        sourceNode = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        destinationNode = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator)
+            const node = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
             routerNodes.push(node)
         }
 
@@ -69,7 +64,6 @@ describe('Route Message With Mock Connections', () => {
         const message: Message = {
             serviceId: 'unknown',
             messageId: v4(),
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper
@@ -81,29 +75,28 @@ describe('Route Message With Mock Connections', () => {
         await runAndWaitForEvents3<DhtNodeEvents>([() => {
             sourceNode.router!.doRouteMessage({
                 message,
-                destinationPeer: destinationNode.getLocalPeerDescriptor(),
+                target: destinationNode.getLocalPeerDescriptor().nodeId,
                 requestId: v4(),
                 sourcePeer: sourceNode.getLocalPeerDescriptor(),
                 reachableThrough: [],
-                routingPath: []
-
+                routingPath: [],
+                parallelRootNodeIds: []
             })
         }], [[destinationNode, 'message']], 20000)
     }, 30000)
 
     it('Receives multiple messages', async () => {
-        const numOfMessages = 20
+        const messageCount = 20
         let receivedMessages = 0
         destinationNode.on('message', () => {
             receivedMessages += 1
         })
         const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
 
-        for (let i = 0; i < numOfMessages; i++) {
+        for (let i = 0; i < messageCount; i++) {
             const message: Message = {
                 serviceId: 'unknown',
                 messageId: v4(),
-                messageType: MessageType.RPC,
                 body: {
                     oneofKind: 'rpcMessage',
                     rpcMessage: rpcWrapper
@@ -113,53 +106,34 @@ describe('Route Message With Mock Connections', () => {
             }
             sourceNode.router!.doRouteMessage({
                 message,
-                destinationPeer: destinationNode.getLocalPeerDescriptor(),
+                target: destinationNode.getLocalPeerDescriptor().nodeId,
                 requestId: v4(),
                 sourcePeer: sourceNode.getLocalPeerDescriptor(),
                 reachableThrough: [],
-                routingPath: []
+                routingPath: [],
+                parallelRootNodeIds: []
             })
         }
-        await waitForCondition(() => receivedMessages === numOfMessages)
+        await waitForCondition(() => receivedMessages === messageCount)
     })
 
     it('From all to all', async () => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        for (const i in routerNodes) {
-            const arr: Array<number> = []
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            for (const j in routerNodes) {
-                arr.push(0)
-            }
-            receiveMatrix.push(arr)
-        }
-
-        const numsOfReceivedMessages: Record<string, number> = {}
+        const receivedMessageCounts: Record<DhtAddress, number> = {}
         routerNodes.forEach((node) => {
-            numsOfReceivedMessages[node.getNodeId().toKey()] = 0
-            node.on('message', (msg: Message) => {
-                numsOfReceivedMessages[node.getNodeId().toKey()] = numsOfReceivedMessages[node.getNodeId().toKey()] + 1
-                try {
-                    const target = receiveMatrix[parseInt(node.getNodeId().toString()) - 1]
-                    target[parseInt(PeerID.fromValue(msg.sourceDescriptor!.kademliaId).toString()) - 1]++
-                } catch (e) {
-                    console.error(e)
-                }
-                if (parseInt(node.getNodeId().toString()) > routerNodes.length || parseInt(node.getNodeId().toString()) === 0) {
-                    console.error(node.getNodeId().toString())
-                }
+            const key = node.getNodeId()
+            receivedMessageCounts[key] = 0
+            node.on('message', () => {
+                receivedMessageCounts[key] = receivedMessageCounts[key] + 1
             })
-        }
-        )
+        })
         await Promise.all(
             routerNodes.map(async (node) =>
                 Promise.all(routerNodes.map(async (receiver) => {
-                    if (!node.getNodeId().equals(receiver.getNodeId())) {
+                    if (node.getNodeId() !== receiver.getNodeId()) {
                         const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
                         const message: Message = {
                             serviceId: 'nonexisting_service',
                             messageId: v4(),
-                            messageType: MessageType.RPC,
                             body: {
                                 oneofKind: 'rpcMessage',
                                 rpcMessage: rpcWrapper
@@ -169,21 +143,21 @@ describe('Route Message With Mock Connections', () => {
                         }
                         node.router!.doRouteMessage({
                             message,
-                            destinationPeer: receiver.getLocalPeerDescriptor(),
+                            target: receiver.getLocalPeerDescriptor().nodeId,
                             sourcePeer: node.getLocalPeerDescriptor(),
                             requestId: v4(),
                             reachableThrough: [],
-                            routingPath: []
+                            routingPath: [],
+                            parallelRootNodeIds: []
                         })
                     }
                 }))
             )
         )
-        await waitForCondition(() => numsOfReceivedMessages[PeerID.fromString('1').toKey()] >= routerNodes.length - 1
-            , 30000)
+        await waitForCondition(() => receivedMessageCounts[routerNodes[0].getNodeId()] >= routerNodes.length - 1, 30000)
         await Promise.all(
-            Object.keys(numsOfReceivedMessages).map(async (key) =>
-                waitForCondition(() => numsOfReceivedMessages[key] >= routerNodes.length - 1, 30000)
+            Object.keys(receivedMessageCounts).map(async (key) =>
+                waitForCondition(() => receivedMessageCounts[key as DhtAddress] >= routerNodes.length - 1, 30000)
             )
         )
 
@@ -194,22 +168,22 @@ describe('Route Message With Mock Connections', () => {
         const closestPeersRequestMessage: Message = {
             serviceId: 'unknown',
             messageId: v4(),
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: closestPeersRequest
             },
-            sourceDescriptor: sourceNode.getLocalPeerDescriptor()!,
-            targetDescriptor: destinationNode.getLocalPeerDescriptor()!
+            sourceDescriptor: sourceNode.getLocalPeerDescriptor(),
+            targetDescriptor: destinationNode.getLocalPeerDescriptor()
         }
 
         const routeMessageWrapper: RouteMessageWrapper = {
             message: closestPeersRequestMessage,
-            destinationPeer: destinationNode.getLocalPeerDescriptor(),
+            target: destinationNode.getLocalPeerDescriptor().nodeId,
             requestId: v4(),
             sourcePeer: sourceNode.getLocalPeerDescriptor(),
             reachableThrough: [entryPointDescriptor],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         }
 
         const rpcMessage: RpcMessage = {
@@ -224,22 +198,22 @@ describe('Route Message With Mock Connections', () => {
         const requestMessage: Message = {
             serviceId: 'layer0',
             messageId: v4(),
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage
             },
-            sourceDescriptor: sourceNode.getLocalPeerDescriptor()!,
-            targetDescriptor: entryPoint.getLocalPeerDescriptor()!
+            sourceDescriptor: sourceNode.getLocalPeerDescriptor(),
+            targetDescriptor: entryPoint.getLocalPeerDescriptor()
         }
 
         const forwardedMessage: RouteMessageWrapper = {
             message: requestMessage,
             requestId: v4(),
             sourcePeer: sourceNode.getLocalPeerDescriptor(),
-            destinationPeer: entryPoint.getLocalPeerDescriptor()!,
+            target: entryPoint.getLocalPeerDescriptor().nodeId,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         }
 
         await runAndWaitForEvents3<DhtNodeEvents>([() => {

package/test/integration/RouterRpcRemote.test.ts

@@ -1,24 +1,20 @@
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import { RouterRpcRemote } from '../../src/dht/routing/RouterRpcRemote'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RouterRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { createWrappedClosestPeersRequest, generateId, mockRouterRpc } from '../utils/utils'
+import { createMockPeerDescriptor, createWrappedClosestPeersRequest, mockRouterRpc } from '../utils/utils'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+
+const SERVICE_ID = 'test'
 
 describe('RemoteRouter', () => {
 
     let remoteRouter: RouterRpcRemote
-    let clientRpcCommunicator: RpcCommunicator
-    let serverRpcCommunicator: RpcCommunicator
-    const serviceId = 'test'
-    const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('client'),
-        type: NodeType.NODEJS
-    }
-    const serverPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('server'),
-        type: NodeType.NODEJS
-    }
+    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
+    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
+    const clientPeerDescriptor = createMockPeerDescriptor()
+    const serverPeerDescriptor = createMockPeerDescriptor()
 
     beforeEach(() => {
         clientRpcCommunicator = new RpcCommunicator()
@@ -30,16 +26,14 @@ describe('RemoteRouter', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new RouterRpcClient(clientRpcCommunicator.getRpcClientTransport()))
-        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
+        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, RouterRpcClient)
     })
 
     it('routeMessage happy path', async () => {
         const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor)
         const routed: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageId: 'routed',
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper
@@ -49,9 +43,10 @@ describe('RemoteRouter', () => {
             requestId: 'routed',
             message: routed,
             sourcePeer: clientPeerDescriptor,
-            destinationPeer: serverPeerDescriptor,
+            target: serverPeerDescriptor.nodeId,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         })
         expect(routable).toEqual(true)
     })
@@ -60,9 +55,8 @@ describe('RemoteRouter', () => {
         serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', mockRouterRpc.throwRouteMessageError)
         const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor)
         const routed: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageId: 'routed',
-            messageType: MessageType.RPC,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: rpcWrapper
@@ -72,9 +66,10 @@ describe('RemoteRouter', () => {
             requestId: 'routed',
             message: routed,
             sourcePeer: clientPeerDescriptor,
-            destinationPeer: serverPeerDescriptor,
+            target: serverPeerDescriptor.nodeId,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         })
         expect(routable).toEqual(false)
     })

package/test/integration/ScaleDownDht.test.ts

@@ -2,35 +2,37 @@ import { LatencyType, 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'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
+import { getRandomRegion } from '../../src/connection/simulator/pings'
+import { areEqualPeerDescriptors, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
+const NUM_NODES = 80
+const MAX_CONNECTIONS = 15
+const K = 2
+
 describe('Scaling down a Dht network', () => {
+
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.REAL)
-    const NUM_NODES = 80
-    const MAX_CONNECTIONS = 15
-    const K = 2
 
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            undefined, K, MAX_CONNECTIONS)
+        entryPoint = await createMockConnectionDhtNode(simulator,
+            createRandomDhtAddress(), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
 
         entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
+            nodeId: getRawFromDhtAddress(entryPoint.getNodeId()),
+            type: NodeType.NODEJS,
+            region: getRandomRegion()
         }
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, MAX_CONNECTIONS)
+            const node = await createMockConnectionDhtNode(simulator, undefined, K, MAX_CONNECTIONS)
             nodes.push(node)
         }
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
@@ -52,7 +54,7 @@ describe('Scaling down a Dht network', () => {
             const stoppingPeerDescriptor = nodes[nodeIndex].getLocalPeerDescriptor()
             await nodes[nodeIndex].stop()
             const nodeIsCleaned = nodes.every((node) =>
-                node.getAllConnectionPeerDescriptors().every((peer) => {
+                node.getConnections().every((peer) => {
                     if (areEqualPeerDescriptors(peer, stoppingPeerDescriptor)) {
                         logger.error(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 
                             + getNodeIdFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')