def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(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(common_args.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())
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) if os.name == "nt": asyncio.set_event_loop(asyncio.ProactorEventLoop()) loop = asyncio.get_event_loop() if args.simulation: from .sim import NewFocus8742Sim dev = loop.run_until_complete(NewFocus8742Sim.connect()) elif args.tcp: from .tcp import NewFocus8742TCP dev = loop.run_until_complete(NewFocus8742TCP.connect(args.tcp)) else: from .usb import NewFocus8742USB dev = loop.run_until_complete(NewFocus8742USB.connect()) try: simple_server_loop({"newfocus8742": dev}, common_args.bind_address_from_args(args), args.port) except KeyboardInterrupt: pass finally: dev.close()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) try: signal_handler = SignalHandler() signal_handler.setup() 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(common_args.bind_address_from_args(args), args.port)) try: _, pending = loop.run_until_complete(asyncio.wait( [signal_handler.wait_terminate(), server.wait_terminate(), get_logs_task], return_when=asyncio.FIRST_COMPLETED)) for task in pending: task.cancel() finally: loop.run_until_complete(server.stop()) finally: pass finally: signal_handler.teardown() finally: loop.close()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) atexit.register(loop.close) signal_handler = SignalHandler() signal_handler.setup() atexit.register(signal_handler.teardown) writer = DBWriter(args.baseurl_db, args.user_db, args.password_db, args.database, args.table) writer.start() atexit_register_coroutine(writer.stop) filter = Filter(args.pattern_file) rpc_server = Server({"influxdb_filter": filter}, builtin_terminate=True) loop.run_until_complete(rpc_server.start(common_args.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, filter._filter, writer) reader.start() atexit_register_coroutine(reader.stop) _, pending = loop.run_until_complete(asyncio.wait( [signal_handler.wait_terminate(), rpc_server.wait_terminate()], return_when=asyncio.FIRST_COMPLETED)) for task in pending: task.cancel()
def start(self): """ Start the server """ self.executor = ThreadPoolExecutor(max_workers=2) self.loop = loop = asyncio.get_event_loop() atexit.register(loop.close) # start control server bind = bind_address_from_args(self.args) loop.run_until_complete( self.server_control.start(bind, self.args.port_control)) atexit_register_coroutine(self.server_control.stop) # start notify server loop.run_until_complete( self.server_notify.start(bind, self.args.port_notify)) atexit_register_coroutine(self.server_notify.stop) asyncio.ensure_future(self.measurement_task()) for laser in self.lasers: asyncio.ensure_future(self.lock_task(laser)) # backup of configuration file backup_config(self.args, "_server") asyncio.ensure_future(regular_config_backup(self.args, "_server")) atexit.register(backup_config, self.args, "_server") logger.info("server started") self.running = True loop.run_forever()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(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(common_args.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_from_args(args) if args.lock_current: client = WavemeterPIClientTopticaEthernetCurrent( host=args.server, port=args.port, channel=args.channel, dlc_address=args.dlc_address, laser_id=args.laser, output_offset=args.current_center, output_span=args.current_span, setpoint=args.setpoint, cp=args.cp, ci=args.ci, integrator_timeout=args.integrator_timeout, integrator_cutoff=args.integrator_cutoff, output_sensitivity=args.output_sensitivity, startup_locked=args.startup_locked) else: client = WavemeterPIClientTopticaEthernetPZT( host=args.server, port=args.port, channel=args.channel, dlc_address=args.dlc_address, laser_id=args.laser, output_offset=args.pzt_center, output_span=args.pzt_span, setpoint=args.setpoint, cp=args.cp, ci=args.ci, integrator_timeout=args.integrator_timeout, integrator_cutoff=args.integrator_cutoff, output_sensitivity=args.output_sensitivity, current_center=args.current_center, current_span=args.current_span, startup_locked=args.startup_locked) pub = Publisher( {"lock_client_{}".format(args.channel): client.status_notifier}) asyncio.get_event_loop().run_until_complete( pub.start(bind_address_from_args(args), args.port_pub)) simple_server_loop({"lock_client_{}".format(args.channel): client}, bind_address_from_args(args), args.port_rpc) client.close_subscriber() client.close_dlc_connection()
async def run(): async with RPCClient(NetworkConnection(args.device, loop=loop)) as dev: server = Server({"laser": dev}, None, True) await server.start(common_args.bind_address_from_args(args), args.port) try: await server.wait_terminate() finally: await server.stop()
async def run(): with await Shutter.connect(args.device, loop=loop) as dev: server = Server({"ptb_shutter": 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_from_args(args) if args.aux_output: client = WavemeterPIClientRedLabPlusAuxOut( host=args.server, port=args.port, channel=args.channel, board_num=args.board, channel_id=args.id, board_num_aux=args.board2, channel_id_aux=args.id2, setpoint=args.setpoint, cp=args.cp, ci=args.ci, integrator_timeout=args.integrator_timeout, integrator_cutoff=args.integrator_cutoff, output_sensitivity=args.output_sensitivity, output_offset=args.output_offset, startup_locked=args.startup_locked) else: client = WavemeterPIClientRedLab( host=args.server, port=args.port, channel=args.channel, board_num=args.board, channel_id=args.id, setpoint=args.setpoint, cp=args.cp, ci=args.ci, integrator_timeout=args.integrator_timeout, integrator_cutoff=args.integrator_cutoff, output_sensitivity=args.output_sensitivity, output_offset=args.output_offset, startup_locked=args.startup_locked) pub = Publisher( {"lock_client_{}".format(args.channel): client.status_notifier}) asyncio.get_event_loop().run_until_complete( pub.start(bind_address_from_args(args), args.port_pub)) simple_server_loop({"lock_client_{}".format(args.channel): client}, bind_address_from_args(args), args.port_rpc) client.close_subscriber()
async def run(): await dev.connect(args.uri, user=args.user, password=args.password) await dev.misc() server = Server({"oors": dev}, None, True) await server.start(bind_address_from_args(args), args.port) try: await server.wait_terminate() except KeyboardInterrupt: pass finally: await server.stop()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) if args.simulation: lda = Ldasim() else: lda = Lda(args.device, args.product) try: simple_server_loop({"lda": lda}, common_args.bind_address_from_args(args), args.port) finally: lda.close()
def main(): args = get_argparser().parse_args() channels = [] for ch in args.channel: try: channels.append(int(ch)) except ValueError: pass init_logger_from_args(args) simple_server_loop( { "wavemeter_server": WavemeterServer(channels=channels, num_hw_channels=args.nchannels, get_temperature=args.T, get_pressure=args.p, skip_threshold_nm=args.skip_thr, install_callback=args.callback, start_publisher=args.start_pub, publisher_host=bind_address_from_args(args), publisher_port=args.port_pub) }, bind_address_from_args(args), args.port_rpc)
async def run(): with await Wavemeter.connect(args.device, port=args.device_port, loop=loop) as dev: # only wavemeter # logger.debug("connected, version %s", await dev.get_version()) server = Server({"wavemeter": dev}, None, True) await server.start(common_args.bind_address_from_args(args), args.port) try: await server.wait_terminate() finally: await server.stop()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) cam = Cam(args.device) if args.exposure: cam.set_exposure(float(args.exposure)) try: logger.info("Camera open. Serving...") simple_server_loop({"camera": cam}, common_args.bind_address_from_args(args), args.port) finally: cam.close()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) if not args.serialPort: print("You need to specify -s") sys.exit(1) psu = PSU(args.serialPort) try: logger.info("DP700 open. Serving...") simple_server_loop({"DP700": psu}, common_args.bind_address_from_args(args), args.port) finally: psu.close()
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) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) atexit.register(loop.close) signal_handler = SignalHandler() signal_handler.setup() atexit.register(signal_handler.teardown) 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, args.host_filter) 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(common_args.bind_address_from_args(args), args.port_control)) atexit_register_coroutine(rpc_server.stop) _, pending = loop.run_until_complete(asyncio.wait( [signal_handler.wait_terminate(), rpc_server.wait_terminate()], return_when=asyncio.FIRST_COMPLETED)) for task in pending: task.cancel()
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(common_args.bind_address_from_args(args), args.port_control)) atexit_register_coroutine(rpc_server.stop) loop.run_until_complete(rpc_server.wait_terminate())
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) if os.name == "nt": asyncio.set_event_loop(asyncio.ProactorEventLoop()) if not args.simulation and args.device is None: print("You need to specify either --simulation or -d/--device " "argument. Use --help for more information.") sys.exit(1) dev = Novatech409B(args.device if not args.simulation else None) asyncio.get_event_loop().run_until_complete(dev.setup()) try: simple_server_loop( {"novatech409b": dev}, common_args.bind_address_from_args(args), args.port) finally: dev.close()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) bind_address = common_args.bind_address_from_args(args) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) try: signal_handler = SignalHandler() signal_handler.setup() try: monitor_mux = MonitorMux() comm_moninj = CommMonInj(monitor_mux.monitor_cb, monitor_mux.injection_status_cb, monitor_mux.disconnect_cb) monitor_mux.comm_moninj = comm_moninj loop.run_until_complete(comm_moninj.connect(args.core_addr)) try: proxy_server = ProxyServer(monitor_mux) loop.run_until_complete(proxy_server.start(bind_address, args.port_proxy)) try: server = Server({"moninj_proxy": PingTarget()}, None, True) loop.run_until_complete(server.start(bind_address, args.port_control)) try: _, pending = loop.run_until_complete(asyncio.wait( [signal_handler.wait_terminate(), server.wait_terminate(), comm_moninj.wait_terminate()], return_when=asyncio.FIRST_COMPLETED)) for task in pending: task.cancel() finally: loop.run_until_complete(server.stop()) finally: loop.run_until_complete(proxy_server.stop()) finally: loop.run_until_complete(comm_moninj.close()) finally: signal_handler.teardown() finally: loop.close()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) if not args.simulation and args.device is None: print("You need to specify either --simulation or -d/--device " "argument. Use --help for more information.") sys.exit(1) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) try: product = args.product.lower() if args.simulation: if product == "tdc001": dev = TdcSim() elif product == "tpz001": dev = TpzSim() else: print("Invalid product string (-P/--product), " "choose from tdc001 or tpz001") sys.exit(1) else: if product == "tdc001": dev = Tdc(args.device) elif product == "tpz001": dev = Tpz(args.device) loop.run_until_complete(dev.get_tpz_io_settings()) else: print("Invalid product string (-P/--product), " "choose from tdc001 or tpz001") sys.exit(1) try: simple_server_loop({product: dev}, common_args.bind_address_from_args(args), args.port, loop=loop) finally: dev.close() finally: loop.close()
def main(): args = get_argparser().parse_args() log_forwarder = init_log(args) if os.name == "nt": loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() atexit.register(loop.close) bind = common_args.bind_address_from_args(args) server_broadcast = Broadcaster() loop.run_until_complete(server_broadcast.start( bind, args.port_broadcast)) atexit_register_coroutine(server_broadcast.stop) log_forwarder.callback = (lambda msg: server_broadcast.broadcast("log", msg)) def ccb_issue(service, *args, **kwargs): msg = { "service": service, "args": args, "kwargs": kwargs } server_broadcast.broadcast("ccb", msg) device_db = DeviceDB(args.device_db) dataset_db = DatasetDB(args.dataset_db) dataset_db.start() atexit_register_coroutine(dataset_db.stop) worker_handlers = dict() if args.git: repo_backend = GitBackend(args.repository) else: repo_backend = FilesystemBackend(args.repository) experiment_db = ExperimentDB( repo_backend, worker_handlers, args.experiment_subdir) atexit.register(experiment_db.close) scheduler = Scheduler(RIDCounter(), worker_handlers, experiment_db) scheduler.start() atexit_register_coroutine(scheduler.stop) config = MasterConfig(args.name) worker_handlers.update({ "get_device_db": device_db.get_device_db, "get_device": device_db.get, "get_dataset": dataset_db.get, "update_dataset": dataset_db.update, "scheduler_submit": scheduler.submit, "scheduler_delete": scheduler.delete, "scheduler_request_termination": scheduler.request_termination, "scheduler_get_status": scheduler.get_status, "scheduler_check_pause": scheduler.check_pause, "ccb_issue": ccb_issue, }) experiment_db.scan_repository_async() server_control = RPCServer({ "master_config": config, "master_device_db": device_db, "master_dataset_db": dataset_db, "master_schedule": scheduler, "master_experiment_db": experiment_db }, allow_parallel=True) loop.run_until_complete(server_control.start( bind, args.port_control)) atexit_register_coroutine(server_control.stop) server_notify = Publisher({ "schedule": scheduler.notifier, "devices": device_db.data, "datasets": dataset_db.data, "explist": experiment_db.explist, "explist_status": experiment_db.status }) loop.run_until_complete(server_notify.start( bind, args.port_notify)) atexit_register_coroutine(server_notify.stop) server_logging = LoggingServer() loop.run_until_complete(server_logging.start( bind, args.port_logging)) atexit_register_coroutine(server_logging.stop) print("ARTIQ master is now ready.") loop.run_forever()
def main(extra_args=None): logging.getLogger(name).info("Launching controller %s", name) def get_argparser(): parser = argparse.ArgumentParser( description="Generic controller for {}".format(name)) group = parser.add_argument_group(name) group.add_argument( "--id", required=True, type=str, help= "VISA id to connect to. This Controller will obtain an exclusive lock.", ) group.add_argument( "--simulation", action="store_true", help= "Run this controller in simulation mode. ID will be ignored but is still required.", ) common_args.simple_network_args(parser, default_port) common_args.verbosity_args(parser) return parser args = get_argparser().parse_args(extra_args) common_args.init_logger_from_args(args) driver_obj = driver_class(None, id=args.id, simulation=args.simulation, **driver_kwargs) loop = asyncio.get_event_loop() # Start an ARTIQ server for this device. # # Allow parallel connections so that functions which don't touch the # serial device can be done simultaneously: functions which do are # protected by @with_lock. server = Server( {name: driver_obj}, description="An automatically generated server for {}".format( driver_class.__name__), builtin_terminate=True, allow_parallel=True, ) loop.run_until_complete( server.start( host=common_args.bind_address_from_args(args), port=args.port, )) try: loop.run_until_complete(server.wait_terminate()) finally: try: loop.run_until_complete(server.stop()) finally: # Close the VISA connection after the server has shutdown driver_obj.close() loop.close()
def main(): args = get_argparser().parse_args() common_args.init_logger_from_args(args) simple_server_loop({"dummy": Dummy()}, common_args.bind_address_from_args(args), args.port)