def setUp(self):
self.wallet = Wallet()
# Wallets for VKs
self.test_wallet_1 = Wallet()
self.test_wallet_2 = Wallet()
self.peer_table = {
self.test_wallet_1.verifying_key().hex(): 'ipc:///tmp/n1',
self.test_wallet_2.verifying_key().hex(): 'ipc:///tmp/n2',
}
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.contacts = MockContacts(
masters=[self.test_wallet_1.verifying_key().hex()],
delegates=[self.test_wallet_2.verifying_key().hex()])
self.paramaters = Parameters(socket_base='tcp://127.0.0.1',
wallet=self.wallet,
ctx=self.ctx,
contacts=self.contacts)
self.authenticator = SocketAuthenticator(wallet=self.wallet,
contacts=self.contacts,
ctx=self.ctx)
asyncio.set_event_loop(self.loop)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.driver = ContractDriver(driver=InMemDriver())
asyncio.set_event_loop(self.loop)
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(driver=self.driver), ctx=self.ctx)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
self.driver = ContractDriver(driver=InMemDriver())
self.client = ContractingClient(driver=self.driver)
self.client.flush()
asyncio.set_event_loop(self.loop)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.ctx.max_sockets = 50_000
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
ContractingClient().flush()
MasterStorage().drop_collections()
def hb_channel(self):
"""Get the hb channel object for this kernel."""
if self._hb_channel is None:
url = self._make_url('hb')
self.log.debug("connecting heartbeat channel to %s", url)
loop = asyncio.new_event_loop()
self._hb_channel = self.hb_channel_class(self.context,
self.session, url, loop)
return self._hb_channel
def setUp(self):
self.sk = '06391888e37a48cef1ded85a375490df4f9b2c74f7723e88c954a055f3d2685a'
self.vk = '82540bb5a9c84162214c5540d6e43be49bbfe19cf49685660cab608998a65144'
self.private_key = 'f0ca3d349e56e419e72f11c1fd734ae929a483f9490907d2ded554d9f794f361'
self.public_key = '73619fa1464ce16802b480a0fd7868ffcce0f7285050a927a07ef1ffdd34c162'
self.curve_public_key = b'B77YmmOI=O0<)GJ@DJ2Q+&5jzp/absPNMCh?88@S'
self.ironhouse = Ironhouse(self.sk,
wipe_certs=True,
auth_validate=auth_validate)
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
self.b = masternode.BlockService(blocks=storage.BlockStorage(),
driver=ContractDriver())
self.r = router.Router(socket_id='tcp://127.0.0.1:18001', ctx=self.ctx)
self.r.add_service(base.BLOCK_SERVICE, self.b)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.blocks = storage.BlockStorage()
self.driver = ContractDriver(driver=InMemDriver())
self.b = masternode.BlockService(blocks=self.blocks,
driver=self.driver)
self.blocks.drop_collections()
self.driver.flush()
self.authenticator = authentication.SocketAuthenticator(
client=ContractingClient(), ctx=self.ctx)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
def setUp(self):
self.ctx = zmq.asyncio.Context()
self.loop = asyncio.new_event_loop()
ContractingClient().flush()
asyncio.set_event_loop(self.loop)
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.t = BlockchainDriver()
self.ctx = zmq.asyncio.Context()
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)
class OverlayInterface(object):
"""
This class provides a high level API to interface with the overlay network
"""
event_url = 'ipc://overlay-event-ipc-sock-{}'.format(
os.getenv('HOST_IP', 'test'))
cmd_url = 'ipc://overlay-cmd-ipc-sock-{}'.format(
os.getenv('HOST_IP', 'test'))
loop = asyncio.new_event_loop()
_started = False
@classmethod
def _start_service(cls, sk):
ctx = zmq.asyncio.Context()
cls.event_sock = ctx.socket(zmq.PUB)
cls.event_sock.bind(cls.event_url)
cls.discovery_mode = 'test' if os.getenv(
'TEST_NAME') else 'neighborhood'
cls.dht = DHT(sk=sk,
mode=cls.discovery_mode,
loop=cls.loop,
alpha=ALPHA,
ksize=KSIZE,
event_sock=cls.event_sock,
max_peers=MAX_PEERS,
block=False,
cmd_cli=False,
wipe_certs=True)
cls._started = True
cls.listener_fut = asyncio.ensure_future(cls._listen_for_cmds())
cls.event_sock.send_json({'event': 'service_started'})
cls.loop.run_forever()
@classmethod
def _stop_service(cls):
try:
cls._started = False
cls.event_sock.close()
cls.cmd_sock.close()
try:
cls.listener_fut.set_result('done')
except:
cls.listener_fut.cancel()
cls.dht.cleanup()
log.info('Service stopped.')
except:
pass
@classmethod
async def _listen_for_cmds(cls):
log.info('Listening for overlay commands over {}'.format(cls.cmd_url))
ctx = zmq.asyncio.Context()
cls.cmd_sock = ctx.socket(zmq.ROUTER)
cls.cmd_sock.bind(cls.cmd_url)
while True:
msg = await cls.cmd_sock.recv_multipart()
log.debug('[Overlay] Received cmd (Proc={}): {}'.format(
msg[0], msg[1:]))
data = [b.decode() for b in msg[2:]]
getattr(cls, msg[1].decode())(*data)
@classmethod
def _overlay_command_socket(cls):
ctx = zmq.asyncio.Context()
cls.cmd_send_sock = ctx.socket(zmq.DEALER)
cls.cmd_send_sock.setsockopt(zmq.IDENTITY, str(os.getpid()).encode())
cls.cmd_send_sock.connect(cls.cmd_url)
@classmethod
@command
def get_node_from_vk(cls, *args, **kwargs):
pass
@classmethod
def _get_node_from_vk(cls, event_id, vk: str, timeout=3):
async def coro():
node = None
if vk in VKBook.get_all():
try:
node, cached = await asyncio.wait_for(
cls.dht.network.lookup_ip(vk), timeout)
except:
log.notice('Did not find an ip for VK {}'.format(vk))
if node:
cls.event_sock.send_json({
'event': 'got_ip',
'event_id': event_id,
'public_key': node.public_key.decode(),
'ip': node.ip,
'vk': vk
})
else:
cls.event_sock.send_json({
'event': 'not_found',
'event_id': event_id
})
asyncio.ensure_future(coro())
@classmethod
@command
def get_service_status(cls, *args, **kwargs):
pass
@classmethod
def _get_service_status(cls, event_id):
if cls._started:
cls.event_sock.send_json({
'event': 'service_status',
'status': 'ready'
})
else:
cls.event_sock.send_json({
'event': 'service_status',
'status': 'not_ready'
})
@classmethod
def overlay_event_socket(cls):
ctx = zmq.asyncio.Context()
socket = ctx.socket(zmq.SUB)
socket.setsockopt(zmq.SUBSCRIBE, b"")
socket.connect(cls.event_url)
return socket
@classmethod
async def event_listener(cls, event_handler):
log.info('Listening for overlay events over {}'.format(cls.event_url))
cls.listener_sock = cls.overlay_event_socket()
while True:
try:
msg = await cls.listener_sock.recv_json()
event_handler(msg)
except Exception as e:
log.warning(e)
@classmethod
def stop_listening(cls):
cls.cmd_send_sock.close()
cls.listener_sock.close()
@classmethod
def listen_for_events(cls, event_handler):
cls.loop.run_until_complete(cls.event_listener(event_handler))
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
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)
