status-im
/
nimbus-eth1
mirror of https://github.com/status-im/nimbus-eth1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Improve the tests of the local testnet (#953) 

* Improve the tests of the local testnet

The local testnet test was rather flaky and would occasionally
fail. It has been made more robust by adding the ENRs directly
to the routing table instead of doing some random lookups.

Additionally, the amount of nodes were increased (=64), ip limits
configuration was added, and the bits-per-hop value was set to 1
in order to make the lookups more likely to hit the network
instead of only the local routing table.

Failure is obviously still possible to happen when sufficient
packets get lost. If this turns out to be the case with the current
amount of nodes, we might have to revise the testing strategy here.

* Disable lookup test for State network

Disable lookup test for State network due to issue with custom
distance function causing the lookup to not always converging
towards the target.
This commit is contained in:
Kim De Mey 2022-02-02 22:48:33 +01:00 committed by GitHub
parent 3e60948785
commit 38036966a6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 150 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
fluffy/fluffy.nim
View File

@ -54,13 +54,17 @@ proc run(config: PortalConf) {.raises: [CatchableError, Defect].} =
loadBootstrapFile(string config.bootstrapNodesFile, bootstrapRecords)
bootstrapRecords.add(config.bootstrapNodes)
let d = newProtocol(
config.networkKey,
extIp, none(Port), extUdpPort,
bootstrapRecords = bootstrapRecords,
bindIp = bindIp, bindPort = udpPort,
enrAutoUpdate = config.enrAutoUpdate,
rng = rng)
let
discoveryConfig = DiscoveryConfig.init(
config.tableIpLimit, config.bucketIpLimit, config.bitsPerHop)
d = newProtocol(
config.networkKey,
extIp, none(Port), extUdpPort,
bootstrapRecords = bootstrapRecords,
bindIp = bindIp, bindPort = udpPort,
enrAutoUpdate = config.enrAutoUpdate,
config = discoveryConfig,
rng = rng)
d.open()

6
fluffy/rpc/rpc_calls/rpc_discovery_calls.nim
View File

@ -3,13 +3,13 @@ proc discv5_routingTableInfo(): RoutingTableInfo
proc discv5_nodeInfo(): NodeInfo
proc discv5_updateNodeInfo(kvPairs: seq[(string, string)]): RoutingTableInfo
proc discv5_setEnr(enr: Record): bool
proc discv5_addEnrs(enrs: seq[Record]): bool
proc discv5_getEnr(nodeId: NodeId): Record
proc discv5_deleteEnr(nodeId: NodeId): bool
proc discv5_lookupEnr(nodeId: NodeId): Record
proc discv5_ping(nodeId: Record): PongResponse
proc discv5_findNodes(nodeId: Record, distances: seq[uint16]): seq[Record]
proc discv5_talk(nodeId: Record, protocol, payload: string): string
proc discv5_findNode(nodeId: Record, distances: seq[uint16]): seq[Record]
proc discv5_talkReq(nodeId: Record, protocol, payload: string): string
proc discv5_recursiveFindNodes(): seq[Record]

24
fluffy/rpc/rpc_calls/rpc_portal_calls.nim
View File

@ -2,10 +2,34 @@
proc portal_state_nodeInfo(): NodeInfo
proc portal_state_routingTableInfo(): RoutingTableInfo
proc portal_state_lookupEnr(nodeId: NodeId): Record
proc portal_state_addEnrs(enrs: seq[Record]): bool
proc portal_state_ping(enr: Record): tuple[
seqNum: uint64, customPayload: string]
proc portal_state_findNodes(enr: Record): seq[Record]
proc portal_state_findContent(enr: Record, contentKey: string): tuple[
connectionId: Option[string],
content: Option[string],
enrs: Option[seq[Record]]]
proc portal_state_findContentExt(enr: Record, contentKey: string): tuple[
content: Option[string],
enrs: Option[seq[Record]]]
proc portal_state_offerExt(enr: Record, contentKey: string): bool
proc portal_state_recursiveFindNodes(): seq[Record]
## Portal History Network json-rpc calls
proc portal_history_nodeInfo(): NodeInfo
proc portal_history_routingTableInfo(): RoutingTableInfo
proc portal_history_lookupEnr(nodeId: NodeId): Record
proc portal_history_addEnrs(enrs: seq[Record]): bool
proc portal_history_ping(enr: Record): tuple[
seqNum: uint64, customPayload: string]
proc portal_history_findNodes(enr: Record): seq[Record]
proc portal_history_findContent(enr: Record, contentKey: string): tuple[
connectionId: Option[string],
content: Option[string],
enrs: Option[seq[Record]]]
proc portal_history_findContentExt(enr: Record, contentKey: string): tuple[
content: Option[string],
enrs: Option[seq[Record]]]
proc portal_history_offerExt(enr: Record, contentKey: string): bool
proc portal_history_recursiveFindNodes(): seq[Record]

