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())