Now that you've added addr relay statistics to getpeerinfo, you can isolate and observe the (predictable) p2p behaviour, rather than the (stochastic) addrman effects:
<details>
<summary>Diff</summary>
@@ -244,25 +244,55 @@ class AddrTest(BitcoinTestFramework):
assert_equal(addr_count_0, 0)
# Send 600 addresses. For all but the block-relay-only peer this should result in at least 1 address.
- peer.send_and_ping(self.setup_rand_addr_msg(600))
- addr_count_1 = len(self.nodes[0].getnodeaddresses(0))
- assert_greater_than_or_equal(tokens, addr_count_1)
- assert_greater_than_or_equal(addr_count_0 + 600, addr_count_1)
- assert_equal(addr_count_1 > addr_count_0, tokens > 0)
+ addrs = 600
+ peer.send_and_ping(self.setup_rand_addr_msg(addrs))
+
+ peerinfo_1 = self.nodes[0].getpeerinfo()[0]
+ addrs_processed_1 = peerinfo_1['addr_processed']
+ addrs_rate_limited_1 = peerinfo_1['addr_rate_limited']
+ self.log.info(f"addrs_processed = {addrs_processed_1}, addrs_rate_limited = {addrs_rate_limited_1}")
+
+ if not no_relay:
+ assert_equal(addrs_processed_1, min(addrs, tokens))
+ assert_equal(addrs_rate_limited_1, addrs - min(addrs, tokens))
+ else:
+ assert_equal(addrs_processed_1, 0)
+ assert_equal(addrs_rate_limited_1, 0)
# Send 600 more addresses. For the outbound-full-relay peer (which sends a GETADDR, and thus will
# process up to 1001 incoming addresses), this means more entries will appear.
- peer.send_and_ping(self.setup_rand_addr_msg(600))
- addr_count_2 = len(self.nodes[0].getnodeaddresses(0))
- assert_greater_than_or_equal(tokens, addr_count_2)
- assert_greater_than_or_equal(addr_count_1 + 600, addr_count_2)
- assert_equal(addr_count_2 > addr_count_1, tokens > 600)
+ new_addrs = 600
+ peer.send_and_ping(self.setup_rand_addr_msg(new_addrs))
+
+ addrs += new_addrs
+ peerinfo_2 = self.nodes[0].getpeerinfo()[0]
+ addrs_processed_2 = peerinfo_2['addr_processed']
+ addrs_rate_limited_2 = peerinfo_2['addr_rate_limited']
+ self.log.info(f"addrs_processed = {addrs_processed_2}, addrs_rate_limited = {addrs_rate_limited_2}")
+
+ if not no_relay:
+ assert_equal(addrs_processed_2, min(addrs, tokens))
+ assert_equal(addrs_rate_limited_2, addrs - min(addrs, tokens))
+ else:
+ assert_equal(addrs_processed_2, 0)
+ assert_equal(addrs_rate_limited_2, 0)
# Send 10 more. As we reached the processing limit for all nodes, this should have no effect.
- peer.send_and_ping(self.setup_rand_addr_msg(10))
- addr_count_3 = len(self.nodes[0].getnodeaddresses(0))
- assert_greater_than_or_equal(tokens, addr_count_3)
- assert_equal(addr_count_2, addr_count_3)
+ new_addrs = 10
+ peer.send_and_ping(self.setup_rand_addr_msg(new_addrs))
+
+ addrs += new_addrs
+ peerinfo_3 = self.nodes[0].getpeerinfo()[0]
+ addrs_processed_3 = peerinfo_3['addr_processed']
+ addrs_rate_limited_3 = peerinfo_3['addr_rate_limited']
+ self.log.info(f"addrs_processed = {addrs_processed_3}, addrs_rate_limited = {addrs_rate_limited_3}")
+
+ if not no_relay:
+ assert_equal(addrs_processed_3, min(addrs, tokens))
+ assert_equal(addrs_rate_limited_3, addrs - min(addrs, tokens))
+ else:
+ assert_equal(addrs_processed_3, 0)
+ assert_equal(addrs_rate_limited_3, 0)
# Advance the time by 100 seconds, permitting the processing of 10 more addresses. Send 200,
# but verify that no more than 10 are processed.
@@ -270,10 +300,21 @@ class AddrTest(BitcoinTestFramework):
self.nodes[0].setmocktime(self.mocktime)
new_tokens = 0 if no_relay else 10
tokens += new_tokens
- peer.send_and_ping(self.setup_rand_addr_msg(200))
- addr_count_4 = len(self.nodes[0].getnodeaddresses(0))
- assert_greater_than_or_equal(tokens, addr_count_4)
- assert_greater_than_or_equal(addr_count_3 + new_tokens, addr_count_4)
+ new_addrs = 200
+ peer.send_and_ping(self.setup_rand_addr_msg(new_addrs))
+
+ addrs += new_addrs
+ peerinfo_4 = self.nodes[0].getpeerinfo()[0]
+ addrs_processed_4 = peerinfo_4['addr_processed']
+ addrs_rate_limited_4 = peerinfo_4['addr_rate_limited']
+ self.log.info(f"addrs_processed = {addrs_processed_4}, addrs_rate_limited = {addrs_rate_limited_4}")
+
+ if not no_relay:
+ assert_equal(addrs_processed_4, min(addrs, tokens))
+ assert_equal(addrs_rate_limited_4, addrs - min(addrs, tokens))
+ else:
+ assert_equal(addrs_processed_4, 0)
+ assert_equal(addrs_rate_limited_4, 0)
# Advance the time by 1000 seconds, permitting the processing of 100 more addresses. Send 200,
# but verify that no more than 100 are processed (and at least some).
@@ -281,11 +322,21 @@ class AddrTest(BitcoinTestFramework):
self.nodes[0].setmocktime(self.mocktime)
new_tokens = 0 if no_relay else 100
tokens += new_tokens
- peer.send_and_ping(self.setup_rand_addr_msg(200))
- addr_count_5 = len(self.nodes[0].getnodeaddresses(0))
- assert_greater_than_or_equal(tokens, addr_count_5)
- assert_greater_than_or_equal(addr_count_4 + new_tokens, addr_count_5)
- assert_equal(addr_count_5 > addr_count_4, not no_relay)
+ new_addrs = 200
+ peer.send_and_ping(self.setup_rand_addr_msg(new_addrs))
+
+ addrs += new_addrs
+ peerinfo_5 = self.nodes[0].getpeerinfo()[0]
+ addrs_processed_5 = peerinfo_5['addr_processed']
+ addrs_rate_limited_5 = peerinfo_5['addr_rate_limited']
+ self.log.info(f"addrs_processed = {addrs_processed_5}, addrs_rate_limited = {addrs_rate_limited_5}")
+
+ if not no_relay:
+ assert_equal(addrs_processed_5, min(addrs, tokens))
+ assert_equal(addrs_rate_limited_5, addrs - min(addrs, tokens))
+ else:
+ assert_equal(addrs_processed_5, 0)
+ assert_equal(addrs_rate_limited_5, 0)
self.nodes[0].disconnect_p2ps()
</details>
(Obviously, there's a lot of duplicate code above that can be factored out into a send_and_test() routine.)
