def setUp(self) -> None: pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866" opts = gateway_helpers.get_gateway_opts(8000, pub_key=pub_key) node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock()) self.node = EthGatewayNode(opts, node_ssl_service) self.relay_1 = MockNode( helpers.get_common_opts(8000, region="us-east-1")) self.relay_connection_1 = helpers.create_connection( EthRelayConnection, self.node, node_opts=self.relay_1.opts, file_no=1, ip="1.2.3.4") self.relay_2 = MockNode( helpers.get_common_opts(8001, region="eu-west-1")) self.relay_connection_2 = helpers.create_connection( EthRelayConnection, self.node, node_opts=self.relay_2.opts, file_no=1, ip="1.2.3.5") self.node.broadcast = MagicMock() self.node.has_active_blockchain_peer = MagicMock(return_value=True)
def setUp(self): self.conn_pool1 = ConnectionPool() 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, ip_address=self.ip1, port=self.port1), self.node1) 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, ip_address=self.ip2, port=self.port2), self.node2) 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, ip_address=self.ip3, port=self.port3), self.node3)
def test_add_special_objects(self): node1 = MockNode(get_common_opts(1001, external_ip="128.128.128.128")) conn1 = MockConnection( MockSocketConnection(1, node1, ip_address="123.123.123.123", port=1000), node1) conn1.inputbuf.add_bytes(bytearray(b"0000" * 10)) conn1.outputbuf.prepend_msgbytes(bytearray(b"1111" * 100)) total_special_size, ids = memory_utils.get_special_size(conn1) self.assertTrue(ids) self.assertTrue(id(conn1.inputbuf.input_list) in ids) self.assertTrue(id(conn1.outputbuf.output_msgs) in ids) expected_special_size = memory_utils.get_special_size( conn1.inputbuf.input_list).size expected_special_size += memory_utils.get_special_size( conn1.outputbuf.output_msgs).size self.assertEqual(total_special_size, expected_special_size) s, s_id = memory_utils.get_special_size(conn1.outputbuf.output_msgs) self.assertNotEqual(s, 0) s, ids = memory_utils.get_special_size(conn1.outputbuf.output_msgs, ids) self.assertEqual(s, 0)
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 test_get_object_size(self): mock_node = MockNode(get_common_opts(1234)) object_size = memory_utils.get_object_size(mock_node) self.assertIsInstance(object_size, ObjectSize) self.assertTrue(object_size.size > 0) self.assertTrue(object_size.flat_size > 0) self.assertTrue(object_size.is_actual_size) self.assertEqual(0, len(object_size.references)) ex_set = ExpiringSet(AlarmQueue(), 10, "testset") s = set() h1 = Sha256Hash(b"1" * 32) h2 = Sha256Hash(b"0" * 32) print(memory_utils.get_object_size(ex_set).size) print(memory_utils.get_object_size(s).size) print(memory_utils.get_object_size(h1).size) print(memory_utils.get_object_size(h2).size) print(memory_utils.get_special_size(ex_set).size) print(memory_utils.get_special_size(s).size) print(memory_utils.get_special_size(h1).size) print(memory_utils.get_special_size(h2).size) ex_set.add(h1) ex_set.add(h2) s.add(h1) s.add(h2) print(memory_utils.get_object_size(ex_set).size) print(memory_utils.get_special_size(ex_set).size) print(memory_utils.get_object_size(s).size)
async def setUp(self) -> None: self.rpc_port = 8001 self.rpc_url = f"http://{constants.LOCALHOST}:{self.rpc_port}" self.node = MockNode( helpers.get_common_opts(8000, rpc_port=self.rpc_port) ) self.rpc_server = HttpRpcServer(self.node) await self.rpc_server.start()
def setUp(self) -> None: self.socket_instance = MagicMock(spec=socket.socket) self.socket_instance.fileno = MagicMock(return_value=1) self.node = AbstractNode(helpers.get_common_opts(1234)) self.sut = SocketConnection(self.socket_instance, self.node, False) self.connection = helpers.create_connection(MockConnection, self.node, from_me=True) self.connection.socket_connection = self.sut
def setUp(self): throughput_statistics.set_node(MockNode(helpers.get_common_opts(8888))) self.inbound_throughput_event1 = ThroughputEvent(Direction.INBOUND, "test_in_msg", 100, "localhost 0000") self.inbound_throughput_event2 = ThroughputEvent(Direction.INBOUND, "test_in_msg", 50, "localhost 0000") self.inbound_throughput_event3 = ThroughputEvent(Direction.INBOUND, "mock_msg", 60, "localhost 0000") self.outbound_throughput_event1 = ThroughputEvent(Direction.OUTBOUND, "test_out_msg", 100, "localhost 0000") self.outbound_throughput_event2 = ThroughputEvent(Direction.OUTBOUND, "test_out_msg", 75, "localhost 0000")
def setUp(self): self.node = MockNode(helpers.get_common_opts(8888)) # noinspection PyTypeChecker connection = helpers.create_connection(MockConnection, self.node, port=9999) self.node.connection_pool = ConnectionPool() self.node.connection_pool.add(1, connection.peer_ip, connection.peer_port, connection) node_info_statistics.set_node(self.node)
def setUp(self) -> None: self.mock_node = MockNode( helpers.get_common_opts( 8000, node_type=NodeType.EXTERNAL_GATEWAY, log_level_overrides={} ) ) self.mock_node.opts.transaction_pool_memory_limit = self.TEST_MEMORY_LIMIT_MB self.mock_node.network_num = 5 self.transaction_service = self._get_transaction_service()
def setUp(self): sdn_http_service.submit_peer_connection_error_event = MagicMock() self.node = TestNode(helpers.get_common_opts(4321), None) self.fileno = 1 self.ip = "123.123.123.123" self.port = 8000 self.connection = helpers.create_connection(MockConnection, self.node, file_no=self.fileno, ip=self.ip, port=self.port, add_to_pool=False, from_me=True) self.connection.dispose = MagicMock(side_effect=self.connection.dispose) self.socket_connection = self.connection.socket_connection
def setUp(self): self.node = TestNode(helpers.get_common_opts(4321)) self.fileno = 1 self.ip = "123.123.123.123" self.port = 8000 self.connection = helpers.create_connection(MockConnection, self.node, fileno=self.fileno, ip=self.ip, port=self.port, add_to_pool=False) self.connection.close = MagicMock(side_effect=self.connection.close) self.socket_connection = self.connection.socket_connection
def test_get_detailed_object_size(self): mock_node = MockNode(get_common_opts(1234)) object_size = memory_utils.get_detailed_object_size(mock_node, 10000) self.assertIsInstance(object_size, ObjectSize) self.assertTrue(object_size.size > 0) self.assertTrue(object_size.flat_size > 0) self.assertTrue(object_size.is_actual_size) self.assertTrue(len(object_size.references) > 0) for ref in object_size.references: self.assertIsInstance(ref, ObjectSize) self.assertTrue(ref.size > 0) self.assertTrue(ref.flat_size > 0) self.assertTrue(ref.is_actual_size)
def test_get_by_connection_types_performance(self): log_config.set_level([ "bxcommon.connections.abstract_node", "bxcommon.services.transaction_service" ], LogLevel.INFO) conn_pool = ConnectionPool() self.conn1.CONNECTION_TYPE = ConnectionType.EXTERNAL_GATEWAY self.conn2.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK self.conn3.CONNECTION_TYPE = ConnectionType.RELAY_ALL number_of_iteration = 100 for i in range(40): ip = f"{i}.{i}.{i}.{i}" node = MockNode(helpers.get_common_opts(i, external_ip=ip)) conn = MockConnection( MockSocketConnection(i, ip_address=ip, port=i), node) if i % 7 == 0: conn.CONNECTION_TYPE = ConnectionType.RELAY_BLOCK elif i % 5 == 0: conn.CONNECTION_TYPE = ConnectionType.RELAY_TRANSACTION elif i % 3 == 0: conn.CONNECTION_TYPE = ConnectionType.INTERNAL_GATEWAY else: conn.CONNECTION_TYPE = ConnectionType.EXTERNAL_GATEWAY conn_pool.add(i, ip, i, conn) timeit_get_by_connections_types_one_type = timeit.timeit( lambda: conn_pool.get_by_connection_types([ConnectionType.GATEWAY] ), number=number_of_iteration) timeit_get_by_connections_types_two_types = timeit.timeit( lambda: conn_pool.get_by_connection_types( [ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION]), number=number_of_iteration) print( f"\ntimeit_get_by_connections_types_one_type # 2: {timeit_get_by_connections_types_one_type * 1000 / number_of_iteration:.4f}ms, " f"#connections: {len(list(conn_pool.get_by_connection_types([ConnectionType.GATEWAY])))}" f"\ntimeit_get_by_connections_types_two_types # 2: {timeit_get_by_connections_types_two_types * 1000 / number_of_iteration:.4f}ms, " f"#connections: {len(list(conn_pool.get_by_connection_types([ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION])))}" ) print("*****") for c in conn_pool.get_by_connection_types( [ConnectionType.GATEWAY, ConnectionType.RELAY_TRANSACTION]): print(f"connection: {c}, connection type: {c.CONNECTION_TYPE}")
def __init__(self, port, peers_ports, timeout=None, send_bytes=None): opts = helpers.get_common_opts(port) super(TestNode, self).__init__(opts) self.port = port self.peers_ports = peers_ports self.timeout = timeout self.initialized = False self.closed = False self.finished_sending = True self.ready_to_close = False self.connections = [] self.send_bytes = send_bytes if send_bytes is not None else bytearray( 0) self.memory_view = memoryview(self.send_bytes) self.bytes_sent = 0 self.receive_buffers = {} self.timeout_triggered_loops = 0
def setUp(self) -> None: self.node = MockNode( helpers.get_common_opts(1001, external_ip="128.128.128.128")) self.tracker = MessageTracker( MockConnection(MockSocketConnection(), self.node)) self.output_buffer = OutputBuffer(enable_buffering=True)
def test_sizer(self): s = Sizer() node1 = MockNode(get_common_opts(1001, external_ip="128.128.128.128")) s.set_excluded_asizer("bxcommon.test_utils.mocks.mock_node.MockNode") self.assertGreater(memory_utils.get_object_size(node1).size, 0) self.assertEqual(memory_utils.get_object_size(node1, sizer=s.sizer).size, 0)
def setUp(self) -> None: self.mock_node = MockNode(helpers.get_common_opts(8000, node_type=NodeType.GATEWAY)) self.mock_node.opts.transaction_pool_memory_limit = self.TEST_MEMORY_LIMIT_MB self.transaction_service = self._get_transaction_service()
def setUp(self) -> None: self.node = MockNode(helpers.get_common_opts(8000)) self.connection_pool = ConnectionPool() self.sut = TestBroadcastService(self.connection_pool)
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.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.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.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 setUp(self) -> None: self.node = MockNode(helpers.get_common_opts(1234)) self.network_num = 4 self.transaction_service = TransactionService(self.node, self.network_num)
def setUp(self): self.node = MockNode(helpers.get_common_opts(8888)) tx_stats.set_node(self.node) tx_stats.configure_network(1, 0.5, 0.06) tx_stats.configure_network(2, 50, 60)
def get_gateway_opts( port, node_id=None, external_ip=constants.LOCALHOST, blockchain_address=None, test_mode=None, peer_gateways=None, peer_relays=None, peer_transaction_relays=None, protocol_version=1, bloxroute_version="bloxroute 1.5", pub_key=None, include_default_ont_args=False, blockchain_network_num=constants.DEFAULT_NETWORK_NUM, min_peer_gateways=0, remote_blockchain_ip=None, remote_blockchain_port=None, connect_to_remote_blockchain=False, blockchain_peers=None, blockchain_peers_file=None, is_internal_gateway=False, is_gateway_miner=False, enable_buffered_send=False, encrypt_blocks=True, cookie_file_path=COOKIE_FILE_PATH, blockchain_block_hold_timeout_s=30, blockchain_block_recovery_timeout_s=30, stay_alive_duration=30 * 60, source_version="v1.1.1.1", initial_liveliness_check=30, block_interval=600, non_ssl_port: int = 9001, has_fully_updated_tx_service: bool = False, max_block_interval_s: float = 10, default_tx_flag: TransactionFlag = TransactionFlag.NO_FLAGS, log_level_overrides=None, enable_network_content_logs=False, account_model=None, ipc=False, ipc_file="bxgateway.ipc", ws=False, ws_host=constants.LOCALHOST, ws_port=28333, request_remote_transaction_streaming: bool = False, enable_block_compression: bool = True, filter_txs_factor: float = 0, blockchain_protocol: str = "Ethereum", should_restart_on_high_memory: bool = False, account_id: str = constants.DECODED_EMPTY_ACCOUNT_ID, **kwargs, ) -> GatewayOpts: if node_id is None: node_id = "Gateway at {0}".format(port) if peer_gateways is None: peer_gateways = set() if peer_relays is None: peer_relays = set() if peer_transaction_relays is None: peer_transaction_relays = [] if blockchain_address is None: blockchain_address = ("127.0.0.1", 7000 ) # not real, just a placeholder if test_mode is None: test_mode = [] if log_level_overrides is None: log_level_overrides = {} if remote_blockchain_ip is not None and remote_blockchain_port is not None: remote_blockchain_peer = (remote_blockchain_ip, remote_blockchain_port) else: remote_blockchain_peer = None # below is the same as `class ParseBlockchainPeers(argparse.Action)` if blockchain_peers is not None: blockchain_peers_set = set() blockchain_protocol = blockchain_protocol for peer in blockchain_peers.split(","): blockchain_peer = argument_parsers.parse_peer( blockchain_protocol, peer) # from bxgateway import argument_parsers, blockchain_peers_set.add(blockchain_peer) blockchain_peers = blockchain_peers_set partial_apply_args = locals().copy() for kwarg, arg in partial_apply_args["kwargs"].items(): partial_apply_args[kwarg] = arg partial_apply_args["outbound_peers"] = set(peer_gateways).union( peer_relays) opts = Namespace() common_opts = get_common_opts(**partial_apply_args) opts.__dict__.update(common_opts.__dict__) opts.__dict__.update({ "bloxroute_version": bloxroute_version, "blockchain_ip": blockchain_address[0], "blockchain_port": blockchain_address[1], "blockchain_protocol": blockchain_protocol, "blockchain_network": "Mainnet", "blockchain_version": 12345, "test_mode": test_mode, "peer_gateways": peer_gateways, "peer_relays": peer_relays, "peer_transaction_relays": peer_transaction_relays, "protocol_version": protocol_version, "min_peer_gateways": min_peer_gateways, "remote_blockchain_ip": remote_blockchain_ip, "remote_blockchain_port": remote_blockchain_port, "remote_blockchain_peer": remote_blockchain_peer, "connect_to_remote_blockchain": connect_to_remote_blockchain, "blockchain_peers": blockchain_peers, "blockchain_peers_file": blockchain_peers_file, "is_internal_gateway": is_internal_gateway, "is_gateway_miner": is_gateway_miner, "encrypt_blocks": encrypt_blocks, "enable_buffered_send": enable_buffered_send, "compact_block": True, "compact_block_min_tx_count": BTC_COMPACT_BLOCK_DECOMPRESS_MIN_TX_COUNT, "tune_send_buffer_size": False, "dump_short_id_mapping_compression": False, "max_block_interval_s": max_block_interval_s, "cookie_file_path": cookie_file_path, "config_update_interval": 60, "blockchain_message_ttl": 10, "remote_blockchain_message_ttl": 10, "stay_alive_duration": stay_alive_duration, "initial_liveliness_check": initial_liveliness_check, "has_fully_updated_tx_service": has_fully_updated_tx_service, "source_version": source_version, "require_blockchain_connection": True, "non_ssl_port": non_ssl_port, "default_tx_flag": default_tx_flag, "should_update_source_version": False, "enable_network_content_logs": False, "enable_node_cache": True, "dump_short_id_mapping_compression_path": "", "ws": ws, "ws_host": constants.LOCALHOST, "ws_port": 28333, "account_id": account_id, "ipc": False, "ipc_file": "bxgateway.ipc", "request_remote_transaction_streaming": request_remote_transaction_streaming, "process_node_txs_in_extension": True, "enable_eth_extensions": True, # TODO remove, "request_recovery": True, "enable_block_compression": enable_block_compression, "filter_txs_factor": filter_txs_factor, "min_peer_relays_count": None, "should_restart_on_high_memory": should_restart_on_high_memory, }) # bitcoin opts.__dict__.update({ "blockchain_net_magic": 12345, "blockchain_version": 23456, "blockchain_nonce": 0, "blockchain_services": 1, }) # ethereum opts.__dict__.update({ "private_key": "294549f8629f0eeb2b8e01aca491f701f5386a9662403b485c4efe7d447dfba3", "node_public_key": pub_key, "remote_public_key": pub_key, "network_id": 1, "chain_difficulty": 4194304, "genesis_hash": "1e8ff5fd9d06ab673db775cf5c72a6b2d63171cd26fe1e6a8b9d2d696049c781", "no_discovery": True, "enode": "enode://294549f8629f0eeb2b8e01aca491f701f5386a9662403b485c4efe7d447dfba3@127.0.0.1:8000", "eth_ws_uri": None }) # ontology opts.__dict__.update({ "blockchain_net_magic": 12345, "blockchain_version": 23456, "is_consensus": True, "sync_port": 10001, "http_info_port": 10002, "consensus_port": 10003, "cap": bytes(32), "blockchain_nonce": 0, "relay": True, "soft_version": "myversion", "blockchain_services": 1, }) for key, val in kwargs.items(): opts.__dict__[key] = val gateway_opts = GatewayOpts.from_opts(opts) if account_model: gateway_opts.set_account_options(account_model) # some attributes are usually set by the node runner gateway_opts.__dict__.update({ "node_type": NodeType.EXTERNAL_GATEWAY, "outbound_peers": common_opts.outbound_peers, "sid_expire_time": common_opts.sid_expire_time, "blockchain_networks": common_opts.blockchain_networks, "blockchain_network_num": common_opts.blockchain_network_num, "split_relays": common_opts.split_relays, "should_update_source_version": False, "blockchain_block_interval": block_interval, "blockchain_ignore_block_interval_count": 3, "blockchain_block_recovery_timeout_s": blockchain_block_recovery_timeout_s, "blockchain_block_hold_timeout_s": blockchain_block_hold_timeout_s, }) return gateway_opts
def setUp(self): self.node = MockNode(helpers.get_common_opts(8888))