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 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 test_get_txs_multiple_sid_assignments(self): block = self.ont_block() transactions = self.ont_transactions(block) # assign short ids that the local connection won't know about until it gets the txs message remote_transaction_service1 = ExtensionTransactionService( MockNode(gateway_helpers.get_gateway_opts(8999)), 0) short_id_mapping1 = {} for i, transaction in enumerate(transactions): remote_transaction_service1.assign_short_id( transaction.tx_hash(), i + 1) remote_transaction_service1.set_transaction_contents( transaction.tx_hash(), transaction.tx()) short_id_mapping1[transaction.tx_hash()] = TransactionInfo( transaction.tx_hash(), transaction.tx(), i + 1) txs_message_1 = TxsMessage([tx for tx in short_id_mapping1.values()]) self.sut.msg_txs(txs_message_1) for transaction_hash, tx_info in short_id_mapping1.items(): transaction_key = self.gateway_node.get_tx_service( ).get_transaction_key(transaction_hash) self.assertEqual( tx_info.short_id, self.gateway_node.get_tx_service().get_short_id_by_key( transaction_key)) stored_hash, stored_content, _ = self.gateway_node.get_tx_service( ).get_transaction(tx_info.short_id) self.assertEqual(transaction_hash, stored_hash) self.assertEqual(tx_info.contents, stored_content) remote_transaction_service2 = ExtensionTransactionService( MockNode(gateway_helpers.get_gateway_opts(8999)), 0) short_id_mapping2 = {} for i, transaction in enumerate(transactions): remote_transaction_service2.assign_short_id( transaction.tx_hash(), i + 101) remote_transaction_service2.set_transaction_contents( transaction.tx_hash(), transaction.tx()) short_id_mapping2[transaction.tx_hash()] = TransactionInfo( transaction.tx_hash(), transaction.tx(), i + 101) txs_message_2 = TxsMessage([tx for tx in short_id_mapping2.values()]) self.sut.msg_txs(txs_message_2) for transaction_hash, tx_info in short_id_mapping2.items(): stored_hash, stored_content, _ = self.gateway_node.get_tx_service( ).get_transaction(tx_info.short_id) self.assertEqual(transaction_hash, stored_hash) self.assertEqual(tx_info.contents, stored_content)
def init(self, use_extensions: bool): opts = Namespace() opts.use_extensions = use_extensions opts.import_extensions = use_extensions opts.tx_mem_pool_bucket_size = DEFAULT_TX_MEM_POOL_BUCKET_SIZE ont_message_converter = converter_factory.create_ont_message_converter(self.MAGIC, opts) if use_extensions: helpers.set_extensions_parallelism() tx_service = ExtensionTransactionService(MockNode( gateway_helpers.get_gateway_opts(8999)), 0) else: tx_service = TransactionService(MockNode( gateway_helpers.get_gateway_opts(8999)), 0) return tx_service, ont_message_converter
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_txs_block_recovery_encrypted(self): block: BlockOntMessage = self.ont_block() transactions: List[TxOntMessage] = self.ont_transactions(block) # assign short ids that the local connection won't know about until it gets the txs message remote_transaction_service = ExtensionTransactionService( MockNode(gateway_helpers.get_gateway_opts(8999)), 0) short_id_mapping = {} for i, transaction in enumerate(transactions): tx_hash = transaction.tx_hash() remote_transaction_service.assign_short_id(tx_hash, i + 1) remote_transaction_service.set_transaction_contents( tx_hash, transaction.rawbytes()) short_id_mapping[tx_hash] = TransactionInfo( tx_hash, transaction.rawbytes(), i + 1) bx_block = bytes( self.gateway_node.message_converter.block_to_bx_block( block, remote_transaction_service)[0]) self.gateway_node.block_recovery_service.add_block = \ MagicMock(wraps=self.gateway_node.block_recovery_service.add_block) self.gateway_node.send_msg_to_node = MagicMock() self.gateway_node.broadcast = MagicMock() key, ciphertext = symmetric_encrypt(bx_block) block_hash = crypto.double_sha256(ciphertext) key_message = KeyMessage(Sha256Hash(block_hash), DEFAULT_NETWORK_NUM, "", key) broadcast_message = BroadcastMessage(Sha256Hash(block_hash), DEFAULT_NETWORK_NUM, "", BroadcastMessageType.BLOCK, True, ciphertext) self.sut.msg_broadcast(broadcast_message) self.gateway_node.broadcast.reset_mock() self.sut.msg_key(key_message) self.gateway_node.block_recovery_service.add_block.assert_called_once() self.assertEqual(2, self.gateway_node.broadcast.call_count) recovery_broadcast = self.gateway_node.broadcast.call_args_list[0] ((gettxs_message, ), recovery_kwargs) = recovery_broadcast self.assertIsInstance(gettxs_message, GetTxsMessage) self.assertIn(ConnectionType.RELAY_TRANSACTION, recovery_kwargs["connection_types"]) key_broadcast = self.gateway_node.broadcast.call_args_list[1] ((key_message, _conn), recovery_kwargs) = key_broadcast self.assertIsInstance(key_message, KeyMessage) self.assertIn(ConnectionType.GATEWAY, recovery_kwargs["connection_types"]) txs = [tx for tx in short_id_mapping.values()] txs_message = TxsMessage(txs=txs) self.sut.msg_txs(txs_message) self._assert_block_sent(block)
def create_connection(connection_cls: Type[Connection], node: Optional[AbstractNode] = None, node_opts: Optional[Namespace] = None, fileno: int = 1, ip: str = constants.LOCALHOST, port: int = 8001, from_me: bool = False, add_to_pool: bool = True) -> Connection: if node_opts is None: node_opts = get_common_opts(8002) if node is None: node = MockNode(node_opts) if isinstance(node, MockNode): add_to_pool = False test_address = (ip, port) test_socket_connection = MockSocketConnection(fileno, node) connection = connection_cls(test_socket_connection, test_address, node, from_me) if add_to_pool: node.connection_pool.add(fileno, ip, port, connection) return connection
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_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): 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 test_msg_broadcast_duplicate_block_with_different_short_id(self): # test scenario when first received block is compressed with unknown short ids, # but second received block is compressed with known short ids ont_block = self.ont_block() block_hash = ont_block.block_hash() transactions = self.bx_transactions() unknown_sid_transaction_service = ExtensionTransactionService(MockNode( gateway_helpers.get_gateway_opts(8999)), 0) for i, transaction in enumerate(transactions): unknown_sid_transaction_service.assign_short_id(transaction.tx_hash(), i) unknown_sid_transaction_service.set_transaction_contents(transaction.tx_hash(), transaction.tx_val()) unknown_short_id_block = bytes( self.gateway_node.message_converter.block_to_bx_block( ont_block, unknown_sid_transaction_service, True, self.gateway_node.network.min_tx_age_seconds )[0] ) unknown_key, unknown_cipher = symmetric_encrypt(unknown_short_id_block) unknown_block_hash = crypto.double_sha256(unknown_cipher) unknown_message = BroadcastMessage(Sha256Hash(unknown_block_hash), self.TEST_NETWORK_NUM, "", BroadcastMessageType.BLOCK, False, bytearray(unknown_short_id_block)) unknown_key_message = KeyMessage(Sha256Hash(unknown_block_hash), self.TEST_NETWORK_NUM, "", unknown_key) local_transaction_service = self.gateway_node.get_tx_service() for i, transaction in enumerate(transactions): local_transaction_service.assign_short_id(transaction.tx_hash(), i + 20) local_transaction_service.set_transaction_contents(transaction.tx_hash(), transaction.tx_val()) known_short_id_block = bytes( self.gateway_node.message_converter.block_to_bx_block( ont_block, local_transaction_service, True, self.gateway_node.network.min_tx_age_seconds )[0] ) known_key, known_cipher = symmetric_encrypt(known_short_id_block) known_block_hash = crypto.double_sha256(known_cipher) known_message = BroadcastMessage(Sha256Hash(known_block_hash), self.TEST_NETWORK_NUM, "", BroadcastMessageType.BLOCK, False, bytearray(known_short_id_block)) known_key_message = KeyMessage(Sha256Hash(known_block_hash), self.TEST_NETWORK_NUM, "", known_key) self.sut.msg_broadcast(unknown_message) self.sut.msg_key(unknown_key_message) self.assertEqual(1, len(self.gateway_node.block_queuing_service)) self.assertEqual(True, self.gateway_node.block_queuing_service._blocks_waiting_for_recovery[block_hash]) self.assertEqual(1, len(self.gateway_node.block_recovery_service._block_hash_to_bx_block_hashes)) self.assertNotIn(block_hash, self.gateway_node.blocks_seen.contents) self.sut.msg_broadcast(known_message) self.sut.msg_key(known_key_message) self.gateway_node_sut.msg_get_data(GetDataOntMessage(self.magic, InventoryOntType.MSG_BLOCK.value, block_hash)) self.gateway_node.broadcast.assert_called() self.assertEqual(0, len(self.gateway_node.block_queuing_service)) self.assertEqual(0, len(self.gateway_node.block_recovery_service._block_hash_to_bx_block_hashes)) self.assertIn(block_hash, self.gateway_node.blocks_seen.contents)
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 init(self, use_extensions: bool): opts = Namespace() opts.use_extensions = use_extensions opts.import_extensions = use_extensions opts.tx_mem_pool_bucket_size = DEFAULT_TX_MEM_POOL_BUCKET_SIZE btc_message_converter = converter_factory.create_btc_message_converter(self.MAGIC, opts=opts) if use_extensions: helpers.set_extensions_parallelism() tx_service = ExtensionTransactionService(MockNode( gateway_helpers.get_gateway_opts(8999)), 0) else: tx_service = TransactionService(MockNode( gateway_helpers.get_gateway_opts(8999)), 0) if self.txns: for idx, txn in enumerate(self.txns): sha = btc_common_utils.get_txid(txn) if idx % 2 == 0: tx_service.assign_short_id(sha, self.short_ids[int(idx/2)]) tx_service.set_transaction_contents(sha, txn) return tx_service, btc_message_converter
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 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_txs_block_recovery(self): block: BlockOntMessage = self.ont_block() transactions: List[TxOntMessage] = self.ont_transactions(block) # assign short ids that the local connection won't know about until it gets the txs message remote_transaction_service = ExtensionTransactionService( MockNode(gateway_helpers.get_gateway_opts(8999)), 0) short_id_mapping = {} for i, transaction in enumerate(transactions): tx_hash = transaction.tx_hash() remote_transaction_service.assign_short_id(tx_hash, i + 1) remote_transaction_service.set_transaction_contents( tx_hash, transaction.rawbytes()) short_id_mapping[tx_hash] = TransactionInfo( tx_hash, transaction.rawbytes(), i + 1) bx_block = bytes( self.gateway_node.message_converter.block_to_bx_block( block, remote_transaction_service, True, self.gateway_node.network.min_tx_age_seconds)[0]) self.gateway_node.block_recovery_service.add_block = \ MagicMock(wraps=self.gateway_node.block_recovery_service.add_block) self.gateway_node.broadcast = MagicMock() broadcast_message = BroadcastMessage(block.block_hash(), DEFAULT_NETWORK_NUM, "", BroadcastMessageType.BLOCK, False, bytearray(bx_block)) self.sut.msg_broadcast(broadcast_message) self.gateway_node.block_recovery_service.add_block.assert_called_once() self.assertEqual(1, self.gateway_node.broadcast.call_count) recovery_broadcast = self.gateway_node.broadcast.call_args_list[0] ((gettxs_message, ), recovery_kwargs) = recovery_broadcast self.assertIsInstance(gettxs_message, GetTxsMessage) self.assertIn(ConnectionType.RELAY_TRANSACTION, recovery_kwargs["connection_types"]) txs = [tx for tx in short_id_mapping.values()] txs_message = TxsMessage(txs=txs) self.sut.msg_txs(txs_message) self._assert_block_sent(block)
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 create_connection( connection_cls: Type[Connection], node: Optional[AbstractNode] = None, node_opts: Optional[CommonOpts] = None, file_no: int = 1, ip: str = constants.LOCALHOST, port: int = 8001, from_me: bool = False, add_to_pool: bool = True, authentication_info: Optional[AuthenticatedPeerInfo] = None ) -> Connection: if node_opts is None: node_opts = get_common_opts(8002) if node is None: node = MockNode(node_opts, None) if authentication_info is None: authentication_info = AuthenticatedPeerInfo( connection_cls.CONNECTION_TYPE, node_opts.node_id, "" ) if isinstance(node, MockNode): add_to_pool = False test_socket_connection = MockSocketConnection(file_no, node, ip_address=ip, port=port) if not from_me: test_socket_connection.direction = NetworkDirection.INBOUND connection = connection_cls(test_socket_connection, node) connection.on_connection_authenticated(authentication_info) connection.peer_model = OutboundPeerModel(ip, port, node_opts.node_id) if add_to_pool: node.connection_pool.add(file_no, ip, port, connection) return connection
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) -> 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 setUp(self): self.eth_message_converter: EthAbstractMessageConverter = converter_factory.create_eth_message_converter( gateway_helpers.get_gateway_opts(8000) ) self.tx_service = ExtensionTransactionService(MockNode(gateway_helpers.get_gateway_opts(8000)), 0) self.test_network_num = 12345
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): 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 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))