def __init__(self,
opts: Namespace,
node_ssl_service: Optional[NodeSSLService] = None):
if node_ssl_service is None:
node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock())
helpers.set_extensions_parallelism()
super().__init__(opts, node_ssl_service)
def setUp(self) -> None:
if constants.USE_EXTENSION_MODULES:
helpers.set_extensions_parallelism()
self.gateway_info_1 = full_gateway_node.of_type(
self.gateway_class(), self.gateway_opts_1())
self.gateway_info_2 = full_gateway_node.of_type(
self.gateway_class(), self.gateway_opts_2())
(
self.gateway_1,
self.blockchain_fileno_1,
self.relay_fileno_1,
self.gateway_fileno_1,
_,
_,
_,
self.blockchain_connection_1,
self.gateway_connection_1,
self.relay_connection_1,
) = self.gateway_info_1
(
self.gateway_2,
self.blockchain_fileno_2,
self.relay_fileno_2,
self.gateway_fileno_2,
_,
_,
_,
self.blockchain_connection_2,
self.gateway_connection_2,
self.relay_connection_2,
) = self.gateway_info_2
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000,
include_default_ont_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockOntGatewayNode(opts)
self.node.neutrality_service = MagicMock()
self.connection = OntNodeConnection(
MockSocketConnection(1,
node=self.node,
ip_address=LOCALHOST,
port=123), self.node)
gateway_helpers.add_blockchain_peer(self.node, self.connection)
self.tx_hash = OntObjectHash(buf=helpers.generate_bytearray(32),
length=ONT_HASH_LEN)
self.block_hash = OntObjectHash(buf=helpers.generate_bytearray(32),
length=ONT_HASH_LEN)
self.sut = OntNodeConnectionProtocol(self.connection)
while self.connection.outputbuf.length > 0:
initial_bytes = self.connection.get_bytes_to_send()
self.connection.advance_sent_bytes(len(initial_bytes))
def test_split_relay_connection(self):
relay_connections = [
OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.RELAY_BLOCK)
]
network_latency.get_best_relays_by_ping_latency_one_per_country = MagicMock(
return_value=[relay_connections[0]])
opts = gateway_helpers.get_gateway_opts(8000,
split_relays=True,
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
node.enqueue_connection = MagicMock()
node._register_potential_relay_peers(
node._find_best_relay_peers(
network_latency.
get_best_relays_by_ping_latency_one_per_country()))
self.assertEqual(1, len(node.peer_relays))
self.assertEqual(1, len(node.peer_transaction_relays))
self.assertEqual(8002, next(iter(node.peer_transaction_relays)).port)
node.enqueue_connection.assert_has_calls([
call(LOCALHOST, 8001, ConnectionType.RELAY_BLOCK),
call(LOCALHOST, 8002, ConnectionType.RELAY_TRANSACTION),
],
any_order=True)
node.on_connection_added(
MockSocketConnection(1, node, ip_address=LOCALHOST, port=8001))
self._check_connection_pool(node, 1, 1, 0, 1)
node.on_connection_added(
MockSocketConnection(2, node, ip_address=LOCALHOST, port=8002))
self._check_connection_pool(node, 2, 1, 1, 2)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000,
include_default_ont_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism(
opts.thread_pool_parallelism_degree)
node_ssl_service = MockNodeSSLService(OntGatewayNode.NODE_TYPE,
MagicMock())
self.gateway_node = OntGatewayNode(opts, node_ssl_service)
self.gateway_node.opts.has_fully_updated_tx_service = True
self.gateway_node.opts.is_consensus = False
self.sut = OntRelayConnection(
MockSocketConnection(node=self.gateway_node,
ip_address=LOCALHOST,
port=8001), self.gateway_node)
self.gateway_node.node_conn = MockConnection(
MockSocketConnection(1,
self.gateway_node,
ip_address=LOCALHOST,
port=8002), self.gateway_node)
self.gateway_node_sut = OntNodeConnectionProtocol(
self.gateway_node.node_conn)
self.gateway_node.message_converter = converter_factory.create_ont_message_converter(
12345, self.gateway_node.opts)
self.gateway_node.node_conn.state = ConnectionState.ESTABLISHED
self.gateway_node.send_msg_to_node = MagicMock()
self.sut.enqueue_msg = MagicMock()
gateway_transaction_stats_service.set_node(self.gateway_node)
def test_gateway_peer_never_destroy_cli_peer(self):
peer_gateways = [OutboundPeerModel(LOCALHOST, 8001)]
opts = gateway_helpers.get_gateway_opts(8000,
peer_gateways=peer_gateways)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
node.enqueue_connection = MagicMock()
node.alarm_queue.register_alarm = MagicMock()
node.alarm_queue.register_approx_alarm = MagicMock()
mock_socket = MockSocketConnection(7,
node,
ip_address=LOCALHOST,
port=8001)
node.on_connection_added(mock_socket)
cli_peer_conn = node.connection_pool.get_by_ipport(LOCALHOST, 8001)
node.num_retries_by_ip[(LOCALHOST, 8001)] = MAX_CONNECT_RETRIES
cli_peer_conn.state = ConnectionState.CONNECTING
node._connection_timeout(cli_peer_conn)
self.assertFalse(mock_socket.alive)
node.on_connection_closed(mock_socket.fileno())
# timeout is fib(3) == 3
node.alarm_queue.register_alarm.assert_has_calls([
call(3, node._retry_init_client_socket, LOCALHOST, 8001,
ConnectionType.EXTERNAL_GATEWAY)
])
node._retry_init_client_socket(LOCALHOST, 8001,
ConnectionType.EXTERNAL_GATEWAY)
self.assertEqual(MAX_CONNECT_RETRIES + 1,
node.num_retries_by_ip[(LOCALHOST, 8001)])
async def setUp(self) -> None:
pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866"
opts = gateway_helpers.get_gateway_opts(
8000,
include_default_eth_args=True,
pub_key=pub_key,
)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE,
MagicMock())
self.node = EthGatewayNode(opts, node_ssl_service)
self.feed_manager = FeedManager(self.node)
self.node.feed_manager = self.feed_manager
self.rpc = SubscriptionRpcHandler(self.node, self.feed_manager,
Case.SNAKE)
self.feed_name = NewTransactionFeed.NAME
self.node.init_live_feeds()
self.feed_service_model = FeedServiceModelBase(
allow_filtering=True, available_fields=["all"])
self.base_feed_service_model = BdnFeedServiceModelConfigBase(
expire_date="2999-01-01", feed=self.feed_service_model)
self.node.account_model = BdnAccountModelBase(
account_id="account_id",
certificate="",
logical_account_name="test",
new_transaction_streaming=self.base_feed_service_model,
)
def initialize_split_relay_node():
relay_connections = [
OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.RELAY_BLOCK)
]
network_latency.get_best_relays_by_ping_latency_one_per_country = MagicMock(
return_value=[relay_connections[0]])
opts = gateway_helpers.get_gateway_opts(8000,
split_relays=True,
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
node.enqueue_connection = MagicMock()
node._register_potential_relay_peers(
node._find_best_relay_peers(
network_latency.get_best_relays_by_ping_latency_one_per_country()))
node.enqueue_connection.assert_has_calls([
call(LOCALHOST, 8001, ConnectionType.RELAY_BLOCK),
call(LOCALHOST, 8002, ConnectionType.RELAY_TRANSACTION),
],
any_order=True)
node.on_connection_added(
MockSocketConnection(1, node, ip_address=LOCALHOST, port=8001))
node.on_connection_added(
MockSocketConnection(2, node, ip_address=LOCALHOST, port=8002))
node.alarm_queue = AlarmQueue()
node.enqueue_connection.reset_mock()
return node
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000, include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism(opts.thread_pool_parallelism_degree)
node_ssl_service = MockNodeSSLService(BtcGatewayNode.NODE_TYPE, MagicMock())
self.gateway_node = BtcGatewayNode(opts, node_ssl_service)
self.gateway_node.opts.has_fully_updated_tx_service = True
self.sut = BtcRelayConnection(
MockSocketConnection(1, node=self.gateway_node, ip_address=LOCALHOST, port=8001), self.gateway_node
)
self.gateway_node.message_converter = converter_factory.create_btc_message_converter(
12345, self.gateway_node.opts
)
self.node_conn = MockConnection(
MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8002), self.gateway_node
)
self.gateway_node.connection_pool.add(1, LOCALHOST, 8002, self.node_conn)
gateway_helpers.add_blockchain_peer(self.gateway_node, self.node_conn)
self.node_conn_2 = MockConnection(
MockSocketConnection(1, self.gateway_node, ip_address=LOCALHOST, port=8003), self.gateway_node
)
self.gateway_node.connection_pool.add(1, LOCALHOST, 8003, self.node_conn_2)
gateway_helpers.add_blockchain_peer(self.gateway_node, self.node_conn_2)
self.blockchain_connections = [self.node_conn, self.node_conn_2]
self.node_conn.enqueue_msg = MagicMock()
self.node_conn_2.enqueue_msg = MagicMock()
self.gateway_node.broadcast = MagicMock()
self.sut.enqueue_msg = MagicMock()
gateway_transaction_stats_service.set_node(self.gateway_node)
self.gateway_node.has_active_blockchain_peer = MagicMock(return_value=True)
def __init__(self,
opts,
node_ssl_service: Optional[NodeSSLService] = None,
block_queueing_cls=BtcBlockQueuingService):
if opts.use_extensions:
helpers.set_extensions_parallelism()
if node_ssl_service is None:
node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock())
super(MockGatewayNode, self).__init__(opts, node_ssl_service)
self.broadcast_messages = []
self.broadcast_to_nodes_messages = []
self._tx_service = GatewayTransactionService(self, 0)
self.block_cleanup_service = self._get_cleanup_service()
self.block_queuing_service = block_queueing_cls(self)
self.message_converter = MockMessageConverter()
if opts.use_extensions:
from bxgateway.services.extension_gateway_transaction_service import ExtensionGatewayTransactionService
self._tx_service = ExtensionGatewayTransactionService(
self, self.network_num)
else:
self._tx_service = GatewayTransactionService(
self, self.network_num)
self.opts.has_fully_updated_tx_service = True
self.requester = MagicMock()
self.has_active_blockchain_peer = MagicMock(return_value=True)
self.min_tx_from_node_gas_price = MagicMock()
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 setUpClass(cls):
arg_parser = argparse.ArgumentParser(add_help=False)
cli.add_argument_parser_logging(arg_parser,
default_log_level=LogLevel.DEBUG)
opts = arg_parser.parse_args(args=[])
log_config.setup_logging(
opts.log_format,
opts.log_level,
default_logger_names=[
"bxcommon", "bxgateway", "bxrelay", "bxgateway_internal",
"bxapi"
],
log_level_overrides=opts.log_level_overrides,
enable_fluent_logger=opts.log_fluentd_enable,
fluentd_host=opts.log_fluentd_host,
fluentd_queue_size=opts.log_fluentd_queue_size,
third_party_loggers=node_runner.THIRD_PARTY_LOGGERS,
fluent_log_level=opts.log_level_fluentd,
stdout_log_level=opts.log_level_stdout,
)
log_config.set_level([LogRecordType.Config.value], LogLevel.WARNING)
http_service.get_json = MagicMock()
http_service.post_json = MagicMock()
http_service.patch_json = MagicMock()
http_service.delete_json = MagicMock()
memory_statistics.start_recording = MagicMock()
REGISTRY.register = MagicMock()
helpers.set_extensions_parallelism()
def test_gateway_peer_sdn_update(self):
# handle duplicates, keeps old, self ip, and maintain peers from CLI
peer_gateways = [
OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.EXTERNAL_GATEWAY),
OutboundPeerModel(LOCALHOST, 8002, node_type=NodeType.EXTERNAL_GATEWAY)
]
opts = gateway_helpers.get_gateway_opts(8000, peer_gateways=peer_gateways)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
node.peer_gateways.add(OutboundPeerModel(LOCALHOST, 8004, node_type=NodeType.EXTERNAL_GATEWAY))
time.time = MagicMock(return_value=time.time() + 10)
node.alarm_queue.fire_alarms()
gateway_peers = [
OutboundPeerModel(LOCALHOST, 8000, node_type=NodeType.EXTERNAL_GATEWAY),
OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.EXTERNAL_GATEWAY),
OutboundPeerModel(LOCALHOST, 8003, node_type=NodeType.EXTERNAL_GATEWAY)
]
future_obj = Future()
future_obj.set_result(gateway_peers)
node._process_gateway_peers_from_sdn(future_obj)
self.assertEqual(4, len(node.outbound_peers))
self.assertEqual(4, len(node.peer_gateways))
self.assertNotIn(OutboundPeerModel(LOCALHOST, 8000, node_type=NodeType.EXTERNAL_GATEWAY), node.peer_gateways)
self.assertIn(OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.EXTERNAL_GATEWAY), node.peer_gateways)
self.assertIn(OutboundPeerModel(LOCALHOST, 8002, node_type=NodeType.EXTERNAL_GATEWAY), node.peer_gateways)
self.assertIn(OutboundPeerModel(LOCALHOST, 8003, node_type=NodeType.EXTERNAL_GATEWAY), node.peer_gateways)
self.assertIn(OutboundPeerModel(LOCALHOST, 8004, node_type=NodeType.EXTERNAL_GATEWAY), node.peer_gateways)
def make_spy_node(gateway_cls, port, **kwargs):
opts = gateway_helpers.get_gateway_opts(port, **kwargs)
if opts.use_extensions:
helpers.set_extensions_parallelism()
gateway_node = gateway_cls(
opts, MockNodeSSLService(gateway_cls.NODE_TYPE, MagicMock()))
gateway_node.broadcast = MagicMock(wraps=gateway_node.broadcast)
gateway_node.requester = MagicMock()
return gateway_node
def test_gateway_peer_sdn_update(self):
# handle duplicates, keeps old, self ip, and maintain peers from CLI
peer_gateways = [
OutboundPeerModel(LOCALHOST,
8001,
node_type=NodeType.EXTERNAL_GATEWAY),
OutboundPeerModel(LOCALHOST,
8002,
node_type=NodeType.EXTERNAL_GATEWAY)
]
opts = gateway_helpers.get_gateway_opts(8000,
peer_gateways=peer_gateways)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
node.peer_gateways.add(
OutboundPeerModel(LOCALHOST,
8004,
node_type=NodeType.EXTERNAL_GATEWAY))
sdn_http_service.fetch_gateway_peers = MagicMock(return_value=[
OutboundPeerModel(
LOCALHOST, 8000, node_type=NodeType.EXTERNAL_GATEWAY),
OutboundPeerModel(
LOCALHOST, 8001, node_type=NodeType.EXTERNAL_GATEWAY),
OutboundPeerModel(
LOCALHOST, 8003, node_type=NodeType.EXTERNAL_GATEWAY)
])
node._send_request_for_gateway_peers()
self.assertEqual(4, len(node.outbound_peers))
self.assertEqual(4, len(node.peer_gateways))
self.assertNotIn(
OutboundPeerModel(LOCALHOST,
8000,
node_type=NodeType.EXTERNAL_GATEWAY),
node.peer_gateways)
self.assertIn(
OutboundPeerModel(LOCALHOST,
8001,
node_type=NodeType.EXTERNAL_GATEWAY),
node.peer_gateways)
self.assertIn(
OutboundPeerModel(LOCALHOST,
8002,
node_type=NodeType.EXTERNAL_GATEWAY),
node.peer_gateways)
self.assertIn(
OutboundPeerModel(LOCALHOST,
8003,
node_type=NodeType.EXTERNAL_GATEWAY),
node.peer_gateways)
self.assertIn(
OutboundPeerModel(LOCALHOST,
8004,
node_type=NodeType.EXTERNAL_GATEWAY),
node.peer_gateways)
def setUp(self):
super().setUp()
self.node1.alarm_queue = AlarmQueue()
self.node2.alarm_queue = AlarmQueue()
self.network_num = 1
self.magic = 12345
self.version = 23456
self.prev_block_hash = bytearray(crypto.double_sha256(b"123"))
self.prev_block = BtcObjectHash(self.prev_block_hash,
length=crypto.SHA256_HASH_LEN)
self.merkle_root_hash = bytearray(crypto.double_sha256(b"234"))
self.merkle_root = BtcObjectHash(self.merkle_root_hash,
length=crypto.SHA256_HASH_LEN)
self.bits = 2
self.nonce = 3
opts = self.gateway_1_opts()
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.btc_message_converter = btc_message_converter_factory.create_btc_message_converter(
self.magic, opts)
self.btc_transactions = [
TxBtcMessage(self.magic, self.version, [], [], i)
for i in range(self.TRANSACTIONS_COUNT)
]
self.btc_transactions_for_block = [
tx_btc_message.rawbytes()[btc_constants.BTC_HDR_COMMON_OFF:]
for tx_btc_message in self.btc_transactions
]
self.transactions = [
self.btc_message_converter.tx_to_bx_txs(tx_btc_message,
self.network_num)[0][0]
for tx_btc_message in self.btc_transactions
]
self.transactions_with_short_ids = [
TxMessage(tx_message.tx_hash(), tx_message.network_num(), "",
i + 1, tx_message.tx_val())
for i, tx_message in enumerate(self.transactions)
]
self.transactions_with_no_content = [
TxMessage(tx_message.tx_hash(), tx_message.network_num(), "",
i + 1) for i, tx_message in enumerate(self.transactions)
]
self.transactions_by_short_id = {
tx_message.short_id(): tx_message
for tx_message in self.transactions_with_short_ids
}
self.block = BlockBtcMessage(self.magic, self.version,
self.prev_block, self.merkle_root,
int(time.time()), self.bits, self.nonce,
self.btc_transactions_for_block)
def setUp(self) -> None:
pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866"
self.opts = gateway_helpers.get_gateway_opts(
8000,
include_default_eth_args=True,
pub_key=pub_key,
track_detailed_sent_messages=True)
if self.opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = self._get_gateway_node()
self.transaction_service = self._get_transaction_service()
def setUp(self) -> None:
crypto_utils.recover_public_key = MagicMock(
return_value=bytes(32))
pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866"
opts = gateway_helpers.get_gateway_opts(8000, include_default_eth_args=True, pub_key=pub_key,
track_detailed_sent_messages=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE, MagicMock())
self.node = EthGatewayNode(opts, node_ssl_service)
self.sut = EthNewBlockFeed(self.node)
async def test_gateway_peer_get_more_peers_when_too_few_gateways(self):
peer_gateways = [
OutboundPeerModel(LOCALHOST,
8001,
node_type=NodeType.EXTERNAL_GATEWAY),
]
opts = gateway_helpers.get_gateway_opts(8000,
peer_gateways=peer_gateways,
min_peer_gateways=2)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
node.peer_gateways.add(
OutboundPeerModel(LOCALHOST,
8002,
node_type=NodeType.EXTERNAL_GATEWAY))
sdn_http_service.fetch_gateway_peers = MagicMock(return_value=[
OutboundPeerModel(
LOCALHOST, 8003, "12345", node_type=NodeType.EXTERNAL_GATEWAY)
])
node.on_connection_added(
MockSocketConnection(node=node, ip_address=LOCALHOST, port=8002))
not_cli_peer_conn = node.connection_pool.get_by_ipport(LOCALHOST, 8002)
not_cli_peer_conn.mark_for_close(False)
time.time = MagicMock(return_value=time.time() +
constants.SDN_CONTACT_RETRY_SECONDS + 1)
sdn_http_service.fetch_gateway_peers.assert_not_called()
node.alarm_queue.fire_alarms()
sdn_http_service.fetch_gateway_peers.assert_has_calls(
[call(node.opts.node_id, False)])
self.assertEqual(
2,
len([
node for node in node.outbound_peers
if node.node_type in NodeType.GATEWAY_TYPE
]))
self.assertIn(
OutboundPeerModel(LOCALHOST,
8001,
node_type=NodeType.EXTERNAL_GATEWAY),
node.outbound_peers)
self.assertIn(
OutboundPeerModel(LOCALHOST,
8003,
"12345",
node_type=NodeType.EXTERNAL_GATEWAY),
node.outbound_peers)
def setUp(self):
opts = gateway_helpers.get_gateway_opts(8000, include_default_ont_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockOntGatewayNode(opts)
self.node.block_processing_service = MagicMock()
self.connection = MagicMock()
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
self.sut = OntBaseConnectionProtocol(self.connection)
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 setUp(self) -> None:
self.block_confirmations_count = 3
opts = gateway_helpers.get_gateway_opts(
8000,
block_confirmations_count=self.block_confirmations_count - 1,
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
self.node = MockGatewayNode(opts)
self.transaction_service = self._get_transaction_service()
self.cleanup_service = self._get_cleanup_service()
self.node._tx_service = self.transaction_service
self.node.block_cleanup_service = self.cleanup_service
self.node.post_block_cleanup_tasks = MagicMock()
self.tx_hashes = []
def _initialize_gateway(self, initialize_blockchain_conn: bool,
initialize_relay_conn: bool) -> GatewayNode:
opts = gateway_helpers.get_gateway_opts(
8000,
blockchain_address=(LOCALHOST, 8001),
peer_relays=[OutboundPeerModel(LOCALHOST, 8002)],
include_default_btc_args=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node = GatewayNode(opts)
if initialize_blockchain_conn:
node.on_connection_added(
MockSocketConnection(1, node, ip_address=LOCALHOST, port=8001))
self.assertEqual(
1,
len(
list(
node.connection_pool.get_by_connection_types(
[ConnectionType.BLOCKCHAIN_NODE]))))
blockchain_conn = next(
iter(
node.connection_pool.get_by_connection_types(
[ConnectionType.BLOCKCHAIN_NODE])))
node.on_blockchain_connection_ready(blockchain_conn)
self.assertIsNone(node._blockchain_liveliness_alarm)
if initialize_relay_conn:
node.on_connection_added(
MockSocketConnection(2, node, ip_address=LOCALHOST, port=8002))
self.assertEqual(
1,
len(
list(
node.connection_pool.get_by_connection_types(
[ConnectionType.RELAY_ALL]))))
relay_conn = next(
iter(
node.connection_pool.get_by_connection_types(
[ConnectionType.RELAY_ALL])))
node.on_relay_connection_ready()
self.assertIsNone(node._relay_liveliness_alarm)
return node
def setUp(self) -> None:
pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866"
opts = gateway_helpers.get_gateway_opts(
8000,
include_default_eth_args=True,
pub_key=pub_key,
track_detailed_sent_messages=True)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE,
MagicMock())
self.node = EthGatewayNode(opts, node_ssl_service)
self.connection_fileno = 1
self.connection = helpers.create_connection(
EthNodeConnection, node=self.node, file_no=self.connection_fileno)
cipher1, cipher2 = AbstractRLPxCipherTest().setup_ciphers()
self.connection.connection_protocol.rlpx_cipher = cipher1
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()
self.connection.node = self.node
self.connection.peer_ip = LOCALHOST
self.connection.peer_port = 8001
self.connection.network_num = 2
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 = EthBaseConnectionProtocol(self.connection, True, dummy_private_key, dummy_public_key)
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):
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 __init__(self, opts, node_ssl_service: Optional[NodeSSLService] = None):
if opts.use_extensions:
helpers.set_extensions_parallelism()
if node_ssl_service is None:
node_ssl_service = MockNodeSSLService(self.NODE_TYPE, MagicMock())
super(MockOntGatewayNode, self).__init__(opts, node_ssl_service)
self.requester = MagicMock()
self.broadcast_messages = []
self.send_to_node_messages = []
self._tx_service = TransactionService(self, 0)
self.block_cleanup_service = self._get_cleanup_service()
self.block_queuing_service = OntBlockQueuingService(self)
self.message_converter = MockMessageConverter()
if opts.use_extensions:
from bxcommon.services.extension_transaction_service import ExtensionTransactionService
self._tx_service = ExtensionTransactionService(self, self.network_num)
else:
self._tx_service = TransactionService(self, self.network_num)
self.opts.has_fully_updated_tx_service = True
self.node_conn = MagicMock()
self.node_conn.is_active = MagicMock(return_value=True)
def setUp(self) -> None:
crypto_utils.recover_public_key = MagicMock(return_value=bytes(32))
pub_key = "a04f30a45aae413d0ca0f219b4dcb7049857bc3f91a6351288cce603a2c9646294a02b987bf6586b370b2c22d74662355677007a14238bb037aedf41c2d08866"
opts = gateway_helpers.get_gateway_opts(8000,
include_default_eth_args=True,
pub_key=pub_key)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE,
MagicMock())
self.node = EthGatewayNode(opts, node_ssl_service)
self.node_conn = MockConnection(
MockSocketConnection(1, self.node, ip_address=LOCALHOST,
port=8002), self.node)
self.node.connection_pool.add(1, LOCALHOST, 8002, self.node_conn)
gateway_helpers.add_blockchain_peer(self.node, self.node_conn)
self.block_queuing_service = self.node.block_queuing_service_manager.get_designated_block_queuing_service(
)
self.sut = EthNewBlockFeed(self.node)
def _set_up_test_node(self, initialize_handshake, generate_pub_key=False):
# Dummy address
self.server_ip = "127.0.0.1"
self.server_port = 1234
self.blockchain_ip = "0.0.0.0"
self.blockchain_port = 30303
# Setting up dummy server addresses
self.servers = [
OutboundPeerModel("172.0.0.1", 2222, node_type=NodeType.GATEWAY),
OutboundPeerModel("172.0.0.2", 3333, node_type=NodeType.GATEWAY),
OutboundPeerModel("172.0.0.3", 4444, node_type=NodeType.GATEWAY)
]
if generate_pub_key:
pub_key = convert.bytes_to_hex(self._get_dummy_public_key())
else:
pub_key = None
opts = gateway_helpers.get_gateway_opts(
self.server_port,
sid_expire_time=0,
external_ip=self.server_ip,
test_mode=[],
peer_gateways=[],
peer_relays=self.servers,
blockchain_address=(self.blockchain_ip, self.blockchain_port),
include_default_eth_args=True,
pub_key=pub_key,
no_discovery=not initialize_handshake)
if opts.use_extensions:
helpers.set_extensions_parallelism()
node_ssl_service = MockNodeSSLService(EthGatewayNode.NODE_TYPE,
MagicMock())
self.node = EthGatewayNode(opts, node_ssl_service)
self.node.requester = MagicMock()
self.assertTrue(self.node)
return self.node
