Merge bitcoin/bitcoin#31859: test: Rename send_message to send_without_ping

fa9cf38 scripted-diff: test: Rename send_message to send_without_ping (MarcoFalke)
fa43567 test: Prefer send_and_ping over send_message+sync_with_ping (MarcoFalke)

Pull request description:

  `send_message` is problematic, because it is easy to forget a `sync_with_ping` (or other `wait_until`), leading to intermittent test failures. (Example: bitcoin/bitcoin#31837 (comment))

  There are more uses of `send_and_ping` in the codebase than `send_message`, so in most cases `send_and_ping` is needed anyway.

  For the remaining cases, clearly document that no sync happens by renaming `send_message` to `send_without_ping`.

ACKs for top commit:
  instagibbs:
    ACK bitcoin/bitcoin@fa9cf38

Tree-SHA512: 31caa6568d292ae3d3dda931a94aaa30cc1205ec2ef537a484393eb55687f86c212f1e751ac4a7636610bdf591502a50995dc63bf02f97be9fdc482072160b07

Author: fanquake

test/functional/README.md

@@ -183,7 +183,7 @@ way is the use the `profile_with_perf` context manager, e.g.
 with node.profile_with_perf("send-big-msgs"):
     # Perform activity on the node you're interested in profiling, e.g.:
     for _ in range(10000):
-        node.p2ps[0].send_message(some_large_message)
+        node.p2ps[0].send_without_ping(some_large_message)
 ```
 
 To see useful textual output, run

test/functional/example_test.py

@@ -184,7 +184,7 @@ def run_test(self):
             block.solve()
             block_message = msg_block(block)
             # Send message is used to send a P2P message to the node over our P2PInterface
-            peer_messaging.send_message(block_message)
+            peer_messaging.send_without_ping(block_message)
             self.tip = block.sha256
             blocks.append(self.tip)
             self.block_time += 1
@@ -209,7 +209,7 @@ def run_test(self):
         getdata_request = msg_getdata()
         for block in blocks:
             getdata_request.inv.append(CInv(MSG_BLOCK, block))
-        peer_receiving.send_message(getdata_request)
+        peer_receiving.send_without_ping(getdata_request)
 
         # wait_until() will loop until a predicate condition is met. Use it to test properties of the
         # P2PInterface objects.

test/functional/feature_assumeutxo.py

@@ -309,7 +309,7 @@ def test_sync_from_assumeutxo_node(self, snapshot):
         msg = msg_headers()
         for block_num in range(1, miner.getblockcount()+1):
             msg.headers.append(from_hex(CBlockHeader(), miner.getblockheader(miner.getblockhash(block_num), verbose=False)))
-        headers_provider_conn.send_message(msg)
+        headers_provider_conn.send_without_ping(msg)
 
         # Ensure headers arrived
         default_value = {'status': ''}  # No status

test/functional/feature_assumevalid.py

@@ -58,7 +58,7 @@ class BaseNode(P2PInterface):
     def send_header_for_blocks(self, new_blocks):
         headers_message = msg_headers()
         headers_message.headers = [CBlockHeader(b) for b in new_blocks]
-        self.send_message(headers_message)
+        self.send_without_ping(headers_message)
 
 
 class AssumeValidTest(BitcoinTestFramework):
@@ -80,7 +80,7 @@ def send_blocks_until_disconnected(self, p2p_conn):
             if not p2p_conn.is_connected:
                 break
             try:
-                p2p_conn.send_message(msg_block(self.blocks[i]))
+                p2p_conn.send_without_ping(msg_block(self.blocks[i]))
             except IOError:
                 assert not p2p_conn.is_connected
                 break
@@ -157,7 +157,7 @@ def run_test(self):
 
         # Send all blocks to node1. All blocks will be accepted.
         for i in range(2202):
-            p2p1.send_message(msg_block(self.blocks[i]))
+            p2p1.send_without_ping(msg_block(self.blocks[i]))
         # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
         p2p1.sync_with_ping(timeout=960)
         assert_equal(self.nodes[1].getblock(self.nodes[1].getbestblockhash())['height'], 2202)

test/functional/feature_maxuploadtarget.py

@@ -124,7 +124,7 @@ def run_test(self):
         # the test has been running so far).
         with self.nodes[0].assert_debug_log(expected_msgs=["historical block serving limit reached, disconnecting peer=0"]):
             for _ in range(3):
-                p2p_conns[0].send_message(getdata_request)
+                p2p_conns[0].send_without_ping(getdata_request)
             p2p_conns[0].wait_for_disconnect()
         assert_equal(len(self.nodes[0].getpeerinfo()), 2)
         self.log.info("Peer 0 disconnected after downloading old block too many times")
@@ -148,7 +148,7 @@ def run_test(self):
         # But if p2p_conns[1] tries for an old block, it gets disconnected too.
         getdata_request.inv = [CInv(MSG_BLOCK, big_old_block)]
         with self.nodes[0].assert_debug_log(expected_msgs=["historical block serving limit reached, disconnecting peer=1"]):
-            p2p_conns[1].send_message(getdata_request)
+            p2p_conns[1].send_without_ping(getdata_request)
             p2p_conns[1].wait_for_disconnect()
         assert_equal(len(self.nodes[0].getpeerinfo()), 1)
 
@@ -198,7 +198,7 @@ def run_test(self):
 
         self.log.info("Peer gets disconnected for a mempool request after limit is reached")
         with self.nodes[0].assert_debug_log(expected_msgs=["mempool request with bandwidth limit reached, disconnecting peer=0"]):
-            peer.send_message(msg_mempool())
+            peer.send_without_ping(msg_mempool())
             peer.wait_for_disconnect()
 
         self.log.info("Test passing an unparsable value to -maxuploadtarget throws an error")

test/functional/feature_versionbits_warning.py

@@ -47,7 +47,7 @@ def send_blocks_with_version(self, peer, numblocks, version):
         for _ in range(numblocks):
             block = create_block(tip, create_coinbase(height + 1), block_time, version=version)
             block.solve()
-            peer.send_message(msg_block(block))
+            peer.send_without_ping(msg_block(block))
             block_time += 1
             height += 1
             tip = block.sha256

test/functional/interface_usdt_net.py

@@ -473,7 +473,7 @@ def handle_misbehaving_connection(_, data, __):
         for _ in range(EXPECTED_MISBEHAVING_CONNECTIONS):
             testnode = P2PInterface()
             self.nodes[0].add_p2p_connection(testnode)
-            testnode.send_message(msg)
+            testnode.send_without_ping(msg)
             bpf.perf_buffer_poll(timeout=500)
             testnode.peer_disconnect()
 

test/functional/p2p_addr_relay.py

@@ -76,9 +76,9 @@ def addr_received(self):
 
     def on_version(self, message):
         self.send_version()
-        self.send_message(msg_verack())
+        self.send_without_ping(msg_verack())
         if (self.send_getaddr):
-            self.send_message(msg_getaddr())
+            self.send_without_ping(msg_getaddr())
 
     def getaddr_received(self):
         return self.message_count['getaddr'] > 0
@@ -142,7 +142,7 @@ def oversized_addr_test(self):
 
         msg = self.setup_addr_msg(1010)
         with self.nodes[0].assert_debug_log(['addr message size = 1010']):
-            addr_source.send_message(msg)
+            addr_source.send_without_ping(msg)
             addr_source.wait_for_disconnect()
 
         self.nodes[0].disconnect_p2ps()

test/functional/p2p_addrfetch.py

@@ -62,7 +62,7 @@ def run_test(self):
 
         self.log.info("Check that answering with larger addr messages leads to disconnect")
         msg.addrs = [ADDR] * 2
-        peer.send_message(msg)
+        peer.send_without_ping(msg)
         peer.wait_for_disconnect(timeout=5)
 
         self.log.info("Check timeout for addr-fetch peer that does not send addrs")

test/functional/p2p_addrv2_relay.py

@@ -79,7 +79,7 @@ def run_test(self):
         self.log.info('Check disconnection when sending sendaddrv2 after verack')
         conn = self.nodes[0].add_p2p_connection(P2PInterface())
         with self.nodes[0].assert_debug_log(['sendaddrv2 received after verack, disconnecting peer=0']):
-            conn.send_message(msg_sendaddrv2())
+            conn.send_without_ping(msg_sendaddrv2())
             conn.wait_for_disconnect()
 
         self.log.info('Create connection that sends addrv2 messages')
@@ -104,7 +104,7 @@ def run_test(self):
         self.log.info('Send too-large addrv2 message')
         msg.addrs = ADDRS * 101
         with self.nodes[0].assert_debug_log(['addrv2 message size = 1010']):
-            addr_source.send_message(msg)
+            addr_source.send_without_ping(msg)
             addr_source.wait_for_disconnect()