def __init__(self, log, exit_callback=None):
threading.Thread.__init__(self)
self.setDaemon(False)
self.name = 'HFMgrThread'
self._log = log
self._exit_callback = exit_callback
self._stop_event = threading.Event()
self._state = ''
self._change_state('waiting_for_power_on')
self._serial_port_open = False
self._newline = str('\x0D')
self._cntl_c = str('\x03')
self._data_file = None
self._data_file_path = None
self._sys_index = None
self._sys_call_sign = None
self._sys_name = None
self._sys_num = None
self._test_msg = None
self._rx_buf_list = []
self._time_stamp = None
self._hw_mgr_svr_proxy = None
self._hw_mgr_lock = utils.Lock(self._log)
self._running = False
self._started = False
self.start()
while not self._started:
utils.wait(0.05)
def register(phone):
'''
注册指定账号，并返回session
'''
with utils.Lock(PROCESS):
with Browser(headless=True) as browser:
_login(browser, phone)
cookies = browser.cookies.all()
return gen_session(cookies)
def __init__(self, log):
"""
"""
self._log = log
self.setpoint = super_config.temp_default_setpoint
self._hysteresis = super_config.temp_hysteresis
self._htr_desired_state = 0
self._hw_mgr_server = None
self._hw_mgr_lock = utils.Lock(self._log)
def _wait_for_UTC_sync(self):
hw_mgr_server = None
dummy_lock = utils.Lock(self._log)
while not self._stop_event.isSet():
[utc_sync_age,
hw_mgr_server] = utils.get_hw_status('sync_age', hw_mgr_server,
dummy_lock, self._log)
if (utc_sync_age is not None) and (utc_sync_age < 10000):
break
utils.wait(0.5)
def __init__(self, log):
"""Instantiate an RudicsModem object
"""
self._log = log
self._port = None
self._connected = False
self._iccid = 'coming soon'
self._raw_response = ''
self._hw_mgr_server = None
self._hw_mgr_lock = utils.Lock(self._log)
def __init__(self, log):
self._log = log
self._hw_mgr_lock = utils.Lock(self._log)
self._kill_power = False
self._power_cntl_cmd_pending = False
self._timer = time.time()
self._hw_mgr_server = None
self._svr_proxy_server = None
self._power_up_modem()
self._data_xfer_timer = time.time()
self._comm_state = 'powered_up'
def __init__(self, host, port, console, log):
BasicXMLRPCThread.__init__(self, host, port, log)
self._log = log
self._console = console
self._exec_lock = utils.Lock(log)
self._server.register_function(self.help)
self._server.register_function(self.set_power)
self._server.register_function(self.reset_overcurrent)
self._server.register_function(self.status)
self._server.register_function(self.get_status)
self._server.register_function(self.get_full_status)
self._server.register_function(self.refresh)
def __init__(self, log):
self._log = log
self.fg_power_setting = 1
self.sc_power_setting = 1
self._hw_mgr_server = None
self._hw_mgr_lock = utils.Lock(self._log)
self._hw_mgr_server = utils.set_power_state('fg', 'on',
self._hw_mgr_server,
self._hw_mgr_lock,
self._log)
self._hw_mgr_server = utils.set_power_state('sc', 'on',
self._hw_mgr_server,
self._hw_mgr_lock,
self._log)
def _get_data_row(self, time_stamp):
"""Return a CSV string containing all the hskp values
Return None if status data was not available
"""
dummy_lock = utils.Lock(self._log)
[hw_status, self._server_proxy
] = utils.get_full_hw_status(self._server_proxy, dummy_lock,
self._log)
if hw_status is None:
self._log.error(
'StoreHskp._get_data_row: Could not get full status from hw_mgr'
)
return None
parts = []
# Build up a row of CSV data
try:
parts.append(','.join([ \
'%d' % time_stamp.year,
'%d' % time_stamp.month,
'%d' % time_stamp.day,
'%d' % time_stamp.hour,
'%d' % time_stamp.minute,
'%d' % time_stamp.second,
str(hw_status['irid_pwr']),
str(hw_status['fg_pwr']),
str(hw_status['sc_pwr']),
str(hw_status['cases_pwr']),
str(hw_status['hf_pwr']),
str(hw_status['htr_pwr']),
str(hw_status['gps_pwr']),
str(hw_status['ovr_cur_status']),
'%.2f' % hw_status['batt_1_temp'],
'%.2f' % hw_status['batt_2_temp'],
'%.2f' % hw_status['batt_3_temp'],
'%.2f' % hw_status['fg_elec_temp'],
'%.2f' % hw_status['fg_sens_temp'],
'%.2f' % hw_status['router_temp'],
'%.2f' % hw_status['batt_1_volt'],
'%.2f' % hw_status['batt_2_volt'],
'%.2f' % hw_status['batt_3_volt'],
'%.3f' % hw_status['in_current'],
'%.3f' % hw_status['in_power'],
'%.6f' % hw_status['lat'],
'%.6f' % hw_status['long'],
'%.6f' % hw_status['sys_time_error'],
'%d,' % hw_status['sync_age']]))
except Exception, e:
self._log.error('StoreHskp._get_data_row exception: %s' % e)
return None
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 __init__(self, log):
self.master_power_enable = 0 # 0 = off, 1 = on
self._log = log
self._hw_mgr_svr_proxy = None
self._temp_valid = False
self._over_temp = False
self._under_temp = False
self._power_state = None
self._thermostat_switch_on = True
self._temp = 0
self._hf_sched_state = 1
self._hf_stop_time = None
self._hw_mgr_lock = utils.Lock(self._log)
self._hw_mgr_svr_proxy = utils.set_power_state('hf', 'off', self._hw_mgr_svr_proxy, self._hw_mgr_lock, self._log)
# True if master_power_enable has sole control of power. Used only for testing.
self._manual_power_override = False
def run(self):
"""The actual thread code"""
self._log.debug('Starting %s ' % self.name)
self._running = True
self._started = True
self._open_serial_port()
if not self._serial_port_open:
self._stop_event.set()
self._log.info('Waiting for UTC synchronization')
hw_mgr_server = None
dummy_lock = utils.Lock(self._log)
while not self._stop_event.isSet():
[utc_sync_age,
hw_mgr_server] = utils.get_hw_status('sync_age', hw_mgr_server,
dummy_lock, self._log)
# 3 Lines Added Jan2018 by SEC to bypass UTC sync in case of GPS fault
if (utc_sync_age is not None) and (utc_sync_age > 10000):
self._log.info('SYNC_AGE_FAULT: Bypassing UTC Synchronization')
break
if (utc_sync_age is not None) and (utc_sync_age < 10000):
break
utils.wait(0.5)
if not self._stop_event.isSet():
self._log.info('Synchronized with UTC')
self._port.flushInput()
while not self._stop_event.isSet():
bytes_avail = self._port.inWaiting()
if bytes_avail > 0:
self._process_rx_bytes(self._port.read(bytes_avail))
utils.wait(0.05)
self._running = False
self._close_data_file()
if self._data_file_path is not None:
self._close_data_file()
save_file_thread = SaveFileThread(self._data_file_path, True,
self._log)
save_file_thread.join()
if self._serial_port_open:
self._port.close()
#self._log.debug('Stopping %s ' % self.name)
if self._exit_callback:
self._exit_callback(self)
self._log.debug('Exiting %s ' % self.name)
def _wait_for_hw_mgr(log):
"""hw_mgr takes a while before it is ready to
accept XMLRPC commands. Wait here until
it accepts a command.
Return True if successful.
"""
start_time = time.time()
hw_mgr_server = None
dummy_lock = utils.Lock(log)
while True:
if (time.time() - start_time) > super_config.xmlrpc_conn_timeout:
log.error('Timed out connecting to hw_mgr XMLRPC server.')
return False
[status, hw_mgr_server] = utils.get_hw_status('fg_pwr', hw_mgr_server,
dummy_lock, log)
if status is None:
utils.wait(1)
else:
break
return True
def __init__(self, log):
self.master_power_enable = 0 # 0 = off, 1 = on
self.mode = "normal" # "normal", "storm" or "update"
self._log = log
self._hw_mgr_svr_proxy = None
self._temp_valid = False
self._over_temp = False
self._under_temp = False
self._power_state = None
self._thermostat_switch_on = True
self._temp = 0
self._hit_data_limit = False
self._cases_sched_state = 1
self._cases_stop_time = None
self._cases_data_limit = None
self._hw_mgr_lock = utils.Lock(self._log)
self._hw_mgr_svr_proxy = utils.set_power_state('cases', 'off',
self._hw_mgr_svr_proxy,
self._hw_mgr_lock,
self._log)
self._power_down_pending = False
def __init__(self, log):
self._log = log
self._max_sync_age = super_config.gps_max_sync_age
self._hw_mgr_server = None
self._hw_mgr_lock = utils.Lock(self._log)
def __init__(self, log):
self._lock = utils.Lock(log)
self._time = time.time()
import sqlite3
import UtilFunc
from baiducloud import errors
import os
import os.path
import re
from functools import wraps
import utils
import threading
logger = UtilFunc.getLogger()
DB_NAME = u'/data/popoCloudData/CloudBackup/baidupcs/CloudBackup.db'
DB_NAME_BACKUP = u'/data/popoCloudData/CloudBackup/baidupcs/CloudBackup.bak'
DB_OP_LOCK = utils.Lock()
DB_DUMP_COUNT_MAX = 100
DB_DUMP_COUNTER = 0
def handle_exceptions(func):
@wraps(func)
def wrapper(*args, **kwargs):
try:
res = func(*args, **kwargs)
except sqlite3.OperationalError, e:
logger.error(str(e))
if str(e) == u'table record already exists':
res = {
u'result': 1,
