def main(): args = get_argparser().parse_args() tools.init_logger(args) loop = asyncio.get_event_loop() try: get_logs_task = asyncio.ensure_future( get_logs_sim(args.core_addr) if args. simulation else get_logs(args.core_addr)) try: server = Server({"corelog": PingTarget()}, None, True) loop.run_until_complete( server.start(tools.bind_address_from_args(args), args.port)) try: loop.run_until_complete(server.wait_terminate()) finally: loop.run_until_complete(server.stop()) finally: get_logs_task.cancel() try: loop.run_until_complete(get_logs_task) except asyncio.CancelledError: pass finally: loop.close()
def main(): args = get_argparser().parse_args() init_logger(args) loop = asyncio.get_event_loop() atexit.register(loop.close) writer = DBWriter(args.baseurl_db, args.user_db, args.password_db, args.database, args.table) writer.start() atexit_register_coroutine(writer.stop) log = Log(writer) server = Logger() rpc_server = Server({"schedule_logger": server}, builtin_terminate=True) loop.run_until_complete( rpc_server.start(bind_address_from_args(args), args.port_control)) atexit_register_coroutine(rpc_server.stop) reader = MasterReader(args.server_master, args.port_master, args.retry_master, log) reader.start() atexit_register_coroutine(reader.stop) loop.run_until_complete(rpc_server.wait_terminate())
async def run(): with await HUT2.connect(args.device, loop=loop) as dev: server = Server({"hut2": dev}, None, True) await server.start(bind_address_from_args(args), args.port) try: await server.wait_terminate() finally: await server.stop()
async def run(): async with RPCClient(NetworkConnection(args.device, loop=loop)) as dev: server = Server({"laser": dev}, None, True) await server.start(bind_address_from_args(args), args.port) try: await server.wait_terminate() finally: await server.stop()
def main(): args = get_argparser().parse_args() init_logger(args) if os.name == "nt": loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() atexit.register(lambda: loop.close()) ddb = FlatFileDB(args.ddb) pdb = FlatFileDB(args.pdb) rtr = Notifier(dict()) log = Log(1000) if args.git: repo_backend = GitBackend(args.repository) else: repo_backend = FilesystemBackend(args.repository) repository = Repository(repo_backend, log.log) atexit.register(repository.close) repository.scan_async() worker_handlers = { "get_device": ddb.get, "get_parameter": pdb.get, "set_parameter": pdb.set, "update_rt_results": lambda mod: process_mod(rtr, mod), "log": log.log } scheduler = Scheduler(get_last_rid() + 1, worker_handlers, repo_backend) worker_handlers["scheduler_submit"] = scheduler.submit scheduler.start() atexit.register(lambda: loop.run_until_complete(scheduler.stop())) server_control = Server({ "master_ddb": ddb, "master_pdb": pdb, "master_schedule": scheduler, "master_repository": repository }) loop.run_until_complete(server_control.start( args.bind, args.port_control)) atexit.register(lambda: loop.run_until_complete(server_control.stop())) server_notify = Publisher({ "schedule": scheduler.notifier, "devices": ddb.data, "parameters": pdb.data, "rt_results": rtr, "explist": repository.explist, "log": log.data }) loop.run_until_complete(server_notify.start( args.bind, args.port_notify)) atexit.register(lambda: loop.run_until_complete(server_notify.stop())) loop.run_forever()
def main(): args = get_argparser().parse_args() init_logger(args) ddb = FlatFileDB("ddb.pyon") pdb = FlatFileDB("pdb.pyon") simplephist = SimpleHistory(30) pdb.hooks.append(simplephist) rtr = RTResults() repository = Repository() explist = FlatFileDB("explist.pyon") loop = asyncio.get_event_loop() atexit.register(lambda: loop.close()) def run_cb(rid, run_params): rtr.current_group = run_params["rtr_group"] scheduler = Scheduler( { "req_device": ddb.request, "req_parameter": pdb.request, "set_parameter": pdb.set, "init_rt_results": rtr.init, "update_rt_results": rtr.update }, run_cb) loop.run_until_complete(scheduler.start()) atexit.register(lambda: loop.run_until_complete(scheduler.stop())) server_control = Server({ "master_ddb": ddb, "master_pdb": pdb, "master_schedule": scheduler, "master_repository": repository, "master_explist": explist }) loop.run_until_complete(server_control.start(args.bind, args.port_control)) atexit.register(lambda: loop.run_until_complete(server_control.stop())) server_notify = Publisher({ "queue": scheduler.queue, "timed": scheduler.timed, "devices": ddb.data, "parameters": pdb.data, "parameters_simplehist": simplephist.history, "rt_results": rtr.groups, "explist": explist.data }) loop.run_until_complete(server_notify.start(args.bind, args.port_notify)) atexit.register(lambda: loop.run_until_complete(server_notify.stop())) loop.run_forever()
def main(): args = get_argparser().parse_args() root_logger = logging.getLogger() root_logger.setLevel(logging.NOTSET) source_adder = SourceFilter( logging.WARNING + args.quiet * 10 - args.verbose * 10, "ctlmgr({})".format(platform.node())) console_handler = logging.StreamHandler() console_handler.setFormatter( logging.Formatter("%(levelname)s:%(source)s:%(name)s:%(message)s")) console_handler.addFilter(source_adder) root_logger.addHandler(console_handler) if os.name == "nt": loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() atexit.register(loop.close) logfwd = LogForwarder(args.server, args.port_logging, args.retry_master) logfwd.addFilter(source_adder) root_logger.addHandler(logfwd) logfwd.start() atexit_register_coroutine(logfwd.stop) ctlmgr = ControllerManager(args.server, args.port_notify, args.retry_master) ctlmgr.start() atexit_register_coroutine(ctlmgr.stop) class CtlMgrRPC: retry_now = ctlmgr.retry_now rpc_target = CtlMgrRPC() rpc_server = Server({"ctlmgr": rpc_target}, builtin_terminate=True) loop.run_until_complete( rpc_server.start(bind_address_from_args(args), args.port_control)) atexit_register_coroutine(rpc_server.stop) loop.run_until_complete(rpc_server.wait_terminate())
def run_simple_rpc_server(port, setup_args, interface_name, setup_interface): parser = ArgumentParser() influxdb_args(parser) simple_network_args(parser, port) verbosity_args(parser) if setup_args: setup_args(parser) args = parser.parse_args() init_logger(args) loop = asyncio.get_event_loop() atexit.register(loop.close) influx_pusher = influxdb_pusher_from_args(args) if influx_pusher: t = asyncio.ensure_future(influx_pusher.run()) def stop(): t.cancel() try: loop.run_until_complete(t) except asyncio.CancelledError: pass atexit.register(stop) interface = setup_interface(args, influx_pusher, loop) # Provide a default ping() method, which ARTIQ calls regularly for # heartbeating purposes. if not hasattr(interface, "ping"): setattr(interface, "ping", lambda: True) rpc_server = Server({interface_name: interface}, builtin_terminate=True) loop.run_until_complete(rpc_server.start(bind_address_from_args(args), args.port)) atexit_register_coroutine(rpc_server.stop) loop.run_until_complete(rpc_server.wait_terminate())
def main(): args = get_argparser().parse_args() loop = asyncio.get_event_loop() try: get_logs_task = asyncio.ensure_future(get_logs(args.core_addr)) try: server = Server({"corelog": PingTarget()}, None, True) loop.run_until_complete( server.start(bind_address_from_args(args), args.port)) try: multiline_log_config(logging.TRACE) loop.run_until_complete(server.wait_terminate()) finally: loop.run_until_complete(server.stop()) finally: get_logs_task.cancel() try: loop.run_until_complete(get_logs_task) except asyncio.CancelledError: pass finally: loop.close()
def main(): args = get_argparser().parse_args() init_logger(args) loop = asyncio.get_event_loop() atexit.register(lambda: loop.close()) writer = DBWriter(args.baseurl_db, args.user_db, args.password_db, args.database, args.table) writer.start() atexit.register(lambda: loop.run_until_complete(writer.stop())) filter = Filter(args.pattern_file) rpc_server = Server({"influxdb_filter": filter}, builtin_terminate=True) loop.run_until_complete(rpc_server.start(args.bind, args.bind_port)) atexit.register(lambda: loop.run_until_complete(rpc_server.stop())) reader = MasterReader(args.server_master, args.port_master, args.retry_master, filter._filter, writer) reader.start() atexit.register(lambda: loop.run_until_complete(reader.stop())) loop.run_until_complete(rpc_server.wait_terminate())
def main(): args = get_argparser().parse_args() init_logger(args) if os.name == "nt": loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() atexit.register(lambda: loop.close()) ctlmgr = ControllerManager(args.server, args.port, args.retry_master) ctlmgr.start() atexit.register(lambda: loop.run_until_complete(ctlmgr.stop())) class CtlMgrRPC: retry_now = ctlmgr.retry_now rpc_target = CtlMgrRPC() rpc_server = Server({"ctlmgr": rpc_target}, builtin_terminate=True) loop.run_until_complete(rpc_server.start(args.bind, args.bind_port)) atexit.register(lambda: loop.run_until_complete(rpc_server.stop())) loop.run_until_complete(rpc_server.wait_terminate())
async def do_test(self): server = Server({"target": Target()}) await server.start("::1", 7777) await self.check_value() await server.stop()