def _run_mgr(log):
"""
Run the HF manager until terminated
"""
log.info('')
log.info('****** Starting HF manager ******')
try:
hf_mgr_thread = HFMgrThread(log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(1)
if not hf_mgr_thread.is_running():
log.error('Data thread died unexpectedly')
break
except KeyboardInterrupt:
if hf_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)
hf_mgr_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting HF manager ******')
def _run_wd(log):
"""
Run the watchdog until terminated
"""
global gv
log.info('')
log.info('****** Starting CPU load watchdog ******')
try:
wd_thread = WDThread(log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(0.5)
if not wd_thread.is_running():
log.error('Watchdog thread died unexpectedly')
break
except KeyboardInterrupt:
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 ******')
def _run_super(log):
log.info('')
log.info('****** Starting AAL-PIP Supervisor ******')
try:
controllers = _init_super(log)
except Exception, e:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
print 'Exception in super._run_super: %s' % e
sys.exit(1)
def write(self, data):
"""Write a string to the modem"""
if self._serial_port_is_open():
#self._log.debug('to modem: %s' % data)
try:
self._port.write(data)
except serial.SerialTimeoutException:
self._log.info('Exception: Serial port write timeout')
except KeyboardInterrupt:
raise
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, self._log)
def _run_mgr(log):
"""
Run the instrument manager until terminated
"""
global gv
log.info('')
log.info('****** Starting fluxgate instrument manager ******')
try:
gv.console = SockConsole('localhost', fg_mgr_config.console_port, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
data_thread = DataThread(gv.console, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
xmlrpc_thread = XMLRPCThread('localhost', fg_mgr_config.XMLRPC_port,
data_thread, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(0.5)
if not gv.console.is_running():
log.error('Console thread died unexpectedly')
break
if not xmlrpc_thread.is_running():
log.error('XMLRPC server thread died unexpectedly')
break
if not data_thread.is_running():
log.error('Data thread died unexpectedly')
break
except KeyboardInterrupt:
if fg_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)
data_thread.stop()
gv.console.stop()
xmlrpc_thread.stop()
utils.wait_for_child_threads()
log.info('****** Exiting fluxgate instrument manager ******')
def _run_mgr(log):
"""
Run the instrument manager until terminated
via XMLRPC command
"""
log.info('')
log.info('****** Starting USB manager ******')
try:
console = SockConsole('localhost',
usb_mgr_config.console_port,
log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
dispatcher = Dispatcher(log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
xmlrpc_thread = XMLRPCThread('localhost',
usb_mgr_config.XMLRPC_port, console, dispatcher, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(0.5)
if not console.is_running():
log.error('Console thread died unexpectedly')
break
if not xmlrpc_thread.is_running():
log.error('XMLRPC server thread died unexpectedly')
break
if not dispatcher.is_running():
log.error('Dispatcher thread died unexpectedly')
break
except KeyboardInterrupt:
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 ******')
def get_status(self, name_of_value):
"""Return a single status value"""
global status
#self._log.debug('Entering get_status. name_of_value = %s' % name_of_value)
value = ''
self._exec_lock.acquire()
try:
value = status[name_of_value]
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
value = 'failed'
self._exec_lock.release()
#self._log.debug('Exiting _get_status')
return value
def status(self):
"""Write the current status it to the console"""
#self._log.debug('Entering status')
ret_val = 'OK'
self._exec_lock.acquire()
try:
status_to_console(self._console)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
#self._log.debug('Exiting status')
ret_val = 'failed'
self._exec_lock.release()
#self._log.debug('Exiting status')
return ret_val
def _open(self):
"""Open the modem port and intialize the modem
Returns True if the modem was initialized successfully
"""
self._connected = False
if self._serial_port_is_open():
self._port.close()
self._port = None
m_writeTimeout = modem_config.write_timeout
m_writeTimeout = datefunc.timedelta_as_seconds(m_writeTimeout)
m_readTimeout = modem_config.read_timeout
m_readTimeout = datefunc.timedelta_as_seconds(m_readTimeout)
# Use mgetty compatible lock
# mgetty also uses this port as a back door console.
# The lock provides modem mutual exclusion.
#self._lockfile = lockfile.LockFile(modem_config.lock_file_path, self._log)
#if not self._lockfile.acquire():
# self._log.error('Could not acquire modem lock file')
# return False
try:
self._port = serial.Serial(port=modem_config.serial_device,
baudrate=modem_config.baud_rate,
rtscts=1,
timeout=m_readTimeout,
writeTimeout=m_writeTimeout,
stopbits=serial.STOPBITS_TWO)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback,
self._log)
return False
if self._serial_port_is_open():
self._log.debug('Serial port %s opened' % self._port.portstr)
self._toggleDTR(delay=10)
else:
self._log.error('Serial port %s failed to open' %
self._port.portstr)
self._close()
return False
self._log.debug(self._port)
modem_up = self._initModem()
if not modem_up:
self._close()
return modem_up
def _run_svr(log):
"""
Run the file server until terminated
"""
log.info('')
log.info('****** Starting File Server ******')
try:
lan_client_connector = ClientConnector(global_config.our_lan_ip_addr,
log)
rudics_client_connector = ClientConnector('localhost', log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(1)
if not lan_client_connector.is_running():
log.error('lan_client_connector died unexpectedly')
break
if not rudics_client_connector.is_running():
log.error('rudics_client_connector died unexpectedly')
break
except KeyboardInterrupt:
if file_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)
sys.exit(1)
lan_client_connector.stop()
rudics_client_connector.stop()
utils.wait_for_child_threads()
log.info('****** Exiting File Server ******')
def _run_mgr(log):
"""
Run the hardware manager until terminated
"""
global subprocess_lock
log.info('')
log.info('****** Starting hardware manager ******')
subprocess_lock = utils.Lock(log)
_init_status()
_init_digital_IO(log)
_init_adc_params(log)
try:
console = SockConsole('localhost', hw_mgr_config.console_port, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
xmlrpc_thread = XMLRPCThread('localhost', hw_mgr_config.XMLRPC_port,
console, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(0.5)
if not console.is_running():
log.error('Console thread died unexpectedly')
break
if not xmlrpc_thread.is_running():
log.error('XMLRPC server thread died unexpectedly')
break
except KeyboardInterrupt:
if hw_mgr_config.accept_sigint:
log.info('Got SIGINT (shutting down)')
break
else:
log.info('Got SIGINT (ignored)')
except Exception, e:
# handle all unexpected application exceptions
print '*** Unexpected exception in hw_mgr: %s' % e
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
break
def _run_proxy(log):
"""
Run the server proxy until terminated
via KeyboardInterrupt or XMLRPC command
"""
log.info('')
log.info('****** Starting server proxy ******')
xfer_rec = XferRec(log)
try:
modem_svr_connector = ModemSvrConnector(xfer_rec, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
xmlrpc_thread = XMLRPCThread('localhost',
svr_proxy_config.XMLRPC_port, xfer_rec, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(0.5)
if not modem_svr_connector.is_running():
break
if not xmlrpc_thread.is_running():
log.error('XMLRPC server thread died unexpectedly')
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 ******')
def run_server(log, use_modem):
"""
Run the modem server until terminated
via KeyboardInterrupt or XMLRPC command
"""
log.info('')
log.info('****** Starting modem server ******')
try:
xmlrpc_thread = XMLRPCThread('localhost', modem_svr_config.XMLRPC_port,
log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
rudics_conn = RUDICSSvrProxyConnector(log, xmlrpc_thread)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
while True:
try:
utils.wait(0.5)
if not rudics_conn.is_running():
break
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 ******')
def _compress_file(self, src_path, dest_path):
""" Compress a file
Return True if successful
"""
msg = 'Compressing %s to %s' % (src_path, dest_path)
self._log.debug(msg)
try:
input = open(src_path, 'rb')
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, self._log)
return False
try:
output = gzip.open(dest_path, 'wb', compresslevel=9)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, self._log)
return False
while True:
try:
chunk = input.read(1024)
if not chunk:
break
output.write(chunk)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, self._log)
output.close()
return False
try:
output.close()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, self._log)
return False
return True
def _run_mgr(log, test=False):
"""
Run the instrument manager until terminated
"""
log.info('')
log.info('****** Starting CASES manager ******')
"""Open the instrument serial port"""
try:
serial_port = serial.Serial(port=cases_mgr_config.serial_device,
baudrate=cases_mgr_config.baud_rate,
rtscts=0,
timeout=0,
writeTimeout=0,
stopbits=serial.STOPBITS_ONE)
except serial.SerialException:
pass
if serial_port.isOpen():
log.info('Serial port %s opened' % serial_port.portstr)
else:
log.error('Serial port %s failed to open' % serial_port.portstr)
sys.exit(1)
log.debug(serial_port)
try:
console = SockConsole('localhost', cases_mgr_config.console_port, log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
tx_data_thread = TxDataThread(log, serial_port)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
rx_data_thread = RxDataThread(log, serial_port)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
try:
xmlrpc_thread = XMLRPCThread('localhost', cases_mgr_config.XMLRPC_port,
tx_data_thread, rx_data_thread, console,
log)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
utils.log_exc_traceback(exc_type, exc_value, exc_traceback, log)
sys.exit(1)
i = 1
while True:
try:
"""
i += 1
if (i % 8) == 0:
data_buf = '0123456789ABCDEF' * 128 # 2K data buffer
pkt = CASESPkt.CASESPkt()
pkt.build(CASESPkt.CASESPkt.UPLOAD_DSP_IMAGE_CMD, data_buf[:2037])
tx_data_thread.enqueue_pkt(pkt)
"""
utils.wait(0.5)
if not console.is_running():
log.error('Console thread died unexpectedly')
break
if not xmlrpc_thread.is_running():
log.error('XMLRPC server thread died unexpectedly')
break
if not tx_data_thread.is_running():
log.error('Tx data thread died unexpectedly')
break
if not rx_data_thread.is_running():
log.error('Rx data thread died unexpectedly')
break
except KeyboardInterrupt:
if cases_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)
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 ******')
"""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)
