@streamr/trackerless-network 0.0.1-tatum.0

package/test/integration/Inspect.test.ts

@@ -0,0 +1,102 @@
+import { LatencyType, NodeType, PeerDescriptor, PeerID, Simulator, SimulatorTransport } from '@streamr/dht'
+import { NetworkStack } from '../../src/NetworkStack'
+import { range } from 'lodash'
+import { createStreamMessage } from '../utils/utils'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+
+describe('inspect', () => {
+
+    let simulator: Simulator
+
+    const streamId = 'stream#0'
+    let sequenceNumber: number
+
+    const publisherDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('publisher').value,
+        type: NodeType.NODEJS,
+    }
+
+    const inspectorPeerDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('inspector').value,
+        type: NodeType.NODEJS,
+    }
+
+    const inspectedNodeCount = 12
+
+    let publisherNode: NetworkStack
+    let inspectorNode: NetworkStack
+    let inspectedNodes: NetworkStack[]
+
+    let publishInterval: NodeJS.Timeout
+
+    const initiateNode = async (peerDescriptor: PeerDescriptor, simulator: Simulator): Promise<NetworkStack> => {
+        const transportLayer = new SimulatorTransport(peerDescriptor, simulator)
+        const node = new NetworkStack({
+            layer0: {
+                entryPoints: [publisherDescriptor],
+                peerDescriptor,
+                transportLayer
+            },
+            networkNode: {}
+        })
+        await node.start()
+        return node
+    }
+
+    beforeEach(async () => {
+        Simulator.useFakeTimers()
+        simulator = new Simulator(LatencyType.RANDOM)
+
+        publisherNode = await initiateNode(publisherDescriptor, simulator)
+        inspectorNode = await initiateNode(inspectorPeerDescriptor, simulator)
+
+        inspectedNodes = []
+        await Promise.all(range(inspectedNodeCount).map(async (i) => {
+            const peerDescriptor: PeerDescriptor = {
+                kademliaId: PeerID.fromString(`inspected${i}`).value,
+                type: NodeType.NODEJS
+            }
+            const node = await initiateNode(peerDescriptor, simulator)
+            inspectedNodes.push(node)
+        }))
+        await Promise.all([
+            publisherNode.getStreamrNode().waitForJoinAndSubscribe(streamId, 5000, 4),
+            inspectorNode.getStreamrNode().waitForJoinAndSubscribe(streamId, 5000, 4),
+            ...inspectedNodes.map((node) => node.getStreamrNode().waitForJoinAndSubscribe(streamId, 5000, 4))
+        ])
+        sequenceNumber = 0
+    }, 30000)
+
+    afterEach(async () => {
+        clearInterval(publishInterval)
+        await Promise.all([
+            publisherNode.stop(),
+            inspectorNode.stop(),
+            ...inspectedNodes.map((node) => node.stop())
+        ])
+        Simulator.useFakeTimers(false)
+    })
+
+    it('gets successful inspections from all suspects', async () => {
+        publishInterval = setInterval(async () => {
+            const content: ContentMessage = {
+                body: JSON.stringify({ hello: 'WORLD' })
+            }
+            const msg = createStreamMessage(
+                content,
+                'stream',
+                'publisher',
+                123123,
+                sequenceNumber
+            )
+            await publisherNode.getStreamrNode().publishToStream(streamId, msg)
+            sequenceNumber += 1
+        }, 200)
+
+        for (const node of inspectedNodes) {
+            const result = await inspectorNode.getStreamrNode().inspect(node.getLayer0DhtNode().getPeerDescriptor(), streamId)
+            expect(result).toEqual(true)
+        }
+    }, 25000)
+
+})

package/test/integration/NetworkNode.test.ts

@@ -0,0 +1,99 @@
+import { NetworkNode } from '../../src/NetworkNode'
+import { NodeType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+import {
+    MessageID,
+    MessageRef,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartIDUtils,
+    toStreamID
+} from '@streamr/protocol'
+import { EthereumAddress, waitForCondition } from '@streamr/utils'
+
+describe('NetworkNode', () => {
+
+    let transport1: SimulatorTransport
+    let transport2: SimulatorTransport
+
+    let node1: NetworkNode
+    let node2: NetworkNode
+
+    const pd1: PeerDescriptor = {
+        kademliaId: new Uint8Array([1, 2, 3]),
+        type: NodeType.NODEJS
+    }
+
+    const pd2: PeerDescriptor = {
+        kademliaId: new Uint8Array([1, 1, 1]),
+        type: NodeType.NODEJS
+    }
+
+    const STREAM_ID = StreamPartIDUtils.parse('test#0')
+
+    beforeEach(async () => {
+        Simulator.useFakeTimers()
+        const simulator = new Simulator()
+        transport1 = new SimulatorTransport(pd1, simulator)
+        transport2 = new SimulatorTransport(pd2, simulator)
+
+        node1 = new NetworkNode({
+            layer0: {
+                entryPoints: [pd1],
+                peerDescriptor: pd1,
+                transportLayer: transport1
+            },
+            networkNode: {}
+        })
+        node2 = new NetworkNode({
+            layer0: {
+                entryPoints: [pd1],
+                peerDescriptor: pd2,
+                transportLayer: transport2
+            },
+            networkNode: {}
+        })
+
+        await node1.start()
+        node1.setStreamPartEntryPoints(STREAM_ID, [pd1])
+        await node2.start()
+        node2.setStreamPartEntryPoints(STREAM_ID, [pd1])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            node1.stop(),
+            node2.stop()
+        ])
+        Simulator.useFakeTimers(false)
+    })
+
+    it('wait for join + publish and subscribe', async () => {
+        const streamMessage = new StreamMessage({
+            messageId: new MessageID(
+                toStreamID('test'),
+                0,
+                666,
+                0,
+                'peer2' as EthereumAddress,
+                'msgChainId'
+            ),
+            prevMsgRef: new MessageRef(665, 0),
+            content: {
+                hello: 'world'
+            },
+            messageType: StreamMessageType.MESSAGE,
+            signature: 'signature',
+        })
+
+        let msgCount = 0
+        await node1.subscribeAndWaitForJoin(STREAM_ID)
+        node1.addMessageListener((msg) => {
+            expect(msg.messageId.timestamp).toEqual(666)
+            expect(msg.getSequenceNumber()).toEqual(0)
+            msgCount += 1
+        })
+        await node2.waitForJoinAndPublish(streamMessage)
+        await waitForCondition(() => msgCount === 1)
+    })
+
+})

package/test/integration/NetworkRpc.test.ts

@@ -0,0 +1,61 @@
+import {
+    RpcCommunicator,
+    ProtoCallContext,
+    ProtoRpcClient,
+    toProtoRpcClient
+} from '@streamr/proto-rpc'
+import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import {
+    StreamMessage,
+    ContentMessage
+} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { waitForCondition } from '@streamr/utils'
+import { Empty } from '../../src/proto/google/protobuf/empty'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { createStreamMessage } from '../utils/utils'
+import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Simulator } from '@streamr/dht'
+
+describe('Network RPC', () => {
+    let rpcCommunicator1: RpcCommunicator
+    let rpcCommunicator2: RpcCommunicator
+    let client: ProtoRpcClient<NetworkRpcClient>
+    let recvCounter = 0
+
+    beforeEach(() => {
+        Simulator.useFakeTimers()
+        rpcCommunicator1 = new RpcCommunicator()
+        rpcCommunicator2 = new RpcCommunicator()
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: ProtoCallContext) => {
+            rpcCommunicator2.handleIncomingMessage(message)
+        })
+        client = toProtoRpcClient(new NetworkRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        rpcCommunicator2.registerRpcNotification(
+            StreamMessage,
+            'sendData',
+            async (_msg: StreamMessage, _context: ServerCallContext): Promise<Empty> => {
+                recvCounter += 1
+                return {}
+            }
+        )
+    })
+
+    afterEach(() => {
+        rpcCommunicator1.stop()
+        rpcCommunicator2.stop()
+        Simulator.useFakeTimers(false)
+    })
+
+    it('sends Data', async () => {
+        const content: ContentMessage = {
+            body: JSON.stringify({ hello: 'WORLD' })
+        }
+        const msg = createStreamMessage(
+            content,
+            'testStream',
+            'peer1'
+        )
+        await client.sendData(msg)
+        await waitForCondition(() => recvCounter === 1)
+    })
+})

