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