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')