17
fluffy/rpc/rpc_discovery_api.nim
View File

@ -48,11 +48,18 @@ proc installDiscoveryApiHandlers*(rpcServer: RpcServer|RpcProxy,
return d.routingTable.getNodeInfo()
rpcServer.rpc("discv5_setEnr") do(enr: Record) -> bool:
if d.addNode(enr):
return true
else:
raise newException(ValueError, "Could not add node with this ENR to routing table")
rpcServer.rpc("discv5_addEnrs") do(enrs: seq[Record]) -> bool:
# TODO: We could also adjust the API of addNode & newNode to accept a seen
# parameter, but perhaps only if that makes sense on other locations in
# discv5/portal that are not testing/debug related.
for enr in enrs:
let nodeRes = newNode(enr)
if nodeRes.isOk():
let node = nodeRes.get()
discard d.addNode(node)
d.routingTable.setJustSeen(node)
return true
rpcServer.rpc("discv5_getEnr") do(nodeId: NodeId) -> Record:
let node = d.getNode(nodeId)

10
fluffy/rpc/rpc_portal_api.nim
View File

@ -42,6 +42,16 @@ proc installPortalApiHandlers*(
else:
raise newException(ValueError, "Record not found in DHT lookup.")
rpcServer.rpc("portal_" & network & "_addEnrs") do(enrs: seq[Record]) -> bool:
for enr in enrs:
let nodeRes = newNode(enr)
if nodeRes.isOk():
let node = nodeRes.get()
discard p.addNode(node)
p.routingTable.setJustSeen(node)
return true
rpcServer.rpc("portal_" & network & "_ping") do(
enr: Record) -> tuple[seqNum: uint64, customPayload: string]:
let

24
fluffy/scripts/launch_local_testnet.sh
View File

@ -37,7 +37,7 @@ OPTS="h:n:d"
LONGOPTS="help,nodes:,data-dir:,enable-htop,log-level:,base-port:,base-rpc-port:,base-metrics-port:,reuse-existing-data-dir,timeout:,kill-old-processes"
# default values
NUM_NODES="17"
NUM_NODES="64"
DATA_DIR="local_testnet_data"
USE_HTOP="0"
LOG_LEVEL="TRACE"
@ -260,20 +260,12 @@ for NUM_NODE in $(seq 0 $(( NUM_NODES - 1 ))); do
done
fi
# Increasing the loopback address here with NUM_NODE as listen address to
# avoid hitting the IP limits in the routing tables.
# TODO: This simple increase will limit the amount of max nodes to 255.
# Could also fix this by having a compiler flag that starts the routing tables
# in fluffy with a very high limit or simply an adjustment in the routing
# table code that disable the checks on loopback address.
# macOS doesn't have these default
if uname | grep -qi darwin; then
sudo ifconfig lo0 alias 127.0.0.$((1 + NUM_NODE))
fi
# Running with bits-per-hop of 1 to make the lookups more likely requiring
# to request to nodes over the network instead of having most of them in the
# own routing table.
./build/fluffy \
--listen-address:127.0.0.$((1 + NUM_NODE)) \
--nat:extip:127.0.0.$((1 + NUM_NODE)) \
--listen-address:127.0.0.1 \
--nat:extip:127.0.0.1 \
--log-level="${LOG_LEVEL}" \
--udp-port=$(( BASE_PORT + NUM_NODE )) \
--data-dir="${NODE_DATA_DIR}" \
@ -284,7 +276,9 @@ for NUM_NODE in $(seq 0 $(( NUM_NODES - 1 ))); do
--metrics \
--metrics-address="127.0.0.1" \
--metrics-port="$(( BASE_METRICS_PORT + NUM_NODE ))" \
--bits-per-hop=5 \
--table-ip-limit=1024 \
--bucket-ip-limit=24 \
--bits-per-hop=1 \
${EXTRA_ARGS} \
> "${DATA_DIR}/log${NUM_NODE}.txt" 2>&1 &

141
fluffy/scripts/test_portal_testnet.nim
View File

@ -46,100 +46,115 @@ procSuite "Portal testnet tests":
let config = PortalTestnetConf.load()
let rng = newRng()
asyncTest "Discv5 - RoutingTableInfo at start":
let clients = await connectToRpcServers(config)
for i, client in clients:
let routingTableInfo = await client.discv5_routingTableInfo()
var start: seq[NodeId]
let nodes = foldl(routingTableInfo.buckets, a & b, start)
if i == 0:
# bootstrap node has all nodes (however not all verified), however this
# is highly dependent on the bits per hop and the amount of nodes
# launched and can thus easily fail.
# TODO: Set up the network with multiple bootstrap nodes to have a more
# robust set-up.
check nodes.len == config.nodeCount - 1
else: # Other nodes will have bootstrap node at this point, and maybe more
check nodes.len > 0
asyncTest "Discv5 - Random node lookup from each node":
let clients = await connectToRpcServers(config)
var nodeInfos: seq[NodeInfo]
for client in clients:
# We need to run a recursive lookup for each node to kick-off the network
discard await client.discv5_recursiveFindNodes()
let nodeInfo = await client.discv5_nodeInfo()
nodeInfos.add(nodeInfo)
# Kick off the network by trying to add all records to each node.
# These nodes are also set as seen, so they get passed along on findNode
# requests.
# Note: The amount of Records added here can be less but then the
# probability that all nodes will still be reached needs to be calculated.
# Note 2: One could also ping all nodes but that is much slower and more
# error prone
for client in clients:
# grab a random json-rpc client and take its `NodeInfo`
let randomClient = sample(rng[], clients)
let nodeInfo = await randomClient.discv5_nodeInfo()
var enr: Record
try:
enr = await client.discv5_lookupEnr(nodeInfo.nodeId)
except ValueError as e:
discard await client.discv5_addEnrs(nodeInfos.map(
proc(x: NodeInfo): Record = x.nodeENR))
except CatchableError as e:
# Call shouldn't fail, unless there are json rpc server/client issues
echo e.msg
check enr == nodeInfo.nodeENR
raise e
asyncTest "Portal State - RoutingTableInfo at start":
let clients = await connectToRpcServers(config)
for i, client in clients:
let routingTableInfo = await client.portal_state_routingTableInfo()
for client in clients:
let routingTableInfo = await client.discv5_routingTableInfo()
var start: seq[NodeId]
let nodes = foldl(routingTableInfo.buckets, a & b, start)
if i == 0: # bootstrap node has all nodes (however not all verified)
check nodes.len == config.nodeCount - 1
else: # Other nodes will have bootstrap node at this point, and maybe more
check nodes.len > 0
# A node will have at least the first bucket filled. One could increase
# this based on the probability that x amount of nodes fit in the buckets.
check nodes.len >= (min(config.nodeCount - 1, 16))
# grab a random node its `NodeInfo` and lookup that node from all nodes.
let randomNodeInfo = sample(rng[], nodeInfos)
for client in clients:
var enr: Record
try:
enr = await client.discv5_lookupEnr(randomNodeInfo.nodeId)
except CatchableError as e:
echo e.msg
check enr == randomNodeInfo.nodeENR
asyncTest "Portal State - Random node lookup from each node":
let clients = await connectToRpcServers(config)
var nodeInfos: seq[NodeInfo]
for client in clients:
# We need to run a recursive lookup for each node to kick-off the network
discard await client.portal_state_recursiveFindNodes()
let nodeInfo = await client.portal_state_nodeInfo()
nodeInfos.add(nodeInfo)
for client in clients:
# grab a random json-rpc client and take its `NodeInfo`
let randomClient = sample(rng[], clients)
let nodeInfo = await randomClient.portal_state_nodeInfo()
var enr: Record
try:
enr = await client.portal_state_lookupEnr(nodeInfo.nodeId)
except ValueError as e:
discard await client.portal_state_addEnrs(nodeInfos.map(
proc(x: NodeInfo): Record = x.nodeENR))
except CatchableError as e:
# Call shouldn't fail, unless there are json rpc server/client issues
echo e.msg
check enr == nodeInfo.nodeENR
raise e
asyncTest "Portal History - RoutingTableInfo at start":
let clients = await connectToRpcServers(config)
for i, client in clients:
let routingTableInfo = await client.portal_history_routingTableInfo()
for client in clients:
let routingTableInfo = await client.portal_state_routingTableInfo()
var start: seq[NodeId]
let nodes = foldl(routingTableInfo.buckets, a & b, start)
if i == 0: # bootstrap node has all nodes (however not all verified)
check nodes.len == config.nodeCount - 1
else: # Other nodes will have bootstrap node at this point, and maybe more
check nodes.len > 0
check nodes.len >= (min(config.nodeCount - 1, 16))
# grab a random node its `NodeInfo` and lookup that node from all nodes.
let randomNodeInfo = sample(rng[], nodeInfos)
for client in clients:
var enr: Record
try:
enr = await client.portal_state_lookupEnr(randomNodeInfo.nodeId)
except CatchableError as e:
echo e.msg
# TODO: For state network this occasionally fails. It might be because the
# distance function is not used in all locations, or perhaps it just
# doesn't converge to the target always with this distance function. To be
# further investigated.
skip()
# check enr == randomNodeInfo.nodeENR
asyncTest "Portal History - Random node lookup from each node":
let clients = await connectToRpcServers(config)
var nodeInfos: seq[NodeInfo]
for client in clients:
# We need to run a recursive lookup for each node to kick-off the network
discard await client.portal_history_recursiveFindNodes()
let nodeInfo = await client.portal_history_nodeInfo()
nodeInfos.add(nodeInfo)
for client in clients:
# grab a random json-rpc client and take its `NodeInfo`
let randomClient = sample(rng[], clients)
let nodeInfo = await randomClient.portal_history_nodeInfo()
try:
discard await client.portal_history_addEnrs(nodeInfos.map(
proc(x: NodeInfo): Record = x.nodeENR))
except CatchableError as e:
# Call shouldn't fail, unless there are json rpc server/client issues
echo e.msg
raise e
for client in clients:
let routingTableInfo = await client.portal_history_routingTableInfo()
var start: seq[NodeId]
let nodes = foldl(routingTableInfo.buckets, a & b, start)
check nodes.len >= (min(config.nodeCount - 1, 16))
# grab a random node its `NodeInfo` and lookup that node from all nodes.
let randomNodeInfo = sample(rng[], nodeInfos)
for client in clients:
var enr: Record
try:
enr = await client.portal_history_lookupEnr(nodeInfo.nodeId)
except ValueError as e:
enr = await client.portal_history_lookupEnr(randomNodeInfo.nodeId)
except CatchableError as e:
echo e.msg
check enr == nodeInfo.nodeENR
check enr == randomNodeInfo.nodeENR

4
fluffy/tests/test_helpers.nim
View File

@ -21,7 +21,7 @@ proc initDiscoveryNode*(rng: ref BrHmacDrbgContext,
localEnrFields: openArray[(string, seq[byte])] = [],
previousRecord = none[enr.Record]()): discv5_protocol.Protocol =
# set bucketIpLimit to allow bucket split
let tableIpLimits = TableIpLimits(tableIpLimit: 1000, bucketIpLimit: 24)
let config = DiscoveryConfig.init(1000, 24, 5)
result = newProtocol(privKey,
some(address.ip),
@ -30,7 +30,7 @@ proc initDiscoveryNode*(rng: ref BrHmacDrbgContext,
bootstrapRecords = bootstrapRecords,
localEnrFields = localEnrFields,
previousRecord = previousRecord,
tableIpLimits = tableIpLimits,
config = config,
rng = rng)
result.open()

2
vendor/nim-eth vendored

@ -1 +1 @@
Subproject commit cf95b688e647e52bd8dd937926d20257b564fe43
Subproject commit 41edd4a3f2bf4daf146b16bb94dbc477f12e7a13