def __init__(self):
self.log = get_logger("PubSubNode")
self.log.info("-- PubSubNode Init-ing --")
self.reactor = ReactorInterface(self)
self.reactor.execute(Command.ADD_SUB, url=URL, callback='do_something')
self.reactor.execute(Command.ADD_PUB, url=URL)
self.reactor.notify_ready()
def __init__(self, log_color=None):
if log_color:
self.log = get_logger("Node", bg_color=log_color)
else:
self.log = get_logger("Node")
self.log.info("A Node has appeared")
self.reactor = ReactorInterface(router=self)
self.reactor.notify_ready()
def __init__(self):
self.log = get_logger("SlowInitNode")
self.log.info("-- Test Node Init-ing --")
self.reactor = ReactorInterface(self)
self.reactor.execute(Command.ADD_SUB, url=URL, callback='do_something_else')
self.log.critical("Starting very slow init")
time.sleep(6)
self.log.critical("Done with very flow init")
self.reactor.notify_ready()
def build_obj(cls, sk, name='') -> tuple:
loop = asyncio.get_event_loop()
asyncio.set_event_loop(loop)
mock_sm = MagicMock(spec=StateMachine)
mock_sm.__name__ = name
router = MagicMock()
reactor = ReactorInterface(router=router, loop=loop, signing_key=sk)
composer = Composer(interface=reactor, signing_key=sk)
return composer, loop, [reactor._recv_messages()]
class Node:
def __init__(self, log_color=None):
if log_color:
self.log = get_logger("Node", bg_color=log_color)
else:
self.log = get_logger("Node")
self.log.info("A Node has appeared")
self.reactor = ReactorInterface(router=self)
self.reactor.notify_ready()
def handle_msg(self, data):
self.log.info("Handling Msg: {}".format(data))
def build_obj(cls) -> tuple:
mock_parent = MagicMock()
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
reactor = ReactorInterface(mock_parent, loop=loop)
return reactor, loop
def _build_node(loop, signing_key, ip, node_cls, name) -> NodeBase:
node = node_cls(signing_key=signing_key, ip=ip, loop=loop, name=name)
router = Router(statemachine=node, name=name)
interface = ReactorInterface(router=router, loop=loop, signing_key=signing_key, name=name)
composer = Composer(interface=interface, signing_key=signing_key, name=name)
node.composer = composer
return node
def __init__(self, *args, **kwargs):
self.log = get_logger("BaseNode")
self.log.info("-- BaseNode Initiating --")
self.port = int(os.getenv('PORT', 31337))
self.host = os.getenv('HOST_IP', '127.0.0.1')
self.loop = asyncio.get_event_loop()
self.wallet = ED25519Wallet()
self.router = Router(statemachine=self)
self.reactor = ReactorInterface(self.router, self.loop, self.wallet.s)
self.composer = Composer(self.reactor, self.wallet.s)
def config_router(reactor: ReactorInterface):
def reply_effect(*args, **kwargs):
# log = get_logger("ASSERT ROUTER SIDE EFFECT WTIH")
# log.critical("\n\n sending reply command... \n\n")
reactor.send_cmd(reply)
dealer.send_cmd(reply)
reactor._run_callback = MagicMock()
reactor._run_callback.side_effect = reply_effect
return reactor
class SlowInitNode:
def __init__(self):
self.log = get_logger("SlowInitNode")
self.log.info("-- Test Node Init-ing --")
self.reactor = ReactorInterface(self)
self.reactor.execute(Command.ADD_SUB, url=URL, callback='do_something_else')
self.log.critical("Starting very slow init")
time.sleep(6)
self.log.critical("Done with very flow init")
self.reactor.notify_ready()
def do_something_slow(self, data):
self.log.critical("Starting something slow with data: {}".format(data))
time.sleep(2)
self.log.critical("Done with something slow for data: {}".format(data))
def do_something_else(self, data):
self.log.info("do_something_ELSE with data: {}".format(data))
def __init__(self, loop=None):
self.log = get_logger("GOD")
self.loop = loop or asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
mock_router = MagicMock()
self.interface = ReactorInterface(router=mock_router, loop=self.loop, verifying_key=God._DEFAULT_VK)
# a dict of composer_sk to composer object
self.composers = {}
class Replier:
def __init__(self):
self.reactor = ReactorInterface(self)
self.log = get_logger("Replier")
self.reactor.add_router(url=URL, callback='handle_request')
self.reactor.notify_ready()
def handle_request(self, req, id):
self.log.critical("Got request: {} with sender id: {}".format(req, id))
self.reactor.reply(url=URL, id=id, data=b'heres your reply my guy')
class PubSubNode:
def __init__(self):
self.log = get_logger("PubSubNode")
self.log.info("-- PubSubNode Init-ing --")
self.reactor = ReactorInterface(self)
self.reactor.execute(Command.ADD_SUB, url=URL, callback='do_something')
self.reactor.execute(Command.ADD_PUB, url=URL)
self.reactor.notify_ready()
def do_something(self, data):
self.log.debug("Doing something with data: {}".format(data))
def _start_test(self, rdy_sig_q, cmd_q):
async def recv_cmd():
while True:
log.critical("waiting for cmd")
cmd = await cmd_q.coro_get()
func, args, kwargs = cmd
log.critical("got cmd: {}".format(cmd))
log.critical("cmd name: {}\nkwargs: {}".format(func, kwargs))
getattr(reactor, func)(*args, **kwargs)
async def check_assertions():
self.log.debug("Starting assertion checks")
timeout = TEST_TIMEOUT
while timeout > 0:
try:
self.assert_fn(reactor)
self.log.critical("Assertions successful with {} left!".format(timeout))
rdy_sig_q.put("BIG TIME PLAYERS MAKE BIG TIME PLAYS")
break
except Exception as e:
self.log.warning("assertion failed: {}".format(e))
await asyncio.sleep(TEST_CHECK_FREQ)
timeout -= TEST_CHECK_FREQ
log = get_logger("TesterTarget")
loop = asyncio.new_event_loop()
mock_parent = MagicMock()
log.debug("creating reactor")
reactor = ReactorInterface(mock_parent, loop)
log.info("setting mock config")
reactor = self.config_fn(reactor)
log.critical("mock property: {}".format(reactor._run_callback))
log.debug("sending ready sig to parent")
rdy_sig_q.put('ready')
log.debug("starting TestableProcess event loop")
loop.run_until_complete(asyncio.gather(recv_cmd(), check_assertions()))
class Requester:
_ID = 'ASS'
def __init__(self):
self.reactor = ReactorInterface(self)
self.log = get_logger("Requester")
self.reactor.add_dealer(url=URL, callback='handle_reply', id=self._ID)
self.reactor.notify_ready()
def handle_reply(self, rep):
self.log.critical("Got reply: {}".format(rep))
def send_req(self, req_str):
self.reactor.request(url=URL, data=req_str.encode())
def __init__(self, url):
self.url = url
self.reactor = ReactorInterface(self)
self.log = get_logger(type(self).__name__)
super().__init__()
def config_dealer(reactor: ReactorInterface):
reactor._run_callback = MagicMock()
return reactor
def configure_interface(reactor: ReactorInterface):
reactor._run_callback = MagicMock()
return reactor
def __init__(self):
self.reactor = ReactorInterface(self)
self.log = get_logger("Requester")
self.reactor.add_dealer(url=URL, callback='handle_reply', id=self._ID)
self.reactor.notify_ready()
def __init__(self):
self.reactor = ReactorInterface(self)
self.log = get_logger("Replier")
self.reactor.add_router(url=URL, callback='handle_request')
self.reactor.notify_ready()
def configure_interface(reactor: ReactorInterface):
print("\n\n configing interface \n\n")
reactor._run_callback = MagicMock()
return reactor
def __init__(self, url):
self.url = url
self.reactor = ReactorInterface(self)
def __init__(self):
self.log = get_logger("Tester")
self.log.info("ReactorTester created")
self.loop = asyncio.new_event_loop()
self.reactor = ReactorInterface(self, self.loop)
