def test_block_hold_timeout(self):
block = btc_block()
block_hash = block.block_hash()
block_hold_msg_bytes = BlockHoldingMessage(block_hash, 1).rawbytes()
helpers.receive_node_message(self.node1, self.gateway_fileno, block_hold_msg_bytes)
helpers.receive_node_message(self.node1, self.blockchain_fileno, block.rawbytes())
block_hold_msg_bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(block_hold_msg_bytes_to_send, block_hold_msg_bytes)
self.assertEqual(1, len(self.node1.block_processing_service._holds.contents))
self.node1.on_bytes_sent(self.relay_fileno, len(block_hold_msg_bytes_to_send))
time.time = MagicMock(
return_value=time.time() + self.node1.block_processing_service._compute_hold_timeout(block))
self.node1.alarm_queue.fire_alarms()
# send ciphertext from node1, receipt from node2, key from node1
relayed_block = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(BroadcastMessage.MESSAGE_TYPE, relayed_block.tobytes())
self.node1.on_bytes_sent(self.relay_fileno, len(relayed_block))
helpers.receive_node_message(self.node2, self.relay_fileno, relayed_block)
block_receipt = self.node2.get_bytes_to_send(self.gateway_fileno)
self.assertIn(BlockReceivedMessage.MESSAGE_TYPE, block_receipt.tobytes())
helpers.receive_node_message(self.node1, self.gateway_fileno, block_receipt)
key_message = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(KeyMessage.MESSAGE_TYPE, key_message.tobytes())
self.assertNotEqual(OutputBuffer.EMPTY, bytearray(key_message.tobytes()))
helpers.receive_node_message(self.node2, self.relay_fileno, key_message)
bytes_to_blockchain = self.node2.get_bytes_to_send(self.blockchain_fileno)
block_bytes = block.rawbytes().tobytes()
self.assertEqual(block_bytes, bytes_to_blockchain[0:len(block_bytes)].tobytes())
def test_send_receive_block_decrypted(self):
self.node1.opts.encrypt_blocks = False
send_block = btc_block(int(time.time()))
self._populate_transaction_services(send_block)
# propagate block
helpers.receive_node_message(self.node1, self.blockchain_fileno, send_block.rawbytes())
block_hold_msg = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(BlockHoldingMessage.MESSAGE_TYPE, block_hold_msg.tobytes())
self.node1.on_bytes_sent(self.relay_fileno, len(block_hold_msg))
relayed_block = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(BroadcastMessage.MESSAGE_TYPE, relayed_block.tobytes())
self.node1.on_bytes_sent(self.relay_fileno, len(relayed_block))
# block directly propagated
helpers.receive_node_message(self.node2, self.relay_fileno, relayed_block)
bytes_to_blockchain = self.node2.get_bytes_to_send(self.blockchain_fileno)
self.assertEqual(len(send_block.rawbytes()), len(bytes_to_blockchain))
received_block = BlockBtcMessage(buf=bytearray(bytes_to_blockchain))
self.assertEqual(send_block.magic(), received_block.magic())
self.assertEqual(send_block.version(), received_block.version())
self.assertEqual(send_block.timestamp(), received_block.timestamp())
self.assertEqual(send_block.bits(), received_block.bits())
self.assertEqual(send_block.nonce(), received_block.nonce())
def test_recover_from_single_tx_short_id(self):
for tx_message in self.transactions_with_short_ids[:-1]:
helpers.receive_node_message(self.node1, self.relay_fileno,
tx_message.rawbytes())
helpers.clear_node_buffer(self.node1, self.blockchain_fileno)
_get_txs_message = self._send_compressed_block_to_node_1()
helpers.receive_node_message(
self.node1, self.relay_fileno,
self.transactions_with_short_ids[-1].rawbytes())
self._assert_sent_block_node_1()
def _verify_recovery_after_bad_message(self):
self.assertTrue(self.btc_node_connection.is_alive())
gateway_bytes_to_send = self.gateway_node.get_bytes_to_send(
self.local_node_fileno)
self.assertTrue(len(gateway_bytes_to_send) > 0)
self.gateway_node.on_bytes_sent(self.local_node_fileno,
len(gateway_bytes_to_send))
self.assertTrue(self.btc_node_connection.num_bad_messages > 0)
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
self.txmsg)
self.assertEqual(0, self.btc_node_connection.num_bad_messages)
def test_block_headers_request(self):
sent_get_headers = GetHeadersBtcMessage(12345, 23456, [self.HASH],
self.HASH)
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
sent_get_headers.rawbytes())
self.btc_remote_node_connection.enqueue_msg.assert_called_once_with(
sent_get_headers)
response_headers = HeadersBtcMessage(12345, [])
helpers.receive_node_message(self.gateway_node,
self.remote_node_fileno,
response_headers.rawbytes())
self.btc_node_connection.enqueue_msg.assert_called_once_with(
response_headers)
def test_recover_multiple_iterations(self):
for tx_message in self.transactions:
helpers.receive_node_message(self.node1, self.relay_fileno,
tx_message.rawbytes())
helpers.clear_node_buffer(self.node1, self.blockchain_fileno)
get_txs_message = self._send_compressed_block_to_node_1()
txs_message = self._build_txs_message(
get_txs_message.get_short_ids()[:5])
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[0])
self.node1.alarm_queue.fire_alarms()
get_txs_bytes_2 = helpers.get_queued_node_bytes(
self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE)
get_txs_message_2 = GetTxsMessage(buf=get_txs_bytes_2.tobytes())
self.assertEqual(5, len(get_txs_message_2.get_short_ids()))
txs_message = self._build_txs_message(
get_txs_message_2.get_short_ids()[:-1])
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
# retry again in a longer interval
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[0])
self.node1.alarm_queue.fire_alarms()
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[1])
self.node1.alarm_queue.fire_alarms()
get_txs_bytes_3 = helpers.get_queued_node_bytes(
self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE)
get_txs_message_3 = GetTxsMessage(buf=get_txs_bytes_3.tobytes())
self.assertEqual(1, len(get_txs_message_3.get_short_ids()))
txs_message = self._build_txs_message(
get_txs_message_3.get_short_ids())
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
self._assert_sent_block_node_1()
def test_recover_all_short_ids(self):
for tx_message in self.transactions:
helpers.receive_node_message(self.node1, self.relay_fileno,
tx_message.rawbytes())
helpers.clear_node_buffer(self.node1, self.blockchain_fileno)
get_txs_message = self._send_compressed_block_to_node_1()
self.assertEqual(10, len(get_txs_message.get_short_ids()))
txs_message = self._build_txs_message(get_txs_message.get_short_ids())
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
self._assert_sent_block_node_1()
def send_received_block_and_key(self, block=None):
if block is None:
block = btc_block()
self._populate_transaction_services(block)
# propagate block
helpers.receive_node_message(self.node1, self.blockchain_fileno,
block.rawbytes())
block_hold_request_relay = self.node1.get_bytes_to_send(
self.relay_fileno)
self.assertIn(BlockHoldingMessage.MESSAGE_TYPE,
block_hold_request_relay.tobytes())
self.node1.on_bytes_sent(self.relay_fileno,
len(block_hold_request_relay))
relayed_block = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(BroadcastMessage.MESSAGE_TYPE, relayed_block.tobytes())
self.node1.on_bytes_sent(self.relay_fileno, len(relayed_block))
# block hold sent out
block_hold_request_gateway = self.node1.get_bytes_to_send(
self.gateway_fileno)
self.assertIsNotNone(block_hold_request_gateway)
self.assertIn(BlockHoldingMessage.MESSAGE_TYPE,
block_hold_request_gateway.tobytes())
self.clear_all_buffers()
# key not available until receipt
key_not_yet_available = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(OutputBuffer.EMPTY, key_not_yet_available)
# send receipt
helpers.receive_node_message(self.node2, self.relay_fileno,
relayed_block)
block_receipt = self.node2.get_bytes_to_send(self.gateway_fileno)
self.assertIn(BlockReceivedMessage.MESSAGE_TYPE,
block_receipt.tobytes())
# send key
helpers.receive_node_message(self.node1, self.gateway_fileno,
block_receipt)
key_message = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(KeyMessage.MESSAGE_TYPE, key_message.tobytes())
helpers.receive_node_message(self.node2, self.relay_fileno,
key_message)
bytes_to_blockchain = self.node2.get_bytes_to_send(
self.blockchain_fileno)
self.assertEqual(len(block.rawbytes()), len(bytes_to_blockchain))
return BlockBtcMessage(buf=bytearray(bytes_to_blockchain))
def test_block_headers_request(self):
get_headers = GetBlockHeadersEthProtocolMessage(None, self.BLOCK_HASH, 111, 222, 0)
# Reply with empty headers to the first get headers request for fast sync mode support
get_headers_frames = map(self.eth_node_cipher.encrypt_frame,
frame_utils.get_frames(get_headers.msg_type, get_headers.rawbytes()))
for get_headers_frame in get_headers_frames:
helpers.receive_node_message(self.gateway_node, self.local_node_fileno, get_headers_frame)
self.eth_remote_node_connection.enqueue_msg.assert_not_called()
self.eth_node_connection.enqueue_msg.assert_called_once_with(BlockHeadersEthProtocolMessage(None, []))
# The second get headers message should be proxied to remote blockchain node
get_headers_frames = map(self.eth_node_cipher.encrypt_frame,
frame_utils.get_frames(get_headers.msg_type, get_headers.rawbytes()))
for get_headers_frame in get_headers_frames:
helpers.receive_node_message(self.gateway_node, self.local_node_fileno, get_headers_frame)
self.eth_remote_node_connection.enqueue_msg.assert_called_once_with(get_headers)
headers = BlockHeadersEthProtocolMessage(None, [
mock_eth_messages.get_dummy_block_header(1), mock_eth_messages.get_dummy_block_header(2)
])
headers_frames = map(self.eth_node_cipher.encrypt_frame,
frame_utils.get_frames(headers.msg_type, headers.rawbytes()))
for headers_frame in headers_frames:
helpers.receive_node_message(self.gateway_node, self.remote_node_fileno, headers_frame)
self.eth_node_connection.enqueue_msg.assert_called_with(headers)
def test_drops_connection_after_multiple_recoverable_bad_messages(self):
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
self.handshake)
bytes_to_send = self.gateway_node.get_bytes_to_send(
self.local_node_fileno)
# send bad message
for i in range(constants.MAX_BAD_MESSAGES):
helpers.receive_node_message(
self.gateway_node, self.local_node_fileno,
self.transform.change_msgtype(self.txmsg,
"dummy_msg".encode("utf-8")))
self._verify_recovery_after_bad_message()
# send more bad messages
for i in range(constants.MAX_BAD_MESSAGES + 1):
helpers.receive_node_message(
self.gateway_node, self.local_node_fileno,
self.transform.change_msgtype(self.txmsg,
"dummy_msg".encode("utf-8")))
self._verify_connection_closed()
def _send_compressed_block_to_node_1(self):
for tx_message_with_short_id in self.transactions_with_short_ids:
helpers.receive_node_message(self.node2, self.relay_fileno,
tx_message_with_short_id.rawbytes())
helpers.clear_node_buffer(self.node1, self.blockchain_fileno)
helpers.receive_node_message(self.node2, self.blockchain_fileno,
self.block.rawbytes())
broadcast_bytes = helpers.get_queued_node_bytes(
self.node2, self.relay_fileno, BroadcastMessage.MESSAGE_TYPE)
helpers.receive_node_message(self.node1, self.relay_fileno,
broadcast_bytes)
get_txs_bytes = helpers.get_queued_node_bytes(
self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE)
get_txs_message = GetTxsMessage(buf=get_txs_bytes.tobytes())
self._assert_no_block_node_1()
return get_txs_message
def test_unknown_message(self):
bytes_to_send = self.handshake + self.transform.change_msgtype(
self.txmsg, "dummy_msg".encode("utf-8"))
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
bytes_to_send)
self._verify_recovery_after_bad_message()
def test_bad_payload(self):
bytes_to_send = self.handshake + self.transform.change_payload(
self.txmsg, bytearray(len(self.txmsg) - 24))
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
bytes_to_send)
self._verify_recovery_after_bad_message()
def test_bad_checksum(self):
bytes_to_send = self.handshake + self.transform.change_checksum(
self.txmsg, 1)
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
bytes_to_send)
self._verify_recovery_after_bad_message()
def test_bad_payload_len(self):
bytes_to_send = self.handshake + self.transform.change_payloadlen(
self.txmsg, 5901) + self.blockmsg
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
bytes_to_send)
self._verify_connection_closed()
def test_handshake_null_bytes(self):
bytes_to_send = self.handshake + bytearray(100)
helpers.receive_node_message(self.gateway_node, self.local_node_fileno,
bytes_to_send)
self._verify_connection_closed()
def test_request_block_propagation(self):
block = btc_block().rawbytes()
# propagate block
helpers.receive_node_message(self.node1, self.blockchain_fileno, block)
block_hold_request_relay = self.node1.get_bytes_to_send(
self.relay_fileno)
self.assertIn(BlockHoldingMessage.MESSAGE_TYPE,
block_hold_request_relay.tobytes())
self.node1.on_bytes_sent(self.relay_fileno,
len(block_hold_request_relay))
relayed_block = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertIn(BroadcastMessage.MESSAGE_TYPE, relayed_block.tobytes())
block_hold_request_gateway = self.node1.get_bytes_to_send(
self.gateway_fileno)
self.assertIn(BlockHoldingMessage.MESSAGE_TYPE,
block_hold_request_gateway.tobytes())
self.clear_all_buffers()
# receipt timeout
time.time = MagicMock(
return_value=time.time() +
gateway_constants.NEUTRALITY_BROADCAST_BLOCK_TIMEOUT_S)
self.node1.alarm_queue.fire_alarms()
key_msg_gateway = self.node1.get_bytes_to_send(self.gateway_fileno)
self.assertIn(KeyMessage.MESSAGE_TYPE, key_msg_gateway.tobytes())
self.node1.on_bytes_sent(self.gateway_fileno, len(key_msg_gateway))
block_prop_request = self.node1.get_bytes_to_send(self.gateway_fileno)
self.assertIn(BlockPropagationRequestMessage.MESSAGE_TYPE,
block_prop_request.tobytes())
self.clear_all_buffers()
# get new block to send
helpers.receive_node_message(self.node2, self.gateway_fileno,
block_prop_request)
new_relayed_block = self.node2.get_bytes_to_send(self.relay_fileno)
self.assertIn(BroadcastMessage.MESSAGE_TYPE,
new_relayed_block.tobytes())
helpers.clear_node_buffer(self.node2, self.relay_fileno)
# receive new block
helpers.receive_node_message(self.node1, self.relay_fileno,
new_relayed_block)
block_receipt = self.node1.get_bytes_to_send(self.gateway_fileno)
self.assertIn(BlockReceivedMessage.MESSAGE_TYPE,
block_receipt.tobytes())
# receive block receipt
helpers.receive_node_message(self.node2, self.gateway_fileno,
block_receipt)
key_message = self.node2.get_bytes_to_send(self.relay_fileno)
self.assertIn(KeyMessage.MESSAGE_TYPE, key_message.tobytes())
# receive key, but already seen so dont forward to blockchain
helpers.receive_node_message(self.node1, self.relay_fileno,
key_message)
bytes_to_blockchain = self.node1.get_bytes_to_send(
self.blockchain_fileno)
self.assertEqual(OutputBuffer.EMPTY, bytes_to_blockchain)
# clear blocks seen, rereceive
self.node1.blocks_seen = ExpiringSet(
self.node1.alarm_queue,
gateway_constants.GATEWAY_BLOCKS_SEEN_EXPIRATION_TIME_S, "testset")
helpers.receive_node_message(self.node1, self.relay_fileno,
key_message)
# ignore key message even if block is not in "blocks_seen"
bytes_to_blockchain = self.node1.get_bytes_to_send(
self.blockchain_fileno)
self.assertEqual(OutputBuffer.EMPTY, bytes_to_blockchain)
def gateway_1_receive_message_from_blockchain(self,
message: AbstractMessage):
helpers.receive_node_message(self.gateway_1, self.blockchain_fileno_1,
message.rawbytes())
def test_recover_give_up(self):
gateway_constants.BLOCK_RECOVERY_MAX_RETRY_ATTEMPTS = 3
for tx_message in self.transactions:
helpers.receive_node_message(self.node1, self.relay_fileno,
tx_message.rawbytes())
helpers.clear_node_buffer(self.node1, self.blockchain_fileno)
self._send_compressed_block_to_node_1()
txs_message = self._build_txs_message([])
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
# retry, first attempt
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[0])
self.node1.alarm_queue.fire_alarms()
get_txs_bytes_2 = helpers.get_queued_node_bytes(
self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE)
get_txs_message_2 = GetTxsMessage(buf=get_txs_bytes_2.tobytes())
self.assertEqual(10, len(get_txs_message_2.get_short_ids()))
txs_message = self._build_txs_message([])
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
# retry, attempt 2
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[1])
self.node1.alarm_queue.fire_alarms()
get_txs_bytes_3 = helpers.get_queued_node_bytes(
self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE)
get_txs_message_3 = GetTxsMessage(buf=get_txs_bytes_3.tobytes())
self.assertEqual(10, len(get_txs_message_3.get_short_ids()))
txs_message = self._build_txs_message([])
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
# retry, attempt 3
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[2])
self.node1.alarm_queue.fire_alarms()
get_txs_bytes_4 = helpers.get_queued_node_bytes(
self.node1, self.relay_fileno, GetTxsMessage.MESSAGE_TYPE)
get_txs_message_4 = GetTxsMessage(buf=get_txs_bytes_4.tobytes())
self.assertEqual(10, len(get_txs_message_4.get_short_ids()))
txs_message = self._build_txs_message([])
helpers.receive_node_message(self.node1, self.relay_fileno,
txs_message.rawbytes())
# retry given up
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCK_RECOVERY_RECOVERY_INTERVAL_S[3] * 20)
self.node1.alarm_queue.fire_alarms()
# no bytes, even after timeout
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(0, len(bytes_to_send))
self._assert_no_block_node_1()
def test_send_receive_block_and_key_block_hold_removed(self):
block = btc_block()
block_hash = block.block_hash()
block_hold_msg_bytes = BlockHoldingMessage(block_hash, 1).rawbytes()
helpers.receive_node_message(self.node1, self.gateway_fileno, block_hold_msg_bytes)
helpers.receive_node_message(self.node1, self.blockchain_fileno, block.rawbytes())
bytes_to_send = self.node1.get_bytes_to_send(self.relay_fileno)
self.assertEqual(bytes_to_send, block_hold_msg_bytes)
self.assertEqual(1, len(self.node1.block_processing_service._holds.contents))
# node 2 encrypts and sends over block
helpers.receive_node_message(self.node2, self.blockchain_fileno, block.rawbytes())
block_hold_request_relay = self.node2.get_bytes_to_send(self.relay_fileno)
self.assertIn(BlockHoldingMessage.MESSAGE_TYPE, block_hold_request_relay.tobytes())
self.node2.on_bytes_sent(self.relay_fileno, len(block_hold_request_relay))
relayed_block = self.node2.get_bytes_to_send(self.relay_fileno)
self.assertIn(BroadcastMessage.MESSAGE_TYPE, relayed_block.tobytes())
self.node2.on_bytes_sent(self.relay_fileno, len(relayed_block))
# send receipt
helpers.receive_node_message(self.node1, self.relay_fileno, relayed_block)
block_receipt = self.node1.get_bytes_to_send(self.gateway_fileno)
self.assertIn(BlockReceivedMessage.MESSAGE_TYPE, block_receipt.tobytes())
# send key
helpers.receive_node_message(self.node2, self.gateway_fileno, block_receipt)
key_message = self.node2.get_bytes_to_send(self.relay_fileno)
self.assertIn(KeyMessage.MESSAGE_TYPE, key_message.tobytes())
# receive key and lift hold
helpers.receive_node_message(self.node1, self.relay_fileno, key_message)
inv_message = self.node1.get_bytes_to_send(self.blockchain_fileno)
self.assertIn(InvBtcMessage.MESSAGE_TYPE, inv_message.tobytes())
self.assertEqual(0, len(self.node1.block_processing_service._holds.contents))
def reinitialize_gateways(self, opts1, opts2):
node_ssl_service = MockNodeSSLService(BtcGatewayNode.NODE_TYPE, MagicMock())
self.node1 = BtcGatewayNode(opts1, node_ssl_service)
self.node1.opts.has_fully_updated_tx_service = True
self.node1.requester.send_threaded_request = MagicMock()
self.node2 = BtcGatewayNode(opts2, node_ssl_service)
self.node2.opts.has_fully_updated_tx_service = True
self.node2.requester.send_threaded_request = MagicMock()
self.node1.peer_gateways = {OutboundPeerModel(LOCALHOST, 7002)}
self.node1.peer_relays = {OutboundPeerModel(LOCALHOST, 7001)}
self.node2.peer_gateways = {OutboundPeerModel(LOCALHOST, 7002)}
self.node2.peer_relays = {OutboundPeerModel(LOCALHOST, 7001)}
self.blockchain_fileno = 1
self.relay_fileno = 2
self.gateway_fileno = 3
self.blockchain_connection = MockSocketConnection(
self.blockchain_fileno, self.node1, ip_address=LOCALHOST, port=7000
)
self.relay_connection = MockSocketConnection(self.relay_fileno, self.node1, ip_address=LOCALHOST, port=7001)
self.gateway_connection = MockSocketConnection(self.gateway_fileno, self.node1, ip_address=LOCALHOST, port=7002)
# add node1 connections
self.node1.on_connection_added(self.blockchain_connection)
self.node1.on_connection_added(self.relay_connection)
self.node1.on_connection_added(self.gateway_connection)
# add node 2 connections
self.node2.on_connection_added(self.blockchain_connection)
self.node2.on_connection_added(self.relay_connection)
self.node2.on_connection_added(self.gateway_connection)
# initialize node1 connections
helpers.receive_node_message(self.node1, self.blockchain_fileno, btc_version_message().rawbytes())
helpers.receive_node_message(self.node1, self.relay_fileno, hello_message().rawbytes())
helpers.receive_node_message(self.node1, self.relay_fileno, AckMessage().rawbytes())
helpers.receive_node_message(self.node1, self.gateway_fileno, AckMessage().rawbytes())
# initialize node2 connections
helpers.receive_node_message(self.node2, self.blockchain_fileno, btc_version_message().rawbytes())
helpers.receive_node_message(self.node2, self.relay_fileno, hello_message().rawbytes())
helpers.receive_node_message(self.node2, self.relay_fileno, AckMessage().rawbytes())
helpers.receive_node_message(self.node2, self.gateway_fileno, AckMessage().rawbytes())
self.clear_all_buffers()
def gateway_2_receive_message_from_gateway(self, message: AbstractMessage):
helpers.receive_node_message(self.gateway_2, self.gateway_fileno_2,
message.rawbytes())