package/test/integration/NetworkStack.test.ts

@@ -0,0 +1,74 @@
+import { NetworkStack } from '../../src/NetworkStack'
+import { NodeType, PeerDescriptor, PeerID } from '@streamr/dht'
+import {
+    StreamPartIDUtils,
+    toStreamID,
+} from '@streamr/protocol'
+import { waitForCondition } from '@streamr/utils'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { createStreamMessage } from '../utils/utils'
+
+describe('NetworkStack', () => {
+
+    let stack1: NetworkStack
+    let stack2: NetworkStack
+    const streamPartId = StreamPartIDUtils.parse('stream1#0')
+
+    const epDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('entrypoint').value,
+        type: NodeType.NODEJS,
+        websocket: { ip: 'localhost', port: 32222 },
+        nodeName: 'entrypoint'
+    }
+
+    beforeEach(async () => {
+        stack1 = new NetworkStack({
+            layer0: {
+                peerDescriptor: epDescriptor,
+                entryPoints: [epDescriptor],
+                nodeName: 'entrypoint'
+            },
+            networkNode: {}
+        })
+        stack2 = new NetworkStack({
+            layer0: {
+                webSocketPort: 32223,
+                peerIdString: 'network-stack',
+                entryPoints: [epDescriptor],
+                nodeName: 'node2'
+            },
+            networkNode: {}
+        })
+
+        await stack1.start()
+        stack1.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epDescriptor])
+        await stack2.start()
+        stack2.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epDescriptor])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            stack1.stop(),
+            stack2.stop()
+        ])
+    })
+
+    it('Can use NetworkNode pub/sub via NetworkStack', async () => {
+        let receivedMessages = 0
+        await stack1.getStreamrNode().waitForJoinAndSubscribe(streamPartId)
+        stack1.getStreamrNode().on('newMessage', () => {
+            receivedMessages += 1
+        })
+        const content: ContentMessage = {
+            body: JSON.stringify({ hello: 'WORLD' })
+        }
+        const msg = createStreamMessage(
+            content,
+            toStreamID(streamPartId),
+            PeerID.fromString('network-stack').toKey()
+        )
+        await stack2.getStreamrNode().waitForJoinAndPublish(streamPartId, msg)
+        await waitForCondition(() => receivedMessages === 1)
+    })
+
+})

package/test/integration/NetworkStackStoppedDuringStart.test.ts

@@ -0,0 +1,45 @@
+import { PeerID } from '@streamr/dht'
+import { NetworkStack } from '../../src/NetworkStack'
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+describe('NetworkStack can be stopped during start', () => {
+    
+    const epDescriptor = {
+        kademliaId: PeerID.fromString('entrypoint').value,
+        type: NodeType.NODEJS,
+        websocket: { ip: 'localhost', port: 32224 },
+    }
+    let entryPoint: NetworkStack
+    let peer: NetworkStack
+
+    beforeEach(async () => {
+        entryPoint = new NetworkStack({
+            layer0: {
+                peerDescriptor: epDescriptor,
+                entryPoints: [epDescriptor]
+            },
+            networkNode: {}
+        })
+        peer = new NetworkStack({
+            layer0: {
+                peerDescriptor: {
+                    kademliaId: PeerID.fromString('peer').value,
+                    type: NodeType.NODEJS
+                },
+                entryPoints: [epDescriptor]
+            },
+            networkNode: {}
+        })
+        await entryPoint.start()
+    })
+    
+    afterEach(async () => {
+        await entryPoint.stop()
+    })
+
+    it('Can be stopped during start', async () => {
+        setImmediate(() => peer.stop())
+        await peer.start()
+    })
+
+})

package/test/integration/Propagation.test.ts

