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)
