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,