def test_get_ping_latencies_one_country(self, mock_get_ping_latencies):
relays = [
OutboundPeerModel("34.227.149.148",
1609,
node_id="0",
attributes={"country": "China"}),
OutboundPeerModel("35.198.90.230",
1609,
node_id="1",
attributes={"country": "China"}),
OutboundPeerModel("52.221.211.38",
1609,
node_id="2",
attributes={"country": "China"}),
OutboundPeerModel("34.245.23.125",
1609,
node_id="3",
attributes={"country": "EU"}),
OutboundPeerModel("34.238.245.201",
1609,
node_id="4",
attributes={"country": "EU"}),
]
mock_get_ping_latencies.return_value = [
NodeLatencyInfo(relays[4], 100),
NodeLatencyInfo(relays[1], 101),
NodeLatencyInfo(relays[3], 109),
NodeLatencyInfo(relays[2], 120),
NodeLatencyInfo(relays[0], 130),
]
best_relays = network_latency.get_best_relays_by_ping_latency_one_per_country(
relays, 1)
self.assertEqual(1, len(best_relays))
self.assertEqual("1", best_relays[0].node_id)
def test_on_updated_peers(self):
self.node.connection_pool.add(self.fileno, self.ip, self.port,
self.connection)
self.node.opts.outbound_peers = [
OutboundPeerModel("222.222.222.222",
2000,
node_type=NodeType.GATEWAY)
]
self.node.outbound_peers = [
OutboundPeerModel("111.111.111.111",
1000,
node_type=NodeType.GATEWAY),
OutboundPeerModel("222.222.222.222",
2000,
node_type=NodeType.GATEWAY),
OutboundPeerModel(self.ip, self.port, node_type=NodeType.GATEWAY)
]
outbound_peer_models = [
OutboundPeerModel("111.111.111.111",
1000,
node_type=NodeType.GATEWAY)
]
self.node.on_updated_peers(outbound_peer_models)
self.assertEqual(outbound_peer_models, self.node.outbound_peers)
self._assert_socket_disconnected(False)
def test_get_ping_latencies_in_threads(self):
relays = [
OutboundPeerModel("34.227.149.148",
1609,
node_id="0",
attributes={"country": "China"}),
OutboundPeerModel("35.198.90.230",
1609,
node_id="1",
attributes={"country": "China"}),
OutboundPeerModel("52.221.211.38",
1609,
node_id="2",
attributes={"country": "China"}),
OutboundPeerModel("34.245.23.125",
1609,
node_id="3",
attributes={"country": "China"}),
OutboundPeerModel("34.238.245.201",
1609,
node_id="4",
attributes={"country": "China"}),
]
start = time.time()
network_latency.get_best_relays_by_ping_latency_one_per_country(
relays, 1)
end = time.time() - start
self.assertTrue(end < constants.PING_TIMEOUT_S + 1)
def test_get_best_relay_sorted_relays(self):
relays = [
OutboundPeerModel("34.227.149.148",
1609,
node_id="0",
attributes={"country": "China"}),
OutboundPeerModel("35.198.90.230",
1609,
node_id="1",
attributes={"country": "China"}),
OutboundPeerModel("52.221.211.38",
1609,
node_id="2",
attributes={"country": "China"}),
OutboundPeerModel("34.245.23.125",
1609,
node_id="3",
attributes={"country": "China"}),
OutboundPeerModel("34.238.245.201",
1609,
node_id="4",
attributes={"country": "China"}),
]
sorted_relays_ping_latency = [
NodeLatencyInfo(relays[0], 100),
NodeLatencyInfo(relays[1], 101),
NodeLatencyInfo(relays[2], 109),
NodeLatencyInfo(relays[3], 120),
NodeLatencyInfo(relays[4], 130),
]
best_relay = network_latency._get_best_relay_latencies_one_per_country(
sorted_relays_ping_latency, relays, 1)
self.assertEqual("0", best_relay[0].node.node_id)
def of_type(gateway_class: Type[AbstractGatewayNode], opts: GatewayOpts) -> FullGatewayInfo:
# probably pyre bug
# pyre-fixme[45]: Cannot instantiate abstract class `AbstractGatewayNode`.
gateway = gateway_class(opts, MockNodeSSLService(gateway_class.NODE_TYPE, MagicMock()))
gateway.requester = MagicMock()
blockchain_fileno = 1
relay_fileno = 2
gateway_fileno = 3
blockchain_socket = MockSocketConnection(file_no=blockchain_fileno, ip_address=constants.LOCALHOST, port=7000)
relay_socket = MockSocketConnection(file_no=relay_fileno, ip_address=constants.LOCALHOST, port=7001)
gateway_socket = MockSocketConnection(file_no=gateway_fileno, ip_address=constants.LOCALHOST, port=7002)
gateway.on_connection_added(blockchain_socket)
gateway.peer_relays.add(OutboundPeerModel(constants.LOCALHOST, 7001))
gateway.on_connection_added(relay_socket)
gateway.peer_gateways.add(OutboundPeerModel(constants.LOCALHOST, 7002))
gateway.on_connection_added(gateway_socket)
blockchain_connection = gateway.connection_pool.get_by_fileno(blockchain_fileno)
assert blockchain_connection is not None
assert isinstance(blockchain_connection, AbstractGatewayBlockchainConnection)
relay_connection = gateway.connection_pool.get_by_fileno(relay_fileno)
assert relay_connection is not None
assert isinstance(relay_connection, AbstractRelayConnection)
gateway_connection = gateway.connection_pool.get_by_fileno(gateway_fileno)
assert gateway_connection is not None
assert isinstance(gateway_connection, GatewayConnection)
gateway.on_blockchain_connection_ready(blockchain_connection)
blockchain_connection.state |= ConnectionState.ESTABLISHED
relay_connection.state |= ConnectionState.ESTABLISHED
gateway_connection.state |= ConnectionState.ESTABLISHED
# clear output buffers
if blockchain_connection.outputbuf.length:
blockchain_connection.advance_sent_bytes(blockchain_connection.outputbuf.length)
if relay_connection.outputbuf.length:
relay_connection.advance_sent_bytes(relay_connection.outputbuf.length)
if gateway_connection.outputbuf.length:
gateway_connection.advance_sent_bytes(gateway_connection.outputbuf.length)
return FullGatewayInfo(
gateway,
blockchain_fileno,
relay_fileno,
gateway_fileno,
blockchain_socket,
relay_socket,
gateway_socket,
blockchain_connection,
relay_connection,
gateway_connection
)
def test_parse_peer_string(self):
peers = main.parse_peer_string("127.0.0.1:8000,192.168.1.1:80001")
self.assertEqual(2, len(peers))
self.assertEqual(OutboundPeerModel("127.0.0.1", 8000), peers[0])
self.assertEqual(OutboundPeerModel("192.168.1.1", 80001), peers[1])
peers2 = main.parse_peer_string("127.0.0.1:8000, 192.168.1.1:80001")
self.assertEqual(peers, peers2)
def test_relay_connection_update(self):
relay_connections = [
OutboundPeerModel(LOCALHOST, 8001, node_type=NodeType.RELAY_BLOCK),
OutboundPeerModel(LOCALHOST, 9001, 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, ip_address=LOCALHOST, port=8001, node=node))
self._check_connection_pool(node, 1, 1, 0, 1)
node.on_connection_added(MockSocketConnection(2, ip_address=LOCALHOST, port=8002, node=node))
self._check_connection_pool(node, 2, 1, 1, 2)
network_latency.get_best_relays_by_ping_latency_one_per_country = MagicMock(return_value=[relay_connections[1]])
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(9001, next(iter(node.peer_relays)).port)
self.assertEqual(9002, next(iter(node.peer_transaction_relays)).port)
node.enqueue_connection.assert_has_calls([
call(LOCALHOST, 9001, ConnectionType.RELAY_BLOCK),
call(LOCALHOST, 9002, ConnectionType.RELAY_TRANSACTION),
], any_order=True)
node.on_connection_added(MockSocketConnection(3, ip_address=LOCALHOST, port=9001))
node.on_connection_added(MockSocketConnection(4, ip_address=LOCALHOST, port=9002))
for conn in node.connection_pool.get_by_connection_types([ConnectionType.RELAY_BLOCK]):
self.assertEqual(9001, conn.peer_port)
for conn in node.connection_pool.get_by_connection_types([ConnectionType.RELAY_TRANSACTION]):
self.assertEqual(9002, conn.peer_port)
def test_get_ping_latencies_in_threads(self):
relays = [
OutboundPeerModel("34.227.149.148", node_id="0"),
OutboundPeerModel("35.198.90.230", node_id="1"),
OutboundPeerModel("52.221.211.38", node_id="2"),
OutboundPeerModel("34.245.23.125", node_id="3"),
OutboundPeerModel("34.238.245.201", node_id="4")
]
start = time.time()
network_latency.get_best_relay_by_ping_latency(relays)
end = time.time() - start
self.assertTrue(end < constants.PING_TIMEOUT_S + 1)
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)
async def setUp(self) -> None:
account_model = BdnAccountModelBase(
"account_id", "account_name", "fake_certificate",
new_transaction_streaming=BdnServiceModelConfigBase(
expire_date=date(2999, 1, 1).isoformat()
)
)
gateway_opts = gateway_helpers.get_gateway_opts(8000, ws=True)
gateway_opts.set_account_options(account_model)
self.gateway_node = MockGatewayNode(gateway_opts)
self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY
self.transaction_streamer_peer = OutboundPeerModel("127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY)
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service",
self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S
)
self.gateway_node.requester.start()
self.server = WsServer(
constants.LOCALHOST, 8005, self.gateway_node.feed_manager, self.gateway_node
)
self.ws_uri = f"ws://{constants.LOCALHOST}:8005"
await self.server.start()
async def setUp(self) -> None:
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)
account_model = BdnAccountModelBase(
"account_id",
"account_name",
"fake_certificate",
tier_name="Developer",
new_transaction_streaming=self.base_feed_service_model,
new_pending_transaction_streaming=self.base_feed_service_model,
on_block_feed=self.base_feed_service_model,
transaction_receipts_feed=self.base_feed_service_model)
gateway_opts = gateway_helpers.get_gateway_opts(8000, ws=True)
gateway_opts.set_account_options(account_model)
self.gateway_node = MockGatewayNode(gateway_opts)
self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY
self.transaction_streamer_peer = OutboundPeerModel(
"127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY)
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service",
self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S,
)
self.gateway_node.requester.start()
self.server = WsServer(constants.LOCALHOST, 8005,
self.gateway_node.feed_manager,
self.gateway_node)
self.ws_uri = f"ws://{constants.LOCALHOST}:8005"
await self.server.start()
self.gateway_node.get_ws_server_status = MagicMock(return_value=True)
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)])
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 gateway_2_opts(self):
return gateway_helpers.get_gateway_opts(
9001,
peer_gateways=[OutboundPeerModel(LOCALHOST, 7002)],
include_default_btc_args=True,
encrypt_blocks=False,
sync_tx_service=False)
def test_better_relays_from_sdn(self):
self.gateway_node.peer_relays = {
OutboundPeerModel("2.1.1.1", 1609, node_type=NodeType.RELAY_BLOCK),
OutboundPeerModel("2.1.1.2", 1609, node_type=NodeType.RELAY_BLOCK),
}
self.gateway_node.peer_transaction_relays = {
OutboundPeerModel("2.1.1.1",
1610,
node_type=NodeType.RELAY_TRANSACTION),
OutboundPeerModel("2.1.1.2",
1610,
node_type=NodeType.RELAY_TRANSACTION),
}
self._run_connection_process()
self._assert_connects_to_relays(0)
self._assert_reevaluation_alarm_set()
def test_make_sync_request(self):
other_connections = []
for i in range(2, 5):
fileno = i
port = 8000 + i
connection = MockConnection(fileno, (LOCALHOST, port), self.node)
connection.state |= ConnectionState.ESTABLISHED
connection.enqueue_msg = MagicMock()
self.node.connection_pool.add(fileno, LOCALHOST, port, connection)
other_connections.append(connection)
preferred_connection = other_connections[0]
self.node.peer_gateways.add(OutboundPeerModel(LOCALHOST, 8002))
request = GetHeadersBtcMessage(self.MAGIC, self.VERSION, self.HASHES,
self.HASH2)
self.blockchain_sync_service.make_sync_request(request.command(),
request)
request_message = BlockchainSyncRequestMessage(request.command(),
request.rawbytes())
preferred_connection.enqueue_msg.assert_called_once_with(
request_message, prepend=True)
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCKCHAIN_SYNC_BROADCAST_DELAY_S)
self.node.alarm_queue.fire_alarms()
self.assertIn(request_message, self.node.broadcast_messages)
def test_remote_sync_response_broadcast_response(self):
self.node.send_msg_to_node = MagicMock()
not_responding_connection = GatewayConnection(MockSocketConnection(1),
(LOCALHOST, 8002),
self.node)
not_responding_connection.enqueue_msg = MagicMock()
not_responding_connection.state |= ConnectionState.ESTABLISHED
responding_connection = GatewayConnection(MockSocketConnection(2),
(LOCALHOST, 8003), self.node)
responding_connection.enqueue_msg = MagicMock()
responding_connection.state |= ConnectionState.ESTABLISHED
self.node.connection_pool.add(1, LOCALHOST, 8002,
not_responding_connection)
self.node.connection_pool.add(2, LOCALHOST, 8003,
responding_connection)
self.node.peer_gateways.add(
OutboundPeerModel(LOCALHOST, 8002, is_internal=True))
self.node.peer_gateways.add(
OutboundPeerModel(LOCALHOST, 8003, is_internal=False))
request = GetHeadersBtcMessage(self.MAGIC, self.VERSION, self.HASHES,
self.HASH2)
self.blockchain_sync_service.make_sync_request(request.command(),
request)
not_responding_connection.enqueue_msg.assert_called_once()
responding_connection.enqueue_msg.assert_not_called()
time.time = MagicMock(
return_value=time.time() +
gateway_constants.BLOCKCHAIN_SYNC_BROADCAST_DELAY_S)
self.node.alarm_queue.fire_alarms()
self.assertEqual(1, len(self.node.broadcast_messages))
remote_response = HeadersBtcMessage(self.MAGIC, headers=[])
self.blockchain_sync_service.process_remote_sync_response(
remote_response.command(), remote_response, responding_connection)
self.node.send_msg_to_node.assert_called_once_with(remote_response)
self.assertEqual(
0,
len(self.blockchain_sync_service.
awaiting_local_callback_connections))
self.assertEqual(responding_connection,
self.node.get_preferred_gateway_connection())
def reinitialize_gateways(self, opts1, opts2):
node_ssl_service = MockNodeSSLService(BtcGatewayNode.NODE_TYPE, MagicMock())
self.node1 = BtcGatewayNode(opts1, node_ssl_service)
self.node1.opts.has_fully_updated_tx_service = True
self.node1.requester.send_threaded_request = MagicMock()
self.node2 = BtcGatewayNode(opts2, node_ssl_service)
self.node2.opts.has_fully_updated_tx_service = True
self.node2.requester.send_threaded_request = MagicMock()
self.node1.peer_gateways = {OutboundPeerModel(LOCALHOST, 7002)}
self.node1.peer_relays = {OutboundPeerModel(LOCALHOST, 7001)}
self.node2.peer_gateways = {OutboundPeerModel(LOCALHOST, 7002)}
self.node2.peer_relays = {OutboundPeerModel(LOCALHOST, 7001)}
self.blockchain_fileno = 1
self.relay_fileno = 2
self.gateway_fileno = 3
self.blockchain_connection = MockSocketConnection(
self.blockchain_fileno, self.node1, ip_address=LOCALHOST, port=7000
)
self.relay_connection = MockSocketConnection(self.relay_fileno, self.node1, ip_address=LOCALHOST, port=7001)
self.gateway_connection = MockSocketConnection(self.gateway_fileno, self.node1, ip_address=LOCALHOST, port=7002)
# add node1 connections
self.node1.on_connection_added(self.blockchain_connection)
self.node1.on_connection_added(self.relay_connection)
self.node1.on_connection_added(self.gateway_connection)
# add node 2 connections
self.node2.on_connection_added(self.blockchain_connection)
self.node2.on_connection_added(self.relay_connection)
self.node2.on_connection_added(self.gateway_connection)
# initialize node1 connections
helpers.receive_node_message(self.node1, self.blockchain_fileno, btc_version_message().rawbytes())
helpers.receive_node_message(self.node1, self.relay_fileno, hello_message().rawbytes())
helpers.receive_node_message(self.node1, self.relay_fileno, AckMessage().rawbytes())
helpers.receive_node_message(self.node1, self.gateway_fileno, AckMessage().rawbytes())
# initialize node2 connections
helpers.receive_node_message(self.node2, self.blockchain_fileno, btc_version_message().rawbytes())
helpers.receive_node_message(self.node2, self.relay_fileno, hello_message().rawbytes())
helpers.receive_node_message(self.node2, self.relay_fileno, AckMessage().rawbytes())
helpers.receive_node_message(self.node2, self.gateway_fileno, AckMessage().rawbytes())
self.clear_all_buffers()
def test_on_updated_peers(self):
self.node.connection_pool.add(self.fileno, self.ip, self.port,
self.connection)
self.node.opts.outbound_peers = [
OutboundPeerModel("222.222.222.222", 2000)
]
self.node.outbound_peers = [
OutboundPeerModel("111.111.111.111", 1000),
OutboundPeerModel("222.222.222.222", 2000),
OutboundPeerModel(self.ip, self.port)
]
outbound_peer_models = [OutboundPeerModel("111.111.111.111", 1000)]
self.node.on_updated_peers(outbound_peer_models)
self.assertEqual(outbound_peer_models, self.node.outbound_peers)
self.assertIn((self.fileno, False), self.node.disconnect_queue)
def test_get_best_relay_sorted_relays(self):
relays = [
OutboundPeerModel("34.227.149.148", node_id="0"),
OutboundPeerModel("35.198.90.230", node_id="1"),
OutboundPeerModel("52.221.211.38", node_id="2"),
OutboundPeerModel("34.245.23.125", node_id="3"),
OutboundPeerModel("34.238.245.201", node_id="4")
]
sorted_relays_ping_latency = [
NodeLatencyInfo(relays[0], 100),
NodeLatencyInfo(relays[1], 101),
NodeLatencyInfo(relays[2], 109),
NodeLatencyInfo(relays[3], 120),
NodeLatencyInfo(relays[4], 130)
]
best_relay = network_latency._get_best_relay(
sorted_relays_ping_latency, relays)
self.assertEqual("0", best_relay.node.node_id)
def test_get_ping_latency(self):
relay = OutboundPeerModel("34.227.149.148",
1609,
node_id="0",
attributes={"country": "China"})
start = time.time()
network_latency.get_best_relays_by_ping_latency_one_per_country(
[relay], 1)
end = time.time() - start
self.assertTrue(end < constants.PING_TIMEOUT_S + 1)
async def setUp(self) -> None:
await super().setUp()
self.gateway_node.NODE_TYPE = NodeType.INTERNAL_GATEWAY
self.transaction_streamer_peer = OutboundPeerModel(
"127.0.0.1", 8006, node_type=NodeType.INTERNAL_GATEWAY)
self.feed_manager = FeedManager(self.gateway_node)
self.server = IpcServer("bxgateway.ipc", self.feed_manager,
self.gateway_node, Case.SNAKE)
self.ipc_path = self.server.ipc_path
await self.server.start()
def opts_defaults(cls, opts) -> Namespace:
opts = super().opts_defaults(opts)
if "blockchain_networks" not in opts:
# node_cache dependencies should be untangled
# parameter to call `node_cache.read` but got `Namespace`
cache_file_info = node_cache.read(opts)
if cache_file_info is not None:
opts.blockchain_networks = cache_file_info.blockchain_networks
opts.outbound_peers = set(opts.peer_gateways).union(opts.peer_relays)
if opts.connect_to_remote_blockchain and opts.remote_blockchain_ip and opts.remote_blockchain_port:
opts.remote_blockchain_peer = OutboundPeerModel(
opts.remote_blockchain_ip, opts.remote_blockchain_port)
else:
opts.remote_blockchain_peer = None
opts.account_model = None
opts.is_docker = os.path.exists("/.dockerenv")
# Request streaming from BDN if ws server is turned on
opts.request_remote_transaction_streaming = opts.ws
# set by node runner
opts.blockchain_block_interval = 0
opts.blockchain_ignore_block_interval_count = 0
opts.blockchain_block_recovery_timeout_s = 0
opts.blockchain_block_hold_timeout_s = 0
opts.enable_network_content_logs = False
opts.should_update_source_version = False
# set after initialization
opts.peer_transaction_relays = []
if opts.blockchain_protocol:
opts.blockchain_protocol = opts.blockchain_protocol.lower()
else:
opts.blockchain_protocol = None
if not opts.blockchain_peers:
opts.blockchain_peers = set()
if opts.blockchain_peers_file:
cls.read_blockchain_peers_from_file(opts)
if not opts.cookie_file_path:
opts.cookie_file_path = gateway_constants.COOKIE_FILE_PATH_TEMPLATE.format(
"{}_{}".format(get_sdn_hostname(opts.sdn_url),
opts.external_ip))
opts.min_peer_relays_count = 1
return opts
def test_get_ping_latencies_current_relay_within_threshold_of_fastest(
self, mock_get_ping_latencies):
current_relay = OutboundPeerModel("52.221.211.38",
1609,
node_id="2",
attributes={"country": "EU"})
fastest_relay = OutboundPeerModel("35.198.90.230",
1609,
node_id="1",
attributes={"country": "EU"})
first_recommended_relay = OutboundPeerModel(
"34.227.149.148", 1609, node_id="0", attributes={"country": "EU"})
self.peer_relays = set()
self.peer_relays.add(current_relay)
relays = [
first_recommended_relay,
fastest_relay,
current_relay,
OutboundPeerModel("34.245.23.125",
1609,
node_id="3",
attributes={"country": "China"}),
OutboundPeerModel("34.238.245.201",
1609,
node_id="4",
attributes={"country": "China"}),
]
mock_get_ping_latencies.return_value = [
NodeLatencyInfo(relays[4], 100),
NodeLatencyInfo(fastest_relay, 8),
NodeLatencyInfo(relays[3], 109),
NodeLatencyInfo(current_relay, 10),
NodeLatencyInfo(first_recommended_relay, 9),
]
best_relays = network_latency.get_best_relays_by_ping_latency_one_per_country(
relays, 2, self.peer_relays)
self.assertEqual(2, len(best_relays))
self.assertEqual("2", best_relays[0].node_id)
self.assertEqual("3", best_relays[1].node_id)
def test_get_best_relay_less_relays(self):
relays = [
OutboundPeerModel("34.227.149.148",
1609,
node_id="0",
attributes={"country": "China"})
]
sorted_relays_ping_latency = [NodeLatencyInfo(relays[0], 100)]
best_relays = network_latency._get_best_relay_latencies_one_per_country(
sorted_relays_ping_latency, relays, 2)
self.assertEqual(1, len(best_relays))
self.assertEqual("0", best_relays[0].node.node_id)
def parse_peer_string(peer_string):
"""
Parses string of format ip:port,ip:port,ip:port,... to list of OutboundPeerModels.
"""
peers = []
for ip_port_string in peer_string.split(","):
if ip_port_string:
ip_port_list = ip_port_string.strip().split(":")
ip = ip_port_list[0]
port = int(ip_port_list[1])
peers.append(OutboundPeerModel(ip, port))
return peers
def parse_peer_string(peer_string):
"""
Parses string of format ip:port:node_type,ip:port,ip:port:node_type,... to list of OutboundPeerModels.
"""
peers = []
for ip_port_string in peer_string.split(","):
if ip_port_string:
ip, port_str, node_type_str = ip_port_string.strip().split(":")
peers.append(
OutboundPeerModel(ip,
int(port_str),
node_type=NodeType[node_type_str.upper()]))
return peers
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
def setUp(self) -> None:
self.gateway_node = MockGatewayNode(
gateway_helpers.get_gateway_opts(8000, split_relays=True))
self.gateway_node.alarm_queue = AlarmQueue()
self.gateway_node.requester = ThreadedRequestService(
"mock_thread_service", self.gateway_node.alarm_queue,
constants.THREADED_HTTP_POOL_SLEEP_INTERVAL_S)
self.gateway_node.requester.start()
self.outbound_peer_models = [
OutboundPeerModel("1.1.1.1", 1609, node_type=NodeType.RELAY_BLOCK),
OutboundPeerModel("1.1.1.2", 1609, node_type=NodeType.RELAY_BLOCK),
OutboundPeerModel("1.1.1.3", 1609, node_type=NodeType.RELAY_BLOCK),
]
sdn_http_service.fetch_potential_relay_peers_by_network = MagicMock(
side_effect=lambda *args: self.outbound_peer_models)
sdn_http_service.submit_peer_connection_error_event = MagicMock()
self.latencies = [10, 20, 30]
ping_latency.get_ping_latencies = MagicMock(side_effect=lambda *args: [
NodeLatencyInfo(self.outbound_peer_models[0], self.latencies[0]),
NodeLatencyInfo(self.outbound_peer_models[1], self.latencies[1]),
NodeLatencyInfo(self.outbound_peer_models[2], self.latencies[2]),
])
self.gateway_node.enqueue_connection = MagicMock()
def test_msg_notification_assigning_short_ids(self):
# set test connection to be transaction relay connection
relay_id = str(uuid.uuid4())
peer_model = OutboundPeerModel(constants.LOCALHOST, 12345, relay_id)
self.node.peer_transaction_relays = {peer_model}
self.connection.peer_id = relay_id
self.connection.peer_model = peer_model
self.assertEqual(1, len(self.node.peer_transaction_relays))
self.connection.msg_notify(NotificationMessage(NotificationCode.ASSIGNING_SHORT_IDS))
relay_peer = next(iter(self.node.peer_transaction_relays))
self.assertTrue(relay_peer.assigning_short_ids)
self.connection.msg_notify(NotificationMessage(NotificationCode.NOT_ASSIGNING_SHORT_IDS))
relay_peer = next(iter(self.node.peer_transaction_relays))
self.assertFalse(relay_peer.assigning_short_ids)