Differential D9200 Diff 27650 test/functional/test_framework/mininode.py

Changeset View

Standalone View

test/functional/test_framework/mininode.py

Show All 22 Lines
import struct		import struct
import sys		import sys
import threading		import threading

from test_framework.messages import (		from test_framework.messages import (
CBlockHeader,		CBlockHeader,
MIN_VERSION_SUPPORTED,		MIN_VERSION_SUPPORTED,
msg_addr,		msg_addr,
		msg_addrv2,
msg_avapoll,		msg_avapoll,
msg_tcpavaresponse,		msg_tcpavaresponse,
msg_avahello,		msg_avahello,
msg_block,		msg_block,
MSG_BLOCK,		MSG_BLOCK,
msg_blocktxn,		msg_blocktxn,
msg_cfcheckpt,		msg_cfcheckpt,
msg_cfheaders,		msg_cfheaders,
Show All 10 Lines	from test_framework.messages import (
msg_getheaders,		msg_getheaders,
msg_headers,		msg_headers,
msg_inv,		msg_inv,
msg_mempool,		msg_mempool,
msg_merkleblock,		msg_merkleblock,
msg_notfound,		msg_notfound,
msg_ping,		msg_ping,
msg_pong,		msg_pong,
		msg_sendaddrv2,
msg_sendcmpct,		msg_sendcmpct,
msg_sendheaders,		msg_sendheaders,
msg_tx,		msg_tx,
MSG_TX,		MSG_TX,
MSG_TYPE_MASK,		MSG_TYPE_MASK,
msg_verack,		msg_verack,
msg_version,		msg_version,
NODE_NETWORK,		NODE_NETWORK,
sha256,		sha256,
)		)
from test_framework.util import wait_until		from test_framework.util import wait_until

logger = logging.getLogger("TestFramework.mininode")		logger = logging.getLogger("TestFramework.mininode")

MESSAGEMAP = {		MESSAGEMAP = {
b"addr": msg_addr,		b"addr": msg_addr,
		b"addrv2": msg_addrv2,
b"avapoll": msg_avapoll,		b"avapoll": msg_avapoll,
b"avaresponse": msg_tcpavaresponse,		b"avaresponse": msg_tcpavaresponse,
b"avahello": msg_avahello,		b"avahello": msg_avahello,
b"block": msg_block,		b"block": msg_block,
b"blocktxn": msg_blocktxn,		b"blocktxn": msg_blocktxn,
b"cfcheckpt": msg_cfcheckpt,		b"cfcheckpt": msg_cfcheckpt,
b"cfheaders": msg_cfheaders,		b"cfheaders": msg_cfheaders,
b"cfilter": msg_cfilter,		b"cfilter": msg_cfilter,
Show All 9 Lines	MESSAGEMAP = {
b"getheaders": msg_getheaders,		b"getheaders": msg_getheaders,
b"headers": msg_headers,		b"headers": msg_headers,
b"inv": msg_inv,		b"inv": msg_inv,
b"mempool": msg_mempool,		b"mempool": msg_mempool,
b"merkleblock": msg_merkleblock,		b"merkleblock": msg_merkleblock,
b"notfound": msg_notfound,		b"notfound": msg_notfound,
b"ping": msg_ping,		b"ping": msg_ping,
b"pong": msg_pong,		b"pong": msg_pong,
		b"sendaddrv2": msg_sendaddrv2,
b"sendcmpct": msg_sendcmpct,		b"sendcmpct": msg_sendcmpct,
b"sendheaders": msg_sendheaders,		b"sendheaders": msg_sendheaders,
b"tx": msg_tx,		b"tx": msg_tx,
b"verack": msg_verack,		b"verack": msg_verack,
b"version": msg_version,		b"version": msg_version,
}		}

MAGIC_BYTES = {		MAGIC_BYTES = {
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines	class P2PInterface(P2PConnection):

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
node over P2P.		node over P2P.

Individual testcases should subclass this and override the on_* methods		Individual testcases should subclass this and override the on_* methods
if they want to alter message handling behaviour."""		if they want to alter message handling behaviour."""

def __init__(self):		def __init__(self, support_addrv2=False):
super().__init__()		super().__init__()

# Track number of messages of each type received and the most recent		# Track number of messages of each type received and the most recent
# message of each type		# message of each type
self.message_count = defaultdict(int)		self.message_count = defaultdict(int)
self.last_message = {}		self.last_message = {}

# A count of the number of ping messages we've sent to the node		# A count of the number of ping messages we've sent to the node
self.ping_counter = 1		self.ping_counter = 1

# The network services received from the peer		# The network services received from the peer
self.nServices = 0		self.nServices = 0

		self.support_addrv2 = support_addrv2

def peer_connect(self, *args, services=NODE_NETWORK,		def peer_connect(self, *args, services=NODE_NETWORK,
send_version=True, **kwargs):		send_version=True, **kwargs):
create_conn = super().peer_connect(args, *kwargs)		create_conn = super().peer_connect(args, *kwargs)

if send_version:		if send_version:
# Send a version msg		# Send a version msg
vt = msg_version()		vt = msg_version()
vt.nServices = services		vt.nServices = services
Show All 31 Lines	class P2PInterface(P2PConnection):
def on_open(self):		def on_open(self):
pass		pass

def on_close(self):		def on_close(self):
pass		pass

def on_addr(self, message): pass		def on_addr(self, message): pass

		def on_addrv2(self, message): pass

def on_avapoll(self, message): pass		def on_avapoll(self, message): pass

def on_avaresponse(self, message): pass		def on_avaresponse(self, message): pass

def on_avahello(self, message): pass		def on_avahello(self, message): pass

def on_block(self, message): pass		def on_block(self, message): pass

Show All 30 Lines	class P2PInterface(P2PConnection):
def on_mempool(self, message): pass		def on_mempool(self, message): pass

def on_merkleblock(self, message): pass		def on_merkleblock(self, message): pass

def on_notfound(self, message): pass		def on_notfound(self, message): pass

def on_pong(self, message): pass		def on_pong(self, message): pass

		def on_sendaddrv2(self, message): pass

def on_sendcmpct(self, message): pass		def on_sendcmpct(self, message): pass

def on_sendheaders(self, message): pass		def on_sendheaders(self, message): pass

def on_tx(self, message): pass		def on_tx(self, message): pass

def on_inv(self, message):		def on_inv(self, message):
want = msg_getdata()		want = msg_getdata()
for i in message.inv:		for i in message.inv:
if i.type != 0:		if i.type != 0:
want.inv.append(i)		want.inv.append(i)
if len(want.inv):		if len(want.inv):
self.send_message(want)		self.send_message(want)

def on_ping(self, message):		def on_ping(self, message):
self.send_message(msg_pong(message.nonce))		self.send_message(msg_pong(message.nonce))

def on_verack(self, message):		def on_verack(self, message):
pass		pass

def on_version(self, message):		def on_version(self, message):
assert message.nVersion >= MIN_VERSION_SUPPORTED, "Version {} received. Test framework only supports versions greater than {}".format(		assert message.nVersion >= MIN_VERSION_SUPPORTED, "Version {} received. Test framework only supports versions greater than {}".format(
message.nVersion, MIN_VERSION_SUPPORTED)		message.nVersion, MIN_VERSION_SUPPORTED)
self.send_message(msg_verack())		self.send_message(msg_verack())
		if self.support_addrv2:
		self.send_message(msg_sendaddrv2())
self.nServices = message.nServices		self.nServices = message.nServices

# 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,		wait_until(test_function, timeout=timeout, lock=mininode_lock,
timeout_factor=self.timeout_factor)		timeout_factor=self.timeout_factor)

▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines