def test_start_and_stopping_destroys_servers_ipc(self):
# Create Network service
w1 = Wallet()
n1 = NetworkParameters(peer_ipc='peers1',
event_ipc='events1',
discovery_ipc='discovery1')
p1 = Network(wallet=w1,
ctx=self.ctx,
socket_base='ipc:///tmp',
params=n1)
# Create Network service
w2 = Wallet()
n2 = NetworkParameters(peer_ipc='peers2', event_port='events2')
p2 = Network(wallet=w2,
ctx=self.ctx,
socket_base='ipc:///tmp',
params=n2)
async def stop(n: Network, s):
await asyncio.sleep(s)
n.peer_service.stop()
tasks = asyncio.gather(p1.peer_service.start(),
p2.peer_service.start(), stop(p1, 0.3),
stop(p2, 0.3))
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
def test_start_and_stopping_destroys_servers(self):
# Create Network service
w1 = Wallet()
n1 = NetworkParameters(peer_port=10001, event_port=10002)
p1 = Network(wallet=w1,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n1)
# Create Network service
w2 = Wallet()
n2 = NetworkParameters(peer_port=10003, event_port=10004)
p2 = Network(wallet=w2,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n2)
async def stop(n: Network, s):
await asyncio.sleep(s)
n.peer_service.stop()
tasks = asyncio.gather(p1.peer_service.start(),
p2.peer_service.start(), stop(p1, 0.3),
stop(p2, 0.3))
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
def test_current_contacts_joins_mn_seed_adds_table_to_joiner(self):
n1 = '/tmp/n1'
make_ipc(n1)
mnw1 = Wallet()
mn1 = Network(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}')
mn1.peer_service.table = {'a': 'b', 'c': 'd', 'e': 'f'}
mnw2 = Wallet()
n2 = '/tmp/n2'
make_ipc(n2)
mn2 = Network(wallet=mnw2,
ctx=self.ctx,
socket_base=f'ipc://{n2}',
mn_seed='ipc:///tmp/n1')
tasks = asyncio.gather(mn1.peer_service.start(),
mn2.discovery_server.serve(),
stop_server(mn2.discovery_server, 0.3),
stop_server(mn1.peer_service, 0.3),
mn2.get_current_contacts())
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
self.assertDictEqual(mn1.peer_service.table, mn2.peer_service.table)
def test_network_start(self):
# 4 nodes
# 2 bootnodes
# 2 mns, 2 delegates
bootnodes = ['ipc:///tmp/n1', 'ipc:///tmp/n3']
mnw1 = Wallet()
mnw2 = Wallet()
masternodes = [mnw1.verifying_key().hex(), mnw2.verifying_key().hex()]
dw1 = Wallet()
dw2 = Wallet()
delegates = [dw1.verifying_key().hex(), dw2.verifying_key().hex()]
n1 = '/tmp/n1'
make_ipc(n1)
mn1 = Network(wallet=mnw1,
ctx=self.ctx,
socket_base=f'ipc://{n1}',
bootnodes=bootnodes,
mn_to_find=masternodes,
del_to_find=delegates)
n2 = '/tmp/n2'
make_ipc(n2)
mn2 = Network(wallet=mnw2,
ctx=self.ctx,
socket_base=f'ipc://{n2}',
bootnodes=bootnodes,
mn_to_find=masternodes,
del_to_find=delegates)
n3 = '/tmp/n3'
make_ipc(n3)
d1 = Network(wallet=dw1,
ctx=self.ctx,
socket_base=f'ipc://{n3}',
bootnodes=bootnodes,
mn_to_find=masternodes,
del_to_find=delegates)
n4 = '/tmp/n4'
make_ipc(n4)
d2 = Network(wallet=dw2,
ctx=self.ctx,
socket_base=f'ipc://{n4}',
bootnodes=bootnodes,
mn_to_find=masternodes,
del_to_find=delegates)
# should test to see all ready signals are recieved
tasks = asyncio.gather(mn1.start(), mn2.start(), d1.start(),
d2.start())
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_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_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_ask_returns_table(self):
n1 = '/tmp/n1'
make_ipc(n1)
mnw1 = Wallet()
mn1 = Network(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}')
mn1.peer_service.table = {'a': 'b', 'c': 'd', 'e': 'f'}
ask_message = ['ask', '']
ask_message = json.dumps(ask_message).encode()
async def get():
return await services.get(_socket('ipc:///tmp/n1/peers'),
msg=ask_message,
ctx=self.ctx,
timeout=500)
tasks = asyncio.gather(mn1.peer_service.start(),
stop_server(mn1.peer_service, 0.3), get())
loop = asyncio.get_event_loop()
res = loop.run_until_complete(tasks)
self.assertDictEqual(json.loads(res[-1]), mn1.peer_service.table)
def test_connect_twice_doesnt_modify_socket_object(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=DEL,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
p.connect(SocketStruct.from_string('ipc:///tmp/n1'),
self.test_wallet_1.verifying_key().hex())
socket = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertIsNotNone(socket)
p.connect(SocketStruct.from_string('ipc:///tmp/n1'),
self.test_wallet_1.verifying_key().hex())
socket2 = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertEqual(socket, socket2)
def test_sync_adds_del_if_peers_mn(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=MN,
service_type=ServiceType.INCOMING_WORK)
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
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)
socket_1 = p.sockets.get(self.test_wallet_1.verifying_key().hex())
self.assertIsNotNone(socket_1)
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_resync_removes_old_contact(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
new_wallet = Wallet()
p1.peer_service.table[
new_wallet.verifying_key().hex()] = 'ipc:///tmp/n3'
self.contacts.masternodes.append(new_wallet.verifying_key().hex())
self.authenticator.sync_certs()
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=MN,
service_type=ServiceType.INCOMING_WORK)
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
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)
socket_1 = p.sockets.get(new_wallet.verifying_key().hex())
self.assertIsNotNone(socket_1)
del p1.peer_service.table[new_wallet.verifying_key().hex()]
self.contacts.masternodes.remove(new_wallet.verifying_key().hex())
self.authenticator.sync_certs()
async def late_refresh():
await asyncio.sleep(0.3)
await self.paramaters.refresh()
p.sync_sockets()
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)
socket_1 = p.sockets.get(new_wallet.verifying_key().hex())
self.assertIsNone(socket_1)
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 testInit(self):
p1 = Network(wallet=self.wallet,
ctx=self.ctx,
socket_base='tcp://127.0.0.1')
p1.peer_service.table = self.peer_table
p = Peers(wallet=self.wallet,
ctx=self.ctx,
parameters=self.paramaters,
node_type=DEL,
service_type=ServiceType.INCOMING_WORK)
def test_find_node_fails_if_cant_find_and_retries_are_up(self):
# Create Network service
w1 = Wallet()
n1 = NetworkParameters(peer_port=10001, event_port=10002)
p1 = Network(wallet=w1,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n1)
# Create Network service
w2 = Wallet()
n2 = NetworkParameters(peer_port=10003, event_port=10004)
p2 = Network(wallet=w2,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n2)
w3 = Wallet()
async def get():
return await p1.find_node(_socket('tcp://127.0.0.1:10003'),
w3.verifying_key().hex(),
retries=1)
async def stop(n: Network, s):
await asyncio.sleep(s)
n.peer_service.stop()
tasks = asyncio.gather(
p1.peer_service.start(),
p2.peer_service.start(),
get(),
stop(p1, 0.3),
stop(p2, 0.3),
)
loop = asyncio.get_event_loop()
res = loop.run_until_complete(tasks)
self.assertIsNone(res[2])
def test_find_node_requests_from_others_and_returns_key_if_they_have_it_ipc(
self):
# Create Network service
w1 = Wallet()
n1 = NetworkParameters(peer_ipc='peers1',
event_ipc='events1',
discovery_ipc='discovery1')
p1 = Network(wallet=w1,
ctx=self.ctx,
socket_base='ipc:///tmp',
params=n1)
# Create Network service
w2 = Wallet()
n2 = NetworkParameters(peer_ipc='peers2', event_port='events2')
p2 = Network(wallet=w2,
ctx=self.ctx,
socket_base='ipc:///tmp',
params=n2)
async def get():
return await p1.find_node(_socket('ipc:///tmp/peers2'),
w2.verifying_key().hex())
async def stop(n: Network, s):
await asyncio.sleep(s)
n.peer_service.stop()
tasks = asyncio.gather(
p1.peer_service.start(),
p2.peer_service.start(),
get(),
stop(p1, 0.3),
stop(p2, 0.3),
)
loop = asyncio.get_event_loop()
res = loop.run_until_complete(tasks)
self.assertEqual(res[2].get(w2.verifying_key().hex()), 'ipc:///tmp')
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_contacts_added_if_network_starts_up_and_mn_seed_provided(self):
n1 = '/tmp/n1'
make_ipc(n1)
mnw1 = Wallet()
mn1 = Network(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}')
mn1.peer_service.table = {'a': 'b', 'c': 'd', 'e': 'f'}
mnw2 = Wallet()
n2 = '/tmp/n2'
make_ipc(n2)
mn2 = Network(wallet=mnw2,
ctx=self.ctx,
socket_base=f'ipc://{n2}',
mn_seed='ipc:///tmp/n1')
tasks = asyncio.gather(mn1.peer_service.start(), mn2.start(),
stop_server(mn1.peer_service, 1))
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
def test_find_node_returns_self_if_asked_on_peer_address_and_self_is_the_value_ipc(
self):
# Create Network service
w1 = Wallet()
p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp')
async def get():
return await p1.find_node(p1.peer_service_address,
w1.verifying_key().hex())
loop = asyncio.get_event_loop()
res = loop.run_until_complete(get())
self.assertEqual(res.get(w1.verifying_key().hex()), 'ipc:///tmp')
def test_find_node_gets_node_from_self_if_asked_from_self_and_has_it_as_peer_ipc(
self):
# Create Network service
w1 = Wallet()
p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp')
w2 = Wallet()
p1.peer_service.table[w2.verifying_key().hex()] = 'ipc:///tmp123'
async def get():
return await p1.find_node(p1.peer_service_address,
w2.verifying_key().hex())
loop = asyncio.get_event_loop()
res = loop.run_until_complete(get())
self.assertEqual(res.get(w2.verifying_key().hex()), 'ipc:///tmp123')
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_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_event_service_publisher_starts_up_on_init_ipc(self):
w1 = Wallet()
p1 = Network(wallet=w1, ctx=self.ctx, socket_base='ipc:///tmp')
test_subscriber = self.ctx.socket(zmq.SUB)
test_subscriber.setsockopt(zmq.SUBSCRIBE, b'')
test_subscriber.connect('ipc:///tmp/events')
# TCP takes a bit longer to bind and is prone to dropping messages...
sleep(0.1)
async def send():
await p1.peer_service.event_publisher.send(b'waaaa')
async def recv():
return await test_subscriber.recv()
tasks = asyncio.gather(send(), recv(),
stop_server(p1.peer_service, 0.1))
loop = asyncio.get_event_loop()
res = loop.run_until_complete(tasks)
self.assertEqual(res[1], b'waaaa')
def test_network_start(self):
# 4 nodes
# 2 bootnodes
# 2 mns, 2 delegates
bootnodes = ['ipc:///tmp/n1', 'ipc:///tmp/n3']
mnw1 = Wallet()
mnw2 = Wallet()
masternodes = [mnw1.verifying_key().hex(), mnw2.verifying_key().hex()]
dw1 = Wallet()
dw2 = Wallet()
delegates = [dw1.verifying_key().hex(), dw2.verifying_key().hex()]
constitution = {
"masternodes": [
mnw1.verifying_key().hex(),
mnw2.verifying_key().hex()
],
"masternode_min_quorum": 1,
"delegates": [
dw1.verifying_key().hex(),
dw2.verifying_key().hex()
],
"delegate_min_quorum": 1,
"witnesses": {},
"schedulers": {},
"notifiers": {},
"enable_stamps": False,
"enable_nonces": False
}
n1 = '/tmp/n1'
make_ipc(n1)
mn1 = Masternode(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}', bootnodes=bootnodes,
constitution=constitution, webserver_port=8080)
n2 = '/tmp/n2'
make_ipc(n2)
mn2 = Masternode(wallet=mnw2, ctx=self.ctx, socket_base=f'ipc://{n2}', bootnodes=bootnodes,
constitution=constitution, webserver_port=8081)
n3 = '/tmp/n3'
make_ipc(n3)
d1 = Network(wallet=dw1, ctx=self.ctx, socket_base=f'ipc://{n3}',
bootnodes=bootnodes, mn_to_find=masternodes, del_to_find=delegates)
n4 = '/tmp/n4'
make_ipc(n4)
d2 = Network(wallet=dw2, ctx=self.ctx, socket_base=f'ipc://{n4}',
bootnodes=bootnodes, mn_to_find=masternodes, del_to_find=delegates)
# should test to see all ready signals are recieved
tasks = asyncio.gather(
mn1.start(),
mn2.start(),
d1.start(),
d2.start()
)
async def run():
await tasks
await asyncio.sleep(5)
mn1.stop()
mn2.stop()
d1.stop()
d2.stop()
loop = asyncio.get_event_loop()
loop.run_until_complete(run())
def test_wait_for_quorum_to_succeed_only_one_master(self):
# 0 tries
mnw1 = Wallet()
n1 = NetworkParameters(peer_port=10001, event_port=10002)
mn1 = Network(wallet=mnw1,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n1)
# 1 try
mnw2 = Wallet()
n2 = NetworkParameters(peer_port=10003, event_port=10004)
mn2 = Network(wallet=mnw2,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n2)
dw1 = Wallet()
n3 = NetworkParameters(peer_port=10005, event_port=10006)
d1 = Network(wallet=dw1,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n3)
# 2 tries <- info in this node should be returned
dw2 = Wallet()
n4 = NetworkParameters(peer_port=10007, event_port=10008)
d2 = Network(wallet=dw2,
ctx=self.ctx,
socket_base='tcp://127.0.0.1',
params=n4)
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 stop(n: Network, s):
await asyncio.sleep(s)
n.peer_service.stop()
timeout = 0.3
tasks = asyncio.gather(
mn1.peer_service.start(),
mn2.peer_service.start(),
d1.peer_service.start(),
d2.peer_service.start(),
get(),
stop(mn1, timeout),
stop(mn2, timeout),
stop(d1, timeout),
stop(d1, timeout),
)
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
self.assertIn(mnw2.verifying_key().hex(), mn1.peer_service.table)
def test_wait_for_quorum_to_succeed_only_one_master_ipc(self):
# 0 tries
n1 = '/tmp/n1'
try:
os.mkdir('/tmp/n1')
except:
pass
mnw1 = Wallet()
mn1 = Network(wallet=mnw1, ctx=self.ctx, socket_base=f'ipc://{n1}')
n2 = '/tmp/n2'
try:
os.mkdir('/tmp/n2')
except:
pass
mnw2 = Wallet()
mn2 = Network(wallet=mnw2, ctx=self.ctx, socket_base=f'ipc://{n2}')
n3 = '/tmp/n3'
try:
os.mkdir('/tmp/n3')
except:
pass
dw1 = Wallet()
d1 = Network(wallet=dw1, ctx=self.ctx, socket_base=f'ipc://{n3}')
n4 = '/tmp/n4'
try:
os.mkdir('/tmp/n4')
except:
pass
dw2 = Wallet()
d2 = Network(wallet=dw2, ctx=self.ctx, socket_base=f'ipc://{n4}')
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')])
async def stop(n: Network, s):
await asyncio.sleep(s)
n.peer_service.stop()
timeout = 0.3
tasks = asyncio.gather(
mn1.peer_service.start(),
mn2.peer_service.start(),
d1.peer_service.start(),
d2.peer_service.start(),
get(),
stop(mn1, timeout),
stop(mn2, timeout),
stop(d1, timeout),
stop(d1, timeout),
)
loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
self.assertIn(mnw2.verifying_key().hex(), mn1.peer_service.table)
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 __init__(self,
socket_base,
ctx: zmq.asyncio.Context,
wallet,
constitution: dict,
overwrite=False,
bootnodes=[],
network_parameters=NetworkParameters(),
driver=BlockchainDriver(),
mn_seed=None,
debug=True,
store=False):
self.driver = driver
self.store = store
self.blocks = None
if self.store:
self.blocks = MasterStorage()
self.waiting_for_confirmation = False
self.log = get_logger('NODE')
self.log.propagate = debug
self.log.info(constitution)
self.socket_base = socket_base
self.wallet = wallet
self.ctx = ctx
self.ctx.max_sockets = 50_000
self.client = ContractingClient(
driver=self.driver,
submission_filename=cilantro_ee.contracts.__path__[0] +
'/submission.s.py')
# Sync contracts
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)
self.driver.commit()
self.driver.clear_pending_state()
self.contacts = VKBook(
client=self.client,
boot_mn=constitution['masternode_min_quorum'],
boot_del=constitution['delegate_min_quorum'],
)
self.current_masters = deepcopy(self.contacts.masternodes)
self.current_delegates = deepcopy(self.contacts.delegates)
self.parameters = Parameters(socket_base,
ctx,
wallet,
contacts=self.contacts)
self.socket_authenticator = SocketAuthenticator(ctx=self.ctx)
self.elect_masternodes = self.client.get_contract('elect_masternodes')
self.elect_delegates = self.client.get_contract('elect_delegates')
self.masternode_contract = self.client.get_contract('masternodes')
self.delegate_contract = self.client.get_contract('delegates')
self.update_sockets()
# Cilantro version / upgrade
self.version_state = self.client.get_contract('upgrade')
self.active_upgrade = self.version_state.quick_read('upg_lock')
self.tol_mn = self.version_state.quick_read('tol_mn')
self.tot_dl = self.version_state.quick_read('tot_dl')
if self.tol_mn is None:
self.tol_mn = 0
if self.tot_dl is None:
self.tot_dl = 0
self.all_votes = self.tol_mn + self.tot_dl
self.mn_votes = self.version_state.quick_read('mn_vote')
self.dl_votes = self.version_state.quick_read('dl_vote')
# self.pending_cnt = self.all_votes - self.vote_cnt
# stuff
self.network_parameters = network_parameters
self.bootnodes = bootnodes
self.constitution = constitution
self.overwrite = overwrite
# Should have a function to get the current NBN
self.block_fetcher = BlockFetcher(
wallet=self.wallet,
ctx=self.ctx,
parameters=self.parameters,
)
self.network = Network(
wallet=self.wallet,
ctx=self.ctx,
socket_base=socket_base,
bootnodes=self.bootnodes,
params=self.network_parameters,
initial_del_quorum=deepcopy(self.contacts.delegate_quorum_min),
initial_mn_quorum=deepcopy(self.contacts.masternode_quorum_min),
mn_to_find=deepcopy(self.contacts.masternodes),
del_to_find=deepcopy(self.contacts.delegates),
mn_seed=mn_seed)
self.nbn_inbox = NBNInbox(socket_id=self.network_parameters.resolve(
self.socket_base,
service_type=ServiceType.BLOCK_NOTIFICATIONS,
bind=True),
ctx=self.ctx,
driver=self.driver,
contacts=self.contacts,
wallet=wallet)
self.reward_manager = RewardManager(driver=self.driver, debug=True)
self.running = False
def test_refresh_remove_old_nodes(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')
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 = peeps
ctx2 = zmq.asyncio.Context()
masternodes = Parameters(socket_base='tcp://127.0.0.1',
wallet=w1,
contacts=MockContacts(['stu', 'raghu'],
['tejas', 'steve']),
ctx=ctx2)
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': 'tcp://127.0.0.1', 'raghu': 'tcp://127.0.0.8'}
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': 'tcp://127.0.2.1',
'tejas': 'tcp://127.0.2.1',
}
self.assertDictEqual(masternodes.sockets, expected)