@@ -0,0 +1,79 @@
+import { DhtNode, PeerDescriptor, Simulator, PeerID, UUID, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { createMockRandomGraphNodeAndDhtNode, createStreamMessage } from '../utils/utils'
+import { range } from 'lodash'
+import { ContentMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { waitForCondition } from '@streamr/utils'
+
+describe('Propagation', () => {
+    const entryPointDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`entrypoint`).value,
+        type: 1
+    }
+    let dhtNodes: DhtNode[]
+    let randomGraphNodes: RandomGraphNode[]
+    const STREAM_ID = 'testingtesting'
+    let totalReceived: number
+    const NUM_OF_NODES = 256
+
+    beforeEach(async () => {
+        totalReceived = 0
+        const simulator = new Simulator()
+        dhtNodes = []
+        randomGraphNodes = []
+        const [entryPoint, node1] = createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_ID, simulator)
+        await entryPoint.start()
+        await entryPoint.joinDht([entryPointDescriptor])
+        await node1.start()
+        node1.on('message', () => {totalReceived += 1})
+        dhtNodes.push(entryPoint)
+        randomGraphNodes.push(node1)
+
+        await Promise.all(range(NUM_OF_NODES).map(async (_i) => {
+            const descriptor: PeerDescriptor = {
+                kademliaId: PeerID.fromString(new UUID().toString()).value,
+                type: 1
+            }
+            const [dht, graph] = createMockRandomGraphNodeAndDhtNode(
+                descriptor,
+                entryPointDescriptor,
+                STREAM_ID,
+                simulator
+            )
+            await dht.start()
+            await graph.start()
+            await dht.joinDht([entryPointDescriptor]).then(() => {
+                graph.on('message', () => { totalReceived += 1 })
+                dhtNodes.push(dht)
+                randomGraphNodes.push(graph)
+            })
+        }))
+    }, 45000)
+
+    afterEach(async () => {
+        await Promise.all(randomGraphNodes.map((node) => node.stop()))
+        await Promise.all(dhtNodes.map((node) => node.stop()))
+    })
+
+    it('All nodes receive messages', async () => {
+        await waitForCondition(
+            () => randomGraphNodes.every((peer) => peer.getTargetNeighborStringIds().length >= 3), 30000
+        )
+        await waitForCondition(() => {
+            const avg = randomGraphNodes.reduce((acc, curr) => {
+                return acc + curr.getTargetNeighborStringIds().length
+            }, 0) / randomGraphNodes.length
+            return avg >= 4
+        }, 20000)
+        const content: ContentMessage = {
+            body: JSON.stringify({ hello: 'WORLD' })
+        }
+        const msg = createStreamMessage(
+            content,
+            STREAM_ID,
+            peerIdFromPeerDescriptor(dhtNodes[0].getPeerDescriptor()).toString()
+        )
+        randomGraphNodes[0].broadcast(msg)
+        await waitForCondition(() => totalReceived >= NUM_OF_NODES, 10000)
+    }, 45000)
+})

package/test/integration/RandomGraphNode-Layer1Node-Latencies.test.ts

