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_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)
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 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 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_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_register_potential_relay_peers(self):
node = initialize_split_relay_node()
node.opts.country = constants.NODE_COUNTRY_CHINA
relay1 = OutboundPeerModel(ip="10.10.10.01", port=1, node_id="1", node_type=NodeType.RELAY)
relay2 = OutboundPeerModel(ip="10.10.10.02", port=1, node_id="2", node_type=NodeType.RELAY)
relay3 = OutboundPeerModel(ip="10.10.10.03", port=1, node_id="3", node_type=NodeType.RELAY)
relay4 = OutboundPeerModel(ip="10.10.10.04", port=1, node_id="4", node_type=NodeType.RELAY)
# More then 2 potential relay, get 2 fastest
network_latency.get_best_relays_by_ping_latency_one_per_country.return_value = [relay1, relay2]
node._register_potential_relay_peers(
node._find_best_relay_peers(
network_latency.get_best_relays_by_ping_latency_one_per_country()
)
)
self.assertEqual(2, len(node.peer_relays))
self.assertIn(relay1, node.peer_relays)
self.assertIn(relay2, node.peer_relays)
self.assertEqual(2, len(node.peer_transaction_relays))
self.assertNotIn(relay1, node.peer_transaction_relays)
self.assertNotIn(relay2, node.peer_transaction_relays)
self.assertTrue(
any(
peer.ip == relay1.ip and peer.port == relay1.port + 1
for peer in node.peer_transaction_relays
)
)
self.assertTrue(
any(
peer.ip == relay2.ip and peer.port == relay2.port + 1
for peer in node.peer_transaction_relays
)
)
# Second block relay changed
network_latency.get_best_relays_by_ping_latency_one_per_country.return_value = [relay1, relay3]
node._register_potential_relay_peers(
node._find_best_relay_peers(
[relay1, relay2, relay3]
)
)
self.assertEqual(2, len(node.peer_relays))
self.assertIn(relay1, node.peer_relays)
self.assertIn(relay3, node.peer_relays)
self.assertEqual(2, len(node.peer_transaction_relays))
self.assertNotIn(relay1, node.peer_transaction_relays)
self.assertNotIn(relay3, node.peer_transaction_relays)
self.assertTrue(
any(
peer.ip == relay1.ip and peer.port == relay1.port + 1
for peer in node.peer_transaction_relays
)
)
self.assertTrue(
any(
peer.ip == relay3.ip and peer.port == relay3.port + 1
for peer in node.peer_transaction_relays
)
)
# Both relays changed
network_latency.get_best_relays_by_ping_latency_one_per_country.return_value = [relay4, relay2]
node._register_potential_relay_peers(
node._find_best_relay_peers(
[relay1, relay2, relay3, relay4]
)
)
self.assertEqual(2, len(node.peer_relays))
self.assertIn(relay4, node.peer_relays)
self.assertIn(relay2, node.peer_relays)
self.assertEqual(2, len(node.peer_transaction_relays))
self.assertNotIn(relay4, node.peer_transaction_relays)
self.assertNotIn(relay2, node.peer_transaction_relays)
self.assertTrue(
any(
peer.ip == relay4.ip and peer.port == relay4.port + 1
for peer in node.peer_transaction_relays
)
)
self.assertTrue(
any(
peer.ip == relay2.ip and peer.port == relay2.port + 1
for peer in node.peer_transaction_relays
)
)
# Use existing peers if new peers are empty
network_latency.get_best_relays_by_ping_latency_one_per_country.return_value = [relay4, relay2]
node._register_potential_relay_peers(
node._find_best_relay_peers(
[]
)
)
self.assertEqual(2, len(node.peer_relays))
self.assertIn(relay4, node.peer_relays)
self.assertIn(relay2, node.peer_relays)
self.assertEqual(2, len(node.peer_transaction_relays))
self.assertNotIn(relay4, node.peer_transaction_relays)
self.assertTrue(
any(
peer.ip == relay4.ip and peer.port == relay4.port + 1
for peer in node.peer_transaction_relays
)
)
self.assertTrue(
any(
peer.ip == relay2.ip and peer.port == relay2.port + 1
for peer in node.peer_transaction_relays
)
)
# Only one potential relay
node.peer_relays.clear()
node.peer_transaction_relays.clear()
network_latency.get_best_relays_by_ping_latency_one_per_country.return_value = []
node._register_potential_relay_peers([relay1])
self.assertEqual(1, len(node.peer_relays))
self.assertIn(relay1, node.peer_relays)
self.assertEqual(1, len(node.peer_transaction_relays))
self.assertNotIn(relay1, node.peer_transaction_relays)
self.assertEqual(relay1.ip, next(iter(node.peer_transaction_relays)).ip)
self.assertEqual(relay1.port + 1, next(iter(node.peer_transaction_relays)).port)
