lbry-sdk/torba/tests/client_tests/integration/test_network.py

170 lines
7.9 KiB
Python
Raw Normal View History

import logging
import os
2019-02-12 22:50:43 +01:00
import asyncio
2019-06-03 21:47:08 +02:00
from unittest.mock import Mock
2018-10-17 19:32:45 +02:00
2019-06-03 21:03:20 +02:00
from torba.client.basenetwork import BaseNetwork
from torba.orchstr8.node import SPVNode
2019-06-03 10:21:57 +02:00
from torba.rpc import RPCSession
2019-06-03 21:47:08 +02:00
from torba.testcase import IntegrationTestCase, AsyncioTestCase
2018-10-11 05:07:38 +02:00
2019-06-26 08:41:35 +02:00
class NetworkTests(IntegrationTestCase):
async def test_remote_height_updated_automagically(self):
initial_height = self.ledger.network.remote_height
await self.blockchain.generate(1)
await self.ledger.network.on_header.first
self.assertEqual(self.ledger.network.remote_height, initial_height + 1)
async def test_server_features(self):
2019-10-08 17:01:38 +02:00
self.assertDictEqual({
2019-09-17 21:30:27 +02:00
'genesis_hash': self.conductor.spv_node.coin_class.GENESIS_HASH,
'hash_function': 'sha256',
'hosts': {},
'protocol_max': '1.4',
'protocol_min': '1.1',
'pruning': None,
'description': '',
'payment_address': '',
'daily_fee': 0,
'server_version': '0.5.7'}, await self.ledger.network.get_server_features())
await self.conductor.spv_node.stop()
address = (await self.account.get_addresses(limit=1))[0]
2019-09-17 21:30:27 +02:00
os.environ.update({
'DESCRIPTION': 'Fastest server in the west.',
'DONATION_ADDRESS': address,
'DAILY_FEE': '42'})
await self.conductor.spv_node.start(self.conductor.blockchain_node)
await self.ledger.network.on_connected.first
2019-10-08 17:01:38 +02:00
self.assertDictEqual({
2019-09-17 21:30:27 +02:00
'genesis_hash': self.conductor.spv_node.coin_class.GENESIS_HASH,
'hash_function': 'sha256',
'hosts': {},
'protocol_max': '1.4',
'protocol_min': '1.1',
'pruning': None,
'description': 'Fastest server in the west.',
'payment_address': address,
'daily_fee': 42,
'server_version': '0.5.7'}, await self.ledger.network.get_server_features())
2019-06-26 08:41:35 +02:00
2018-10-11 05:07:38 +02:00
class ReconnectTests(IntegrationTestCase):
2018-11-04 06:55:50 +01:00
VERBOSITY = logging.WARN
2018-10-11 05:07:38 +02:00
async def test_multiple_servers(self):
# we have a secondary node that connects later, so
node2 = SPVNode(self.conductor.spv_module, node_number=2)
self.ledger.network.config['default_servers'].append((node2.hostname, node2.port))
await asyncio.wait_for(self.ledger.stop(), timeout=1)
await asyncio.wait_for(self.ledger.start(), timeout=1)
self.ledger.network.session_pool.new_connection_event.clear()
await node2.start(self.blockchain)
# this is only to speed up the test as retrying would take 4+ seconds
for session in self.ledger.network.session_pool.sessions:
session.trigger_urgent_reconnect.set()
await asyncio.wait_for(self.ledger.network.session_pool.new_connection_event.wait(), timeout=1)
self.assertEqual(2, len(list(self.ledger.network.session_pool.available_sessions)))
self.assertTrue(self.ledger.network.is_connected)
switch_event = self.ledger.network.on_connected.first
await node2.stop(True)
# secondary down, but primary is ok, do not switch! (switches trigger new on_connected events)
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(switch_event, timeout=1)
2018-10-11 05:07:38 +02:00
async def test_connection_drop_still_receives_events_after_reconnected(self):
2018-10-15 06:45:21 +02:00
address1 = await self.account.receiving.get_or_create_usable_address()
2019-08-06 07:17:39 +02:00
# disconnect and send a new tx, should reconnect and get it
2018-10-17 19:32:45 +02:00
self.ledger.network.client.connection_lost(Exception())
2019-08-06 07:17:39 +02:00
self.assertFalse(self.ledger.network.is_connected)
2018-10-11 05:07:38 +02:00
sendtxid = await self.blockchain.send_to_address(address1, 1.1337)
2019-08-06 07:17:39 +02:00
await asyncio.wait_for(self.on_transaction_id(sendtxid), 1.0) # mempool
2018-10-11 05:07:38 +02:00
await self.blockchain.generate(1)
await self.on_transaction_id(sendtxid) # confirmed
2019-08-12 23:16:53 +02:00
self.assertLess(self.ledger.network.client.response_time, 1) # response time properly set lower, we are fine
2018-10-11 05:07:38 +02:00
2018-11-19 05:17:39 +01:00
await self.assertBalance(self.account, '1.1337')
2018-10-11 05:07:38 +02:00
# is it real? are we rich!? let me see this tx...
d = self.ledger.network.get_transaction(sendtxid)
# what's that smoke on my ethernet cable? oh no!
master_client = self.ledger.network.client
2018-10-17 19:32:45 +02:00
self.ledger.network.client.connection_lost(Exception())
2019-08-12 23:16:53 +02:00
with self.assertRaises(asyncio.TimeoutError):
await d
self.assertIsNone(master_client.response_time) # response time unknown as it failed
2018-10-11 05:07:38 +02:00
# rich but offline? no way, no water, let's retry
with self.assertRaisesRegex(ConnectionError, 'connection is not available'):
2018-10-15 06:45:21 +02:00
await self.ledger.network.get_transaction(sendtxid)
2018-10-11 05:07:38 +02:00
# * goes to pick some water outside... * time passes by and another donation comes in
sendtxid = await self.blockchain.send_to_address(address1, 42)
await self.blockchain.generate(1)
2019-10-02 20:04:30 +02:00
# (this is just so the test doesn't hang forever if it doesn't reconnect)
2019-08-12 18:32:20 +02:00
if not self.ledger.network.is_connected:
await asyncio.wait_for(self.ledger.network.on_connected.first, timeout=1.0)
2018-10-11 05:07:38 +02:00
# omg, the burned cable still works! torba is fire proof!
2018-10-15 06:45:21 +02:00
await self.ledger.network.get_transaction(sendtxid)
2019-02-12 22:50:43 +01:00
async def test_timeout_then_reconnect(self):
2019-08-06 07:17:39 +02:00
# tests that it connects back after some failed attempts
2019-06-04 07:34:58 +02:00
await self.conductor.spv_node.stop()
self.assertFalse(self.ledger.network.is_connected)
2019-08-06 07:17:39 +02:00
await asyncio.sleep(0.2) # let it retry and fail once
2019-06-04 07:34:58 +02:00
await self.conductor.spv_node.start(self.conductor.blockchain_node)
await self.ledger.network.on_connected.first
2019-06-03 10:21:57 +02:00
self.assertTrue(self.ledger.network.is_connected)
async def test_online_but_still_unavailable(self):
# Edge case. See issue #2445 for context
self.assertIsNotNone(self.ledger.network.session_pool.fastest_session)
for session in self.ledger.network.session_pool.sessions:
session.response_time = None
self.assertIsNone(self.ledger.network.session_pool.fastest_session)
2019-06-03 21:47:08 +02:00
class ServerPickingTestCase(AsyncioTestCase):
async def _make_fake_server(self, latency=1.0, port=1):
2019-06-03 21:03:20 +02:00
# local fake server with artificial latency
class FakeSession(RPCSession):
async def handle_request(self, request):
await asyncio.sleep(latency)
return {"height": 1}
server = await self.loop.create_server(lambda: FakeSession(), host='127.0.0.1', port=port)
self.addCleanup(server.close)
return '127.0.0.1', port
2019-07-13 00:54:04 +02:00
async def _make_bad_server(self, port=42420):
async def echo(reader, writer):
while True:
writer.write(await reader.read())
server = await asyncio.start_server(echo, host='127.0.0.1', port=port)
2019-06-03 21:03:20 +02:00
self.addCleanup(server.close)
2019-07-13 00:54:04 +02:00
return '127.0.0.1', port
2019-06-03 21:03:20 +02:00
async def test_pick_fastest(self):
2019-06-03 21:47:08 +02:00
ledger = Mock(config={
'default_servers': [
# fast but unhealthy, should be discarded
await self._make_bad_server(),
('localhost', 1),
('example.that.doesnt.resolve', 9000),
2019-08-06 07:17:39 +02:00
await self._make_fake_server(latency=1.0, port=1340),
await self._make_fake_server(latency=0.1, port=1337),
await self._make_fake_server(latency=0.4, port=1339),
2019-06-03 21:47:08 +02:00
],
'connect_timeout': 3
2019-06-03 21:47:08 +02:00
})
2019-06-03 21:03:20 +02:00
2019-06-03 21:47:08 +02:00
network = BaseNetwork(ledger)
self.addCleanup(network.stop)
2019-06-03 21:03:20 +02:00
asyncio.ensure_future(network.start())
2019-08-06 07:17:39 +02:00
await asyncio.wait_for(network.on_connected.first, timeout=1)
2019-06-03 21:03:20 +02:00
self.assertTrue(network.is_connected)
2019-10-08 17:01:38 +02:00
self.assertTupleEqual(network.client.server, ('127.0.0.1', 1337))
2019-08-06 07:17:39 +02:00
self.assertTrue(all([not session.is_closing() for session in network.session_pool.available_sessions]))
# ensure we are connected to all of them after a while
await asyncio.sleep(1)
self.assertEqual(len(list(network.session_pool.available_sessions)), 3)