def launch(**kwargs):
""" Launches the WLM monitor + lock script """
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='laser_stabilizer',
config=kwargs['config'],
logger=logger)
for server in config['servers']:
if 'name' in server:
if server['name'] == 'input':
ai_client = find_client(clients=clients,
settings=config,
client_type=server['type'],
client_config=server['config'],
logger=logger)
if server['name'] == 'output':
ao_client = find_client(clients=clients,
settings=config,
client_type=server['type'],
client_config=server['config'],
logger=logger)
if server['type'] == 'zi_hdawg':
hd = find_client(clients=clients,
settings=config,
client_type='zi_hdawg',
client_config=server['config'],
logger=logger)
if config['check_aom'] == "True":
check_aom = True
else:
check_aom = False
# Instantiate Monitor script
laser_stabilizer = LaserStabilizer(config=config,
ao_client=ao_client,
ai_client=ai_client,
hd=hd,
check_aom=check_aom,
logger=logger)
update_service = Service()
update_service.assign_module(module=laser_stabilizer)
update_service.assign_logger(logger=logger)
update_server, update_port = create_server(update_service,
logger,
host=get_ip())
logger.update_data(data={'port': update_port})
laser_stabilizer.gui.set_network_info(port=update_port)
update_server.start()
# Run continuously
# Note that the actual operation inside run() can be paused using the update server
while True:
laser_stabilizer.run()
def start_logger(self):
""" Starts the log server """
self.log_service = LogService()
if self.LOG_PORT is None and not self.master:
self.log_server, self.log_port = create_server(self.log_service,
host=get_ip())
else:
try:
self.log_server = GenericServer(service=self.log_service,
host=get_ip(),
port=self.log_port)
except ConnectionRefusedError:
print(
f'Failed to insantiate Log Server at port {self.LOG_PORT}')
raise
self.log_server.start()
self.log_service.logger.info('log service succesfully started')
def _launch_script_server(self):
""" Launches a GenericServer attached to this script to enable closing
"""
if 'script_service' in self.config_dict and self.config_dict[
'script_service'] == 'True':
spec = importlib.util.spec_from_file_location(
self.name, self.config_dict['script'])
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
self.service = mod.Service()
else:
self.service = ServiceBase()
self.service.assign_logger(logger=self.logger)
self.script_server, self.script_server_port = create_server(
service=self.service, logger=self.logger, host=get_ip())
self.script_server.start()
self.logger.update_data(data=dict(port=self.script_server_port))
def launch(**kwargs):
""" Launches the sweeper GUI """
# logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs)
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(
'histogram',
kwargs['config'],
logger
)
ctr = find_client(
clients,
config,
client_type='si_tt',
client_config='standard_ctr',
logger=logger
)
# Instantiate Monitor script
trace = TimeTraceGui(
ctr=ctr,
log=logger,
config=config,
)
update_service = Service()
update_service.assign_module(module=trace)
update_service.assign_logger(logger=logger)
update_server, update_port = create_server(update_service, logger, host=get_ip())
logger.update_data(data={'port': update_port})
trace.gui.set_network_info(port=update_port)
update_server.start()
# Run continuously
# Note that the actual operation inside run() can be paused using the update server
while True:
trace.gui.force_update()
def start_gui_server(self):
""" Starts the launch controller GUI server, or connects to the server and updates GUI"""
module_str = ''
if self.proxy:
module_str = '_proxy'
# connect to the logger
try:
self.gui_logger = LogClient(host=self.host,
port=self.log_port,
module_tag=self.GUI_NAME + module_str,
ui=self.LOGGER_UI)
except ConnectionRefusedError:
self.main_window.terminal.setText(
'Failed to connect to master. Shutting down')
self.main_window.force_update()
time.sleep(10)
raise
# if lab name is specified: add to gui_logger
try:
lab_name_dict = load_config("lab_name")
lab_name = lab_name_dict['lab_name']
except:
lab_name = 'NO_LAB'
self.gui_logger.update_data(data=dict(lab_name=lab_name))
# Instantiate GUI server and update GUI with port details
self.gui_service = Service()
self.gui_service.assign_module(module=self.main_window)
self.gui_service.assign_logger(logger=self.gui_logger)
if self.gui_port is None:
self.gui_server, self.gui_port = create_server(
self.gui_service, logger=self.gui_logger, host=get_ip())
my_port = self.gui_port
self.main_window.gui_label.setText(f'GUI Port: {my_port}')
elif self.proxy:
self.gui_server, my_port = create_server(self.gui_service,
logger=self.gui_logger,
host=get_ip())
self.main_window.gui_label.setText(
f'Master (Local) GUI Port: {self.gui_port} ({my_port})')
else:
try:
self.gui_server = GenericServer(service=self.gui_service,
host=get_ip(),
port=self.gui_port)
my_port = self.gui_port
self.main_window.gui_label.setText(f'GUI Port: {my_port}')
except ConnectionRefusedError:
self.gui_logger.error(
f'Failed to instantiate GUI Server at port {self.gui_port}'
)
raise
self.gui_server.start()
self.gui_logger.update_data(data=dict(port=my_port))
if self.proxy:
# Connect to the GUI server
try:
self.gui_client = Client(host=self.host, port=self.gui_port)
except ConnectionRefusedError:
self.gui_logger.error(
f'Failed to connect to GUI Server with IP address: {self.host}, '
f'Port: {self:gui_port}')
raise
# Now update GUI to mirror clients
self._copy_master()
# Get the latest update index
buffer = self.gui_client.get_text('buffer')
try:
self.update_index = int(
re.findall(r'\d+',
re.findall(r'!~\d+~!', buffer)[-1])[0])
except IndexError:
self.update_index = 0
self.gui_service = Service()
self.gui_service.assign_module(module=self.main_window)
self.gui_service.assign_logger(logger=self.gui_logger)
else:
# Update internal attributes and add to list of log clients
self.client_list[self.GUI_NAME] = QtWidgets.QListWidgetItem(
self.GUI_NAME)
self.port_list[self.GUI_NAME] = [
port for port in self.log_server._server.clients
][0]
self.main_window.client_list.addItem(
self.client_list[self.GUI_NAME])
self.client_list[self.GUI_NAME].setToolTip(
dict_to_str(self.log_service.client_data[self.GUI_NAME]))
self.client_data[self.GUI_NAME +
module_str] = self.log_service.client_data[
self.GUI_NAME]