@@ -0,0 +1,141 @@
+import { DhtNode, Simulator, SimulatorTransport, PeerDescriptor, PeerID, LatencyType } from '@streamr/dht'
+import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { range } from 'lodash'
+import { wait, waitForCondition } from '@streamr/utils'
+import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
+
+describe('RandomGraphNode-DhtNode-Latencies', () => {
+    const numOfNodes = 64
+    let dhtNodes: DhtNode[]
+    let dhtEntryPoint: DhtNode
+    let entryPointRandomGraphNode: RandomGraphNode
+    let graphNodes: RandomGraphNode[]
+
+    const streamId = 'Stream1'
+    const entrypointDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('entrypoint').value,
+        type: 0
+    }
+
+    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map((i) => {
+        return {
+            kademliaId: PeerID.fromString(`${i}`).value,
+            type: 0
+        }
+    })
+    beforeEach(async () => {
+        Simulator.useFakeTimers()
+        const simulator = new Simulator(LatencyType.FIXED, 50)
+        const entrypointCm = new SimulatorTransport(entrypointDescriptor, simulator)
+        const cms: SimulatorTransport[] = range(numOfNodes).map((i) =>
+            new SimulatorTransport(peerDescriptors[i], simulator)
+        )
+
+        dhtEntryPoint = new DhtNode({
+            transportLayer: entrypointCm,
+            peerDescriptor: entrypointDescriptor,
+            serviceId: streamId
+        })
+        dhtNodes = range(numOfNodes).map((i) => new DhtNode({
+            transportLayer: cms[i],
+            peerDescriptor: peerDescriptors[i],
+            serviceId: streamId
+        }))
+        graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
+            randomGraphId: streamId,
+            layer1: dhtNodes[i],
+            P2PTransport: cms[i],
+            connectionLocker: cms[i],
+            ownPeerDescriptor: peerDescriptors[i]
+        }))
+        entryPointRandomGraphNode = createRandomGraphNode({
+            randomGraphId: streamId,
+            layer1: dhtEntryPoint,
+            P2PTransport: entrypointCm,
+            connectionLocker: entrypointCm,
+            ownPeerDescriptor: entrypointDescriptor
+        })
+
+        await dhtEntryPoint.start()
+        await dhtEntryPoint.joinDht([entrypointDescriptor])
+        await Promise.all(dhtNodes.map((node) => node.start()))
+    })
+
+    afterEach(async () => {
+        dhtEntryPoint.stop()
+        entryPointRandomGraphNode.stop()
+        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(graphNodes.map((node) => node.stop()))
+        Simulator.useFakeTimers(false)
+    })
+
+    it('happy path single peer', async () => {
+        await dhtNodes[0].joinDht([entrypointDescriptor])
+        entryPointRandomGraphNode.start()
+        await graphNodes[0].start()
+        await Promise.all([
+            waitForCondition(() => graphNodes[0].getNearbyContactPoolIds().length === 1),
+            waitForCondition(() => graphNodes[0].getTargetNeighborStringIds().length === 1)
+        ])
+        expect(graphNodes[0].getNearbyContactPoolIds().length).toEqual(1)
+        expect(graphNodes[0].getTargetNeighborStringIds().length).toEqual(1)
+    })
+
+    it('happy path 5 peers', async () => {
+        entryPointRandomGraphNode.start()
+        range(4).map((i) => graphNodes[i].start())
+        await Promise.all(range(4).map(async (i) => {
+            await dhtNodes[i].joinDht([entrypointDescriptor])
+        }))
+        await Promise.all(range(4).map((i) => {
+            return waitForCondition(() => {
+                return graphNodes[i].getTargetNeighborStringIds().length >= 4
+            }, 10000, 2000)
+        }))
+        range(4).map((i) => {
+            expect(graphNodes[i].getNearbyContactPoolIds().length).toBeGreaterThanOrEqual(4)
+            expect(graphNodes[i].getTargetNeighborStringIds().length).toBeGreaterThanOrEqual(4)
+        })
+        // Check bidirectionality
+        const allNodes = graphNodes
+        allNodes.push(entryPointRandomGraphNode)
+        range(5).map((i) => {
+            const nodeId = allNodes[i].getOwnStringId()
+            allNodes[i].getNearbyContactPoolIds().forEach((stringId) => {
+                const neighbor = allNodes.find((peer) => {
+                    return peer.getOwnStringId() === stringId
+                })
+                expect(neighbor!.getTargetNeighborStringIds()).toContain(nodeId)
+            })
+        })
+    }, 60000)
+
+    it('happy path 64 peers', async () => {
+        await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
+        await Promise.all(range(numOfNodes).map((i) => {
+            dhtNodes[i].joinDht([entrypointDescriptor])
+        }))
+        await Promise.all(graphNodes.map((node) =>
+            waitForCondition(() => node.getTargetNeighborStringIds().length >= 4, 10000)
+        ))
+
+        await Promise.all(graphNodes.map((node) =>
+            waitForCondition(() => node.getNumberOfOutgoingHandshakes() === 0)
+        ))
+
+        await wait(20000)
+        let mismatchCounter = 0
+        graphNodes.forEach((node) => {
+            const nodeId = node.getOwnStringId()
+            node.getTargetNeighborStringIds().forEach((neighborId) => {
+                if (neighborId !== entryPointRandomGraphNode.getOwnStringId()) {
+                    const neighbor = graphNodes.find((n) => n.getOwnStringId() === neighborId)
+                    if (!neighbor!.getTargetNeighborStringIds().includes(nodeId)) {
+                        mismatchCounter += 1
+                    }
+                }
+            })
+        })
+        expect(mismatchCounter).toBeLessThanOrEqual(2)
+    }, 90000)
+})