@streamr/dht 100.2.1 → 100.2.3

package/test/utils/FakeTransport.ts

@@ -1,11 +1,16 @@
 import { EventEmitter } from 'eventemitter3'
-import { ITransport, TransportEvents } from '../../src/transport/ITransport'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../../src/transport/ITransport'
 
 class FakeTransport extends EventEmitter<TransportEvents> implements ITransport {
 
     private onSend: (msg: Message) => void
     private readonly localPeerDescriptor: PeerDescriptor
+    // currently adds a peerDescription to the connections array when a "connect" option is seen in
+    // in send() call and never disconnects (TODO could add some disconnection logic? and maybe
+    // the connection should be seen by another FakeTransport instance, too?)
+    private connections: PeerDescriptor[] = []
 
     constructor(peerDescriptor: PeerDescriptor, onSend: (msg: Message) => void) {
         super()
@@ -13,19 +18,37 @@ class FakeTransport extends EventEmitter<TransportEvents> implements ITransport
         this.localPeerDescriptor = peerDescriptor
     }
 
-    async send(msg: Message): Promise<void> {
+    async send(msg: Message, opts?: SendOptions): Promise<void> {
+        const connect = opts?.connect ?? DEFAULT_SEND_OPTIONS.connect
+        const targetNodeId = getNodeIdFromPeerDescriptor(msg.targetDescriptor!)
+        if (connect && !this.connections.some((c) => getNodeIdFromPeerDescriptor(c) === targetNodeId)) {
+            this.connect(msg.targetDescriptor!)
+        }
         msg.sourceDescriptor = this.localPeerDescriptor
         this.onSend(msg)
     }
 
-    // eslint-disable-next-line class-methods-use-this
     getLocalPeerDescriptor(): PeerDescriptor {
-        throw new Error('not implemented')
+        return this.localPeerDescriptor
+    }
+
+    private connect(peerDescriptor: PeerDescriptor) {
+        this.connections.push(peerDescriptor)
+        this.emit('connected', peerDescriptor)
     }
 
-    // eslint-disable-next-line class-methods-use-this
     getConnections(): PeerDescriptor[] {
-        throw new Error('not implemented')
+        return this.connections
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getConnectionCount(): number {
+        return this.connections.length
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasConnection(nodeId: DhtAddress): boolean {
+        return this.connections.some((c) => getNodeIdFromPeerDescriptor(c) === nodeId)
     }
 
     // eslint-disable-next-line class-methods-use-this
@@ -39,7 +62,11 @@ export class FakeEnvironment {
 
     createTransport(peerDescriptor: PeerDescriptor): ITransport {
         const transport = new FakeTransport(peerDescriptor, (msg) => {
-            this.transports.forEach((t) => t.emit('message', msg))
+            const targetNode = getDhtAddressFromRaw(msg.targetDescriptor!.nodeId)
+            const targetTransport = this.transports.find((t) => getNodeIdFromPeerDescriptor(t.getLocalPeerDescriptor()) === targetNode)
+            if (targetTransport !== undefined) {
+                targetTransport.emit('message', msg)
+            }
         })
         this.transports.push(transport)
         return transport

package/test/utils/mock/Router.ts

@@ -6,17 +6,14 @@ export class MockRouter implements Methods<Router> {
 
     // eslint-disable-next-line class-methods-use-this
     addRoutingSession(): void {
-        return
     }
 
     // eslint-disable-next-line class-methods-use-this
     removeRoutingSession(): void {
-        return
     }
 
     // eslint-disable-next-line class-methods-use-this
     addToDuplicateDetector(): void {
-        return
     }
 
     // eslint-disable-next-line class-methods-use-this

package/test/utils/mock/Transport.ts

@@ -19,6 +19,16 @@ export class MockTransport extends EventEmitter<TransportEvents> implements ITra
         return []
     }
 
+    // eslint-disable-next-line class-methods-use-this
+    getConnectionCount(): number {
+        return 0
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasConnection(): boolean {
+        return false
+    }
+
     // eslint-disable-next-line class-methods-use-this
     stop(): void {
 

package/test/utils/topology.ts

@@ -0,0 +1,80 @@
+import { Multimap } from '@streamr/utils'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { minBy, range, without } from 'lodash'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { getDistance } from '../../src/dht/PeerManager'
+
+export const getTopologyPartitions = (topology: Multimap<DhtAddress, DhtAddress>): Set<DhtAddress>[] => {
+    let partitions: Set<DhtAddress>[] = []
+    for (const nodeId of topology.keys()) {
+        const neighbors = topology.get(nodeId)
+        const existingPartition = partitions.find((partition) => partition.has(nodeId))
+        if (existingPartition !== undefined) {
+            for (const neighbor of neighbors) {
+                if (!existingPartition.has(neighbor)) {
+                    const otherPartition = partitions.find((partition) => partition.has(neighbor))
+                    if (otherPartition !== undefined) {
+                        for (const otherNode of otherPartition) {
+                            existingPartition.add(otherNode)
+                        }
+                        partitions = without(partitions, otherPartition)
+                    } else {
+                        existingPartition.add(neighbor)
+                    }
+                }
+            }
+        } else {
+            const partition = new Set([nodeId, ...neighbors])
+            partitions.push(partition)
+        }
+    }
+    return partitions
+}
+
+const getClosestNodes = (referenceId: DhtAddress, nodeIds: DhtAddress[], count: number, allowToContainReferenceId: boolean): DhtAddress[] => {
+    const list = new SortedContactList({
+        referenceId,
+        allowToContainReferenceId,
+        maxSize: count
+    })
+    list.addContacts(nodeIds.map((n) => ({ getNodeId: () => n })))
+    return list.getClosestContacts().map((c) => c.getNodeId())
+}
+
+/* 
+ * There are no network splits, and each node has only neighbors which are globally closest
+ * to the node's ID.
+ */
+export const createTestTopology = (nodeCount: number, minNeighorCount: number): Multimap<DhtAddress, DhtAddress> => {
+    const topology: Multimap<DhtAddress, DhtAddress> = new Multimap()
+    const nodeIds = range(nodeCount).map(() => createRandomDhtAddress())
+    for (const nodeId of nodeIds) {
+        const closestNodes = getClosestNodes(nodeId, nodeIds, minNeighorCount, false)
+        for (const closestNode of closestNodes) {
+            if (!topology.has(nodeId, closestNode)) {
+                topology.add(nodeId, closestNode)
+            }
+            if (!topology.has(closestNode, nodeId)) {
+                topology.add(closestNode, nodeId)
+            }
+        }
+    }
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const partitions = getTopologyPartitions(topology)
+        if (partitions.length === 1) {
+            break
+        } else {
+            const closestPairs = nodeIds.map((nodeId: DhtAddress) => {
+                const ownPartition = partitions.find((partition) => partition.has(nodeId))!
+                const otherNodes = without(nodeIds, ...[...ownPartition])
+                const closestNodedId = getClosestNodes(nodeId, otherNodes, 1, false)[0]
+                return [nodeId, closestNodedId]
+            })
+            const mergePair = minBy(closestPairs, (pair) => getDistance(getRawFromDhtAddress(pair[0]), getRawFromDhtAddress(pair[1])))!
+            topology.add(mergePair[0], mergePair[1])
+            topology.add(mergePair[1], mergePair[0])
+        }
+    }
+    return topology
+}

package/test/RandomGraphSimulation.ts

@@ -1,53 +0,0 @@
-/* eslint-disable no-console */
-
-import KBucket from 'k-bucket'
-import { range } from 'lodash'
-import { DhtAddressRaw } from '../src/identifiers'
-
-const compareIds = (id1: DhtAddressRaw, id2: DhtAddressRaw) => {
-    const sorted = [id1, id2].sort()
-    return KBucket.distance(sorted[0], sorted[1])
-}
-
-const generateIDs = (count: number): DhtAddressRaw[] => {
-    return range(count).map((i) => new Uint8Array([i, 1, 1]))
-}
-
-const count = 9
-const ids = generateIDs(count)
-
-const distances = ids.map((id1) => ids.map((id2) => {
-    return {
-        distance: compareIds(id1, id2),
-        id: id2.toString()
-    }
-}))
-
-const graph: any[] = []
-for (let i = 0; i < count; i++) {
-    const sorted = distances[i].sort((a, b) => a.distance - b.distance)
-    graph.push([sorted[1], sorted[2], sorted[3], sorted[4]])
-}
-const result = new Map<string, number>()
-ids.forEach((key) => {
-    result.set(key.toString(), 0)
-})
-
-for (let i = 0; i < count; i++) {
-    graph[i].forEach((val: any) => {
-        result.set(val.id, result.get(val.id)! + 1)
-    })
-}
-
-const bidirectional = ids.map((id, i) => {
-    const stringId = id.toString()
-    const allFound = graph[i].some((obj: any) => {
-        const neighborId = obj.id
-        const neighborIndex = parseInt(neighborId.split(',')[0])
-        return graph[neighborIndex].some((obj: any) => obj.id === stringId)
-    })
-    return allFound
-})
-
-console.log(bidirectional)
-console.log(graph)