Merge #19760: test: Remove confusing mininode terminology

d5800da5199527a366024bc80cad7fcca17d5c4a [test] Remove final references to mininode (John Newbery)
5e8df3312e47a73e747ee892face55ed9ababeea test: resort imports (John Newbery)
85165d4332b0f72d30e0c584b476249b542338e6 scripted-diff: Rename mininode to p2p (John Newbery)
9e2897d020b114a10c860f90c5405be029afddba scripted-diff: Rename mininode_lock to p2p_lock (John Newbery)

Pull request description:

  New contributors are often confused by the terminology in the test framework, and what the difference between a _node_ and a _peer_ is. To summarize:

  - a 'node' is a bitcoind instance. This is the thing whose behavior is being tested. Each bitcoind node is managed by a python `TestNode` object which is used to start/stop the node, manage the node's data directory, read state about the node (eg process status, log file), and interact with the node over different interfaces.
  - one of the interfaces that we can use to interact with the node is the p2p interface. Each connection to a node using this interface is managed by a python `P2PInterface` or derived object (which is owned by the `TestNode` object). We can open zero, one or many p2p connections to each bitcoind node. The node sees these connections as 'peers'.

  For historic reasons, the word 'mininode' has been used to refer to those p2p interface objects that we use to connect to the bitcoind node (the code was originally taken from the 'mini-node' branch of https://github.com/jgarzik/pynode/tree/mini-node). However that name has proved to be confusing for new contributors, so rename the remaining references.

ACKs for top commit:
  amitiuttarwar:
    ACK d5800da519
  MarcoFalke:
    ACK d5800da5199527a366024bc80cad7fcca17d5c4a 🚞
Tree-SHA512: 2c46c2ac3c4278b6e3c647cfd8108428a41e80788fc4f0e386e5b0c47675bc687d94779496c09a3e5ea1319617295be10c422adeeff2d2bd68378e00e0eeb5de
This commit is contained in:
Konstantin Akimov 2024-01-16 02:35:29 +07:00
parent 9d33b30a87
commit f34889dcf4
No known key found for this signature in database
GPG Key ID: 2176C4A5D01EA524
55 changed files with 180 additions and 180 deletions

View File

@ -130,8 +130,8 @@ Base class for functional tests.
#### [util.py](test_framework/util.py) #### [util.py](test_framework/util.py)
Generally useful functions. Generally useful functions.
#### [mininode.py](test_framework/mininode.py) #### [p2p.py](test_framework/p2p.py)
Basic code to support P2P connectivity to a dashd. Test objects for interacting with a dashd node over the p2p interface.
#### [script.py](test_framework/script.py) #### [script.py](test_framework/script.py)
Utilities for manipulating transaction scripts (originally from python-bitcoinlib) Utilities for manipulating transaction scripts (originally from python-bitcoinlib)

View File

@ -16,11 +16,11 @@ from collections import defaultdict
# Avoid wildcard * imports # Avoid wildcard * imports
from test_framework.blocktools import (create_block, create_coinbase) from test_framework.blocktools import (create_block, create_coinbase)
from test_framework.messages import CInv, MSG_BLOCK from test_framework.messages import CInv, MSG_BLOCK
from test_framework.mininode import ( from test_framework.p2p import (
P2PInterface, P2PInterface,
mininode_lock,
msg_block, msg_block,
msg_getdata, msg_getdata,
p2p_lock,
) )
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
@ -169,7 +169,7 @@ class ExampleTest(BitcoinTestFramework):
height = self.nodes[0].getblockcount() height = self.nodes[0].getblockcount()
for _ in range(10): for _ in range(10):
# Use the mininode and blocktools functionality to manually build a block # Use the blocktools functionality to manually build a block.
# Calling the generate() rpc is easier, but this allows us to exactly # Calling the generate() rpc is easier, but this allows us to exactly
# control the blocks and transactions. # control the blocks and transactions.
block = create_block(self.tip, create_coinbase(height+1), self.block_time) block = create_block(self.tip, create_coinbase(height+1), self.block_time)
@ -205,13 +205,13 @@ class ExampleTest(BitcoinTestFramework):
# wait_until() will loop until a predicate condition is met. Use it to test properties of the # wait_until() will loop until a predicate condition is met. Use it to test properties of the
# P2PInterface objects. # P2PInterface objects.
wait_until(lambda: sorted(blocks) == sorted(list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5, lock=mininode_lock) wait_until(lambda: sorted(blocks) == sorted(list(self.nodes[2].p2p.block_receive_map.keys())), timeout=5, lock=p2p_lock)
self.log.info("Check that each block was received only once") self.log.info("Check that each block was received only once")
# The network thread uses a global lock on data access to the P2PConnection objects when sending and receiving # The network thread uses a global lock on data access to the P2PConnection objects when sending and receiving
# messages. The test thread should acquire the global lock before accessing any P2PConnection data to avoid locking # messages. The test thread should acquire the global lock before accessing any P2PConnection data to avoid locking
# and synchronization issues. Note wait_until() acquires this global lock when testing the predicate. # and synchronization issues. Note wait_until() acquires this global lock when testing the predicate.
with mininode_lock: with p2p_lock:
for block in self.nodes[2].p2p.block_receive_map.values(): for block in self.nodes[2].p2p.block_receive_map.values():
assert_equal(block, 1) assert_equal(block, 1)

View File

@ -45,7 +45,7 @@ from test_framework.messages import (
msg_block, msg_block,
msg_headers, msg_headers,
) )
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.script import (CScript, OP_TRUE) from test_framework.script import (CScript, OP_TRUE)
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (assert_equal, set_node_times, wait_until) from test_framework.util import (assert_equal, set_node_times, wait_until)

View File

@ -26,7 +26,7 @@ from test_framework.messages import (
uint256_from_compact, uint256_from_compact,
uint256_from_str, uint256_from_str,
) )
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.script import ( from test_framework.script import (
CScript, CScript,
MAX_SCRIPT_ELEMENT_SIZE, MAX_SCRIPT_ELEMENT_SIZE,
@ -53,7 +53,7 @@ from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal from test_framework.util import assert_equal
from data import invalid_txs from data import invalid_txs
# Use this class for tests that require behavior other than normal "mininode" behavior. # Use this class for tests that require behavior other than normal p2p behavior.
# For now, it is used to serialize a bloated varint (b64). # For now, it is used to serialize a bloated varint (b64).
class CBrokenBlock(CBlock): class CBrokenBlock(CBlock):
def initialize(self, base_block): def initialize(self, base_block):

View File

@ -10,7 +10,7 @@ Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height
from test_framework.blocktools import create_coinbase, create_block, create_transaction from test_framework.blocktools import create_coinbase, create_block, create_transaction
from test_framework.messages import CTransaction, msg_block, ToHex from test_framework.messages import CTransaction, msg_block, ToHex
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP, CScriptNum from test_framework.script import CScript, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP, CScriptNum
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (

View File

@ -43,7 +43,7 @@ from io import BytesIO
from test_framework.blocktools import create_coinbase, create_block, create_transaction, TIME_GENESIS_BLOCK from test_framework.blocktools import create_coinbase, create_block, create_transaction, TIME_GENESIS_BLOCK
from test_framework.messages import ToHex, CTransaction from test_framework.messages import ToHex, CTransaction
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.script import ( from test_framework.script import (
CScript, CScript,
OP_CHECKSEQUENCEVERIFY, OP_CHECKSEQUENCEVERIFY,

View File

@ -9,7 +9,7 @@ Test that the DERSIG soft-fork activates at (regtest) height 1251.
from test_framework.blocktools import create_coinbase, create_block, create_transaction from test_framework.blocktools import create_coinbase, create_block, create_transaction
from test_framework.messages import msg_block from test_framework.messages import msg_block
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.script import CScript from test_framework.script import CScript
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (

View File

@ -11,7 +11,7 @@ Checks DIP3 for v19
''' '''
from io import BytesIO from io import BytesIO
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, \ from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, \
QuorumId, ser_uint256 QuorumId, ser_uint256
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework

View File

@ -13,7 +13,7 @@ Checks DIP4 merkle roots in coinbases
from io import BytesIO from io import BytesIO
from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, QuorumId, ser_uint256 from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, QuorumId, ser_uint256
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal, wait_until

View File

@ -4,7 +4,7 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php. # file COPYING or http://www.opensource.org/licenses/mit-license.php.
import time import time
from test_framework.mininode import logger from test_framework.p2p import logger
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.util import force_finish_mnsync, wait_until from test_framework.util import force_finish_mnsync, wait_until

View File

@ -12,7 +12,7 @@ Checks EvoNodes
from _decimal import Decimal from _decimal import Decimal
from io import BytesIO from io import BytesIO
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, \ from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, \
QuorumId, ser_uint256 QuorumId, ser_uint256
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework

View File

@ -14,7 +14,7 @@ import struct
from test_framework.blocktools import create_block_with_mnpayments from test_framework.blocktools import create_block_with_mnpayments
from test_framework.messages import CInv, CTransaction, FromHex, hash256, msg_clsig, msg_inv, ser_string, ToHex, uint256_from_str from test_framework.messages import CInv, CTransaction, FromHex, hash256, msg_clsig, msg_inv, ser_string, ToHex, uint256_from_str
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes, wait_until from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes, wait_until

View File

@ -14,7 +14,7 @@ from io import BytesIO
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, QuorumId, ser_uint256, sha256 from test_framework.messages import CBlock, CBlockHeader, CCbTx, CMerkleBlock, FromHex, hash256, msg_getmnlistd, QuorumId, ser_uint256, sha256
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
assert_greater_than_or_equal, assert_greater_than_or_equal,

View File

@ -11,7 +11,7 @@ Checks LLMQs signing sessions
''' '''
from test_framework.messages import CSigShare, msg_qsigshare, uint256_to_string from test_framework.messages import CSigShare, msg_qsigshare, uint256_to_string
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, hex_str_to_bytes, wait_until from test_framework.util import assert_equal, assert_raises_rpc_error, force_finish_mnsync, hex_str_to_bytes, wait_until

View File

@ -13,7 +13,7 @@ if uploadtarget has been reached.
from collections import defaultdict from collections import defaultdict
from test_framework.messages import CInv, MAX_BLOCK_SIZE, MSG_BLOCK, msg_getdata from test_framework.messages import CInv, MAX_BLOCK_SIZE, MSG_BLOCK, msg_getdata
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, mine_large_block, set_node_times from test_framework.util import assert_equal, mine_large_block, set_node_times

View File

@ -12,7 +12,7 @@ import re
from test_framework.blocktools import create_block, create_coinbase from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import msg_block from test_framework.messages import msg_block
from test_framework.mininode import P2PInterface, mininode_lock from test_framework.p2p import p2p_lock, P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import wait_until from test_framework.util import wait_until
@ -91,7 +91,7 @@ class VersionBitsWarningTest(BitcoinTestFramework):
# Generating one block guarantees that we'll get out of IBD # Generating one block guarantees that we'll get out of IBD
node.generatetoaddress(1, node_deterministic_address) node.generatetoaddress(1, node_deterministic_address)
wait_until(lambda: not node.getblockchaininfo()['initialblockdownload'], timeout=10, lock=mininode_lock) wait_until(lambda: not node.getblockchaininfo()['initialblockdownload'], timeout=10, lock=p2p_lock)
# Generating one more block will be enough to generate an error. # Generating one more block will be enough to generate an error.
node.generatetoaddress(1, node_deterministic_address) node.generatetoaddress(1, node_deterministic_address)
# Check that get*info() shows the versionbits unknown rules warning # Check that get*info() shows the versionbits unknown rules warning

View File

@ -13,7 +13,7 @@ import struct
import time import time
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.util import assert_equal, assert_raises_rpc_error from test_framework.util import assert_equal, assert_raises_rpc_error
from test_framework.messages import ( from test_framework.messages import (
CBlock, CBlock,

View File

@ -8,7 +8,7 @@ from decimal import Decimal
from test_framework.blocktools import COINBASE_MATURITY from test_framework.blocktools import COINBASE_MATURITY
from test_framework.messages import COIN from test_framework.messages import COIN
from test_framework.mininode import P2PTxInvStore from test_framework.p2p import P2PTxInvStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -38,8 +38,8 @@ Test is as follows:
from decimal import Decimal from decimal import Decimal
import os import os
# from test_framework.p2p import P2PTxInvStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
# from test_framework.mininode import P2PTxInvStore
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
assert_greater_than_or_equal, assert_raises_rpc_error, assert_greater_than_or_equal, assert_raises_rpc_error,

View File

@ -7,7 +7,7 @@ to peers until a GETDATA is received."""
import time import time
from test_framework.mininode import P2PTxInvStore from test_framework.p2p import P2PTxInvStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -19,7 +19,7 @@ from test_framework.messages import (
CBlockHeader, CBlockHeader,
BLOCK_HEADER_SIZE, BLOCK_HEADER_SIZE,
) )
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -11,9 +11,7 @@ from test_framework.messages import (
NODE_NETWORK, NODE_NETWORK,
msg_addr, msg_addr,
) )
from test_framework.mininode import ( from test_framework.p2p import P2PInterface
P2PInterface,
)
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -11,7 +11,7 @@ from test_framework.messages import (
msg_addrv2, msg_addrv2,
NODE_NETWORK, NODE_NETWORK,
) )
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal, wait_until

View File

@ -18,7 +18,7 @@ from test_framework.messages import (
ser_uint256, ser_uint256,
uint256_from_str, uint256_from_str,
) )
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -5,7 +5,7 @@
"""Test p2p blocksonly""" """Test p2p blocksonly"""
from test_framework.messages import msg_tx, CTransaction, FromHex from test_framework.messages import msg_tx, CTransaction, FromHex
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal from test_framework.util import assert_equal

View File

@ -9,7 +9,7 @@ import random
from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase
from test_framework.messages import BlockTransactions, BlockTransactionsRequest, calculate_shortid, CBlock, CBlockHeader, CInv, COutPoint, CTransaction, CTxIn, CTxOut, FromHex, HeaderAndShortIDs, msg_block, msg_blocktxn, msg_cmpctblock, msg_getblocktxn, msg_getdata, msg_getheaders, msg_headers, msg_inv, msg_sendcmpct, msg_sendheaders, msg_tx, MSG_BLOCK, MSG_CMPCT_BLOCK, NODE_NETWORK, P2PHeaderAndShortIDs, PrefilledTransaction, ToHex, NODE_HEADERS_COMPRESSED from test_framework.messages import BlockTransactions, BlockTransactionsRequest, calculate_shortid, CBlock, CBlockHeader, CInv, COutPoint, CTransaction, CTxIn, CTxOut, FromHex, HeaderAndShortIDs, msg_block, msg_blocktxn, msg_cmpctblock, msg_getblocktxn, msg_getdata, msg_getheaders, msg_headers, msg_inv, msg_sendcmpct, msg_sendheaders, msg_tx, MSG_BLOCK, MSG_CMPCT_BLOCK, NODE_NETWORK, P2PHeaderAndShortIDs, PrefilledTransaction, ToHex, NODE_HEADERS_COMPRESSED
from test_framework.mininode import mininode_lock, P2PInterface from test_framework.p2p import p2p_lock, P2PInterface
from test_framework.script import CScript, OP_TRUE, OP_DROP from test_framework.script import CScript, OP_TRUE, OP_DROP
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal, wait_until
@ -46,12 +46,12 @@ class TestP2PConn(P2PInterface):
self.block_announced = True self.block_announced = True
self.announced_blockhashes.add(x.hash) self.announced_blockhashes.add(x.hash)
# Requires caller to hold mininode_lock # Requires caller to hold p2p_lock
def received_block_announcement(self): def received_block_announcement(self):
return self.block_announced return self.block_announced
def clear_block_announcement(self): def clear_block_announcement(self):
with mininode_lock: with p2p_lock:
self.block_announced = False self.block_announced = False
self.last_message.pop("inv", None) self.last_message.pop("inv", None)
self.last_message.pop("headers", None) self.last_message.pop("headers", None)
@ -71,7 +71,7 @@ class TestP2PConn(P2PInterface):
def request_headers_and_sync(self, locator, hashstop=0): def request_headers_and_sync(self, locator, hashstop=0):
self.clear_block_announcement() self.clear_block_announcement()
self.get_headers(locator, hashstop) self.get_headers(locator, hashstop)
wait_until(self.received_block_announcement, timeout=30, lock=mininode_lock) wait_until(self.received_block_announcement, timeout=30, lock=p2p_lock)
self.clear_block_announcement() self.clear_block_announcement()
# Block until a block announcement for a particular block hash is # Block until a block announcement for a particular block hash is
@ -79,7 +79,7 @@ class TestP2PConn(P2PInterface):
def wait_for_block_announcement(self, block_hash, timeout=30): def wait_for_block_announcement(self, block_hash, timeout=30):
def received_hash(): def received_hash():
return (block_hash in self.announced_blockhashes) return (block_hash in self.announced_blockhashes)
wait_until(received_hash, timeout=timeout, lock=mininode_lock) wait_until(received_hash, timeout=timeout, lock=p2p_lock)
def send_await_disconnect(self, message, timeout=30): def send_await_disconnect(self, message, timeout=30):
"""Sends a message to the node and wait for disconnect. """Sends a message to the node and wait for disconnect.
@ -87,7 +87,7 @@ class TestP2PConn(P2PInterface):
This is used when we want to send a message into the node that we expect This is used when we want to send a message into the node that we expect
will get us disconnected, eg an invalid block.""" will get us disconnected, eg an invalid block."""
self.send_message(message) self.send_message(message)
wait_until(lambda: not self.is_connected, timeout=timeout, lock=mininode_lock) wait_until(lambda: not self.is_connected, timeout=timeout, lock=p2p_lock)
class CompactBlocksTest(BitcoinTestFramework): class CompactBlocksTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
@ -149,8 +149,8 @@ class CompactBlocksTest(BitcoinTestFramework):
# Make sure we get a SENDCMPCT message from our peer # Make sure we get a SENDCMPCT message from our peer
def received_sendcmpct(): def received_sendcmpct():
return (len(test_node.last_sendcmpct) > 0) return (len(test_node.last_sendcmpct) > 0)
wait_until(received_sendcmpct, timeout=30, lock=mininode_lock) wait_until(received_sendcmpct, timeout=30, lock=p2p_lock)
with mininode_lock: with p2p_lock:
# Check that the first version received is the preferred one # Check that the first version received is the preferred one
assert_equal(test_node.last_sendcmpct[0].version, preferred_version) assert_equal(test_node.last_sendcmpct[0].version, preferred_version)
# And that we receive versions down to 1. # And that we receive versions down to 1.
@ -165,7 +165,7 @@ class CompactBlocksTest(BitcoinTestFramework):
peer.wait_for_block_announcement(block_hash, timeout=30) peer.wait_for_block_announcement(block_hash, timeout=30)
assert peer.block_announced assert peer.block_announced
with mininode_lock: with p2p_lock:
assert predicate(peer), ( assert predicate(peer), (
"block_hash={!r}, cmpctblock={!r}, inv={!r}".format( "block_hash={!r}, cmpctblock={!r}, inv={!r}".format(
block_hash, peer.last_message.get("cmpctblock", None), peer.last_message.get("inv", None))) block_hash, peer.last_message.get("cmpctblock", None), peer.last_message.get("inv", None)))
@ -272,11 +272,11 @@ class CompactBlocksTest(BitcoinTestFramework):
block.rehash() block.rehash()
# Wait until the block was announced (via compact blocks) # Wait until the block was announced (via compact blocks)
wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=mininode_lock) wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock)
# Now fetch and check the compact block # Now fetch and check the compact block
header_and_shortids = None header_and_shortids = None
with mininode_lock: with p2p_lock:
assert "cmpctblock" in test_node.last_message assert "cmpctblock" in test_node.last_message
# Convert the on-the-wire representation to absolute indexes # Convert the on-the-wire representation to absolute indexes
header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids) header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
@ -287,11 +287,11 @@ class CompactBlocksTest(BitcoinTestFramework):
inv = CInv(MSG_CMPCT_BLOCK, block_hash) # 20 == "CompactBlock" inv = CInv(MSG_CMPCT_BLOCK, block_hash) # 20 == "CompactBlock"
test_node.send_message(msg_getdata([inv])) test_node.send_message(msg_getdata([inv]))
wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=mininode_lock) wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock)
# Now fetch and check the compact block # Now fetch and check the compact block
header_and_shortids = None header_and_shortids = None
with mininode_lock: with p2p_lock:
assert "cmpctblock" in test_node.last_message assert "cmpctblock" in test_node.last_message
# Convert the on-the-wire representation to absolute indexes # Convert the on-the-wire representation to absolute indexes
header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids) header_and_shortids = HeaderAndShortIDs(test_node.last_message["cmpctblock"].header_and_shortids)
@ -345,7 +345,7 @@ class CompactBlocksTest(BitcoinTestFramework):
if announce == "inv": if announce == "inv":
test_node.send_message(msg_inv([CInv(MSG_BLOCK, block.sha256)])) test_node.send_message(msg_inv([CInv(MSG_BLOCK, block.sha256)]))
getheaders_key = "getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders" getheaders_key = "getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders"
wait_until(lambda: getheaders_key in test_node.last_message, timeout=30, lock=mininode_lock) wait_until(lambda: getheaders_key in test_node.last_message, timeout=30, lock=p2p_lock)
test_node.send_header_for_blocks([block]) test_node.send_header_for_blocks([block])
else: else:
test_node.send_header_for_blocks([block]) test_node.send_header_for_blocks([block])
@ -362,7 +362,7 @@ class CompactBlocksTest(BitcoinTestFramework):
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p())) test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock) assert_equal(int(node.getbestblockhash(), 16), block.hashPrevBlock)
# Expect a getblocktxn message. # Expect a getblocktxn message.
with mininode_lock: with p2p_lock:
assert "getblocktxn" in test_node.last_message assert "getblocktxn" in test_node.last_message
absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute() absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute()
assert_equal(absolute_indexes, [0]) # should be a coinbase request assert_equal(absolute_indexes, [0]) # should be a coinbase request
@ -399,7 +399,7 @@ class CompactBlocksTest(BitcoinTestFramework):
def test_getblocktxn_response(compact_block, peer, expected_result): def test_getblocktxn_response(compact_block, peer, expected_result):
msg = msg_cmpctblock(compact_block.to_p2p()) msg = msg_cmpctblock(compact_block.to_p2p())
peer.send_and_ping(msg) peer.send_and_ping(msg)
with mininode_lock: with p2p_lock:
assert "getblocktxn" in peer.last_message assert "getblocktxn" in peer.last_message
absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute() absolute_indexes = peer.last_message["getblocktxn"].block_txn_request.to_absolute()
assert_equal(absolute_indexes, expected_result) assert_equal(absolute_indexes, expected_result)
@ -462,13 +462,13 @@ class CompactBlocksTest(BitcoinTestFramework):
assert tx.hash in mempool assert tx.hash in mempool
# Clear out last request. # Clear out last request.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getblocktxn", None) test_node.last_message.pop("getblocktxn", None)
# Send compact block # Send compact block
comp_block.initialize_from_block(block, prefill_list=[0]) comp_block.initialize_from_block(block, prefill_list=[0])
test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256) test_tip_after_message(node, test_node, msg_cmpctblock(comp_block.to_p2p()), block.sha256)
with mininode_lock: with p2p_lock:
# Shouldn't have gotten a request for any transaction # Shouldn't have gotten a request for any transaction
assert "getblocktxn" not in test_node.last_message assert "getblocktxn" not in test_node.last_message
@ -494,7 +494,7 @@ class CompactBlocksTest(BitcoinTestFramework):
comp_block.initialize_from_block(block, prefill_list=[0]) comp_block.initialize_from_block(block, prefill_list=[0])
test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p())) test_node.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
absolute_indexes = [] absolute_indexes = []
with mininode_lock: with p2p_lock:
assert "getblocktxn" in test_node.last_message assert "getblocktxn" in test_node.last_message
absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute() absolute_indexes = test_node.last_message["getblocktxn"].block_txn_request.to_absolute()
assert_equal(absolute_indexes, [6, 7, 8, 9, 10]) assert_equal(absolute_indexes, [6, 7, 8, 9, 10])
@ -538,10 +538,10 @@ class CompactBlocksTest(BitcoinTestFramework):
num_to_request = random.randint(1, len(block.vtx)) num_to_request = random.randint(1, len(block.vtx))
msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request))) msg.block_txn_request.from_absolute(sorted(random.sample(range(len(block.vtx)), num_to_request)))
test_node.send_message(msg) test_node.send_message(msg)
wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10, lock=mininode_lock) wait_until(lambda: "blocktxn" in test_node.last_message, timeout=10, lock=p2p_lock)
[tx.calc_sha256() for tx in block.vtx] [tx.calc_sha256() for tx in block.vtx]
with mininode_lock: with p2p_lock:
assert_equal(test_node.last_message["blocktxn"].block_transactions.blockhash, int(block_hash, 16)) assert_equal(test_node.last_message["blocktxn"].block_transactions.blockhash, int(block_hash, 16))
all_indices = msg.block_txn_request.to_absolute() all_indices = msg.block_txn_request.to_absolute()
for index in all_indices: for index in all_indices:
@ -555,11 +555,11 @@ class CompactBlocksTest(BitcoinTestFramework):
# allowed depth for a blocktxn response. # allowed depth for a blocktxn response.
block_hash = node.getblockhash(current_height) block_hash = node.getblockhash(current_height)
msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [0]) msg.block_txn_request = BlockTransactionsRequest(int(block_hash, 16), [0])
with mininode_lock: with p2p_lock:
test_node.last_message.pop("block", None) test_node.last_message.pop("block", None)
test_node.last_message.pop("blocktxn", None) test_node.last_message.pop("blocktxn", None)
test_node.send_and_ping(msg) test_node.send_and_ping(msg)
with mininode_lock: with p2p_lock:
test_node.last_message["block"].block.calc_sha256() test_node.last_message["block"].block.calc_sha256()
assert_equal(test_node.last_message["block"].block.sha256, int(block_hash, 16)) assert_equal(test_node.last_message["block"].block.sha256, int(block_hash, 16))
assert "blocktxn" not in test_node.last_message assert "blocktxn" not in test_node.last_message
@ -572,21 +572,21 @@ class CompactBlocksTest(BitcoinTestFramework):
for _ in range(MAX_CMPCTBLOCK_DEPTH + 1): for _ in range(MAX_CMPCTBLOCK_DEPTH + 1):
test_node.clear_block_announcement() test_node.clear_block_announcement()
new_blocks.append(node.generate(1)[0]) new_blocks.append(node.generate(1)[0])
wait_until(test_node.received_block_announcement, timeout=30, lock=mininode_lock) wait_until(test_node.received_block_announcement, timeout=30, lock=p2p_lock)
test_node.clear_block_announcement() test_node.clear_block_announcement()
test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))])) test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=mininode_lock) wait_until(lambda: "cmpctblock" in test_node.last_message, timeout=30, lock=p2p_lock)
test_node.clear_block_announcement() test_node.clear_block_announcement()
node.generate(1) node.generate(1)
wait_until(test_node.received_block_announcement, timeout=30, lock=mininode_lock) wait_until(test_node.received_block_announcement, timeout=30, lock=p2p_lock)
test_node.clear_block_announcement() test_node.clear_block_announcement()
with mininode_lock: with p2p_lock:
test_node.last_message.pop("block", None) test_node.last_message.pop("block", None)
test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))])) test_node.send_message(msg_getdata([CInv(MSG_CMPCT_BLOCK, int(new_blocks[0], 16))]))
wait_until(lambda: "block" in test_node.last_message, timeout=30, lock=mininode_lock) wait_until(lambda: "block" in test_node.last_message, timeout=30, lock=p2p_lock)
with mininode_lock: with p2p_lock:
test_node.last_message["block"].block.calc_sha256() test_node.last_message["block"].block.calc_sha256()
assert_equal(test_node.last_message["block"].block.sha256, int(new_blocks[0], 16)) assert_equal(test_node.last_message["block"].block.sha256, int(new_blocks[0], 16))
@ -614,10 +614,10 @@ class CompactBlocksTest(BitcoinTestFramework):
# (to avoid fingerprinting attacks). # (to avoid fingerprinting attacks).
msg = msg_getblocktxn() msg = msg_getblocktxn()
msg.block_txn_request = BlockTransactionsRequest(block.sha256, [0]) msg.block_txn_request = BlockTransactionsRequest(block.sha256, [0])
with mininode_lock: with p2p_lock:
test_node.last_message.pop("blocktxn", None) test_node.last_message.pop("blocktxn", None)
test_node.send_and_ping(msg) test_node.send_and_ping(msg)
with mininode_lock: with p2p_lock:
assert "blocktxn" not in test_node.last_message assert "blocktxn" not in test_node.last_message
def test_end_to_end_block_relay(self, listeners): def test_end_to_end_block_relay(self, listeners):
@ -631,8 +631,8 @@ class CompactBlocksTest(BitcoinTestFramework):
node.submitblock(ToHex(block)) node.submitblock(ToHex(block))
for l in listeners: for l in listeners:
wait_until(lambda: "cmpctblock" in l.last_message, timeout=30, lock=mininode_lock) wait_until(lambda: "cmpctblock" in l.last_message, timeout=30, lock=p2p_lock)
with mininode_lock: with p2p_lock:
for l in listeners: for l in listeners:
assert "cmpctblock" in l.last_message assert "cmpctblock" in l.last_message
l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256() l.last_message["cmpctblock"].header_and_shortids.header.calc_sha256()
@ -681,7 +681,7 @@ class CompactBlocksTest(BitcoinTestFramework):
cmpct_block.initialize_from_block(block) cmpct_block.initialize_from_block(block)
msg = msg_cmpctblock(cmpct_block.to_p2p()) msg = msg_cmpctblock(cmpct_block.to_p2p())
peer.send_and_ping(msg) peer.send_and_ping(msg)
with mininode_lock: with p2p_lock:
assert "getblocktxn" in peer.last_message assert "getblocktxn" in peer.last_message
return block, cmpct_block return block, cmpct_block

View File

@ -4,7 +4,7 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php. # file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test being able to connect to the same devnet""" """Test being able to connect to the same devnet"""
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal from test_framework.util import assert_equal

View File

@ -15,11 +15,11 @@ Therefore, this test is limited to the remaining protection criteria.
import time import time
from test_framework.test_framework import BitcoinTestFramework
from test_framework.mininode import P2PInterface, P2PDataStore
from test_framework.util import assert_equal, wait_until
from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase from test_framework.blocktools import COINBASE_MATURITY, create_block, create_coinbase
from test_framework.messages import CTransaction, FromHex, msg_pong, msg_tx from test_framework.messages import CTransaction, FromHex, msg_pong, msg_tx
from test_framework.p2p import P2PDataStore, P2PInterface
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until
class SlowP2PDataStore(P2PDataStore): class SlowP2PDataStore(P2PDataStore):

View File

@ -19,7 +19,7 @@ from test_framework.messages import (
msg_mempool, msg_mempool,
msg_version, msg_version,
) )
from test_framework.mininode import P2PInterface, mininode_lock from test_framework.p2p import P2PInterface, p2p_lock
from test_framework.script import MAX_SCRIPT_ELEMENT_SIZE from test_framework.script import MAX_SCRIPT_ELEMENT_SIZE
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
@ -60,22 +60,22 @@ class P2PBloomFilter(P2PInterface):
@property @property
def tx_received(self): def tx_received(self):
with mininode_lock: with p2p_lock:
return self._tx_received return self._tx_received
@tx_received.setter @tx_received.setter
def tx_received(self, value): def tx_received(self, value):
with mininode_lock: with p2p_lock:
self._tx_received = value self._tx_received = value
@property @property
def merkleblock_received(self): def merkleblock_received(self):
with mininode_lock: with p2p_lock:
return self._merkleblock_received return self._merkleblock_received
@merkleblock_received.setter @merkleblock_received.setter
def merkleblock_received(self, value): def merkleblock_received(self, value):
with mininode_lock: with p2p_lock:
self._merkleblock_received = value self._merkleblock_received = value

View File

@ -11,7 +11,7 @@ import time
from test_framework.blocktools import (create_block, create_coinbase) from test_framework.blocktools import (create_block, create_coinbase)
from test_framework.messages import CInv, MSG_BLOCK from test_framework.messages import CInv, MSG_BLOCK
from test_framework.mininode import ( from test_framework.p2p import (
P2PInterface, P2PInterface,
msg_headers, msg_headers,
msg_block, msg_block,

View File

@ -5,9 +5,9 @@
"""Test addr response caching""" """Test addr response caching"""
from test_framework.messages import msg_getaddr from test_framework.messages import msg_getaddr
from test_framework.mininode import ( from test_framework.p2p import (
P2PInterface, P2PInterface,
mininode_lock p2p_lock
) )
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
@ -27,7 +27,7 @@ class AddrReceiver(P2PInterface):
self.received_addrs = None self.received_addrs = None
def get_received_addrs(self): def get_received_addrs(self):
with mininode_lock: with p2p_lock:
return self.received_addrs return self.received_addrs
def on_addr(self, message): def on_addr(self, message):

View File

@ -9,7 +9,7 @@ from test_framework.messages import (
CInv, CInv,
msg_getdata, msg_getdata,
) )
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework

View File

@ -14,7 +14,7 @@ import copy
from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script
from test_framework.messages import COIN from test_framework.messages import COIN
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal from test_framework.util import assert_equal

View File

@ -6,7 +6,7 @@
""" """
from test_framework.messages import msg_getheaders, msg_getblocks, MAX_LOCATOR_SZ from test_framework.messages import msg_getheaders, msg_getblocks, MAX_LOCATOR_SZ
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework

View File

@ -15,7 +15,7 @@ from test_framework.messages import (
msg_inv, msg_inv,
MSG_TX, MSG_TX,
) )
from test_framework.mininode import ( from test_framework.p2p import (
P2PDataStore, P2PInterface P2PDataStore, P2PInterface
) )
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework

View File

@ -14,7 +14,7 @@ from test_framework.messages import (
CTxIn, CTxIn,
CTxOut, CTxOut,
) )
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -19,7 +19,7 @@ from test_framework.messages import (
msg_verack, msg_verack,
msg_version, msg_version,
) )
from test_framework.mininode import mininode_lock, P2PInterface from test_framework.p2p import p2p_lock, P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
@ -121,9 +121,9 @@ class P2PLeakTest(BitcoinTestFramework):
# verack, since we never sent one # verack, since we never sent one
no_verack_idlenode.wait_for_verack() no_verack_idlenode.wait_for_verack()
wait_until(lambda: no_version_bannode.ever_connected, timeout=10, lock=mininode_lock) wait_until(lambda: no_version_bannode.ever_connected, timeout=10, lock=p2p_lock)
wait_until(lambda: no_version_idlenode.ever_connected, timeout=10, lock=mininode_lock) wait_until(lambda: no_version_idlenode.ever_connected, timeout=10, lock=p2p_lock)
wait_until(lambda: no_verack_idlenode.version_received, timeout=10, lock=mininode_lock) wait_until(lambda: no_verack_idlenode.version_received, timeout=10, lock=p2p_lock)
# Mine a block and make sure that it's not sent to the connected nodes # Mine a block and make sure that it's not sent to the connected nodes
self.nodes[0].generatetoaddress(1, self.nodes[0].get_deterministic_priv_key().address) self.nodes[0].generatetoaddress(1, self.nodes[0].get_deterministic_priv_key().address)

View File

@ -5,7 +5,7 @@
"""Test that we don't leak txs to inbound peers that we haven't yet announced to""" """Test that we don't leak txs to inbound peers that we haven't yet announced to"""
from test_framework.messages import msg_getdata, CInv, MSG_TX from test_framework.messages import msg_getdata, CInv, MSG_TX
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,

View File

@ -12,7 +12,7 @@ Test that, when bloom filters are not enabled, peers are disconnected if:
""" """
from test_framework.messages import msg_mempool, msg_filteradd, msg_filterload, msg_filterclear from test_framework.messages import msg_mempool, msg_filteradd, msg_filterload, msg_filterclear
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal from test_framework.util import assert_equal

View File

@ -9,7 +9,7 @@ and that it responds to getdata requests for blocks correctly:
- send a block within 288 + 2 of the tip - send a block within 288 + 2 of the tip
- disconnect peers who request blocks older than that.""" - disconnect peers who request blocks older than that."""
from test_framework.messages import CInv, MSG_BLOCK, msg_getdata, NODE_BLOOM, NODE_NETWORK_LIMITED, NODE_HEADERS_COMPRESSED, msg_verack from test_framework.messages import CInv, MSG_BLOCK, msg_getdata, NODE_BLOOM, NODE_NETWORK_LIMITED, NODE_HEADERS_COMPRESSED, msg_verack
from test_framework.mininode import P2PInterface, mininode_lock from test_framework.p2p import P2PInterface, p2p_lock
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal, wait_until
@ -22,7 +22,7 @@ class P2PIgnoreInv(P2PInterface):
self.firstAddrnServices = message.addrs[0].nServices self.firstAddrnServices = message.addrs[0].nServices
def wait_for_addr(self, timeout=5): def wait_for_addr(self, timeout=5):
test_function = lambda: self.last_message.get("addr") test_function = lambda: self.last_message.get("addr")
wait_until(test_function, timeout=timeout, lock=mininode_lock) wait_until(test_function, timeout=timeout, lock=p2p_lock)
def send_getdata_for_block(self, blockhash): def send_getdata_for_block(self, blockhash):
getdata_request = msg_getdata() getdata_request = msg_getdata()
getdata_request.inv.append(CInv(MSG_BLOCK, int(blockhash, 16))) getdata_request.inv.append(CInv(MSG_BLOCK, int(blockhash, 16)))

View File

@ -12,7 +12,7 @@ from test_framework.messages import (
CTransaction, CTransaction,
FromHex, FromHex,
) )
from test_framework.mininode import P2PDataStore from test_framework.p2p import P2PDataStore
from test_framework.script import ( from test_framework.script import (
CScript, CScript,
OP_TRUE, OP_TRUE,
@ -107,7 +107,7 @@ class P2PPermissionsTests(BitcoinTestFramework):
self.sync_all() self.sync_all()
self.log.debug("Create a connection from a forcerelay peer that rebroadcasts raw txs") self.log.debug("Create a connection from a forcerelay peer that rebroadcasts raw txs")
# A python mininode is needed to send the raw transaction directly. If a full node was used, it could only # A test framework p2p connection is needed to send the raw transaction directly. If a full node was used, it could only
# rebroadcast via the inv-getdata mechanism. However, even for forcerelay connections, a full node would # rebroadcast via the inv-getdata mechanism. However, even for forcerelay connections, a full node would
# currently not request a txid that is already in the mempool. # currently not request a txid that is already in the mempool.
self.restart_node(1, extra_args=["-whitelist=forcerelay@127.0.0.1"]) self.restart_node(1, extra_args=["-whitelist=forcerelay@127.0.0.1"])

View File

@ -6,8 +6,8 @@
import time import time
from test_framework.messages import msg_qgetdata, msg_qwatch from test_framework.messages import msg_qgetdata, msg_qwatch
from test_framework.mininode import ( from test_framework.p2p import (
mininode_lock, p2p_lock,
P2PInterface, P2PInterface,
) )
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
@ -106,7 +106,7 @@ class QuorumDataInterface(P2PInterface):
assert_qdata(self.get_qdata(), qgetdata, expected_error, len_vvec, len_contributions) assert_qdata(self.get_qdata(), qgetdata, expected_error, len_vvec, len_contributions)
def wait_for_qmessage(self, message=None, timeout=3, message_expected=True): def wait_for_qmessage(self, message=None, timeout=3, message_expected=True):
wait_until(lambda: self.message_count[message] > 0, timeout=timeout, lock=mininode_lock, do_assert=message_expected) wait_until(lambda: self.message_count[message] > 0, timeout=timeout, lock=p2p_lock, do_assert=message_expected)
if not message_expected: if not message_expected:
assert self.message_count[message] == 0 assert self.message_count[message] == 0
self.message_count[message] = 0 self.message_count[message] = 0

View File

@ -87,10 +87,10 @@ e. Announce one more that doesn't connect.
""" """
from test_framework.blocktools import create_block, create_coinbase from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import CInv, NODE_HEADERS_COMPRESSED from test_framework.messages import CInv, NODE_HEADERS_COMPRESSED
from test_framework.mininode import ( from test_framework.p2p import (
CBlockHeader, CBlockHeader,
P2PInterface, P2PInterface,
mininode_lock, p2p_lock,
MSG_BLOCK, MSG_BLOCK,
msg_block, msg_block,
msg_getblocks, msg_getblocks,
@ -146,7 +146,7 @@ class BaseNode(P2PInterface):
def wait_for_block_announcement(self, block_hash, timeout=60): def wait_for_block_announcement(self, block_hash, timeout=60):
test_function = lambda: self.last_blockhash_announced == block_hash test_function = lambda: self.last_blockhash_announced == block_hash
wait_until(test_function, timeout=timeout, lock=mininode_lock) wait_until(test_function, timeout=timeout, lock=p2p_lock)
def on_inv(self, message): def on_inv(self, message):
self.block_announced = True self.block_announced = True
@ -162,7 +162,7 @@ class BaseNode(P2PInterface):
self.last_blockhash_announced = message.headers[-1].sha256 self.last_blockhash_announced = message.headers[-1].sha256
def clear_block_announcements(self): def clear_block_announcements(self):
with mininode_lock: with p2p_lock:
self.block_announced = False self.block_announced = False
self.last_message.pop("inv", None) self.last_message.pop("inv", None)
self.last_message.pop("headers", None) self.last_message.pop("headers", None)
@ -173,8 +173,8 @@ class BaseNode(P2PInterface):
"""Test whether the last headers announcements received are right. """Test whether the last headers announcements received are right.
Headers may be announced across more than one message.""" Headers may be announced across more than one message."""
test_function = lambda: (len(self.recent_headers_announced) >= len(headers)) test_function = lambda: (len(self.recent_headers_announced) >= len(headers))
wait_until(test_function, timeout=60, lock=mininode_lock) wait_until(test_function, timeout=60, lock=p2p_lock)
with mininode_lock: with p2p_lock:
assert_equal(self.recent_headers_announced, headers) assert_equal(self.recent_headers_announced, headers)
self.block_announced = False self.block_announced = False
self.last_message.pop("headers", None) self.last_message.pop("headers", None)
@ -185,9 +185,9 @@ class BaseNode(P2PInterface):
inv should be a list of block hashes.""" inv should be a list of block hashes."""
test_function = lambda: self.block_announced test_function = lambda: self.block_announced
wait_until(test_function, timeout=60, lock=mininode_lock) wait_until(test_function, timeout=60, lock=p2p_lock)
with mininode_lock: with p2p_lock:
compare_inv = [] compare_inv = []
if "inv" in self.last_message: if "inv" in self.last_message:
compare_inv = [x.hash for x in self.last_message["inv"].inv] compare_inv = [x.hash for x in self.last_message["inv"].inv]
@ -297,7 +297,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.send_header_for_blocks([new_block]) test_node.send_header_for_blocks([new_block])
test_node.wait_for_getdata([new_block.sha256]) test_node.wait_for_getdata([new_block.sha256])
test_node.send_and_ping(msg_block(new_block)) # make sure this block is processed test_node.send_and_ping(msg_block(new_block)) # make sure this block is processed
wait_until(lambda: inv_node.block_announced, timeout=60, lock=mininode_lock) wait_until(lambda: inv_node.block_announced, timeout=60, lock=p2p_lock)
inv_node.clear_block_announcements() inv_node.clear_block_announcements()
test_node.clear_block_announcements() test_node.clear_block_announcements()
@ -455,7 +455,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.send_header_for_blocks(blocks) test_node.send_header_for_blocks(blocks)
test_node.sync_with_ping() test_node.sync_with_ping()
# should not have received any getdata messages # should not have received any getdata messages
with mininode_lock: with p2p_lock:
assert "getdata" not in test_node.last_message assert "getdata" not in test_node.last_message
# This time, direct fetch should work # This time, direct fetch should work
@ -493,7 +493,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.last_message.pop("getdata", None) test_node.last_message.pop("getdata", None)
test_node.send_header_for_blocks(blocks[0:1]) test_node.send_header_for_blocks(blocks[0:1])
test_node.sync_with_ping() test_node.sync_with_ping()
with mininode_lock: with p2p_lock:
assert "getdata" not in test_node.last_message assert "getdata" not in test_node.last_message
# Announcing one more block on fork should trigger direct fetch for # Announcing one more block on fork should trigger direct fetch for
@ -512,7 +512,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.last_message.pop("getdata", None) test_node.last_message.pop("getdata", None)
test_node.send_header_for_blocks(blocks[18:19]) test_node.send_header_for_blocks(blocks[18:19])
test_node.sync_with_ping() test_node.sync_with_ping()
with mininode_lock: with p2p_lock:
assert "getdata" not in test_node.last_message assert "getdata" not in test_node.last_message
self.log.info("Part 4: success!") self.log.info("Part 4: success!")
@ -535,7 +535,7 @@ class SendHeadersTest(BitcoinTestFramework):
block_time += 1 block_time += 1
height += 1 height += 1
# Send the header of the second block -> this won't connect. # Send the header of the second block -> this won't connect.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None) test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None)
test_node.send_header_for_blocks([blocks[1]]) test_node.send_header_for_blocks([blocks[1]])
test_node.wait_for_getheaders() test_node.wait_for_getheaders()
@ -558,7 +558,7 @@ class SendHeadersTest(BitcoinTestFramework):
for i in range(1, MAX_UNCONNECTING_HEADERS): for i in range(1, MAX_UNCONNECTING_HEADERS):
# Send a header that doesn't connect, check that we get a getheaders. # Send a header that doesn't connect, check that we get a getheaders.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None) test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None)
test_node.send_header_for_blocks([blocks[i]]) test_node.send_header_for_blocks([blocks[i]])
test_node.wait_for_getheaders() test_node.wait_for_getheaders()
@ -573,7 +573,7 @@ class SendHeadersTest(BitcoinTestFramework):
# before we get disconnected. Should be 5*MAX_UNCONNECTING_HEADERS # before we get disconnected. Should be 5*MAX_UNCONNECTING_HEADERS
for i in range(5 * MAX_UNCONNECTING_HEADERS - 1): for i in range(5 * MAX_UNCONNECTING_HEADERS - 1):
# Send a header that doesn't connect, check that we get a getheaders. # Send a header that doesn't connect, check that we get a getheaders.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None) test_node.last_message.pop("getheaders2" if test_node.nServices & NODE_HEADERS_COMPRESSED else "getheaders", None)
test_node.send_header_for_blocks([blocks[i % len(blocks)]]) test_node.send_header_for_blocks([blocks[i % len(blocks)]])
test_node.wait_for_getheaders() test_node.wait_for_getheaders()

View File

@ -14,10 +14,10 @@ Setup:
""" """
from test_framework.blocktools import create_block, create_coinbase from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import CInv, NODE_HEADERS_COMPRESSED from test_framework.messages import CInv, NODE_HEADERS_COMPRESSED
from test_framework.mininode import ( from test_framework.p2p import (
CompressibleBlockHeader, CompressibleBlockHeader,
P2PInterface, P2PInterface,
mininode_lock, p2p_lock,
msg_block, msg_block,
msg_getblocks, msg_getblocks,
msg_getdata, msg_getdata,
@ -77,11 +77,11 @@ class BaseNode(P2PInterface):
return return
test_function = lambda: "getdata" in self.last_message and [inv.hash for inv in self.last_message["getdata"].inv] == hash_list test_function = lambda: "getdata" in self.last_message and [inv.hash for inv in self.last_message["getdata"].inv] == hash_list
wait_until(test_function, timeout=timeout, lock=mininode_lock) wait_until(test_function, timeout=timeout, lock=p2p_lock)
def wait_for_block_announcement(self, block_hash, timeout=60): def wait_for_block_announcement(self, block_hash, timeout=60):
test_function = lambda: self.last_blockhash_announced == block_hash test_function = lambda: self.last_blockhash_announced == block_hash
wait_until(test_function, timeout=timeout, lock=mininode_lock) wait_until(test_function, timeout=timeout, lock=p2p_lock)
def on_inv(self, message): def on_inv(self, message):
self.block_announced = True self.block_announced = True
@ -97,7 +97,7 @@ class BaseNode(P2PInterface):
self.last_blockhash_announced = message.headers[-1].sha256 self.last_blockhash_announced = message.headers[-1].sha256
def clear_block_announcements(self): def clear_block_announcements(self):
with mininode_lock: with p2p_lock:
self.block_announced = False self.block_announced = False
self.last_message.pop("inv", None) self.last_message.pop("inv", None)
self.last_message.pop("headers2", None) self.last_message.pop("headers2", None)
@ -107,8 +107,8 @@ class BaseNode(P2PInterface):
"""Test whether the last headers announcements received are right. """Test whether the last headers announcements received are right.
Headers may be announced across more than one message.""" Headers may be announced across more than one message."""
test_function = lambda: (len(self.recent_headers_announced) >= len(headers)) test_function = lambda: (len(self.recent_headers_announced) >= len(headers))
wait_until(test_function, timeout=60, lock=mininode_lock) wait_until(test_function, timeout=60, lock=p2p_lock)
with mininode_lock: with p2p_lock:
assert_equal(self.recent_headers_announced, headers) assert_equal(self.recent_headers_announced, headers)
self.block_announced = False self.block_announced = False
self.last_message.pop("headers2", None) self.last_message.pop("headers2", None)
@ -119,9 +119,9 @@ class BaseNode(P2PInterface):
inv should be a list of block hashes.""" inv should be a list of block hashes."""
test_function = lambda: self.block_announced test_function = lambda: self.block_announced
wait_until(test_function, timeout=60, lock=mininode_lock) wait_until(test_function, timeout=60, lock=p2p_lock)
with mininode_lock: with p2p_lock:
compare_inv = [] compare_inv = []
if "inv" in self.last_message: if "inv" in self.last_message:
compare_inv = [inv.hash for inv in self.last_message["inv"].inv] compare_inv = [inv.hash for inv in self.last_message["inv"].inv]
@ -304,7 +304,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.send_header_for_blocks([new_block]) test_node.send_header_for_blocks([new_block])
test_node.wait_for_getdata([new_block.sha256]) test_node.wait_for_getdata([new_block.sha256])
test_node.send_and_ping(msg_block(new_block)) # make sure this block is processed test_node.send_and_ping(msg_block(new_block)) # make sure this block is processed
wait_until(lambda: inv_node.block_announced, timeout=60, lock=mininode_lock) wait_until(lambda: inv_node.block_announced, timeout=60, lock=p2p_lock)
inv_node.clear_block_announcements() inv_node.clear_block_announcements()
test_node.clear_block_announcements() test_node.clear_block_announcements()
@ -462,7 +462,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.send_header_for_blocks(blocks) test_node.send_header_for_blocks(blocks)
test_node.sync_with_ping() test_node.sync_with_ping()
# should not have received any getdata messages # should not have received any getdata messages
with mininode_lock: with p2p_lock:
assert "getdata" not in test_node.last_message assert "getdata" not in test_node.last_message
# This time, direct fetch should work # This time, direct fetch should work
@ -500,7 +500,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.last_message.pop("getdata", None) test_node.last_message.pop("getdata", None)
test_node.send_header_for_blocks(blocks[0:1]) test_node.send_header_for_blocks(blocks[0:1])
test_node.sync_with_ping() test_node.sync_with_ping()
with mininode_lock: with p2p_lock:
assert "getdata" not in test_node.last_message assert "getdata" not in test_node.last_message
# Announcing one more block on fork should trigger direct fetch for # Announcing one more block on fork should trigger direct fetch for
@ -519,7 +519,7 @@ class SendHeadersTest(BitcoinTestFramework):
test_node.last_message.pop("getdata", None) test_node.last_message.pop("getdata", None)
test_node.send_header_for_blocks(blocks[18:19]) test_node.send_header_for_blocks(blocks[18:19])
test_node.sync_with_ping() test_node.sync_with_ping()
with mininode_lock: with p2p_lock:
assert "getdata" not in test_node.last_message assert "getdata" not in test_node.last_message
self.log.info("Part 4: success!") self.log.info("Part 4: success!")
@ -542,7 +542,7 @@ class SendHeadersTest(BitcoinTestFramework):
block_time += 1 block_time += 1
height += 1 height += 1
# Send the header of the second block -> this won't connect. # Send the header of the second block -> this won't connect.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getheaders2", None) test_node.last_message.pop("getheaders2", None)
test_node.send_header_for_blocks([blocks[1]]) test_node.send_header_for_blocks([blocks[1]])
test_node.wait_for_getheaders() test_node.wait_for_getheaders()
@ -565,7 +565,7 @@ class SendHeadersTest(BitcoinTestFramework):
for i in range(1, MAX_UNCONNECTING_HEADERS): for i in range(1, MAX_UNCONNECTING_HEADERS):
# Send a header that doesn't connect, check that we get a getheaders. # Send a header that doesn't connect, check that we get a getheaders.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getheaders2", None) test_node.last_message.pop("getheaders2", None)
test_node.send_header_for_blocks([blocks[i]]) test_node.send_header_for_blocks([blocks[i]])
test_node.wait_for_getheaders() test_node.wait_for_getheaders()
@ -580,7 +580,7 @@ class SendHeadersTest(BitcoinTestFramework):
# before we get disconnected. Should be 5*MAX_UNCONNECTING_HEADERS # before we get disconnected. Should be 5*MAX_UNCONNECTING_HEADERS
for i in range(5 * MAX_UNCONNECTING_HEADERS - 1): for i in range(5 * MAX_UNCONNECTING_HEADERS - 1):
# Send a header that doesn't connect, check that we get a getheaders. # Send a header that doesn't connect, check that we get a getheaders.
with mininode_lock: with p2p_lock:
test_node.last_message.pop("getheaders2", None) test_node.last_message.pop("getheaders2", None)
test_node.send_header_for_blocks([blocks[i % len(blocks)]]) test_node.send_header_for_blocks([blocks[i % len(blocks)]])
test_node.wait_for_getheaders() test_node.wait_for_getheaders()

View File

@ -24,7 +24,7 @@
from time import sleep from time import sleep
from test_framework.messages import msg_ping from test_framework.messages import msg_ping
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework

View File

@ -15,9 +15,9 @@ from test_framework.messages import (
msg_inv, msg_inv,
msg_notfound, msg_notfound,
) )
from test_framework.mininode import ( from test_framework.p2p import (
P2PInterface, P2PInterface,
mininode_lock, p2p_lock,
) )
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import ( from test_framework.util import (
@ -68,7 +68,7 @@ class TxDownloadTest(BitcoinTestFramework):
def getdata_found(peer_index): def getdata_found(peer_index):
p = self.nodes[0].p2ps[peer_index] p = self.nodes[0].p2ps[peer_index]
with mininode_lock: with p2p_lock:
return p.last_message.get("getdata") and p.last_message["getdata"].inv[-1].hash == txid return p.last_message.get("getdata") and p.last_message["getdata"].inv[-1].hash == txid
while outstanding_peer_index: while outstanding_peer_index:
@ -127,7 +127,7 @@ class TxDownloadTest(BitcoinTestFramework):
p = self.nodes[0].p2ps[0] p = self.nodes[0].p2ps[0]
with mininode_lock: with p2p_lock:
p.tx_getdata_count = 0 p.tx_getdata_count = 0
p.send_message(msg_inv([CInv(t=1, h=i) for i in txids])) p.send_message(msg_inv([CInv(t=1, h=i) for i in txids]))
@ -136,15 +136,15 @@ class TxDownloadTest(BitcoinTestFramework):
self.bump_mocktime(1) self.bump_mocktime(1)
return p.tx_getdata_count >= target return p.tx_getdata_count >= target
wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT), lock=mininode_lock) wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT), lock=p2p_lock)
with mininode_lock: with p2p_lock:
assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT) assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT)
self.log.info("Now check that if we send a NOTFOUND for a transaction, we'll get one more request") self.log.info("Now check that if we send a NOTFOUND for a transaction, we'll get one more request")
p.send_message(msg_notfound(vec=[CInv(t=1, h=txids[0])])) p.send_message(msg_notfound(vec=[CInv(t=1, h=txids[0])]))
wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT + 1), timeout=10, lock=mininode_lock) wait_until(lambda: wait_for_tx_getdata(MAX_GETDATA_IN_FLIGHT + 1), timeout=10, lock=p2p_lock)
with mininode_lock: with p2p_lock:
assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1) assert_equal(p.tx_getdata_count, MAX_GETDATA_IN_FLIGHT + 1)
WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL WAIT_TIME = TX_EXPIRY_INTERVAL // 2 + TX_EXPIRY_INTERVAL

View File

@ -54,7 +54,7 @@ Node1 is unused in tests 3-7:
from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script
from test_framework.messages import CBlockHeader, CInv, MSG_BLOCK, msg_block, msg_headers, msg_inv from test_framework.messages import CBlockHeader, CInv, MSG_BLOCK, msg_block, msg_headers, msg_inv
from test_framework.mininode import mininode_lock, P2PInterface from test_framework.p2p import p2p_lock, P2PInterface
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, assert_raises_rpc_error from test_framework.util import assert_equal, assert_raises_rpc_error
@ -194,13 +194,13 @@ class AcceptBlockTest(BitcoinTestFramework):
# 6. Try to get node to request the missing block. # 6. Try to get node to request the missing block.
# Poke the node with an inv for block at height 3 and see if that # Poke the node with an inv for block at height 3 and see if that
# triggers a getdata on block 2 (it should if block 2 is missing). # triggers a getdata on block 2 (it should if block 2 is missing).
with mininode_lock: with p2p_lock:
# Clear state so we can check the getdata request # Clear state so we can check the getdata request
test_node.last_message.pop("getdata", None) test_node.last_message.pop("getdata", None)
test_node.send_message(msg_inv([CInv(MSG_BLOCK, block_h3.sha256)])) test_node.send_message(msg_inv([CInv(MSG_BLOCK, block_h3.sha256)]))
test_node.sync_with_ping() test_node.sync_with_ping()
with mininode_lock: with p2p_lock:
getdata = test_node.last_message["getdata"] getdata = test_node.last_message["getdata"]
# Check that the getdata includes the right block # Check that the getdata includes the right block

View File

@ -22,17 +22,6 @@ from decimal import Decimal
import http.client import http.client
import subprocess import subprocess
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (
assert_equal,
assert_greater_than,
assert_greater_than_or_equal,
assert_raises,
assert_raises_rpc_error,
assert_is_hex_string,
assert_is_hash_string,
set_node_times,
)
from test_framework.blocktools import ( from test_framework.blocktools import (
create_block, create_block,
create_coinbase, create_coinbase,
@ -43,8 +32,17 @@ from test_framework.messages import (
FromHex, FromHex,
msg_block, msg_block,
) )
from test_framework.mininode import ( from test_framework.p2p import P2PInterface
P2PInterface, from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (
assert_equal,
assert_greater_than,
assert_greater_than_or_equal,
assert_raises,
assert_raises_rpc_error,
assert_is_hex_string,
assert_is_hash_string,
set_node_times,
) )

View File

@ -4,7 +4,7 @@
# file COPYING or http://www.opensource.org/licenses/mit-license.php. # file COPYING or http://www.opensource.org/licenses/mit-license.php.
from test_framework.messages import hash256 from test_framework.messages import hash256
from test_framework.mininode import P2PInterface from test_framework.p2p import P2PInterface
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes from test_framework.util import assert_equal, assert_raises_rpc_error, hex_str_to_bytes

View File

@ -7,6 +7,11 @@
Tests correspond to code in rpc/net.cpp. Tests correspond to code in rpc/net.cpp.
""" """
from test_framework.p2p import P2PInterface
import test_framework.messages
from test_framework.messages import (
NODE_NETWORK,
)
from test_framework.test_framework import DashTestFramework from test_framework.test_framework import DashTestFramework
from test_framework.util import ( from test_framework.util import (
assert_equal, assert_equal,
@ -16,11 +21,6 @@ from test_framework.util import (
p2p_port, p2p_port,
wait_until, wait_until,
) )
from test_framework.mininode import P2PInterface
import test_framework.messages
from test_framework.messages import (
NODE_NETWORK,
)
def assert_net_servicesnames(servicesflag, servicenames): def assert_net_servicesnames(servicesflag, servicenames):

View File

@ -33,7 +33,7 @@ import dash_hash
MIN_VERSION_SUPPORTED = 60001 MIN_VERSION_SUPPORTED = 60001
MY_VERSION = 70230 # MNLISTDIFF_CHAINLOCKS_PROTO_VERSION MY_VERSION = 70230 # MNLISTDIFF_CHAINLOCKS_PROTO_VERSION
MY_SUBVERSION = b"/python-mininode-tester:0.0.3%s/" MY_SUBVERSION = b"/python-p2p-tester:0.0.3%s/"
MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37) MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37)
MAX_LOCATOR_SZ = 101 MAX_LOCATOR_SZ = 101

View File

@ -4,10 +4,14 @@
# Copyright (c) 2010-2020 The Bitcoin Core developers # Copyright (c) 2010-2020 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying # Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php. # file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Dash P2P network half-a-node. """Test objects for interacting with a dashd node over the p2p protocol.
This python code was modified from ArtForz' public domain half-a-node, as The P2PInterface objects interact with the dashd nodes under test using the
found in the mini-node branch of http://github.com/jgarzik/pynode. node's p2p interface. They can be used to send messages to the node, and
callbacks can be registered that execute when messages are received from the
node. Messages are sent to/received from the node on an asyncio event loop.
State held inside the objects must be guarded by the p2p_lock to avoid data
races between the main testing thread and the event loop.
P2PConnection: A low-level connection object to a node's P2P interface P2PConnection: A low-level connection object to a node's P2P interface
P2PInterface: A high-level interface object for communicating to a node over P2P P2PInterface: A high-level interface object for communicating to a node over P2P
@ -79,7 +83,7 @@ from test_framework.messages import (
) )
from test_framework.util import wait_until from test_framework.util import wait_until
logger = logging.getLogger("TestFramework.mininode") logger = logging.getLogger("TestFramework.p2p")
MESSAGEMAP = { MESSAGEMAP = {
b"addr": msg_addr, b"addr": msg_addr,
@ -321,7 +325,7 @@ class P2PConnection(asyncio.Protocol):
class P2PInterface(P2PConnection): class P2PInterface(P2PConnection):
"""A high-level P2P interface class for communicating with a Bitcoin node. """A high-level P2P interface class for communicating with a Dash node.
This class provides high-level callbacks for processing P2P message This class provides high-level callbacks for processing P2P message
payloads, as well as convenience methods for interacting with the payloads, as well as convenience methods for interacting with the
@ -372,7 +376,7 @@ class P2PInterface(P2PConnection):
We keep a count of how many of each message type has been received We keep a count of how many of each message type has been received
and the most recent message of each type.""" and the most recent message of each type."""
with mininode_lock: with p2p_lock:
try: try:
msgtype = message.msgtype.decode('ascii') msgtype = message.msgtype.decode('ascii')
self.message_count[msgtype] += 1 self.message_count[msgtype] += 1
@ -453,7 +457,7 @@ class P2PInterface(P2PConnection):
# Connection helper methods # Connection helper methods
def wait_until(self, test_function, timeout=60): def wait_until(self, test_function, timeout=60):
wait_until(test_function, timeout=timeout, lock=mininode_lock, timeout_factor=self.timeout_factor) wait_until(test_function, timeout=timeout, lock=p2p_lock, timeout_factor=self.timeout_factor)
def wait_for_disconnect(self, timeout=60): def wait_for_disconnect(self, timeout=60):
test_function = lambda: not self.is_connected test_function = lambda: not self.is_connected
@ -495,7 +499,7 @@ class P2PInterface(P2PConnection):
return False return False
return last_filtered_block.merkleblock.header.rehash() == int(blockhash, 16) return last_filtered_block.merkleblock.header.rehash() == int(blockhash, 16)
wait_until(test_function, timeout=timeout, lock=mininode_lock) wait_until(test_function, timeout=timeout, lock=p2p_lock)
def wait_for_getdata(self, hash_list, timeout=60): def wait_for_getdata(self, hash_list, timeout=60):
@ -569,7 +573,7 @@ class P2PInterface(P2PConnection):
# P2PConnection acquires this lock whenever delivering a message to a P2PInterface. # P2PConnection acquires this lock whenever delivering a message to a P2PInterface.
# This lock should be acquired in the thread running the test logic to synchronize # This lock should be acquired in the thread running the test logic to synchronize
# access to any data shared with the P2PInterface or P2PConnection. # access to any data shared with the P2PInterface or P2PConnection.
mininode_lock = threading.Lock() p2p_lock = threading.Lock()
class NetworkThread(threading.Thread): class NetworkThread(threading.Thread):
@ -677,7 +681,7 @@ class P2PDataStore(P2PInterface):
- if success is False: assert that the node's tip doesn't advance - if success is False: assert that the node's tip doesn't advance
- if reject_reason is set: assert that the correct reject message is logged""" - if reject_reason is set: assert that the correct reject message is logged"""
with mininode_lock: with p2p_lock:
for block in blocks: for block in blocks:
self.block_store[block.sha256] = block self.block_store[block.sha256] = block
self.last_block_hash = block.sha256 self.last_block_hash = block.sha256
@ -710,7 +714,7 @@ class P2PDataStore(P2PInterface):
- if expect_disconnect is True: Skip the sync with ping - if expect_disconnect is True: Skip the sync with ping
- if reject_reason is set: assert that the correct reject message is logged.""" - if reject_reason is set: assert that the correct reject message is logged."""
with mininode_lock: with p2p_lock:
for tx in txs: for tx in txs:
self.tx_store[tx.sha256] = tx self.tx_store[tx.sha256] = tx
@ -749,7 +753,7 @@ class P2PTxInvStore(P2PInterface):
self.tx_invs_received[i.hash] += 1 self.tx_invs_received[i.hash] += 1
def get_invs(self): def get_invs(self):
with mininode_lock: with p2p_lock:
return list(self.tx_invs_received.keys()) return list(self.tx_invs_received.keys())
def wait_for_broadcast(self, txns, timeout=60): def wait_for_broadcast(self, txns, timeout=60):

View File

@ -35,8 +35,8 @@ from .messages import (
ser_string, ser_string,
) )
from .script import hash160 from .script import hash160
from .p2p import NetworkThread
from .test_node import TestNode from .test_node import TestNode
from .mininode import NetworkThread
from .util import ( from .util import (
PortSeed, PortSeed,
MAX_NODES, MAX_NODES,

View File

@ -572,7 +572,7 @@ class TestNode():
assert self.p2ps, self._node_msg("No p2p connection") assert self.p2ps, self._node_msg("No p2p connection")
return self.p2ps[0] return self.p2ps[0]
def num_connected_mininodes(self): def num_test_p2p_connections(self):
"""Return number of test framework p2p connections to the node.""" """Return number of test framework p2p connections to the node."""
return len([peer for peer in self.getpeerinfo() if peer['subver'] == MY_SUBVERSION.decode("utf-8")]) return len([peer for peer in self.getpeerinfo() if peer['subver'] == MY_SUBVERSION.decode("utf-8")])
@ -591,7 +591,7 @@ class TestNode():
wait_until(check_peers, timeout=5) wait_until(check_peers, timeout=5)
del self.p2ps[:] del self.p2ps[:]
wait_until(lambda: self.num_connected_mininodes() == 0) wait_until(lambda: self.num_test_p2p_connections() == 0)
class TestNodeCLIAttr: class TestNodeCLIAttr:

View File

@ -7,7 +7,7 @@ import time
from test_framework.blocktools import create_block, create_coinbase from test_framework.blocktools import create_block, create_coinbase
from test_framework.messages import ToHex from test_framework.messages import ToHex
from test_framework.mininode import P2PTxInvStore, mininode_lock from test_framework.p2p import P2PTxInvStore, p2p_lock
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, wait_until from test_framework.util import assert_equal, wait_until
@ -36,7 +36,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
def wait_p2p(): def wait_p2p():
self.bump_mocktime(1) self.bump_mocktime(1)
return node.p2p.tx_invs_received[txid] >= 1 return node.p2p.tx_invs_received[txid] >= 1
wait_until(wait_p2p, lock=mininode_lock) wait_until(wait_p2p, lock=p2p_lock)
# Add a second peer since txs aren't rebroadcast to the same peer (see filterInventoryKnown) # Add a second peer since txs aren't rebroadcast to the same peer (see filterInventoryKnown)
node.add_p2p_connection(P2PTxInvStore()) node.add_p2p_connection(P2PTxInvStore())
@ -74,7 +74,7 @@ class ResendWalletTransactionsTest(BitcoinTestFramework):
def wait_p2p_1(): def wait_p2p_1():
self.bump_mocktime(1) self.bump_mocktime(1)
return node.p2ps[1].tx_invs_received[txid] >= 1 return node.p2ps[1].tx_invs_received[txid] >= 1
wait_until(wait_p2p_1, lock=mininode_lock) wait_until(wait_p2p_1, lock=p2p_lock)
if __name__ == '__main__': if __name__ == '__main__':