async def test_remove_blockchain_peer(self): conn = MockConnection( MockSocketConnection(9, self.gateway_node, ip_address="127.0.0.1", port=30302), self.gateway_node) conn.mark_for_close = MagicMock() self.gateway_node.connection_pool.add(9, "127.0.0.1", 30302, conn) self.gateway_node.blockchain_peers.add( BlockchainPeerInfo( "127.0.0.1", 30302, "d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396" )) result = await self.request( BxJsonRpcRequest( "9", RpcRequestType.REMOVE_BLOCKCHAIN_PEER, { "peer": "enode://d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396@127.0.0.1:30302" })) self.assertNotIn(BlockchainPeerInfo("127.0.0.1", 30302), self.gateway_node.blockchain_peers) conn.mark_for_close.assert_called_once_with(False) self.assertEqual("9", result.id) self.assertIsNone(result.error) self.assertEqual({"removed_peer": "127.0.0.1:30302"}, result.result)
def setUp(self): self.node = MockGatewayNode( gateway_helpers.get_gateway_opts( 8000, max_block_interval_s=gateway_constants.MAX_INTERVAL_BETWEEN_BLOCKS_S, blockchain_message_ttl=TTL ) ) self.node_conn = MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node ) self.node.blockchain_peers.add(BlockchainPeerInfo(self.node_conn.peer_ip, self.node_conn.peer_port)) self.block_queuing_service = TestPushBlockQueuingService(self.node, self.node_conn) self.node.block_queuing_service_manager.add_block_queuing_service(self.node_conn, self.block_queuing_service) self.node_conn.enqueue_msg = MagicMock() self.node_conn_2 = MockConnection( MockSocketConnection(2, self.node, ip_address=LOCALHOST, port=8003), self.node ) self.node.blockchain_peers.add(BlockchainPeerInfo(self.node_conn_2.peer_ip, self.node_conn_2.peer_port)) self.block_queuing_service_2 = TestPushBlockQueuingService(self.node, self.node_conn_2) self.node.block_queuing_service_manager.add_block_queuing_service(self.node_conn_2, self.block_queuing_service_2) self.node_conn_2.enqueue_msg = MagicMock() self.blockchain_connections = [self.node_conn, self.node_conn_2] self.block_queuing_services = [self.block_queuing_service, self.block_queuing_service_2]
def test_blockchain_peers_eth_from_file_and_args(self): blockchain_ip_1 = "1.2.3.4" blockchain_port_1 = 20202 public_key_1 = "00029fb539bbbebc7bcc986bca2b1d3e262a1133901c3cc699f8dd9cba91df51ede5fed9c2c25b74425d64344a9a9d393904c6f0f8bd95cc0c5e2699b6a19ea1" blockchain_peer_1 = BlockchainPeerInfo(blockchain_ip_1, blockchain_port_1, public_key_1) blockchain_ip_2 = "5.6.7.8" blockchain_port_2 = 30303 public_key_2 = "873235d21c380e2b7239cfdcb3a02bd1b92232aed81d36cec394749bd578bd47ee73a9c9270a2f196f4b7734b0edeeedc8788abea4abeffd1ae69f423e9f70ea" blockchain_peer_2 = BlockchainPeerInfo(blockchain_ip_2, blockchain_port_2, public_key_2) blockchain_ip_3 = "172.17.0.1" blockchain_port_3 = 30303 public_key_3 = "X" * 64 * 2 blockchain_peer_3 = BlockchainPeerInfo(blockchain_ip_3, blockchain_port_3, public_key_3) root_dir = os.path.dirname(os.path.abspath(__file__)) file_path = os.path.join(root_dir, "samples/blockchain_peers_eth_sample_file.txt") argv = ["--source-version", "1.2.3", "--external-port", "7000", "--blockchain-protocol", "ethereum", "--blockchain-peers-file", file_path, "--blockchain-peers", f"enode://{public_key_3}@{blockchain_ip_3}:{blockchain_port_3}"] args = main.get_opts(argv) self.assertEqual(3, len(args.blockchain_peers)) self.assertTrue(blockchain_peer_1 in args.blockchain_peers) self.assertTrue(blockchain_peer_2 in args.blockchain_peers) self.assertTrue(blockchain_peer_3 in args.blockchain_peers)
def setUp(self): self.node = MockGatewayNode(gateway_helpers.get_gateway_opts(8000)) self.node_conn = cast( AbstractGatewayBlockchainConnection, MockConnection( MockSocketConnection(1, self.node, ip_address=LOCALHOST, port=8002), self.node)) self.node.blockchain_peers.add( BlockchainPeerInfo(self.node_conn.peer_ip, self.node_conn.peer_port)) self.node_conn_2 = cast( AbstractGatewayBlockchainConnection, MockConnection( MockSocketConnection(2, self.node, ip_address=LOCALHOST, port=8003), self.node)) self.node.blockchain_peers.add( BlockchainPeerInfo(self.node_conn_2.peer_ip, self.node_conn_2.peer_port)) self.node_conn_3 = cast( AbstractGatewayBlockchainConnection, MockConnection( MockSocketConnection(3, self.node, ip_address=LOCALHOST, port=8004), self.node)) self.node.blockchain_peers.add( BlockchainPeerInfo(self.node_conn_3.peer_ip, self.node_conn_3.peer_port))
def test_blockchain_peers_btc(self): blockchain_ip_1 = "172.17.0.1" blockchain_port_1 = 8333 blockchain_peer_1 = BlockchainPeerInfo(blockchain_ip_1, blockchain_port_1) blockchain_ip_2 = "172.17.0.2" blockchain_port_2 = 8555 blockchain_peer_2 = BlockchainPeerInfo(blockchain_ip_2, blockchain_port_2) argv = ["--source-version", "1.2.3", "--external-port", "7000", "--blockchain-protocol", "bitcoin", "--blockchain-peers", f"{blockchain_ip_1}:{blockchain_port_1}, {blockchain_ip_2}:{blockchain_port_2}"] args = main.get_opts(argv) self.assertEqual(2, len(args.blockchain_peers)) self.assertTrue(blockchain_peer_1 in args.blockchain_peers) self.assertTrue(blockchain_peer_2 in args.blockchain_peers)
def mock_add_blockchain_peer( self, connection: AbstractGatewayBlockchainConnection) -> None: self.blockchain_peers.add( BlockchainPeerInfo(connection.peer_ip, connection.peer_port)) block_queuing_service = self.build_block_queuing_service(connection) self.block_queuing_service_manager.add_block_queuing_service( connection, block_queuing_service)
def _should_log_closed_connection(self, connection: AbstractConnection) -> bool: if isinstance(connection, EthNodeConnection): connection_status = connection.connection_protocol.connection_status if (self._should_decrease_version_number(connection.state, connection_status) and connection.CONNECTION_TYPE == ConnectionType.BLOCKCHAIN_NODE): for peer in self.blockchain_peers: if (peer == BlockchainPeerInfo(connection.peer_ip, connection.peer_port) and not peer.connection_established): peer.blockchain_protocol_version = self._get_new_protocol_version( connection, peer.blockchain_protocol_version) return False elif isinstance(connection, EthRemoteConnection): connection_status = connection.connection_protocol.connection_status if (self._should_decrease_version_number(connection.state, connection_status) and connection.CONNECTION_TYPE == ConnectionType.REMOTE_BLOCKCHAIN_NODE and not self.remote_blockchain_connection_established): self.remote_blockchain_protocol_version = \ self._get_new_protocol_version( connection, self.remote_blockchain_protocol_version ) return False return True
def _add_connections(self): self.conn_pool.add(self.fileno1, self.ip1, self.port1, self.conn1) self.conn_pool.add(self.fileno2, self.ip2, self.port2, self.conn2) self.conn_pool.add(self.fileno3, self.ip3, self.port3, self.conn3) self.conn_pool.add(self.fileno4, self.ip4, self.port4, self.conn4) self.conn_pool.add(self.fileno5, self.ip5, self.port5, self.conn5) self.blockchain_peers.add(BlockchainPeerInfo(self.ip5, self.port5))
def test_remove_blockchain_connection_and_add_new(self): self._add_connections() new_desc6 = "1.1.1.1 80" new_ip6 = new_desc6.split()[0] new_port6 = new_desc6.split()[1] new_fileno6 = "10" new_node6 = MockNode(helpers.get_common_opts(1004, external_ip="214.215.216.217")) new_conn6 = MockConnection( MockSocketConnection(new_fileno6, new_node6, ip_address=new_ip6, port=int(new_port6)), new_node6 ) self.conn_pool.delete(self.conn3) self.blockchain_peers.add(BlockchainPeerInfo(new_ip6, int(new_port6))) self.conn_pool.add(int(new_fileno6), new_ip6, int(new_port6), new_conn6) update(self.conn_pool, True, self.source_version, self.ip_address, self.continent, self.country, False, self.blockchain_peers, self.account_id, self.quota_level) summary_loaded, _, _, network_loaded = self._load_status_file() self.assertEqual(summary_loaded, network_loaded.get_summary(self.ip_address, self.continent, self.country, False, self.account_id, self.quota_level)) self.assertEqual(summary_loaded.gateway_status, GatewayStatus.WITH_ERRORS) self.assertEqual(summary_loaded.account_info, summary.gateway_status_get_account_info(None)) self.assertEqual(summary_loaded.quota_level, summary.gateway_status_get_quota_level(self.quota_level)) self.assertEqual( summary_loaded.blockchain_node_connection_states, { f"{new_ip6} {new_port6}": ConnectionState.ESTABLISHED, f"{self.ip3} {self.port3}": ConnectionState.DISCONNECTED, f"{self.ip5} {self.port5}": ConnectionState.ESTABLISHED, } )
def setUp(self): opts = gateway_helpers.get_gateway_opts( 8000, include_default_eth_args=True, track_detailed_sent_messages=True) if opts.use_extensions: helpers.set_extensions_parallelism() self.node = MockGatewayNode(opts) self.node.block_processing_service = MagicMock() self.connection = MagicMock() gateway_helpers.add_blockchain_peer(self.node, self.connection) self.connection.node = self.node self.connection.peer_ip = LOCALHOST self.connection.peer_port = 8001 self.connection.network_num = 2 self.connection.endpoint = IpEndpoint(self.connection.peer_ip, self.connection.peer_port) self.node.blockchain_peers.add( BlockchainPeerInfo(self.connection.peer_ip, self.connection.peer_port)) gateway_bdn_performance_stats_service.set_node(self.node) dummy_private_key = crypto_utils.make_private_key( helpers.generate_bytearray(111)) dummy_public_key = crypto_utils.private_to_public_key( dummy_private_key) self.sut = EthNodeConnectionProtocol(self.connection, True, dummy_private_key, dummy_public_key)
def add_blockchain_peer(node: AbstractGatewayNode, connection: AbstractConnection): node_conn = cast(AbstractGatewayBlockchainConnection, connection) node.blockchain_peers.add( BlockchainPeerInfo(node_conn.peer_ip, node_conn.peer_port)) block_queuing_service = node.build_block_queuing_service(node_conn) node.block_queuing_service_manager.add_block_queuing_service( node_conn, block_queuing_service)
def test_blockchain_peers_btc_from_file_only(self): blockchain_ip_1 = "1.2.3.4" blockchain_port_1 = 8200 blockchain_peer_1 = BlockchainPeerInfo(blockchain_ip_1, blockchain_port_1) blockchain_ip_2 = "5.6.7.8" blockchain_port_2 = 8300 blockchain_peer_2 = BlockchainPeerInfo(blockchain_ip_2, blockchain_port_2) root_dir = os.path.dirname(os.path.abspath(__file__)) file_path = os.path.join(root_dir, "samples/blockchain_peers_btc_sample_file.txt") argv = ["--source-version", "1.2.3", "--external-port", "7000", "--blockchain-protocol", "bitcoin", "--blockchain-peers-file", file_path] args = main.get_opts(argv) self.assertEqual(2, len(args.blockchain_peers)) self.assertTrue(blockchain_peer_1 in args.blockchain_peers) self.assertTrue(blockchain_peer_2 in args.blockchain_peers)
async def test_remove_blockchain_peer_not_in_pool(self): self.gateway_node.alarm_queue.register_alarm = MagicMock() self.gateway_node.blockchain_peers.add( BlockchainPeerInfo( "127.0.0.1", 30302, "d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396" )) result = await self.request( BxJsonRpcRequest( "9", RpcRequestType.REMOVE_BLOCKCHAIN_PEER, { "peer": "enode://d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396@127.0.0.1:30302" })) self.assertNotIn(BlockchainPeerInfo("127.0.0.1", 30302), self.gateway_node.blockchain_peers) self.gateway_node.alarm_queue.register_alarm.assert_called() self.assertEqual("9", result.id) self.assertIsNone(result.error) self.assertEqual({"removed_peer": "127.0.0.1:30302"}, result.result)
def test_blockchain_peers_eth_from_args(self): blockchain_ip_1 = "172.17.0.1" blockchain_port_1 = 30303 public_key_1 = "X" * 64 * 2 blockchain_peer_1 = BlockchainPeerInfo(blockchain_ip_1, blockchain_port_1, public_key_1) blockchain_ip_2 = "172.17.0.2" blockchain_port_2 = 30304 public_key_2 = "Y" * 64 * 2 blockchain_peer_2 = BlockchainPeerInfo(blockchain_ip_2, blockchain_port_2, public_key_2) argv = ["--source-version", "1.2.3", "--external-port", "7000", "--blockchain-protocol", "ethereum", "--blockchain-peers", f"enode://{public_key_1}@{blockchain_ip_1}:{blockchain_port_1}, " f"enode://{public_key_2}@{blockchain_ip_2}:{blockchain_port_2}"] args = main.get_opts(argv) self.assertEqual(2, len(args.blockchain_peers)) self.assertTrue(blockchain_peer_1 in args.blockchain_peers) self.assertTrue(blockchain_peer_2 in args.blockchain_peers)
async def test_add_blockchain_peer(self): self.gateway_node.enqueue_connection = MagicMock() result = await self.request( BxJsonRpcRequest( "8", RpcRequestType.ADD_BLOCKCHAIN_PEER, { "peer": "enode://d76d7d11a822fab02836f8b0ea462205916253eb630935d15191fb6f9d218cd94a768fc5b3d5516b9ed5010a4765f95aea7124a39d0ab8aaf6fa3d57e21ef396@127.0.0.1:30302" })) self.gateway_node.enqueue_connection.assert_called_once_with( "127.0.0.1", 30302, ConnectionType.BLOCKCHAIN_NODE) self.assertIn(BlockchainPeerInfo("127.0.0.1", 30302), self.gateway_node.blockchain_peers) self.assertEqual("8", result.id) self.assertIsNone(result.error) self.assertEqual({"new_peer": "127.0.0.1:30302"}, result.result)
def parse_enode(self, enode: str) -> BlockchainPeerInfo: # Make sure enode is at least as long as the public key if not argument_parsers.enode_is_valid_length(enode): raise RpcInvalidParams( self.request_id, f"Invalid enode: {enode}, with length: {len(enode)}. " f"Expected format: enode://<eth node public key>@<eth node ip>:<port>" ) try: pub_key, ip, port = argument_parsers.get_enode_parts(enode) if not port.isnumeric(): raise RpcInvalidParams(self.request_id, f"Invalid port: {port}") except ValueError: raise RpcInvalidParams( self.request_id, f"Invalid enode: {enode}. " f"Expected format: enode://<eth node public key>@<eth node ip>:<port>" ) else: return BlockchainPeerInfo(ip, int(port), pub_key)
def parse_enode(enode: str) -> BlockchainPeerInfo: if not enode_is_valid_length(enode): logger.fatal(log_messages.ETH_PARSER_INVALID_ENODE_LENGTH, enode, len(enode), exc_info=False) sys.exit(1) try: pub_key, ip, port = get_enode_parts(enode) if not port.isnumeric(): logger.fatal(log_messages.PARSER_INVALID_PORT, port, exc_info=False) sys.exit(1) except ValueError: logger.fatal(log_messages.ETH_PARSER_INVALID_ENODE, enode, exc_info=False) sys.exit(1) else: return BlockchainPeerInfo(ip, int(port), pub_key)
def setUp(self): opts = gateway_helpers.get_gateway_opts(8000, include_default_btc_args=True) if opts.use_extensions: helpers.set_extensions_parallelism() self.node = MockGatewayNode(opts) self.node.block_processing_service = MagicMock() self.connection = MagicMock() gateway_helpers.add_blockchain_peer(self.node, self.connection) self.connection.node = self.node self.connection.peer_ip = LOCALHOST self.connection.peer_port = 8001 self.connection.network_num = 2 self.connection.endpoint = IpEndpoint(self.connection.peer_ip, self.connection.peer_port) self.node.blockchain_peers.add( BlockchainPeerInfo(self.connection.peer_ip, self.connection.peer_port)) gateway_bdn_performance_stats_service.set_node(self.node) self.sut = BtcBaseConnectionProtocol(self.connection)
def setUp(self): self.conn_pool = ConnectionPool() self.source_version = "v1.0.0" self.ip_address = "0.0.0.0" self.continent = "NA" self.country = "United States" self.account_id = None self.blockchain_peers: Set[BlockchainPeerInfo] = set() self.fileno1 = 1 self.ip1 = "123.123.123.123" self.port1 = 1000 self.node1 = MockNode(helpers.get_common_opts(1001, external_ip="128.128.128.128")) self.node_id1 = str(uuid.uuid1()) self.conn1 = MockConnection( MockSocketConnection(self.fileno1, self.node1, ip_address=self.ip1, port=self.port1), self.node1 ) self.conn1.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK self.fileno2 = 5 self.ip2 = "234.234.234.234" self.port2 = 2000 self.node2 = MockNode(helpers.get_common_opts(1003, external_ip="321.321.321.321")) self.node_id2 = str(uuid.uuid1()) self.conn2 = MockConnection( MockSocketConnection(self.fileno2, self.node2, ip_address=self.ip2, port=self.port2), self.node2 ) self.conn2.CONNECTION_TYPE = ConnectionType.RELAY_TRANSACTION self.fileno3 = 6 self.ip3 = "234.234.234.234" self.port3 = 3000 self.node3 = MockNode(helpers.get_common_opts(1003, external_ip="213.213.213.213")) self.node_id3 = str(uuid.uuid1()) self.conn3 = MockConnection( MockSocketConnection(self.fileno3, self.node3, ip_address=self.ip3, port=self.port3), self.node3 ) self.conn3.CONNECTION_TYPE = ConnectionType.BLOCKCHAIN_NODE self.blockchain_peers.add(BlockchainPeerInfo(self.ip3, self.port3)) self.blockchain_conn3 = BlockchainConnection(self.ip3, str(self.port3), str(self.fileno3), None) self.fileno4 = 8 self.ip4 = "111.222.111.222" self.port4 = 3000 self.node4 = MockNode(helpers.get_common_opts(1003, external_ip="101.101.101.101")) self.node_id4 = str(uuid.uuid1()) self.conn4 = MockConnection( MockSocketConnection(self.fileno4, self.node4, ip_address=self.ip4, port=self.port4), self.node4 ) self.conn4.CONNECTION_TYPE = ConnectionType.REMOTE_BLOCKCHAIN_NODE self.fileno5 = 9 self.ip5 = "123.456.456.456" self.port5 = 3000 self.node5 = MockNode(helpers.get_common_opts(1003, external_ip="456.456.456.456")) self.node_id5 = str(uuid.uuid1()) self.conn5 = MockConnection( MockSocketConnection(self.fileno5, self.node5, ip_address=self.ip5, port=self.port5), self.node5 ) self.conn5.CONNECTION_TYPE = ConnectionType.BLOCKCHAIN_NODE self.blockchain_conn5 = BlockchainConnection(self.ip5, str(self.port5), str(self.fileno5), None) self.quota_level = 0 initialize(False, self.source_version, self.ip_address, self.continent, self.country, False, self.account_id, self.quota_level) path = config.get_data_file(STATUS_FILE_NAME) self.addCleanup(os.remove, path)
def parse_ip_port(ip_port_string: str) -> BlockchainPeerInfo: ip, port = get_ip_port_string_parts(ip_port_string) if not port.isnumeric(): logger.fatal(log_messages.PARSER_INVALID_PORT, port, exc_info=False) sys.exit(1) return BlockchainPeerInfo(ip, int(port))
def parse_ip_port(self, ip_port_string: str) -> BlockchainPeerInfo: ip, port = argument_parsers.get_ip_port_string_parts(ip_port_string) if not port.isnumeric(): raise RpcInvalidParams(self.request_id, f"Invalid port: {port}") return BlockchainPeerInfo(ip, int(port))