def test_token_file_db(self):
app = "addisonarches.web"
rv = token("file://{}".format(self.root.name), "test", app)
self.assertIsInstance(rv, Resource)
self.assertEqual(self.root.name, rv.root)
self.assertEqual(app, rv.application)
self.assertTrue(os.path.isdir(os.path.join(*rv[0:5])))
def test_create_routing(self):
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
refs = list(
Flow.create(tok, poa=["udp"], role=[], routing=["application"]))
features = references_by_type(refs)
routes = features[turberfield.ipc.policy.Routing.Application]
self.assertEqual(1, len(routes))
table = Flow.inspect(routes[0])
self.assertIsInstance(table,
turberfield.ipc.policy.Routing.Application)
self.assertFalse(table)
rule = turberfield.ipc.policy.Routing.Application.Rule(
Address("turberfield", "tundish", "test",
"turberfield.ipc.demo.sender"),
Address("turberfield", "tundish", "test",
"turberfield.ipc.demo.receiver"), 1,
Address("turberfield", "tundish", "test",
"turberfield.ipc.demo.hub"))
self.assertIs(None, table.replace(rule.src, rule.dst, rule))
self.assertEqual(1, len(table))
Flow.replace(routes[0], table)
rv = Flow.inspect(routes[0])
self.assertEqual(table, rv)
def test_create_routing(self):
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
refs = list(Flow.create(tok, poa=["udp"], role=[], routing=["application"]))
features = references_by_type(refs)
routes = features[turberfield.ipc.policy.Routing.Application]
self.assertEqual(1, len(routes))
table = Flow.inspect(routes[0])
self.assertIsInstance(table, turberfield.ipc.policy.Routing.Application)
self.assertFalse(table)
rule = turberfield.ipc.policy.Routing.Application.Rule(
Address("turberfield", "tundish", "test", "turberfield.ipc.demo.sender"),
Address("turberfield", "tundish", "test", "turberfield.ipc.demo.receiver"),
1,
Address("turberfield", "tundish", "test", "turberfield.ipc.demo.hub")
)
self.assertIs(None, table.replace(rule.src, rule.dst, rule))
self.assertEqual(1, len(table))
Flow.replace(routes[0], table)
rv = Flow.inspect(routes[0])
self.assertEqual(table, rv)
def test_address_no_via(self):
app = "addisonarches.web"
tok = token("file://{}".format(self.root.name), "test", app)
msg = turberfield.ipc.message.parcel(tok, {"text": "Hello World!"})
self.assertEqual(app, msg.header.src.application)
self.assertEqual(msg.header.src, msg.header.dst)
self.assertIs(None, msg.header.via)
def test_token_other_db(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
rv = token("http://{}".format(self.root.name), "test",
"addisonarches.web")
self.assertIs(None, rv)
self.assertTrue(issubclass(w[-1].category, UserWarning))
self.assertIn("file-based", str(w[-1].message))
def setUpClass(cls):
logging.getLogger("asyncio").setLevel(logging.DEBUG)
cls.asyncioDebug = os.environ.get("PYTHONASYNCIODEBUG", None)
os.environ["PYTHONASYNCIODEBUG"] = str(True)
cls.token = token(
TestUsesNode.connect,
"test",
"addisonarches.test.test_game"
)
def test_reply(self):
app = "addisonarches.web"
tok = token("file://{}".format(self.root.name), "test", app)
msg = turberfield.ipc.message.parcel(tok, {"text": "Hello World!"})
reply = turberfield.ipc.message.reply(msg.header,
{"text": "Goodbye World!"})
self.assertEqual(msg.header.id, reply.header.id)
self.assertEqual(msg.header.src, reply.header.dst)
self.assertEqual(msg.header.dst, reply.header.src)
def test_find_application(self):
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
self.assertIs(None, tok.flow)
results = list(Flow.find(tok, application="addisonarches.game"))
self.assertFalse(results)
def main(args):
log = logging.getLogger("addisonarches.web")
log.setLevel(args.log_level)
formatter = logging.Formatter(
"%(asctime)s %(levelname)-7s %(name)s|%(message)s")
ch = logging.StreamHandler()
if args.log_path is None:
ch.setLevel(args.log_level)
else:
fh = WatchedFileHandler(args.log_path)
fh.setLevel(args.log_level)
fh.setFormatter(formatter)
log.addHandler(fh)
ch.setLevel(logging.WARNING)
ch.setFormatter(formatter)
log.addHandler(ch)
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
#TODO: Read service name from CLI
service = "dev" # Cf qa, demo, prod, etc
tok = token(args.connect, service, APP_NAME)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
app = aiohttp.web.Application()
assets = Assets(app, **vars(args))
reg = Registration(app, tok, down, up, **vars(args))
transitions = Transitions(app, **vars(args))
work = Workflow(app, tok, down, up, **vars(args))
for svc in (assets, reg, transitions, work):
log.info("{0.__class__.__name__} object serves {1}".format(
svc, ", ".join(svc.routes.keys())))
handler = app.make_handler()
f = loop.create_server(handler, args.host, args.port)
srv = loop.run_until_complete(f)
log.info("Serving on {0[0]}:{0[1]}".format(srv.sockets[0].getsockname()))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
loop.run_until_complete(handler.finish_connections(1.0))
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.run_until_complete(app.finish())
loop.close()
def test_route_inspection_use_case(self):
self.test_create_routing()
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
search = ((i, Flow.inspect(i))
for i in Flow.find(tok, policy="application"))
query = (ref for ref, table in search for rule in table
if rule.dst.application == "turberfield.ipc.demo.receiver")
self.assertEqual(1, len(list(query)))
def test_address_no_via(self):
app = "addisonarches.web"
tok = token(
"file://{}".format(self.root.name),
"test",
app
)
msg = turberfield.ipc.message.parcel(tok, {"text": "Hello World!"})
self.assertEqual(app, msg.header.src.application)
self.assertEqual(msg.header.src, msg.header.dst)
self.assertIs(None, msg.header.via)
def test_pool_allocation(self):
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
ports = range(49152, 65536)
for n, p in enumerate(ports):
with self.subTest(n=n, p=p):
flow = list(Flow.create(tok, poa=["udp"], role=[], routing=[]))
query = (Flow.inspect(i) for i in Flow.find(tok, policy="udp"))
alloc = {(i.addr, i.port) for i in query}
self.assertEqual(n + 1, len(alloc))
def test_token_file_db(self):
app = "addisonarches.web"
rv = token(
"file://{}".format(self.root.name),
"test",
app
)
self.assertIsInstance(rv, Resource)
self.assertEqual(self.root.name, rv.root)
self.assertEqual(app, rv.application)
self.assertTrue(os.path.isdir(os.path.join(*rv[0:5])))
def test_reply(self):
app = "addisonarches.web"
tok = token(
"file://{}".format(self.root.name),
"test",
app
)
msg = turberfield.ipc.message.parcel(tok, {"text": "Hello World!"})
reply = turberfield.ipc.message.reply(msg.header, {"text": "Goodbye World!"})
self.assertEqual(msg.header.id, reply.header.id)
self.assertEqual(msg.header.src, reply.header.dst)
self.assertEqual(msg.header.dst, reply.header.src)
def test_token_other_db(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
rv = token(
"http://{}".format(self.root.name),
"test",
"addisonarches.web"
)
self.assertIs(None, rv)
self.assertTrue(
issubclass(w[-1].category, UserWarning))
self.assertIn("file-based", str(w[-1].message))
def test_create_policy_unregistered(self):
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
self.assertIs(None, tok.flow)
rv = next(Flow.find(tok), None)
self.assertIs(None, rv)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
rv = next(Flow.create(tok, poa=["ftp"], role=[], routing=[]))
self.assertIs(None, rv)
self.assertTrue(issubclass(w[-1].category, UserWarning))
self.assertIn("No policy", str(w[-1].message))
def main(args):
log = logging.getLogger(APP_NAME)
log.setLevel(args.log_level)
formatter = logging.Formatter(
"%(asctime)s %(levelname)-7s %(name)s|%(message)s")
ch = logging.StreamHandler()
if args.log_path is None:
ch.setLevel(args.log_level)
else:
fh = WatchedFileHandler(args.log_path)
fh.setLevel(args.log_level)
fh.setFormatter(formatter)
log.addHandler(fh)
ch.setLevel(logging.WARNING)
ch.setFormatter(formatter)
log.addHandler(ch)
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
tok = token(args.connect, APP_NAME)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
loop.create_task(queue_logger(loop, up))
msg = parcel(
tok,
Alert(datetime.datetime.now(), "Hello World!"),
via=Address(tok.namespace, tok.user, tok.service, turberfield.ipc.demo.router.APP_NAME)
)
log.info("Sending message: {}".format(msg))
loop.call_soon_threadsafe(functools.partial(down.put_nowait, msg))
try:
loop.run_forever()
except KeyboardInterrupt:
for task in asyncio.Task.all_tasks(loop=loop):
task.cancel()
for resource in resources:
resource.close()
finally:
loop.close()
def test_pool_allocation(self):
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
ports = range(49152, 65536)
for n, p in enumerate(ports):
with self.subTest(n=n, p=p):
flow = list(Flow.create(tok, poa=["udp"], role=[], routing=[]))
query = (Flow.inspect(i) for i in Flow.find(tok, policy="udp"))
alloc = {(i.addr, i.port) for i in query}
self.assertEqual(n + 1, len(alloc))
def main(args):
log = logging.getLogger(APP_NAME)
log.setLevel(args.log_level)
formatter = logging.Formatter(
"%(asctime)s %(levelname)-7s %(name)s|%(message)s")
ch = logging.StreamHandler()
if args.log_path is None:
ch.setLevel(args.log_level)
else:
fh = WatchedFileHandler(args.log_path)
fh.setLevel(args.log_level)
fh.setFormatter(formatter)
log.addHandler(fh)
ch.setLevel(logging.WARNING)
ch.setFormatter(formatter)
log.addHandler(ch)
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
tok = token(args.connect, APP_NAME)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
loop.create_task(queue_logger(loop, up))
msg = parcel(
tok,
Alert(datetime.datetime.now(), "Hello World!"),
via=Address(tok.namespace, tok.user, tok.service, turberfield.ipc.demo.router.APP_NAME)
)
log.info("Sending message: {}".format(msg))
loop.call_soon_threadsafe(functools.partial(down.put_nowait, msg))
try:
loop.run_forever()
except KeyboardInterrupt:
for task in asyncio.Task.all_tasks(loop=loop):
task.cancel()
for resource in resources:
resource.close()
finally:
loop.close()
def test_find_flow_empty(self):
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
self.assertIs(None, tok.flow)
rv = list(Flow.find(tok))
self.assertFalse(rv)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("ignore")
rv = next(Flow.create(tok, poa=[], role=[], routing=[]), None)
self.assertIs(None, rv)
results = list(Flow.find(tok))
self.assertFalse(results)
def test_route_inspection_use_case(self):
self.test_create_routing()
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
search = ((i, Flow.inspect(i)) for i in Flow.find(tok, policy="application"))
query = (
ref
for ref, table in search
for rule in table
if rule.dst.application == "turberfield.ipc.demo.receiver"
)
self.assertEqual(1, len(list(query)))
def test_create_policy(self):
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
self.assertIs(None, tok.flow)
rv = list(Flow.find(tok))
self.assertFalse(rv)
self.assertTrue(
list(gather_installed("turberfield.ipc.poa")),
"No declared POA endpoints; install package for testing.")
rv = next(Flow.create(tok, poa=["udp"], role=[], routing=[]))
self.assertEqual("udp", rv.policy)
self.assertEqual(".json", rv.suffix)
udp = Flow.inspect(rv)
self.assertIsInstance(udp.port, int)
def test_create_policy_unregistered(self):
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
self.assertIs(None, tok.flow)
rv = next(Flow.find(tok), None)
self.assertIs(None, rv)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
rv = next(Flow.create(tok, poa=["ftp"], role=[], routing=[]))
self.assertIs(None, rv)
self.assertTrue(
issubclass(w[-1].category, UserWarning))
self.assertIn("No policy", str(w[-1].message))
def test_find_flow_empty(self):
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
self.assertIs(None, tok.flow)
rv = list(Flow.find(tok))
self.assertFalse(rv)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("ignore")
rv = next(Flow.create(tok, poa=[], role=[], routing=[]), None)
self.assertIs(None, rv)
results = list(Flow.find(tok))
self.assertFalse(results)
def main(args):
loop = asyncio.SelectorEventLoop()
log = logging.getLogger(log_setup(args, loop=loop))
asyncio.set_event_loop(loop)
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
#TODO: Read service name from CLI
service = "dev" # Cf qa, demo, prod, etc
tok = token(args.connect, service, args.session)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
progress, down, up = addisonarches.game.create(
args.output, args.session, args.name,
tok, down=down, up=up, loop=loop
)
loop.run_forever()
def main(args):
log = logging.getLogger(APP_NAME)
log.setLevel(args.log_level)
formatter = logging.Formatter(
"%(asctime)s %(levelname)-7s %(name)s|%(message)s")
ch = logging.StreamHandler()
if args.log_path is None:
ch.setLevel(args.log_level)
else:
fh = WatchedFileHandler(args.log_path)
fh.setLevel(args.log_level)
fh.setFormatter(formatter)
log.addHandler(fh)
ch.setLevel(logging.WARNING)
ch.setFormatter(formatter)
log.addHandler(ch)
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
tok = token(args.connect, APP_NAME)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
log.info("Starting router node...")
try:
loop.run_forever()
except KeyboardInterrupt:
for task in asyncio.Task.all_tasks(loop=loop):
task.cancel()
for resource in resources:
resource.close()
finally:
loop.close()
def main(args):
log = logging.getLogger(APP_NAME)
log.setLevel(args.log_level)
formatter = logging.Formatter(
"%(asctime)s %(levelname)-7s %(name)s|%(message)s")
ch = logging.StreamHandler()
if args.log_path is None:
ch.setLevel(args.log_level)
else:
fh = WatchedFileHandler(args.log_path)
fh.setLevel(args.log_level)
fh.setFormatter(formatter)
log.addHandler(fh)
ch.setLevel(logging.WARNING)
ch.setFormatter(formatter)
log.addHandler(ch)
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
tok = token(args.connect, APP_NAME)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
log.info("Starting router node...")
try:
loop.run_forever()
except KeyboardInterrupt:
for task in asyncio.Task.all_tasks(loop=loop):
task.cancel()
for resource in resources:
resource.close()
finally:
loop.close()
def test_create_policy(self):
tok = token(
"file://{}".format(self.root.name),
"test",
"addisonarches.web"
)
self.assertIs(None, tok.flow)
rv = list(Flow.find(tok))
self.assertFalse(rv)
self.assertTrue(
list(gather_installed("turberfield.ipc.poa")),
"No declared POA endpoints; install package for testing."
)
rv = next(Flow.create(tok, poa=["udp"], role=[], routing=[]))
self.assertEqual("udp", rv.policy)
self.assertEqual(".json", rv.suffix)
udp = Flow.inspect(rv)
self.assertIsInstance(udp.port, int)
def game_setup(loop, output):
down = asyncio.Queue(loop=loop)
up = asyncio.Queue(loop=loop)
tok = token(
GameTests.connect,
"test",
"addisonarches.test.game"
)
node = create_udp_node(loop, tok, down, up)
loop.create_task(node(token=tok))
game, clock, down, up = create_game(
output, user=GameTests.user, name="test",
down=down, up=up, loop=loop
)
progress, down, up = init_game(
game, clock, down, up, loop=self.loop
)
# Tests start at Addison Arches
game.location = game.home
return progress
def test_find_application(self):
tok = token("file://{}".format(self.root.name), "test",
"addisonarches.web")
self.assertIs(None, tok.flow)
results = list(Flow.find(tok, application="addisonarches.game"))
self.assertFalse(results)
