diff --git a/test/functional/abc-p2p-fullblocktest.py b/test/functional/abc-p2p-fullblocktest.py
--- a/test/functional/abc-p2p-fullblocktest.py
+++ b/test/functional/abc-p2p-fullblocktest.py
@@ -435,8 +435,7 @@
# Wait for SENDCMPCT
def received_sendcmpct():
return (peer.last_sendcmpct != None)
- got_sendcmpt = wait_until(received_sendcmpct, timeout=30)
- assert(got_sendcmpt)
+ wait_until(received_sendcmpct, timeout=30)
sendcmpct = msg_sendcmpct()
sendcmpct.version = 1
@@ -446,8 +445,7 @@
# Exchange headers
def received_getheaders():
return (peer.last_getheaders != None)
- got_getheaders = wait_until(received_getheaders, timeout=30)
- assert(got_getheaders)
+ wait_until(received_getheaders, timeout=30)
# Return the favor
peer.send_message(peer.last_getheaders)
@@ -455,8 +453,7 @@
# Wait for the header list
def received_headers():
return (peer.last_headers != None)
- got_headers = wait_until(received_headers, timeout=30)
- assert(got_headers)
+ wait_until(received_headers, timeout=30)
# It's like we know about the same headers !
peer.send_message(peer.last_headers)
@@ -468,8 +465,7 @@
# Checks the node to forward it via compact block
def received_block():
return (peer.last_cmpctblock != None)
- got_cmpctblock = wait_until(received_block, timeout=30)
- assert(got_cmpctblock)
+ wait_until(received_block, timeout=30)
# Was it our block ?
cmpctblk_header = peer.last_cmpctblock.header_and_shortids.header
@@ -482,8 +478,7 @@
yield accepted()
# Checks the node to forward it via compact block
- got_cmpctblock = wait_until(received_block, timeout=30)
- assert(got_cmpctblock)
+ wait_until(received_block, timeout=30)
# Was it our block ?
cmpctblk_header = peer.last_cmpctblock.header_and_shortids.header
diff --git a/test/functional/bip65-cltv-p2p.py b/test/functional/bip65-cltv-p2p.py
--- a/test/functional/bip65-cltv-p2p.py
+++ b/test/functional/bip65-cltv-p2p.py
@@ -118,7 +118,8 @@
node0.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
- assert wait_until(lambda: "reject" in node0.last_message.keys())
+ wait_until(lambda: "reject" in node0.last_message.keys(),
+ lock=mininode_lock)
with mininode_lock:
assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
assert_equal(
@@ -149,7 +150,8 @@
node0.send_and_ping(msg_block(block))
assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
- assert wait_until(lambda: "reject" in node0.last_message.keys())
+ wait_until(lambda: "reject" in node0.last_message.keys(),
+ lock=mininode_lock)
with mininode_lock:
assert node0.last_message["reject"].code in [
REJECT_INVALID, REJECT_NONSTANDARD]
diff --git a/test/functional/bipdersig-p2p.py b/test/functional/bipdersig-p2p.py
--- a/test/functional/bipdersig-p2p.py
+++ b/test/functional/bipdersig-p2p.py
@@ -86,7 +86,8 @@
node0.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), tip)
- assert wait_until(lambda: "reject" in node0.last_message.keys())
+ wait_until(lambda: "reject" in node0.last_message.keys(),
+ lock=mininode_lock)
with mininode_lock:
assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
assert_equal(
@@ -112,7 +113,8 @@
node0.send_and_ping(msg_block(block))
assert_equal(self.nodes[0].getbestblockhash(), tip)
- assert wait_until(lambda: "reject" in node0.last_message.keys())
+ wait_until(lambda: "reject" in node0.last_message.keys(),
+ lock=mininode_lock)
with mininode_lock:
# We can receive different reject messages depending on whether
# bitcoind is running with multiple script check threads. If script
diff --git a/test/functional/disconnect_ban.py b/test/functional/disconnect_ban.py
--- a/test/functional/disconnect_ban.py
+++ b/test/functional/disconnect_ban.py
@@ -4,11 +4,13 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test node disconnect and ban behavior"""
-from test_framework.mininode import wait_until
from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (assert_equal,
- assert_raises_jsonrpc,
- connect_nodes_bi)
+from test_framework.util import (
+ assert_equal,
+ assert_raises_jsonrpc,
+ connect_nodes_bi,
+ wait_until,
+)
class DisconnectBanTest(BitcoinTestFramework):
@@ -25,7 +27,7 @@
# node1 should have 2 connections to node0 at this point
assert_equal(len(self.nodes[1].getpeerinfo()), 2)
self.nodes[1].setban("127.0.0.1", "add")
- wait_until(lambda: len(self.nodes[1].getpeerinfo()) == 0)
+ wait_until(lambda: len(self.nodes[1].getpeerinfo()) == 0, timeout=10)
# all nodes must be disconnected at this point
assert_equal(len(self.nodes[1].getpeerinfo()), 0)
assert_equal(len(self.nodes[1].listbanned()), 1)
@@ -101,9 +103,9 @@
"disconnectnode: successfully disconnect node by address")
address1 = self.nodes[0].getpeerinfo()[0]['addr']
self.nodes[0].disconnectnode(address=address1)
- wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1)
- assert not [node for node in self.nodes[0]
- .getpeerinfo() if node['addr'] == address1]
+ wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1, timeout=10)
+ assert not [node for node in self.nodes[0].getpeerinfo()
+ if node['addr'] == address1]
self.log.info("disconnectnode: successfully reconnect node")
# reconnect the node
@@ -116,9 +118,9 @@
"disconnectnode: successfully disconnect node by node id")
id1 = self.nodes[0].getpeerinfo()[0]['id']
self.nodes[0].disconnectnode(nodeid=id1)
- wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1)
- assert not [node for node in self.nodes[
- 0].getpeerinfo() if node['id'] == id1]
+ wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 1, timeout=10)
+ assert not [node for node in self.nodes[0].getpeerinfo()
+ if node['id'] == id1]
if __name__ == '__main__':
diff --git a/test/functional/example_test.py b/test/functional/example_test.py
--- a/test/functional/example_test.py
+++ b/test/functional/example_test.py
@@ -23,13 +23,13 @@
mininode_lock,
msg_block,
msg_getdata,
- wait_until,
)
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (
assert_equal,
connect_nodes,
p2p_port,
+ wait_until,
)
# NodeConnCB is a class containing callbacks to be executed when a P2P
@@ -215,8 +215,8 @@
# wait_until() will loop until a predicate condition is met. Use it to test properties of the
# NodeConnCB objects.
- assert wait_until(lambda: sorted(blocks) == sorted(
- list(node2.block_receive_map.keys())), timeout=5)
+ wait_until(lambda: sorted(blocks) == sorted(
+ list(node2.block_receive_map.keys())), timeout=5, lock=mininode_lock)
self.log.info("Check that each block was received only once")
# The network thread uses a global lock on data access to the NodeConn objects when sending and receiving
diff --git a/test/functional/mempool_persist.py b/test/functional/mempool_persist.py
--- a/test/functional/mempool_persist.py
+++ b/test/functional/mempool_persist.py
@@ -32,7 +32,6 @@
"""
import time
-from test_framework.mininode import wait_until
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *
@@ -73,7 +72,7 @@
self.nodes.append(self.start_node(1, self.options.tmpdir))
# Give bitcoind a second to reload the mempool
time.sleep(1)
- assert wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
+ wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
assert_equal(len(self.nodes[1].getrawmempool()), 0)
self.log.debug(
@@ -91,7 +90,7 @@
self.stop_nodes()
self.nodes = []
self.nodes.append(self.start_node(0, self.options.tmpdir))
- assert wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
+ wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
if __name__ == '__main__':
diff --git a/test/functional/p2p-compactblocks.py b/test/functional/p2p-compactblocks.py
--- a/test/functional/p2p-compactblocks.py
+++ b/test/functional/p2p-compactblocks.py
@@ -75,7 +75,8 @@
def request_headers_and_sync(self, locator, hashstop=0):
self.clear_block_announcement()
self.get_headers(locator, hashstop)
- assert wait_until(self.received_block_announcement, timeout=30)
+ wait_until(self.received_block_announcement,
+ timeout=30, lock=mininode_lock)
self.clear_block_announcement()
# Block until a block announcement for a particular block hash is
@@ -83,7 +84,7 @@
def wait_for_block_announcement(self, block_hash, timeout=30):
def received_hash():
return (block_hash in self.announced_blockhashes)
- return wait_until(received_hash, timeout=timeout)
+ wait_until(received_hash, timeout=timeout, lock=mininode_lock)
def send_await_disconnect(self, message, timeout=30):
"""Sends a message to the node and wait for disconnect.
@@ -91,11 +92,8 @@
This is used when we want to send a message into the node that we expect
will get us disconnected, eg an invalid block."""
self.send_message(message)
- success = wait_until(lambda: not self.connected, timeout=timeout)
- if not success:
- logger.error("send_await_disconnect failed!")
- raise AssertionError("send_await_disconnect failed!")
- return success
+ wait_until(lambda: not self.connected,
+ timeout=timeout, lock=mininode_lock)
class CompactBlocksTest(BitcoinTestFramework):
@@ -155,9 +153,7 @@
# Make sure we get a SENDCMPCT message from our peer
def received_sendcmpct():
return (len(test_node.last_sendcmpct) > 0)
- got_message = wait_until(received_sendcmpct, timeout=30)
- assert(received_sendcmpct())
- assert(got_message)
+ wait_until(received_sendcmpct, timeout=30, lock=mininode_lock)
with mininode_lock:
# Check that the first version received is the preferred one
assert_equal(
@@ -173,7 +169,6 @@
block_hash = int(node.generate(1)[0], 16)
peer.wait_for_block_announcement(block_hash, timeout=30)
assert(peer.block_announced)
- assert(got_message)
with mininode_lock:
assert predicate(peer), (
@@ -288,7 +283,7 @@
# Wait until we've seen the block announcement for the resulting tip
tip = int(node.getbestblockhash(), 16)
- assert(test_node.wait_for_block_announcement(tip))
+ test_node.wait_for_block_announcement(tip)
# Make sure we will receive a fast-announce compact block
self.request_cb_announcements(test_node, node)
@@ -303,8 +298,8 @@
block.rehash()
# Wait until the block was announced (via compact blocks)
- wait_until(test_node.received_block_announcement, timeout=30)
- assert(test_node.received_block_announcement())
+ wait_until(test_node.received_block_announcement,
+ timeout=30, lock=mininode_lock)
# Now fetch and check the compact block
header_and_shortids = None
@@ -322,8 +317,8 @@
inv = CInv(4, block_hash) # 4 == "CompactBlock"
test_node.send_message(msg_getdata([inv]))
- wait_until(test_node.received_block_announcement, timeout=30)
- assert(test_node.received_block_announcement())
+ wait_until(test_node.received_block_announcement,
+ timeout=30, lock=mininode_lock)
# Now fetch and check the compact block
header_and_shortids = None
@@ -390,15 +385,13 @@
if announce == "inv":
test_node.send_message(msg_inv([CInv(2, block.sha256)]))
- success = wait_until(
- lambda: "getheaders" in test_node.last_message, timeout=30)
- assert(success)
+ wait_until(lambda: "getheaders" in test_node.last_message,
+ timeout=30, lock=mininode_lock)
test_node.send_header_for_blocks([block])
else:
test_node.send_header_for_blocks([block])
- success = wait_until(
- lambda: "getdata" in test_node.last_message, timeout=30)
- assert(success)
+ wait_until(lambda: "getdata" in test_node.last_message,
+ timeout=30, lock=mininode_lock)
assert_equal(len(test_node.last_message["getdata"].inv), 1)
assert_equal(test_node.last_message["getdata"].inv[0].type, 4)
assert_equal(
@@ -595,9 +588,8 @@
assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
# We should receive a getdata request
- success = wait_until(
- lambda: "getdata" in test_node.last_message, timeout=10)
- assert(success)
+ wait_until(lambda: "getdata" in test_node.last_message,
+ timeout=10, lock=mininode_lock)
assert_equal(len(test_node.last_message["getdata"].inv), 1)
assert(test_node.last_message["getdata"].inv[0].type ==
2 or test_node.last_message["getdata"].inv[0].type == 2 | MSG_WITNESS_FLAG)
@@ -628,9 +620,8 @@
msg.block_txn_request.from_absolute(
sorted(random.sample(range(len(block.vtx)), num_to_request)))
test_node.send_message(msg)
- success = wait_until(
- lambda: "blocktxn" in test_node.last_message, timeout=10)
- assert(success)
+ wait_until(lambda: "blocktxn" in test_node.last_message,
+ timeout=10, lock=mininode_lock)
[tx.calc_sha256() for tx in block.vtx]
with mininode_lock:
@@ -674,24 +665,24 @@
for i in range(MAX_CMPCTBLOCK_DEPTH + 1):
test_node.clear_block_announcement()
new_blocks.append(node.generate(1)[0])
- wait_until(test_node.received_block_announcement, timeout=30)
+ wait_until(test_node.received_block_announcement,
+ timeout=30, lock=mininode_lock)
test_node.clear_block_announcement()
test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
- success = wait_until(
- lambda: "cmpctblock" in test_node.last_message, timeout=30)
- assert(success)
+ wait_until(lambda: "cmpctblock" in test_node.last_message,
+ timeout=30, lock=mininode_lock)
test_node.clear_block_announcement()
node.generate(1)
- wait_until(test_node.received_block_announcement, timeout=30)
+ wait_until(test_node.received_block_announcement,
+ timeout=30, lock=mininode_lock)
test_node.clear_block_announcement()
with mininode_lock:
test_node.last_message.pop("block", None)
test_node.send_message(msg_getdata([CInv(4, int(new_blocks[0], 16))]))
- success = wait_until(
- lambda: "block" in test_node.last_message, timeout=30)
- assert(success)
+ wait_until(lambda: "block" in test_node.last_message,
+ timeout=30, lock=mininode_lock)
with mininode_lock:
test_node.last_message["block"].block.calc_sha256()
assert_equal(
@@ -737,7 +728,8 @@
node.submitblock(ToHex(block))
for l in listeners:
- wait_until(lambda: l.received_block_announcement(), timeout=30)
+ wait_until(lambda: l.received_block_announcement(),
+ timeout=30, lock=mininode_lock)
with mininode_lock:
for l in listeners:
assert "cmpctblock" in l.last_message
diff --git a/test/functional/p2p-leaktests.py b/test/functional/p2p-leaktests.py
--- a/test/functional/p2p-leaktests.py
+++ b/test/functional/p2p-leaktests.py
@@ -150,12 +150,12 @@
NetworkThread().start() # Start up network handling in another thread
- assert wait_until(
- lambda: no_version_bannode.ever_connected, timeout=10)
- assert wait_until(
- lambda: no_version_idlenode.ever_connected, timeout=10)
- assert wait_until(
- lambda: no_verack_idlenode.version_received, timeout=10)
+ wait_until(lambda: no_version_bannode.ever_connected,
+ timeout=10, lock=mininode_lock)
+ wait_until(lambda: no_version_idlenode.ever_connected,
+ timeout=10, lock=mininode_lock)
+ wait_until(lambda: no_verack_idlenode.version_received,
+ timeout=10, lock=mininode_lock)
# Mine a block and make sure that it's not sent to the connected nodes
self.nodes[0].generate(1)
diff --git a/test/functional/sendheaders.py b/test/functional/sendheaders.py
--- a/test/functional/sendheaders.py
+++ b/test/functional/sendheaders.py
@@ -134,7 +134,7 @@
expect_inv = inv if inv != None else []
def test_function(): return self.block_announced
- assert(wait_until(test_function, timeout=60))
+ wait_until(test_function, timeout=60, lock=mininode_lock)
with mininode_lock:
self.block_announced = False
@@ -163,12 +163,12 @@
def test_function(): return "getdata" in self.last_message and [
x.hash for x in self.last_message["getdata"].inv] == hash_list
- assert(wait_until(test_function, timeout=timeout))
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
return
def wait_for_block_announcement(self, block_hash, timeout=60):
def test_function(): return self.last_blockhash_announced == block_hash
- assert(wait_until(test_function, timeout=timeout))
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
return
def send_header_for_blocks(self, new_blocks):
diff --git a/test/functional/test_framework/comptool.py b/test/functional/test_framework/comptool.py
--- a/test/functional/test_framework/comptool.py
+++ b/test/functional/test_framework/comptool.py
@@ -5,7 +5,7 @@
from .mininode import *
from .blockstore import BlockStore, TxStore
-from .util import p2p_port
+from .util import p2p_port, wait_until
import logging
@@ -205,7 +205,7 @@
def wait_for_disconnections(self):
def disconnected():
return all(node.closed for node in self.test_nodes)
- return wait_until(disconnected, timeout=10)
+ wait_until(disconnected, timeout=10, lock=mininode_lock)
def wait_for_verack(self):
return all(node.wait_for_verack() for node in self.test_nodes)
@@ -213,7 +213,7 @@
def wait_for_pings(self, counter):
def received_pongs():
return all(node.received_ping_response(counter) for node in self.test_nodes)
- return wait_until(received_pongs)
+ wait_until(received_pongs, lock=mininode_lock)
# sync_blocks: Wait for all connections to request the blockhash given
# then send get_headers to find out the tip of each node, and synchronize
@@ -227,8 +227,8 @@
)
# --> error if not requested
- if not wait_until(blocks_requested, attempts=20 * num_blocks):
- raise AssertionError("Not all nodes requested block")
+ wait_until(blocks_requested, attempts=20 *
+ num_blocks, lock=mininode_lock)
# Send getheaders message
[c.cb.send_getheaders() for c in self.connections]
@@ -249,8 +249,8 @@
)
# --> error if not requested
- if not wait_until(transaction_requested, attempts=20 * num_events):
- raise AssertionError("Not all nodes requested transaction")
+ wait_until(transaction_requested, attempts=20 *
+ num_events, lock=mininode_lock)
# Get the mempool
[c.cb.send_mempool() for c in self.connections]
diff --git a/test/functional/test_framework/mininode.py b/test/functional/test_framework/mininode.py
--- a/test/functional/test_framework/mininode.py
+++ b/test/functional/test_framework/mininode.py
@@ -38,7 +38,7 @@
from test_framework.siphash import siphash256
from test_framework.cdefs import MAX_BLOCK_SIGOPS_PER_MB
-from test_framework.util import hex_str_to_bytes, bytes_to_hex_str
+from test_framework.util import hex_str_to_bytes, bytes_to_hex_str, wait_until
BIP0031_VERSION = 60000
MY_VERSION = 70014 # past bip-31 for ping/pong
@@ -1402,24 +1402,6 @@
% (self.message, self.code, self.reason, self.data)
-def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf')):
- '''
- This function is subsequently remove in core's PR11712
- '''
- attempt = 0
- elapsed = 0
-
- while attempt < attempts and elapsed < timeout:
- with mininode_lock:
- if predicate():
- return True
- attempt += 1
- elapsed += 0.05
- time.sleep(0.05)
-
- return False
-
-
class msg_feefilter():
command = b"feefilter"
@@ -1660,22 +1642,22 @@
def wait_for_disconnect(self, timeout=60):
def test_function(): return not self.connected
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
# Message receiving helper methods
def wait_for_block(self, blockhash, timeout=60):
def test_function(): return self.last_message.get(
"block") and self.last_message["block"].block.rehash() == blockhash
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
def wait_for_getdata(self, timeout=60):
def test_function(): return self.last_message.get("getdata")
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
def wait_for_getheaders(self, timeout=60):
def test_function(): return self.last_message.get("getheaders")
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
def wait_for_inv(self, expected_inv, timeout=60):
"""Waits for an INV message and checks that the first inv object in the message was as expected."""
@@ -1686,11 +1668,11 @@
def test_function(): return self.last_message.get("inv") and \
self.last_message["inv"].inv[0].type == expected_inv[0].type and \
self.last_message["inv"].inv[0].hash == expected_inv[0].hash
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
def wait_for_verack(self, timeout=60):
def test_function(): return self.message_count["verack"]
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
# Message sending helper functions
@@ -1710,7 +1692,7 @@
def test_function(): return self.last_message.get(
"pong") and self.last_message["pong"].nonce == self.ping_counter
- assert wait_until(test_function, timeout=timeout)
+ wait_until(test_function, timeout=timeout, lock=mininode_lock)
self.ping_counter += 1
# The actual NodeConn class
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -207,6 +207,29 @@
def satoshi_round(amount):
return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+
+def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf'), lock=None):
+ if attempts == float('inf') and timeout == float('inf'):
+ timeout = 60
+ attempt = 0
+ timeout += time.time()
+
+ while attempt < attempts and time.time() < timeout:
+ if lock:
+ with lock:
+ if predicate():
+ return
+ else:
+ if predicate():
+ return
+ attempt += 1
+ time.sleep(0.05)
+
+ # Print the cause of the timeout
+ assert_greater_than(attempts, attempt)
+ assert_greater_than(timeout, time.time())
+ raise RuntimeError('Unreachable')
+
# RPC/P2P connection constants and functions
############################################