def test_discover_works_with_ipc_sockets(self): wallet = Wallet() d = DiscoveryServer(_socket('ipc:///tmp/discovery'), wallet, b'CORRECT_PEPPER', ctx=self.ctx) success_task = ping(_socket('ipc:///tmp/discovery'), pepper=b'CORRECT_PEPPER', ctx=self.ctx, timeout=300) failure_task = ping(_socket('tcp://127.0.0.1:20999'), pepper=b'CORRECT_PEPPER', ctx=self.ctx, timeout=300) async def stop_server(timeout): await asyncio.sleep(timeout) d.stop() tasks = asyncio.gather(success_task, failure_task, d.serve(), stop_server(0.3)) loop = asyncio.get_event_loop() results = loop.run_until_complete(tasks) vk_ip1, vk_ip2, _, _ = results _, vk1 = vk_ip1 _, vk2 = vk_ip2 self.assertEqual(vk1.hex(), wallet.verifying_key().hex()) self.assertIsNone(vk2)
def test_discover_nodes_none_found(self): addresses = [_socket('tcp://127.0.0.1:10999'), _socket('tcp://127.0.0.1:11999'), _socket('tcp://127.0.0.1:12999')] addresses_wrong = [_socket('tcp://127.0.0.1:15999'), _socket('tcp://127.0.0.1:14999'), _socket('tcp://127.0.0.1:13999')] wallets = [Wallet(), Wallet(), Wallet()] pepper = b'CORRECT_PEPPER' server_timeout = 1 servers = [DiscoveryServer(addresses[0], wallets[0], pepper, ctx=self.ctx), DiscoveryServer(addresses[1], wallets[1], pepper, ctx=self.ctx), DiscoveryServer(addresses[2], wallets[2], pepper, ctx=self.ctx)] async def stop_server(s, timeout): await asyncio.sleep(timeout) s.stop() tasks = asyncio.gather( servers[0].serve(), servers[1].serve(), servers[2].serve(), stop_server(servers[0], server_timeout), stop_server(servers[1], server_timeout), stop_server(servers[2], server_timeout), discover_nodes(ip_list=addresses_wrong, pepper=pepper, ctx=self.ctx, timeout=500, retries=3) ) loop = asyncio.get_event_loop() results = loop.run_until_complete(tasks) r = results[-1] self.assertIsNone(r.get(str(addresses[0]))) self.assertIsNone(r.get(str(addresses[1]))) self.assertIsNone(r.get(str(addresses[2])))
def test_peer_table_updated_on_join_command(self): # Network params issue w1 = Wallet() p1 = Network(wallet=w1, socket_base='tcp://127.0.0.1', ctx=self.ctx) w2 = Wallet() d = DiscoveryServer(wallet=w2, socket_id=_socket('tcp://127.0.0.1:19000'), pepper=PEPPER.encode(), ctx=self.ctx, linger=200) # 1. start network # 2. start discovery of other side # 3. send join request # 4. check to see if the data has been added join_message = ['join', (w2.verifying_key().hex(), 'tcp://127.0.0.1')] join_message = json.dumps(join_message).encode() tasks = asyncio.gather( p1.peer_service.serve(), d.serve(), services.get(_socket('tcp://127.0.0.1:10002'), msg=join_message, ctx=self.ctx, timeout=1000), stop_server(p1.peer_service, 0.3), stop_server(d, 0.3)) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) self.assertEqual(p1.peer_service.table[w2.verifying_key().hex()], 'tcp://127.0.0.1')
def test_discover_works_with_blend_of_tcp_and_ipc(self): addresses = [_socket('ipc:///tmp/discover1'), _socket('tcp://127.0.0.1:11999'), _socket('ipc:///tmp/woohoo')] wallets = [Wallet(), Wallet(), Wallet()] pepper = b'CORRECT_PEPPER' server_timeout = 0.3 servers = [DiscoveryServer(addresses[0], wallets[0], pepper, ctx=self.ctx), DiscoveryServer(addresses[1], wallets[1], pepper, ctx=self.ctx), DiscoveryServer(addresses[2], wallets[2], pepper, ctx=self.ctx)] async def stop_server(s, timeout): await asyncio.sleep(timeout) s.stop() tasks = asyncio.gather( servers[0].serve(), servers[1].serve(), servers[2].serve(), stop_server(servers[0], server_timeout), stop_server(servers[1], server_timeout), stop_server(servers[2], server_timeout), discover_nodes(ip_list=addresses, pepper=pepper, ctx=self.ctx) ) loop = asyncio.get_event_loop() results = loop.run_until_complete(tasks) r = results[-1] self.assertEqual(r[str(addresses[0])], wallets[0].verifying_key().hex()) self.assertEqual(r[str(addresses[1])], wallets[1].verifying_key().hex()) self.assertEqual(r[str(addresses[2])], wallets[2].verifying_key().hex())
def test_bootstrap_nodes_ipc(self): w = Wallet() w1 = Wallet() w2 = Wallet() w3 = Wallet() w4 = Wallet() bootnodes = [ _socket('ipc:///tmp/n1/discovery'), _socket('ipc:///tmp/n2/discovery'), _socket('ipc:///tmp/n3/discovery'), _socket('ipc:///tmp/n4/discovery') ] d1 = DiscoveryServer(socket_id=bootnodes[0], wallet=w1, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) d2 = DiscoveryServer(socket_id=bootnodes[1], wallet=w2, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) d3 = DiscoveryServer(socket_id=bootnodes[2], wallet=w3, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) d4 = DiscoveryServer(socket_id=bootnodes[3], wallet=w4, pepper=PEPPER.encode(), ctx=self.ctx, linger=1000, poll_timeout=1000) n = Network(wallet=w, ctx=self.ctx, bootnodes=bootnodes) tasks = asyncio.gather(d1.serve(), d2.serve(), d3.serve(), d4.serve(), stop_server(d1, 1), stop_server(d2, 1), stop_server(d3, 1), stop_server(d4, 1), n.discover_bootnodes(bootnodes)) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) expected_dict = { w.verifying_key().hex(): 'tcp://0.0.0.0', w1.verifying_key().hex(): 'ipc:///tmp/n1', w2.verifying_key().hex(): 'ipc:///tmp/n2', w3.verifying_key().hex(): 'ipc:///tmp/n3', w4.verifying_key().hex(): 'ipc:///tmp/n4' } self.assertDictEqual(n.peer_service.table, expected_dict)
def test_event_service_triggered_when_new_node_added_ipc(self): # Create Network service w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp') n1 = '/tmp/n1' try: os.mkdir('/tmp/n1') except: pass # Create Discovery Server w2 = Wallet() d = DiscoveryServer(wallet=w2, socket_id=_socket('ipc:///tmp/n1/discovery'), pepper=PEPPER.encode(), ctx=self.ctx, poll_timeout=2000, linger=200) # Create raw subscriber subscriber = self.ctx.socket(zmq.SUB) subscriber.setsockopt(zmq.SUBSCRIBE, b'') subscriber.connect('ipc:///tmp/events') # TCP takes a bit longer to bind and is prone to dropping messages... sleep(0.3) # Construct the join RPC message join_message = ['join', (w2.verifying_key().hex(), 'ipc:///tmp/n1')] join_message = json.dumps(join_message).encode() # Wrap recv() in an async async def recv(): msg = await subscriber.recv() return msg tasks = asyncio.gather( p1.peer_service.start( ), # Start the PeerService which will process RPC and emit events d.serve( ), # Start Discovery so PeerService can verify they are online services.get(_socket('ipc:///tmp/peers'), msg=join_message, ctx=self.ctx, timeout=3000), # Push out a join request stop_server(p1.peer_service, 1), stop_server(d, 1), recv() # Collect the subscription result ) loop = asyncio.get_event_loop() res = loop.run_until_complete(tasks) expected_list = ['join', [w2.verifying_key().hex(), 'ipc:///tmp/n1']] got_list = json.loads(res[-1].decode()) self.assertListEqual(expected_list, got_list)
def test_get_sockets_with_service(self): constitution = self.get_vkbook_args() sync.submit_from_genesis_json_file(cilantro_ee.contracts.__path__[0] + '/genesis.json', client=self.client) sync.submit_node_election_contracts( initial_masternodes=constitution['masternodes'], boot_mns=constitution['masternode_min_quorum'], initial_delegates=constitution['delegates'], boot_dels=constitution['delegate_min_quorum'], client=self.client) PhoneBook = VKBook(client=self.client) w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='tcp://127.0.0.1') # 'tcp://127.0.0.1:10003' raw = {'stu': 'tcp://127.0.0.1', 'raghu': 'tcp://127.0.0.2'} p1.peer_service.table = raw expected = { 'stu': _socket('tcp://127.0.0.1:19003'), 'raghu': _socket('tcp://127.0.0.2:19003') } # CHANGE CLIENT TO SOCKET masternodes = Parameters(socket_base='tcp://127.0.0.1', wallet=w1, contacts=MockContacts(['stu'], delegates=['raghu']), ctx=self.ctx) self.assertDictEqual(masternodes.sockets, {}) async def late_refresh(): await asyncio.sleep(0.3) await masternodes.refresh() async def stop(): await asyncio.sleep(0.5) p1.stop() tasks = asyncio.gather(p1.start(discover=False), late_refresh(), stop()) self.loop.run_until_complete(tasks) self.assertEqual( masternodes.get_all_sockets(service=ServiceType.EVENT), expected)
def test_peer_server_init(self): w = Wallet() t = {'woo': 'hoo'} p = PeerServer(socket_id=_socket('tcp://127.0.0.1:19999'), event_address=_socket('tcp://127.0.0.1:19888'), wallet=w, table=t, ctx=self.ctx, linger=100, poll_timeout=100) tasks = asyncio.gather(p.serve(), stop_server(p, 0.1)) loop = asyncio.get_event_loop() loop.run_until_complete(tasks)
def test_other_peers_add_new_nodes_when_join_event_occurs_ipc(self): # N3 runs discovery server and pings N1 # N1 checks to see if N3 is valid, and if so, adds to their table and pings N2 about the new join # Create Network service w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp/n1') # Create Network service w2 = Wallet() p2 = Network(wallet=w2, ctx=self.ctx, socket_base='ipc:///tmp/n2') p2.peer_service.event_service.add_subscription( _socket('ipc:///tmp/n1/events')) # Create Discovery Server w3 = Wallet() d = DiscoveryServer(wallet=w3, socket_id=_socket('ipc:///tmp/n3/discovery'), pepper=PEPPER.encode(), ctx=self.ctx, poll_timeout=2000, linger=2000) # TCP takes a bit longer to bind and is prone to dropping messages... sleep(1) # Construct the join RPC message join_message = ['join', (w3.verifying_key().hex(), 'ipc:///tmp/n3')] join_message = json.dumps(join_message).encode() tasks = asyncio.gather( p1.peer_service.start(), p2.peer_service.start(), d.serve(), services.get(_socket('ipc:///tmp/n1/peers'), msg=join_message, ctx=self.ctx, timeout=1000), stop_server(p1.peer_service, 2), stop_server(p2.peer_service, 2), stop_server(d, 2), ) loop = asyncio.get_event_loop() loop.run_until_complete(tasks) self.assertTrue(w3.verifying_key().hex() in p2.peer_service.table)
def test_peer_server_returns_all_peers_if_doesnt_have_it_or_more_than_response_amount_ipc( self): w1 = Wallet() p1 = Network(wallet=w1, socket_base='ipc:///tmp', ctx=self.ctx) test_dict = {'test': 'value', 'another': 'one', 'something': 'else'} p1.peer_service.table = test_dict find_message = ['find', 'baloney'] find_message = json.dumps(find_message).encode() tasks = asyncio.gather( p1.peer_service.serve(), stop_server(p1.peer_service, 0.3), services.get(_socket('ipc:///tmp/peers'), msg=find_message, ctx=self.ctx, timeout=300)) loop = asyncio.get_event_loop() res = loop.run_until_complete(tasks) response = res[-1] response = response.decode() response = json.loads(response) self.assertDictEqual(test_dict, response)
def test_peer_server_returns_peer_when_asked_ipc(self): w1 = Wallet() p1 = Network(wallet=w1, socket_base='ipc:///tmp', ctx=self.ctx) w2 = Wallet() p1.peer_service.table[w2.verifying_key().hex()] = 'inproc://goodtimes' find_message = ['find', w2.verifying_key().hex()] find_message = json.dumps(find_message).encode() tasks = asyncio.gather( p1.peer_service.serve(), stop_server(p1.peer_service, 0.3), services.get(_socket('ipc:///tmp/peers'), msg=find_message, ctx=self.ctx, timeout=300)) loop = asyncio.get_event_loop() res = loop.run_until_complete(tasks) response = res[-1] response = response.decode() response = json.loads(response) self.assertEqual(response.get(w2.verifying_key().hex()), 'inproc://goodtimes')
def test_nbn_puts_messages_on_q(self): n = NBNInbox( contacts=VKBook(), driver=BlockchainDriver(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=self.ctx, linger=500, poll_timeout=500, verify=False ) async def send(): socket = self.ctx.socket(zmq.DEALER) socket.connect('tcp://127.0.0.1:8888') await socket.send(b'') async def stop(): await asyncio.sleep(0.5) n.stop() tasks = asyncio.gather( n.serve(), send(), stop() ) self.loop.run_until_complete(tasks) self.assertEqual(len(n.q), 1)
def test_block_never_received_goes_through_adequate_consensus(self): a = Aggregator(wallet=Wallet(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=zmq.asyncio.Context(), driver=BlockchainDriver()) c1 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_4', 3)] c2 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_4', 3)] c3 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_X', 3)] a.sbc_inbox.q = [c1, c2, c3] res = self.loop.run_until_complete(a.gather_subblocks(4, adequate_ratio=0.3)) print(res) self.assertFalse(canonical.block_is_failed(res, '0' * 32, 1))
def test_block_notification_wrong_type_throws_exception(self): n = NBNInbox(contacts=VKBook(), driver=BlockchainDriver(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=self.ctx, linger=50, poll_timeout=50) msg = Message.get_message_packed_2(MessageType.BURN_INPUT_HASHES) with self.assertRaises(NotBlockNotificationMessageType): n.validate_nbn(msg)
def test_mixed_results_still_makes_quorum(self): a = Aggregator(wallet=Wallet(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=zmq.asyncio.Context(), driver=BlockchainDriver()) c1 = [MockSBC('input_1', 'res_X', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_4', 3)] c2 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_X', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_4', 3)] c3 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_i', 'res_X', 2), MockSBC('input_4', 'res_4', 3)] c4 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_X', 3)] a.sbc_inbox.q = [c1, c2, c3, c4] res = self.loop.run_until_complete(a.gather_subblocks(4)) self.assertEqual(res['subBlocks'][0]['merkleLeaves'][0], 'res_1') self.assertEqual(res['subBlocks'][1]['merkleLeaves'][0], 'res_2') self.assertEqual(res['subBlocks'][2]['merkleLeaves'][0], 'res_3') self.assertEqual(res['subBlocks'][3]['merkleLeaves'][0], 'res_4')
def test_failed_block_on_one_returns_failed_block(self): a = Aggregator(wallet=Wallet(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=zmq.asyncio.Context(), driver=BlockchainDriver()) c1 = [MockSBC('input_1', 'res_X', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_4', 3)] c2 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_X', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_4', 3)] c3 = [MockSBC('input_1', 'res_X', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_i', 'res_X', 2), MockSBC('input_4', 'res_4', 3)] c4 = [MockSBC('input_1', 'res_1', 0), MockSBC('input_2', 'res_2', 1), MockSBC('input_3', 'res_3', 2), MockSBC('input_4', 'res_X', 3)] a.sbc_inbox.q = [c1, c2, c3, c4] res = self.loop.run_until_complete(a.gather_subblocks(4)) print(res) self.assertTrue(canonical.block_is_failed(res, '0' * 64, 1))
def test_async_ping_timeout_occurs_if_ip_isnt_online(self): loop = asyncio.get_event_loop() loop.run_until_complete(ping(_socket('inproc://dontexist'), pepper=b'DOESNT_MATTER', ctx=self.ctx, timeout=50,) )
def test_run_server(self): d = DiscoveryServer(_socket('tcp://127.0.0.1:10999'), Wallet(), b'blah') tasks = asyncio.gather(timeout_bomb(), d.serve()) run_silent_loop(tasks) d.ctx.destroy()
async def get(): return await mn1.wait_for_quorum( 1, 0, [mnw1.verifying_key().hex(), mnw2.verifying_key().hex()], [dw1.verifying_key().hex(), dw2.verifying_key().hex()], initial_peers=[_socket('tcp://127.0.0.1:10003')])
async def get(): return await mn1.wait_for_quorum( 1, 0, [mnw1.verifying_key().hex(), mnw2.verifying_key().hex()], [dw1.verifying_key().hex(), dw2.verifying_key().hex()], initial_peers=[_socket('ipc:///tmp/n2/peers')])
def test_block_notification_invalid_block_num_throws_exception(self): n = NBNInbox(contacts=VKBook(), driver=BlockchainDriver(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=self.ctx, linger=50, poll_timeout=50) n.driver.set_latest_block_num(1) msg = Message.get_message_packed_2(MessageType.BLOCK_NOTIFICATION, blockNum=100) with self.assertRaises(BlockNumberMismatch): n.validate_nbn(msg)
def test_refresh(self): vkbook_args = self.get_vkbook_args() sync.submit_vkbook(vkbook_args, overwrite=True) PhoneBook = VKBook() w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='tcp://127.0.0.1') #'tcp://127.0.0.1:10003' raw = {'stu': 'tcp://127.0.0.1', 'raghu': 'tcp://127.0.0.2'} p1.peer_service.table.peers = raw expected = { 'stu': _socket('tcp://127.0.0.1:{}'.format(EVENT_PORT)), 'raghu': _socket('tcp://127.0.0.2:{}'.format(EVENT_PORT)) } # CHANGE CLIENT TO SOCKET masternodes = SocketBook( socket_base='tcp://127.0.0.1', service_type=ServiceType.EVENT, ctx=self.ctx, phonebook_function=PhoneBook.contract.get_masternodes) self.assertDictEqual(masternodes.sockets, {}) async def late_refresh(): await asyncio.sleep(0.3) await masternodes.refresh() async def stop(): await asyncio.sleep(0.5) p1.stop() tasks = asyncio.gather(p1.start(discover=False), late_refresh(), stop()) self.loop.run_until_complete(tasks) self.assertDictEqual(masternodes.sockets, expected)
def test_send_message_to_discovery(self): address = 'tcp://127.0.0.1:10999' d = DiscoveryServer(_socket('tcp://127.0.0.1:10999'), Wallet(), b'blah', ctx=self.ctx) async def ping(msg, sleep): await asyncio.sleep(sleep) socket = self.ctx.socket(zmq.REQ) socket.setsockopt(zmq.LINGER, 20) socket.connect(address) socket.send(msg) result = await socket.recv() self.assertTrue(result) tasks = asyncio.gather(ping(b'', TIME_UNIT), d.serve(), timeout_bomb()) run_silent_loop(tasks)
def test_discovery_server_returns_correct_vk_and_pepper(self): address = 'tcp://127.0.0.1:10999' wallet = Wallet() d = DiscoveryServer(_socket('tcp://127.0.0.1:10999'), wallet, b'CORRECT_PEPPER', ctx=self.ctx) async def ping(msg, sleep): await asyncio.sleep(sleep) socket = self.ctx.socket(zmq.REQ) socket.setsockopt(zmq.LINGER, 20) socket.connect(address) socket.send(msg) result = await socket.recv() self.assertTrue(verify_vk_pepper(result, b'CORRECT_PEPPER')) tasks = asyncio.gather(ping(b'', TIME_UNIT), d.serve(), timeout_bomb()) run_silent_loop(tasks)
def test_discover_server_gets_correct_vk_from_msg_decoding(self): address = 'tcp://127.0.0.1:10999' wallet = Wallet() d = DiscoveryServer(_socket('tcp://127.0.0.1:10999'), wallet, b'CORRECT_PEPPER', ctx=self.ctx) async def ping(msg, sleep): await asyncio.sleep(sleep) socket = self.ctx.socket(zmq.REQ) socket.setsockopt(zmq.LINGER, 20) socket.connect(address) socket.send(msg) result = await socket.recv() vk, _ = unpack_pepper_msg(result) self.assertEqual(vk, wallet.verifying_key()) tasks = asyncio.gather(ping(b'', TIME_UNIT), d.serve(), timeout_bomb()) run_silent_loop(tasks)
def test_nbn_wait_for_next_nbn_returns_first_on_q(self): n = NBNInbox(contacts=VKBook(), driver=BlockchainDriver(), socket_id=_socket('tcp://127.0.0.1:8888'), ctx=self.ctx, linger=50, poll_timeout=50, verify=False) async def send(): socket = self.ctx.socket(zmq.DEALER) socket.connect('tcp://127.0.0.1:8888') await socket.send(b'\x00') async def stop(): await asyncio.sleep(0.5) n.stop() tasks = asyncio.gather( n.serve(), send(), stop(), n.wait_for_next_nbn() ) _, _, _, a = self.loop.run_until_complete(tasks) self.assertEqual(a, b'\x00')
def test_peer_server_returns_self_when_asked(self): w1 = Wallet() p1 = Network(wallet=w1, socket_base='tcp://127.0.0.1', ctx=self.ctx) find_message = ['find', w1.verifying_key().hex()] find_message = json.dumps(find_message).encode() tasks = asyncio.gather( p1.peer_service.serve(), stop_server(p1.peer_service, 0.3), services.get(_socket('tcp://127.0.0.1:19002'), msg=find_message, ctx=self.ctx, timeout=300)) loop = asyncio.get_event_loop() res = loop.run_until_complete(tasks) response = res[-1] response = response.decode() response = json.loads(response) self.assertEqual(response.get(w1.verifying_key().hex()), 'tcp://127.0.0.1')
def test_discover_nodes_found_one(self): address = _socket('tcp://127.0.0.1:10999') wallet = Wallet() d = DiscoveryServer(address, wallet, b'CORRECT_PEPPER', ctx=self.ctx) async def stop_server(timeout): await asyncio.sleep(timeout) d.stop() tasks = asyncio.gather( discover_nodes(ip_list=[address], pepper=b'CORRECT_PEPPER', ctx=self.ctx), d.serve(), stop_server(0.2) ) loop = asyncio.get_event_loop() results = loop.run_until_complete(tasks) r = results[0] self.assertEqual(r[str(address)], wallet.verifying_key().hex())
def test_refresh_remove_old_nodes(self): vkbook_args = self.get_vkbook_args() sync.submit_vkbook(vkbook_args, overwrite=True) PhoneBook = VKBook() w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='tcp://127.0.0.1') peeps = { 'stu': 'tcp://127.0.0.1', 'raghu': 'tcp://127.0.0.8', 'tejas': 'tcp://127.0.2.1', 'steve': 'tcp://127.0.54.6' } p1.peer_service.table.peers = peeps ctx2 = zmq.asyncio.Context() masternodes = SocketBook( socket_base='tcp://127.0.0.1', service_type=ServiceType.EVENT, ctx=ctx2, phonebook_function=PhoneBook.contract.get_masternodes) self.assertDictEqual(masternodes.sockets, {}) async def late_refresh(): await asyncio.sleep(0.3) await masternodes.refresh() async def stop(): await asyncio.sleep(0.5) p1.stop() tasks = asyncio.gather(p1.start(discover=False), late_refresh(), stop()) self.loop.run_until_complete(tasks) expected = { 'stu': _socket('tcp://127.0.0.1:{}'.format(EVENT_PORT)), 'raghu': _socket('tcp://127.0.0.8:{}'.format(EVENT_PORT)) } self.assertDictEqual(masternodes.sockets, expected) self.ctx.destroy() self.loop.close() self.ctx = zmq.asyncio.Context() self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) w1 = Wallet() p1 = Network(wallet=w1, ctx=self.ctx, socket_base='tcp://127.0.0.1') peeps = { 'stu': 'tcp://127.0.2.1', 'raghu': 'tcp://127.0.0.8', 'tejas': 'tcp://127.0.2.1', 'steve': 'tcp://127.0.54.6' } p1.peer_service.table.peers = peeps vkbook_args = self.get_vkbook_args(mns=['stu', 'tejas']) sync.submit_vkbook(vkbook_args, overwrite=True) async def late_refresh(): await asyncio.sleep(0.3) await masternodes.refresh() async def stop(): await asyncio.sleep(1) p1.stop() tasks = asyncio.gather(p1.start(discover=False), late_refresh(), stop()) self.loop.run_until_complete(tasks) expected = { 'stu': _socket('tcp://127.0.2.1:{}'.format(EVENT_PORT)), 'tejas': _socket('tcp://127.0.2.1:{}'.format(EVENT_PORT)), } self.assertDictEqual(masternodes.sockets, expected)
def test_init(self): DiscoveryServer(_socket('tcp://127.0.0.1:10999'), Wallet(), b'blah')