# handle all unexpected application exceptions
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
data_thread.stop()
gv.console.stop()
xmlrpc_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting fluxgate instrument manager ******')
class GlobalVars:
""" Global variables """
def __init__(self):
self.console = None
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if fg_mgr_config.daemonize:
utils.daemonize()
gv = GlobalVars
log = logs.open(fg_mgr_config.log_name,
fg_mgr_config.log_dir,
fg_mgr_config.log_level,
file_max_bytes=fg_mgr_config.log_file_max_bytes,
num_backup_files=fg_mgr_config.log_files_backup_files)
utils.make_dirs(fg_mgr_config.temp_dir, log)
_run_mgr(log)
break
else:
log.info('Got SIGINT (ignored)')
except:
# handle all unexpected application exceptions
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
break
tx_data_thread.stop()
rx_data_thread.stop()
console.stop()
serial_port.close()
xmlrpc_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting CASES manager ******')
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if cases_mgr_config.daemonize:
utils.daemonize()
log = logs.open(cases_mgr_config.log_name,
cases_mgr_config.log_dir,
cases_mgr_config.log_level,
file_max_bytes=cases_mgr_config.log_file_max_bytes,
num_backup_files=cases_mgr_config.log_files_backup_files)
utils.make_dirs(cases_mgr_config.temp_dir, log)
_run_mgr(log, test=True)
if not xmlrpc_thread.is_running():
log.error('XMLRPC thread died unexpectedly')
break
except KeyboardInterrupt:
if modem_svr_config.accept_sigint:
log.info('Got SIGINT (shutting down)')
break
else:
log.info('Got SIGINT (ignored)')
except:
# handle all unexpected application exceptions
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
rudics_conn.stop()
xmlrpc_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting modem server ******')
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if modem_svr_config.daemonize:
utils.daemonize()
log = logs.open(modem_svr_config.log_name,
modem_svr_config.log_dir,
modem_svr_config.log_level,
file_max_bytes=modem_svr_config.log_file_max_bytes,
num_backup_files=modem_svr_config.log_files_backup_files)
run_server(log, global_config.use_modem)
"""Read all available data from the connection receive buffer
Return None if the connection is closed
"""
if not self._connected:
return None
parts = []
while not self._read_q.empty():
parts.append(self._read_q.get())
return ''.join(parts)
def _runTest(log):
print 'No test available'
if __name__ == '__main__':
"""Test the RudicsModemSim class"""
print "Testing RudicsModemSim class"
log = logs.open(modem_config.log_name_modem,
modem_config.log_dir,
logging.DEBUG)
try:
_runTest(log)
except KeyboardInterrupt:
log.info('KeyboardInterrupt (ignored)')
except:
print 'Exception raised. See log file'
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
if cpu_load_wd_config.accept_sigint:
log.info('Got SIGINT (shutting down)')
break
else:
log.info('Got SIGINT (ignored)')
except:
sys.exit(1)
wd_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting CPU load watchdog ******')
class GlobalVars:
""" Global variables """
def __init__(self):
self.console = None
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if cpu_load_wd_config.daemonize:
utils.daemonize()
gv = GlobalVars
log = logs.open(cpu_load_wd_config.log_name,
cpu_load_wd_config.log_dir,
cpu_load_wd_config.log_level,
file_max_bytes=cpu_load_wd_config.log_file_max_bytes,
num_backup_files=cpu_load_wd_config.log_files_backup_files)
_run_wd(log)
if usb_mgr_config.accept_sigint:
log.info('Got SIGINT (shutting down)')
break
else:
log.info('Got SIGINT (ignored)')
except:
# handle all unexpected application exceptions
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
xmlrpc_thread.stop()
dispatcher.stop()
console.stop()
utils.wait_for_child_threads()
log.info('****** Exiting USB manager ******')
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if usb_mgr_config.daemonize:
utils.daemonize()
log = logs.open(usb_mgr_config.log_name,
usb_mgr_config.log_dir,
usb_mgr_config.log_level,
file_max_bytes = usb_mgr_config.log_file_max_bytes,
num_backup_files = usb_mgr_config.log_files_backup_files)
utils.make_dirs(usb_mgr_config.temp_dir, log)
_run_mgr(log)
while True:
try:
run_super_loop(controllers, log)
except KeyboardInterrupt:
log.info('Got SIGINT (shutting down)')
break
except:
# handle all unexpected application exceptions
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
break
_shutdown_super(controllers, log)
console.stop()
xmlrpc_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting AAL-PIP Supervisor ******')
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if super_config.daemonize:
utils.daemonize()
log = logs.open(super_config.log_name,
super_config.log_dir,
super_config.log_level,
file_max_bytes=super_config.log_file_max_bytes,
num_backup_files=super_config.log_files_backup_files)
_run_super(log)
raw_cmd = raw_input(prompt)
except Exception:
raise
log.info(''.join((prompt, raw_cmd)))
if raw_cmd.lower().startswith('quit'):
break
if raw_cmd.lower().startswith('exit'):
break
process_console_cmd(raw_cmd, log)
if __name__ == '__main__':
print('Starting console')
log = logs.open(console_config.log_name,
console_config.log_dir,
console_config.log_level,
file_max_bytes=console_config.log_file_max_bytes,
num_backup_files=console_config.log_files_backup_files)
log.info('****** Starting AAL-PIP console ******')
out('', log)
out('****************************************', log)
out('*** AAL-PIP System Console ***', log)
out('*** Enter \'help\' for a ***', log)
out('*** list of commands ***', log)
out('****************************************', log)
out('AAL-PIP software version %s' % global_config.sw_version_number, log)
out('', log)
try:
_run_console(log)
except KeyboardInterrupt:
msg = 'KeyboardInterrupt (exiting)'
break
except KeyboardInterrupt:
if svr_proxy_config.accept_sigint:
log.info('Got SIGINT (shutting down)')
break
else:
log.info('Got SIGINT ignored)')
except:
# handle all unexpected application exceptions
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
modem_svr_connector.stop()
xmlrpc_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting server proxy ******')
if __name__ == '__main__':
sys.setcheckinterval(global_config.check_interval)
if svr_proxy_config.daemonize:
utils.daemonize()
log = logs.open(svr_proxy_config.log_name,
svr_proxy_config.log_dir,
svr_proxy_config.log_level,
file_max_bytes = svr_proxy_config.log_file_max_bytes,
num_backup_files = svr_proxy_config.log_files_backup_files)
_run_proxy(log)
# Send RPC command
print 'Sending test RPC command'
resp = svr_proxy.call('test')
if resp:
print 'Response from test RPC call: %s' % resp
else:
print 'No response from test RPC call'
svr_proxy.close()
rpc_svr_thread.stop()
if __name__ == '__main__':
print 'Testing RPC Library'
log = logs.open('rpc_lib_test',
global_config.field_log_dir,
logging.DEBUG,
file_max_bytes=50000,
num_backup_files=1)
_test_this_module(log)
utils.wait_for_child_threads()
#==================== move to utils.py ==================================
def sock_rpc_set_power_state(device,
state,
server_proxy,
hw_mgr_lock,
log=None):
"""Turn a device on or off using hw_mgr.
state = 'on' | 'off'
Return the server proxy if successful,
