@streamr/dht 100.2.2 → 100.2.4-beta.0

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)