def test_connect(self):
ip = '176.25.187.3'
port = 51001
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
def callback(*args, **kwargs):
print args, kwargs
self.ioloop.add_future(self.client.connect_with_future(), callback)
yield gen.sleep(1)
class TestClientConnect(AsyncTestCase):
def setUp(self):
super(TestClientConnect, self).setUp()
self.ioloop = IOLoop()
self.ioloop.start()
self.ioloop_wait = self.ioloop.loop_interval / 1000.0 + 0.01
def tearDown(self):
print 'begin quit_ioloop'
self.quit_ioloop()
print 'end quit_ioloop'
super(TestClientConnect, self).tearDown()
@gen_test
def quit_ioloop(self):
self.ioloop.quit()
yield gen.sleep(self.ioloop.loop_quit_wait + 0.01)
@gen_test()
def test_connect(self):
ip = '176.25.187.3'
port = 51001
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
def callback(*args, **kwargs):
print args, kwargs
self.ioloop.add_future(self.client.connect_with_future(), callback)
yield gen.sleep(1)
@gen_test(timeout=30)
def test_yield_connect(self):
ip = '176.25.187.3'
port = 51001
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertEqual(result, True)
@gen_test(timeout=30)
def test_yield_connect_failed(self):
ip = '176.25.187.3'
port = 51011
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertEqual(result, False)
def start_client(self):
ip, port = self.get_server()
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
def connect_callback(future):
if not self.client.is_connected:
logger.debug('connect failed and retry')
self.client = None
self.start_client()
else:
self.client.add_message(
Version([
Parameter().ELECTRUM_VERSION,
Parameter().PROTOCOL_VERSION
]))
self.ioloop.add_future(self.client.connect_with_future(),
connect_callback)
def test_message2(self):
ip = '176.25.187.3'
port = 51001
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertTrue(result)
self.assertTrue(self.client.is_connected)
self.is_callback = False
@gen.coroutine
def version_callback(msg_id, msg, param):
self.is_callback = True
self.assertEqual(msg_id, 0)
self.assertEqual(msg, {'params': {}, 'method': 'server.version'})
self.client.add_message(Version({}), version_callback)
yield gen.sleep(2)
self.assertTrue(self.is_callback)
class HowToUseNetwork(AsyncTestCase):
@gen_test
def test_application(self):
manager = NetWorkManager()
manager.start()
@gen.coroutine
def version_callback(msg_id, msg, param):
self.is_callback = True
self.assertEqual(msg_id, 0)
self.assertEqual(msg, {'params': {}, 'method': 'server.version'})
manager.add_message(Version({}), version_callback)
manager.quit()
@gen_test(timeout=6)
def test_detail(self):
manager = NetWorkManager()
self.ioloop = IOLoop()
self.ioloop.start()
ip, port = manager.get_server()
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertTrue(result)
@gen.coroutine
def version_callback(msg_id, msg, param):
self.is_callback = True
self.assertEqual(msg_id, 0)
self.assertEqual(msg, {'params': {}, 'method': 'server.version'})
self.client.add_message(Version({}), version_callback)
yield gen.sleep(2)
self.ioloop.quit()
yield gen.sleep(self.ioloop.loop_quit_wait + 0.01)
def test_http_fetch(self):
set_testnet()
rpclient = RPCClient(self.io_loop)
response = yield rpclient.connect_with_future()
self.assertEqual(response, False)
class TestClientMessage(AsyncTestCase):
def setUp(self):
super(TestClientMessage, self).setUp()
open_logger('network')
open_logger('rpcclient')
self.ioloop = IOLoop()
self.ioloop.start()
self.ioloop_wait = self.ioloop.loop_interval / 1000.0 + 0.01
def tearDown(self):
self.quit_ioloop()
close_logger('network')
close_logger('rpcclient')
super(TestClientMessage, self).tearDown()
@gen_test
def quit_ioloop(self):
self.ioloop.quit()
yield gen.sleep(self.ioloop.loop_quit_wait + 0.01)
@gen_test()
def test_message(self):
ip = '176.25.187.3'
port = 51001
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertTrue(result)
self.assertTrue(self.client.is_connected)
self.is_callback = False
@gen.coroutine
def version_callback(msg_id, msg, param):
self.is_callback = True
self.assertEqual(msg_id, 0)
self.assertEqual(msg, {'params': {}, 'method': 'server.version'})
self.client.add_message(Version({}), version_callback)
yield gen.sleep(2)
self.assertTrue(self.is_callback)
@gen_test()
def test_message2(self):
ip = '176.25.187.3'
port = 51001
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertTrue(result)
self.assertTrue(self.client.is_connected)
self.is_callback = False
@gen.coroutine
def version_callback(msg_id, msg, param):
self.is_callback = True
self.assertEqual(msg_id, 0)
self.assertEqual(msg, {'params': {}, 'method': 'server.version'})
self.client.add_message(Version({}), version_callback)
yield gen.sleep(2)
self.assertTrue(self.is_callback)
def test_yield_connect_failed(self):
ip = '176.25.187.3'
port = 51011
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
result = yield self.client.connect_with_future()
self.assertEqual(result, False)
class NetWorkManager:
"""
1. start/stop ioloop
2. collect client
3. regist notify
"""
__metaclass__ = Singleton
ioloop = None
client = None
def __init__(self):
signal.signal(signal.SIGTERM, self.sig_handler)
signal.signal(signal.SIGINT, self.sig_handler)
"""
interface for application:
network.start()
network.status
"""
def start(self):
"""
:return:
"""
self.start_ioloop()
self.start_client()
status = {}
"""
interface for engine
network.add_message(message, callback)
"""
def add_message(self, message, callback=None, subscribe=None):
if message.__class__ is GetHeaderFile:
self.ioloop.add_future(self.init(), callback)
else:
self.client.add_message(message,
callback=callback,
subscribe=subscribe)
"""
inner method
"""
def start_ioloop(self):
if self.ioloop is None:
self.ioloop = IOLoop()
self.ioloop.start()
def sig_handler(self, sig, frame):
logging.warning('Caught signal: %s', sig)
self.quit()
def quit(self):
if self.ioloop is not None:
self.ioloop.quit()
self.ioloop = None
def start_client(self):
ip, port = self.get_server()
self.client = RPCClient(ioloop=self.ioloop, ip=ip, port=port)
def connect_callback(future):
if not self.client.is_connected:
logger.debug('connect failed and retry')
self.client = None
self.start_client()
else:
self.client.add_message(
Version([
Parameter().ELECTRUM_VERSION,
Parameter().PROTOCOL_VERSION
]))
self.ioloop.add_future(self.client.connect_with_future(),
connect_callback)
"""
dns
"""
def get_server(self):
ip, port, _ = self.deserialize_server(self.pick_random_server())
port = int(port)
logger.debug('begin to connect to %s %d' % (ip, port))
try:
l = socket.getaddrinfo(ip, port, socket.AF_UNSPEC,
socket.SOCK_STREAM)
ip, port = l[0][-1]
except socket.gaierror:
logger.debug('cannot resolve hostname')
return ip, port
def filter_protocol(self, hostmap, protocol='s'):
"""
Filters the hostmap for those implementing protocol.
The result is a list in serialized form.
"""
eligible = []
for host, portmap in hostmap.items():
port = portmap.get(protocol)
if port:
eligible.append(self.serialize_server(host, port, protocol))
return eligible
def pick_random_server(self,
hostmap=None,
protocol='t',
exclude_set=set()):
if hostmap is None:
hostmap = Parameter().DEFAULT_SERVERS
eligible = list(
set(self.filter_protocol(hostmap, protocol)) - exclude_set)
return random.choice(eligible) if eligible else None
def serialize_server(self, host, port, protocol):
return str(':'.join([host, port, protocol]))
def deserialize_server(self, server_str):
host, port, protocol = str(server_str).split(':')
assert protocol in 'st'
int(port) # Throw if cannot be converted to int
return host, port, protocol
def init_header(self, callback=None):
self.ioloop.add_future(self.init(), callback)
@gen.coroutine
def init(self):
retry = 5
while retry > 0:
try:
request = tornado.httpclient.HTTPRequest(
url=Parameter().HEADERS_URL,
connect_timeout=20.0,
request_timeout=60 * 10)
response = yield tornado.gen.Task(AsyncHTTPClient().fetch,
request)
#
# response = yield AsyncHTTPClient().fetch(Parameter().HEADERS_URL)
except Exception as ex:
print ex.message
retry -= 1
else:
raise gen.Return(response.body)