def run_assertions(reactor: ReactorInterface):
cb1 = ReactorCommand.create_callback(callback=ROUTE_CALLBACK,
envelope=env1)
cb2 = ReactorCommand.create_callback(callback=ROUTE_CALLBACK,
envelope=env2)
reactor._run_callback.assert_has_calls(
[call(cb1), call(cb2)], any_order=False)
def assert_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
# cb = ReactorCommand.create_callback(callback=StateInput.INPUT, envelope=env)
# composer.interface.router.route_callback.assert_called_once_with(cb)
expected_cb = call(
ReactorCommand.create_callback(callback=StateInput.INPUT,
envelope=env))
unexpected_cb = call(
ReactorCommand.create_callback(
callback=StateInput.LOOKUP_FAILED, envelope=evil_env))
call_args = composer.manager.router.route_callback.call_args_list
# # DEBUG STUFF
# from cilantro.logger.base import get_logger
# l = get_logger("assert sub")
# l.debug('EXPECTED')
# l.critical(expected_cb)
# l.debug('UNEXPECTED')
# l.critical(unexpected_cb)
# l.important2("got dat call args: {}".format(call_args))
# # END DEBUG STUFF
# composer.interface.router.route_callback.assert_has_calls([expected_cb], any_order=True)
assert expected_cb in call_args, "Expected callback {} to be in call_args {}".format(
expected_cb, call_args)
assert unexpected_cb not in call_args, "Did not expect callback {} to be in call_args {}".format(
unexpected_cb, call_args)
def run_assertions(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
cb1 = ReactorCommand.create_callback(callback=StateInput.INPUT,
envelope=env1)
cb2 = ReactorCommand.create_callback(callback=StateInput.INPUT,
envelope=env2)
composer.manager.router.route_callback.assert_has_calls(
[call(cb1), call(cb2)], any_order=True)
def assert_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
callback1 = ReactorCommand.create_callback(
callback=StateInput.INPUT, envelope=env1)
callback2 = ReactorCommand.create_callback(
callback=StateInput.INPUT, envelope=env2)
calls = [call(callback1), call(callback2)]
call_args = composer.manager.router.route_callback.call_args_list
composer.manager.router.route_callback.assert_has_calls(
calls, any_order=True)
def connection_drop(self, node):
if self.event_sock: self.event_sock.send_json({'event':'disconect', 'ip':node.ip, 'vk': self.ironhouse.pk2vk.get(node.public_key) })
callback = ReactorCommand.create_callback(
callback=StateInput.CONN_DROPPED,
ip=node.ip
)
log.debug("Sending callback failure to mainthread {}".format(callback))
def assert_router(composer: Composer):
from cilantro.protocol.states.decorators import StateInput
from cilantro.messages.reactor.reactor_command import ReactorCommand
cb = ReactorCommand.create_callback(callback=StateInput.REQUEST,
envelope=request_env,
header=dealer_id)
composer.manager.router.route_callback.assert_called_with(cb)
def assert_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
cb = ReactorCommand.create_callback(callback=StateInput.INPUT,
envelope=env)
composer.interface.router.route_callback.assert_called_once_with(
cb)
def assert_bad_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
cb = call(
ReactorCommand.create_callback(callback=StateInput.INPUT,
envelope=env))
assert cb not in composer.manager.router.route_callback.call_args_list
def assert_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
callback1 = ReactorCommand.create_callback(
callback=StateInput.INPUT, envelope=env1)
callback2 = ReactorCommand.create_callback(
callback=StateInput.INPUT, envelope=env2)
calls = [call(callback1), call(callback2)]
call_args = composer.interface.router.route_callback.call_args_list
assert len(call_args) == 2, "route_callback should be called exactly twice, not {} times with {}"\
.format(len(call_args), call_args)
composer.interface.router.route_callback.assert_has_calls(
calls, any_order=True)
async def _lookup_ip(self, cmd, url, vk, *args, **kwargs):
ip, node = None, None
try:
node, cached = await self.dht.network.lookup_ip(vk)
# NOTE while secure, this is a more loose connection policy
self.log.fatal('{} resolves for {}'.format(os.getenv('HOST_IP'),
node))
if node and not cached:
ip = node.ip if type(node) == Node else node.split(':')[0]
public_key = self.dht.network.ironhouse.vk2pk(vk)
authorization = await self.dht.network.ironhouse.authenticate(
public_key, ip)
self.log.fatal('{} -> {} is {}'.format(os.getenv('HOST_IP'),
node, authorization))
if authorization != 'authorized':
node = None
else:
n = Node(node_id=digest(vk),
public_key=public_key,
ip=ip,
port=self.dht.network.network_port)
self.dht.network.protocol.router.addContact(n)
self.dht.network.connect_to_neighbor(n)
self.log.fatal([
item[0]
for item in self.dht.network.bootstrappableNeighbors()
])
except Exception as e:
delim_line = '!' * 64
err_msg = '\n\n' + delim_line + '\n' + delim_line
err_msg += '\n ERROR CAUGHT IN LOOKUP FUNCTION {}\ncalled \w args={}\nand kwargs={}\n'\
.format(args, kwargs)
err_msg += '\nError Message: '
err_msg += '\n\n{}'.format(traceback.format_exc())
err_msg += '\n' + delim_line + '\n' + delim_line
self.log.error(err_msg)
if node is None:
kwargs = cmd.kwargs
callback = ReactorCommand.create_callback(
callback=StateInput.LOOKUP_FAILED, **kwargs)
self.log.debug(
"Sending callback failure to mainthread {}".format(callback))
self.socket.send(callback.serialize())
# TODO -- send callback to SM saying hey i couldnt lookup this vk
return
# Send interpolated command back through pipeline
ip = node.ip if type(node) == Node else node
new_url = IPUtils.interpolate_url(url, ip)
kwargs = cmd.kwargs
kwargs['url'] = new_url
new_cmd = ReactorCommand.create_cmd(envelope=cmd.envelope, **kwargs)
self._execute_cmd(new_cmd)
def call_on_mp(self, callback: str, header: str=None, envelope_binary: bytes=None, **kwargs):
if header:
kwargs['header'] = header
cmd = ReactorCommand.create_callback(callback=callback, envelope_binary=envelope_binary, **kwargs)
# self.log.critical("\ncalling callback cmd to reactor interface: {}".format(cmd)) # DEBUG line remove this
self.inproc_socket.send(cmd.serialize())
def connection_drop(self):
if self.daemon:
callback = ReactorCommand.create_callback(
callback=StateInput.CONN_DROPPED,
vk=self.ironhouse.vk,
ip=self.node.ip)
log.debug(
"Sending callback failure to mainthread {}".format(callback))
self.daemon.socket.send(callback.serialize())
def test_create_callback(self):
"""
Tests create_callback
"""
callback = 'route'
kwargs = {'cats': '18', 'dogs': 'over 9000'}
cmd = ReactorCommand.create_callback(callback, **kwargs)
self.assertEqual(cmd.callback, callback)
for k in kwargs:
self.assertEqual(cmd.kwargs[k], kwargs[k])
def assert_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
expected_calls = []
for env in envs:
callback = ReactorCommand.create_callback(
callback=StateInput.INPUT, envelope=env)
expected_calls.append(call(callback))
call_args = composer.manager.router.route_callback.call_args_list
composer.manager.router.route_callback.assert_has_calls(
expected_calls, any_order=True)
async def _lookup_ip(self, cmd, url, vk, *args, **kwargs):
ip, node = None, None
try:
node, cached = await self.dht.network.lookup_ip(vk)
# NOTE while secure, this is a more loose connection policy
self.log.debugv('IP {} resolves {} into {}'.format(
os.getenv('HOST_IP', '127.0.0.1'), vk, node))
self.log.debugv(
'... but is {} authorized? Until next episode!'.format(node))
if node:
if not self.dht.network.ironhouse.authorized_nodes.get(
node.id):
authorization = await self.dht.network.authenticate(node)
if not authorization:
node = None
else:
node = None
except Exception as e:
delim_line = '!' * 64
err_msg = '\n\n' + delim_line + '\n' + delim_line
err_msg += '\n ERROR CAUGHT IN LOOKUP FOR VK {}\ncalled \w args={}\nand kwargs={}\n'\
.format(vk, args, kwargs)
err_msg += '\nError Message: '
err_msg += '\n\n{}'.format(traceback.format_exc())
err_msg += '\n' + delim_line + '\n' + delim_line
self.log.fatal(err_msg)
if node is None:
kwargs = cmd.kwargs
callback = ReactorCommand.create_callback(
callback=StateInput.LOOKUP_FAILED, **kwargs)
self.log.debug(
"Sending callback failure to mainthread {}".format(callback))
self.socket.send(callback.serialize())
# TODO -- send callback to SM saying hey i couldnt lookup this vk
return
# Send interpolated command back through pipeline
ip = node.ip if type(node) == Node else node
new_url = IPUtils.interpolate_url(url, ip)
kwargs = cmd.kwargs
kwargs['url'] = new_url
new_cmd = ReactorCommand.create_cmd(envelope=cmd.envelope, **kwargs)
self._execute_cmd(new_cmd)
def assert_sub(composer: Composer):
from cilantro.messages.reactor.reactor_command import ReactorCommand
from cilantro.protocol.states.decorators import StateInput
from unittest.mock import call
expected_calls = []
for env in envs:
callback = ReactorCommand.create_callback(
callback=StateInput.INPUT, envelope=env)
expected_calls.append(call(callback))
call_args = composer.interface.router.route_callback.call_args_list
assert len(call_args) == len(expected_calls), "route_callback should be called exactly {} times, not {} " \
"times with {}".format(len(expected_calls), len(call_args), call_args)
composer.interface.router.route_callback.assert_has_calls(
expected_calls, any_order=True)
def assert_dealer(reactor: ReactorInterface):
cb = ReactorCommand.create_callback(callback=ROUTE_CALLBACK,
envelope=rep_env)
reactor._run_callback.assert_called_once_with(cb)
def run_assertions(reactor: ReactorInterface):
cb = ReactorCommand.create_callback(callback=ROUTE_REQ_CALLBACK,
envelope=env,
header=DEALER_ID)
reactor._run_callback.assert_called_once_with(cb)
def run_assertions(reactor: ReactorInterface):
callback = ReactorCommand.create_callback(callback=ROUTE_CALLBACK,
envelope=env)
reactor._run_callback.assert_called_once_with(callback)