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 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.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)
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()
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()
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()
def connect_asyncio_server(self):
self.loop = asyncio.get_event_loop()
self.asyncio_server = Server(
{
"pulse_sequence_visualizer":
PulseSequenceVisualizerServer(self),
"simulation_logger": simulation_logger
}, None, True)
self.task = self.loop.create_task(
self.asyncio_server.start("::1", 3289))
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()
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()
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)
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 connect_server(self):
self.loop = asyncio.get_event_loop()
self.server = Server({"rcg": self.RemotePlotting(self.rcg)}, None,
True)
self.task = self.loop.create_task(
self.server.start(conf.host, conf.port))
def connect_asyncio_server(self):
self.loop = asyncio.get_event_loop()
self.asyncio_server = Server(
{"pmt_histogram": self.RemotePlotting(self)}, None, True)
self.task = self.loop.create_task(
self.asyncio_server.start("::1", 3287))
def connect_asyncio_server(self):
self.loop = asyncio.get_event_loop()
self.asyncio_server = Server(
{"camera_reference_image": self.RemotePlotting(self)}, None, True)
self.task = self.loop.create_task(
self.asyncio_server.start("::1", 3288))
async def do_test(self):
server = Server({"target": Target()})
await server.start("::1", 7777)
await self.check_value()
await server.stop()
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()
