def sub_connect(self, host, port):
self.queue_subscriber = Subscriber("queue", self.init_queue_store)
yield from self.queue_subscriber.connect(host, port)
try:
self.timed_subscriber = Subscriber("timed", self.init_timed_store)
yield from self.timed_subscriber.connect(host, port)
except:
yield from self.queue_subscriber.close()
raise
def sub_connect(self, host, port):
self.parameters_subscriber = Subscriber("parameters",
self.init_parameters_store)
yield from self.parameters_subscriber.connect(host, port)
try:
self.lastchanges_subscriber = Subscriber(
"parameters_simplehist", self.init_lastchanges_store)
yield from self.lastchanges_subscriber.connect(host, port)
except:
yield from self.parameters_subscriber.close()
raise
def __init__(self):
self.ttl_dock = _MonInjDock("TTL")
self.dds_dock = _MonInjDock("DDS")
self.subscriber = Subscriber("devices", self.init_devices)
self.dm = _DeviceManager(self.send_to_device, dict())
self.transport = None
async def _do(self):
try:
subscriber = Subscriber("devices",
self.controller_db.sync_struct_init)
while True:
try:
def set_host_filter():
s = subscriber.writer.get_extra_info("socket")
localhost = s.getsockname()[0]
self.controller_db.set_host_filter(localhost)
await subscriber.connect(self.server, self.port,
set_host_filter)
try:
await asyncio.wait_for(subscriber.receive_task, None)
finally:
await subscriber.close()
except (ConnectionAbortedError, ConnectionError,
ConnectionRefusedError, ConnectionResetError) as e:
logger.warning("Connection to master failed (%s: %s)",
e.__class__.__name__, str(e))
else:
logger.warning("Connection to master lost")
logger.warning("Retrying in %.1f seconds", self.retry_master)
await asyncio.sleep(self.retry_master)
except asyncio.CancelledError:
pass
finally:
await self.controller_db.current_controllers.shutdown()
def subscribe(self):
if self.args.embed is None:
self.subscriber = Subscriber("datasets", self.sub_init,
self.sub_mod)
self.loop.run_until_complete(
self.subscriber.connect(self.args.server, self.args.port))
else:
self.ipc.subscribe(self.datasets, self.sub_init, self.sub_mod)
def _show_list(args, notifier_name, display_fun):
l = []
def init_l(x):
l[:] = x
return l
subscriber = Subscriber(notifier_name, init_l, lambda mod: display_fun(l))
_run_subscriber(args.server, args.port, subscriber)
def _show_dict(args, notifier_name, display_fun):
d = dict()
def init_d(x):
d.clear()
d.update(x)
return d
subscriber = Subscriber(notifier_name, init_d, lambda mod: display_fun(d))
_run_subscriber(args.server, args.port, subscriber)
def __init__(self):
self.ttl_dock = _MonInjDock("TTL")
self.dds_dock = _MonInjDock("DDS")
self.subscriber = Subscriber("devices", self.init_devices)
self.dm = None
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.bind(("", 0))
# Never ceasing to disappoint, asyncio has an issue about UDP
# not being supported on Windows (ProactorEventLoop) open since 2014.
self.loop = asyncio.get_event_loop()
self.thread = threading.Thread(target=self.receiver_thread,
daemon=True)
self.thread.start()
def __init__(self):
self.ttl_dock = _MonInjDock("TTL")
self.dds_dock = _MonInjDock("DDS")
self.dac_dock = _MonInjDock("DAC")
self.dm = _DeviceManager()
self.dm.ttl_cb = lambda: self.ttl_dock.layout_widgets(
self.dm.ttl_widgets.values())
self.dm.dds_cb = lambda: self.dds_dock.layout_widgets(
self.dm.dds_widgets.values())
self.dm.dac_cb = lambda: self.dac_dock.layout_widgets(
self.dm.dac_widgets.values())
self.subscriber = Subscriber("devices", self.dm.init_ddb,
self.dm.notify)
def subscribe(self):
# We want to subscribe only to the experiment-local datasets for our RID
# (but always, even if using IPC – this can be optimised later).
self.subscriber = Subscriber("datasets_rid_{}".format(self.args.rid),
self.sub_init, self.sub_mod)
self.loop.run_until_complete(
self.subscriber.connect(self.args.server, self.args.port))
# Make sure we still respond to non-dataset messages like `terminate` in
# embed mode.
if self.embed is not None:
def ignore(*args):
pass
self.ipc.subscribe([], ignore, ignore)
async def _do(self):
subscriber = Subscriber(
"datasets", partial(Datasets, self.filter_function, self.writer))
while True:
try:
await subscriber.connect(self.server, self.port)
try:
await asyncio.wait_for(subscriber.receive_task, None)
finally:
await subscriber.close()
except (ConnectionAbortedError, ConnectionError,
ConnectionRefusedError, ConnectionResetError) as e:
logger.warning("Connection to master failed (%s: %s)",
e.__class__.__name__, str(e))
else:
logger.warning("Connection to master lost")
logger.warning("Retrying in %.1f seconds", self.retry)
await asyncio.sleep(self.retry)
async def _do(self):
subscriber = Subscriber("schedule",
target_builder=self.writer.init,
notify_cb=self.writer.notify_cb,
disconnect_cb=self.writer.disconnect_cb)
while True:
try:
await subscriber.connect(self.server, self.port)
try:
await asyncio.wait_for(subscriber.receive_task, None)
finally:
await subscriber.close()
except (ConnectionAbortedError, ConnectionError,
ConnectionRefusedError, ConnectionResetError) as e:
logger.warning("Connection to master failed (%s: %s)",
e.__class__.__name__, str(e))
else:
logger.warning("Connection to master lost")
logger.warning("Retrying in %.1f seconds", self.retry)
await asyncio.sleep(self.retry)
def sub_connect(self, host, port):
self.sets_subscriber = Subscriber("rt_results", self.init_groups,
self.on_mod)
yield from self.sets_subscriber.connect(host, port)
async def sub_connect(self, host, port):
self.subscriber = Subscriber("log", self.init_log_model)
await self.subscriber.connect(host, port)
def sub_connect(self, host, port):
self.subscriber = Subscriber("schedule", self.init_schedule_model)
yield from self.subscriber.connect(host, port)
async def sub_connect(self, host, port):
self.explist_subscriber = Subscriber("explist",
self.init_explist_model)
await self.explist_subscriber.connect(host, port)
async def sub_connect(self, host, port):
self.subscriber = Subscriber("schedule", self.init_schedule_model)
await self.subscriber.connect(host, port)
def sub_connect(self, host, port):
self.explist_subscriber = Subscriber("explist",
self.init_explist_store)
yield from self.explist_subscriber.connect(host, port)
def __init__(self):
self.ttl_dock = _MonInjDock("TTL")
self.dds_dock = _MonInjDock("DDS")
self.subscriber = Subscriber("devices", self.init_devices)
self.dm = None
async def sub_connect(self, host, port):
self.subscriber = Subscriber("datasets", self.init_datasets_model,
self.on_mod)
await self.subscriber.connect(host, port)
def sub_connect(self, host, port):
self.subscriber = Subscriber("log", self.init_log_model)
yield from self.subscriber.connect(host, port)
def sub_connect(self, host, port):
self.subscriber = Subscriber("parameters", self.init_parameters_model)
yield from self.subscriber.connect(host, port)
def _show_log(args):
subscriber = Subscriber("log", _LogPrinter)
_run_subscriber(args.server, args.port, subscriber)
def start(self):
""" Connect to the WaND servers """
def init_cb(db, mod):
db.update(mod)
return db
async def subscriber_reconnect(self, server, db):
logger.info("No connection to server '{}'".format(server))
for _, display in self.laser_displays.items():
if display.server == server:
display.server = ""
display.wake_loop.set()
server_cfg = self.config["servers"][server]
subscriber = self.subscribers[server][db]["subscriber"]
if self.win.exit_request.is_set():
return
def make_fut(self, server, db):
fut = asyncio.ensure_future(
subscriber_reconnect(self, server, db))
self.subscribers[server][db]["connected"] = False
self.subscribers[server][db]["future"] = fut
subscriber.disconnect_cb = functools.partial(
make_fut, self, server, db)
while not self.win.exit_request.is_set():
try:
await subscriber.connect(server_cfg["host"],
server_cfg["notify"])
logger.info("Reconnected to server '{}'".format(server))
break
except OSError:
logger.info(
"could not connect to '{}' retry in 10s...".format(
server))
await asyncio.sleep(10)
for server, server_cfg in self.config["servers"].items():
self.subscribers[server] = {}
# ask the servers to keep us updated with changes to laser settings
# (exposures, references, etc)
subscriber = Subscriber(
"laser_db", functools.partial(init_cb, self.laser_db),
functools.partial(self.notifier_cb, "laser_db", server))
fut = asyncio.ensure_future(
subscriber_reconnect(self, server, "laser_db"))
self.subscribers[server]["laser_db"] = {
"subscriber": subscriber,
"connected": False,
"future": fut
}
# ask the servers to keep us updated with the latest frequency data
subscriber = Subscriber(
"freq_db", functools.partial(init_cb, self.freq_db),
functools.partial(self.notifier_cb, "freq_db", server))
fut = asyncio.ensure_future(
subscriber_reconnect(self, server, "freq_db"))
self.subscribers[server]["freq_db"] = {
"subscriber": subscriber,
"connected": False,
"future": fut
}
# ask the servers to keep us updated with the latest osa traces
subscriber = Subscriber(
"osa_db", functools.partial(init_cb, self.osa_db),
functools.partial(self.notifier_cb, "osa_db", server))
fut = asyncio.ensure_future(
subscriber_reconnect(self, server, "osa_db"))
self.subscribers[server]["osa_db"] = {
"subscriber": subscriber,
"connected": False,
"future": fut
}
atexit_register_coroutine(self.shutdown)
self.win.showMaximized()
atexit.register(self.win.exit_request.set)
self.loop.run_until_complete(self.win.exit_request.wait())
