import dbus, threading, platform import sqlite3 from syslog import syslog, LOG_DEBUG, LOG_INFO from time import sleep import FileIface import sys from threading import Thread import SyncObject import logConfig import gobject gobject.threads_init() from dbus import glib glib.init_threads() gUseFileIface = False enable_syslog = True enable_console_out = False # define the cache data items as globals to be exported # ... _batteryPower = SyncObject.cSyncObject("batteryPower", maxage=-1) _cycle = SyncObject.cSyncObject("cycle", maxage=-1) _readyState = SyncObject.cSyncObject("readyState", maxage=-1) _systemErr = SyncObject.cSyncObject("systemErr", maxage=-1) _enableState = SyncObject.cSyncObject("enableState", maxage=-1) _wlanConnState = SyncObject.cSyncObject("wlanConnState", maxage=-1) _wlanRssiLevel = SyncObject.cSyncObject("wlanRssiLevel", maxage=-1) _fccTestMode = SyncObject.cSyncObject("fccTestMode", maxage=-1) _wlanActive = SyncObject.cSyncObject("wlanActive", maxage=-1) _newResult = SyncObject.cSyncObject("newResult", maxage=-1) _cfgFileChanged = SyncObject.cSyncObject("cfgFileChanged", maxage=5) _shutdownSig = SyncObject.cSyncObject("shutdownSig", value=-1, maxage=-1) _currentResConnState = SyncObject.cSyncObject("currResConnState", value=-1, maxage=-1) _currentOperationMode = SyncObject.cSyncObject("currOperationmode", value=-1, maxage=-1) # define global signal handler def hSystemSrv_cfgfilechanged(z_c_FilePath): z_c_FilePath = z_c_FilePath.encode('utf-8') if enable_console_out: print 'Received signal hSystemSrv_cfgfilechanged:', str(z_c_FilePath) if enable_syslog: syslog(LOG_DEBUG, "------------------------CfgFileChanged SIGNAL RECEIVED:::{0}-------------------------------".format( z_c_FilePath)) if "ChanCfg.json" in str(z_c_FilePath): _cfgFileChanged.VALUE = z_c_FilePath elif "wlan.json" in str(z_c_FilePath): def forcedGetWlanActive(): import time for i in range(1, 21): time.sleep(2) BusInst.retrieveWlanActive() import thread thread.start_new_thread(forcedGetWlanActive, ()) elif "fcc.json" in str(z_c_FilePath): def forcedGetFccTestMode(): import time for i in range(1, 21): time.sleep(2) BusInst.retrieveFccTestMode() import thread thread.start_new_thread(forcedGetFccTestMode, ()) def _hSystemSrv_battpowerchanged(i_BattPower): if enable_console_out: print 'Received signal SystemSrv_battpowerchanged i_BattPower:', str(i_BattPower), str( _batteryPower.VALUE) _batteryPower.VALUE = i_BattPower if enable_syslog: syslog(LOG_DEBUG, "------------------------battPowerChanged SIGNAL RECEIVED:::{0}-------------------------------".format( i_BattPower)) def _hSystemSrv_battstatuschanged(i_BattStatus): if enable_console_out: print 'Received signal SystemSrv_battstatuschanged i_BattStatus:', str(i_BattStatus) if enable_syslog: syslog(LOG_DEBUG, "------------------------battStatusChanged SIGNAL RECEIVED:::{0}-------------------------------".format( i_BattStatus)) def _hSystemSrv_toolenable(i_ToolEnable): if enable_console_out: print 'Received signal SystemSrv_toolenable i_ToolEnable:', str(i_ToolEnable) _enableState.VALUE = i_ToolEnable if enable_syslog: syslog(LOG_DEBUG, "------------------------toolEnable SIGNAL RECEIVED:::{0}-------------------------------".format( i_ToolEnable)) def _hSystemSrv_rdychanged(i_RdyIst, i_RdySoll): if enable_console_out: print 'Received signal SystemSrv_rdychanged i_RdyIst:', str(i_RdyIst), 'i_RdySoll:', str( i_RdySoll) _readyState.VALUE = (i_RdyIst, i_RdySoll) if enable_syslog: syslog(LOG_DEBUG, "------------------------rdyChanged SIGNAL RECEIVED::Ist:{0}-------------------------------".format( i_RdyIst)) def _hSystemSrv_sysfault(i_SysFault, i_Class, i_Date): if enable_console_out: print "Received signal SystemSrv_sysfault " + "i_SysFault: " + str( i_SysFault), "i_Class: " + str(i_Class), "i_Date: " + str(i_Date) i_SysFault = fetch_db_error_state(i_SysFault) if enable_syslog: syslog(LOG_DEBUG, "------------------------sysFault SIGNAL RECEIVED:::{0}-------------------------------".format( i_SysFault)) def fetch_db_error_state(i_SysFault): con = sqlite3.connect("/var/log/syserrors.sq3") result = con.execute( """SELECT date, code, max(class) FROM syserrors WHERE ack = 0 GROUP BY code ORDER BY class DESC, date DESC;""") row = result.fetchone() if row: i_Date, i_SysFault, i_Class = row syslog(LOG_DEBUG, "Most relevant error found: " + "date: {0}; sysfault: {1}; class: {2}".format(i_Date, i_SysFault, i_Class)) if i_Class > 0: _systemErr.VALUE = (i_SysFault, i_Class, i_Date) else: _systemErr.VALUE = None else: _systemErr.VALUE = None return i_SysFault def _hSystemSrv_acksysfault(i_ErrNr, i_Sysfault): if enable_console_out: print "Received signal SystemSrv_acksysfault " + "i_ErrNr: " + str( i_ErrNr), "i_Sysfault: " + str(i_Sysfault) if i_Sysfault == 0: _systemErr.VALUE = None i_Sysfault = fetch_db_error_state(i_Sysfault) if enable_syslog: syslog(LOG_DEBUG, "------------------------ackSysFault SIGNAL RECEIVED:::{0}-------------------------------".format( i_Sysfault)) def _hSystemSrv_battcntdwn(i_CntDown): if enable_console_out: print "Received signal SystemSrv_battcntdwn " + "i_CntDown: " + str(i_CntDown) if enable_syslog: syslog(LOG_DEBUG, "------------------------battCountdown SIGNAL RECEIVED:::{0}-------------------------------".format( i_CntDown)) def _hSystemSrv_newresult(z_c_DataBasePath, i_DataSet): if enable_console_out: print "Received signal SystemSrv_newresult " + "z_c_DataBasePath: " + str( z_c_DataBasePath), "i_DataSet: " + str(i_DataSet) if enable_syslog: syslog(LOG_DEBUG, "------------------------SystemNewResult SIGNAL RECEIVED:::{0}-------------------------------".format( i_DataSet)) def _hSystemSrv_prgchanged(i_ToolEnable): if enable_console_out: print "Received signal SystemSrv_prgchanged " + "i_ToolEnable: " + str(i_ToolEnable) if enable_syslog: syslog(LOG_DEBUG, "------------------------PrgChanged SIGNAL RECEIVED:::{0}-------------------------------".format( i_ToolEnable)) def _hSystemSrv_newidcode(i_Dev, i_DevActive, z_c_IdCode): if enable_console_out: print "Received signal SystemSrv_newidcode " + "i_Dev: " + str(i_Dev), "i_DevActive: " + str( i_DevActive), "z_c_IdCode: " + str(z_c_IdCode) if enable_syslog: syslog(LOG_DEBUG, "------------------------SystemNewIdCode SIGNAL RECEIVED:::{0}-------------------------------".format( z_c_IdCode)) def _hSystemSrv_bmsinputchanged(): if enable_console_out: print "Received signal SystemSrv_bmsinputchanged" if enable_syslog: syslog(LOG_DEBUG, "------------------------BMSInputChanged SIGNAL RECEIVED-------------------------------") def _hSystemSrv_bmsoutputchanged(): if enable_console_out: print "Received signal SystemSrv_bmsoutputchanged" if enable_syslog: syslog(LOG_DEBUG, "------------------------BMSOutputChanged SIGNAL RECEIVED-------------------------------") def _hResSrv_newresult(z_c_DataBase, i_DataSetNr): if enable_console_out: print "Received signal ResSrv_newresult " + "z_c_DataBase: " + str( z_c_DataBase), "i_DataSetNr: " + str(i_DataSetNr) _newResult.VALUE = i_DataSetNr if enable_syslog: syslog(LOG_DEBUG, "------------------------ResNewResult SIGNAL RECEIVED:::{0}-------------------------------".format( i_DataSetNr)) def _hResSrv_newidcode(i_Dev, i_DevActive, z_c_IdCode): if enable_console_out: print "Received signal ResSrv_newidcode " + "i_Dev: " + str(i_Dev), "i_DevActive: " + str( i_DevActive), "z_c_IdCode: " + str(z_c_IdCode) # _cycle.VALUE = z_c_IdCode if enable_syslog: syslog(LOG_DEBUG, "------------------------IDCODE SIGNAL RECEIVED:::{0}-------------------------------".format( z_c_IdCode)) def _hResSrv_dbrootchanged(): if enable_console_out: print "Received signal ResSrv_dbrootchanged" if enable_syslog: syslog(LOG_DEBUG, "------------------------dbrootchanged SIGNAL RECEIVED-------------------------------") def _hWlan_changed_connection(changed_connection): if enable_console_out: print "Received signal Wlan_changed_connection " + "changed_connection: " + str( changed_connection) _wlanConnState.VALUE = changed_connection _wlanActive.VALUE = BusInst.retrieveWlanActive() if enable_syslog: syslog(LOG_DEBUG, "------------------------WlanChangedConn SIGNAL RECEIVED:::{0}-------------------------------".format( changed_connection)) def _hWlan_changed_rssilevel(i_rssilevel): if enable_console_out: print "Receivedsignal Wlan_changed_rssilevel " + "i_rssilevel: " + str(i_rssilevel) _wlanRssiLevel.VALUE = i_rssilevel if enable_syslog: syslog(LOG_DEBUG, "------------------------WlanChangedRssiLev SIGNAL RECEIVED:::{0}-------------------------------".format( i_rssilevel)) def _hGuiSrv_sysshutdown(i_sig): if enable_console_out: print 'Received signal GuiSrv_system shutdown i_sig:', str(i_sig), str(_shutdownSig.VALUE) _shutdownSig.VALUE = i_sig if enable_syslog: syslog(LOG_DEBUG, "------------------------system shutdown SIGNAL RECEIVED:::{0}-------------------------------".format( i_sig)) def _hGuiSrv_sysconnState(i_connState): if enable_console_out: print 'Received signal _hGuiSrv_sysconnState :', str(i_connState), str(_currentResConnState.VALUE) _currentResConnState.VALUE = i_connState if enable_syslog: syslog(LOG_DEBUG, "------------------------system currentSysConnState SIGNAL RECEIVED:::{0}-------------------------------".format( i_connState)) def _hGuiSrv_sysOperationMode(i_op_mode): if enable_console_out: print 'Received signal _hGuiSrv_sysOperationMode :', str(i_op_mode), str(_currentOperationMode.VALUE) _currentOperationMode.VALUE = i_op_mode if enable_syslog: syslog(LOG_DEBUG, "------------------------system currentOperationMode SIGNAL RECEIVED:::{0}-------------------------------".format( i_op_mode)) # The dbus client class: implements connection interfaces class cDbusClient(object): ''' constructor ''' def __init__(self, waittimeout=10, monSleep=3, waitEnd=10): self.__waittimeout = waittimeout self.__monSleep = monSleep self.__waitEnd = waitEnd self.BUS = None self.dbus_lock = threading.RLock() self.evLoop = None self.evListenersAdded = False self.threadsStarted = False self.evLoopThrd = None self.__monThrd = None self.shutdown = False self.started = False # GUI Interface def self.__guiSrvBus = 'com.rexroth.akku.GUIService' self.__guiSrvPath = '/GUI' self.__guiSrvIface = 'com.rexroth.akku.gui' # Methods: self.__guiSrvMth_fpopupString = 'fpopupString' self.__guiSrvMth_fclosepopupString = 'fclosepopupString' self.__guiSrvMth_setFccTestMode = 'setFccTestMode' self.__guiSrvMth_getFccTestMode = 'getFccTestMode' self.__guiSrvMth_ftestMode = 'ftestMode' self.__guiSrvMth_ftestModeText = 'ftestModeText' self.__guiSrvMth_ftestModeProgressBar = 'ftestModeProgressBar' self.__guiSrvMth_fpruefsoftwarestarted = 'fpruefsoftwarestarted' # Signals: self.guiSrvSig_sysShutdown = 'systemgoingdown' self.guiSrvSig_sysConnState = 'currentResConnState' self.guiSrvSig_sysOperationMode = 'currentOperationMode' # self.guiSrvSig_pruefsoftwarestarted = 'pruefsoftwarestarted' # SYSTEM Interface def self.__sysSrvBus = 'com.rexroth.akku.SysService' self.sysSrvPath = '/SysObj' self.__sysSrvIface = 'com.rexroth.akku.SysInterface' # Methods: self.__sysSrvMth_frdyget = 'frdyget' self.__sysSrvMth_fsyserrorget = 'fsyserrorget' self.__sysSrvMth_ftoolenableget = 'ftoolenableget' self.__sysSrvMth_fcfgfilechanged = 'fcfgfilechanged' self.__sysSrvMth_fbattpowerget = 'fbattpowerget' self.__sysSrvMth_fackerrlist = 'fackerrlist' self.__sysSrvMth_fdelerrlist = 'fdelerrlist' # Signals: self.sysSrvSig_cfgfilechanged = 'cfgfilechanged' self.__sysSrvSig_battpowerchanged = 'battpowerchanged' self.__sysSrvSig_battstatuschanged = 'battstatuschanged' self.__sysSrvSig_rdychanged = 'rdychanged' self.__sysSrvSig_toolenable = 'toolenable' self.__sysSrvSig_sysfault = 'sysfault' self.__sysSrvSig_acksysfault = 'acksysfault' self.__sysSrvSig_battcntdwn = 'battcntdwn' self.__sysSrvSig_newresult = 'newresult' self.__sysSrvSig_prgchanged = 'prgchanged' self.__sysSrvSig_newidcode = 'newidcode' # WLAN Interface def self.__wlanSrvcBus = 'com.rexroth.akku.WlanService' self.__wlanSrvcPath = '/WlanObj' self.__wlanSrvcIface = 'com.rexroth.akku.WlanInterface' # Methods: self.__wlanSrvcMth_fReqGetConnectionStatus = 'fReqGetConnectionStatus' self.__wlanSrvcMth_fReqGetRssiLevel = 'fReqGetRssiLevel' # Signals: self.__wlanSrvcSig_changed_connection = 'changed_connection' self.__wlanSrvcSig_changed_rssilevel = 'changed_rssilevel' # BMS Interface def self.__bmsSrvcBus = 'com.rexroth.akku.BmsService' self.__bmsSrvcPath = '/BmsObj' self.__bmsSrvcIface = 'com.rexroth.akku.BmsInterface' # Methods: # self.__bmsSrvcMth_ = '' # Signals: self.__bmsSrvcSig_bmsinputchanged = 'bmsinputchanged' self.__bmsSrvcSig_bmsoutputchanged = 'bmsoutputchanged' # RES Interface def self.__resSrvcBus = 'com.rexroth.akku.ResService' self.__resSrvcPath = '/ResObj' self.__resSrvcIface = 'com.rexroth.akku.ResInterface' # Methods: # self.__resSrvcMth_ = '' # Signals: self.__resSrvSig_dbrootchanged = 'dbrootchanged' self.__resSrvSig_newresult = 'newresult' self.__resSrvSig_newidcode = 'newidcode' # Worker thread to handle dbus server signals def __eventLoop(self): self.evLoop = gobject.MainLoop() self.evLoop.run() print 'eventLoop exit' # May throw an exception which is caught by web2py def __addEventListeners(self): # when already added do nothing if not self.evListenersAdded and self.BUS != None: # SystemSrv self.BUS.add_signal_receiver(hSystemSrv_cfgfilechanged, signal_name=self.sysSrvSig_cfgfilechanged, dbus_interface=self.__sysSrvIface, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_battpowerchanged, signal_name=self.__sysSrvSig_battpowerchanged, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_battstatuschanged, signal_name=self.__sysSrvSig_battstatuschanged, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_toolenable, signal_name=self.__sysSrvSig_toolenable, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_rdychanged, signal_name=self.__sysSrvSig_rdychanged, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_sysfault, signal_name=self.__sysSrvSig_sysfault, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_acksysfault, signal_name=self.__sysSrvSig_acksysfault, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_battcntdwn, signal_name=self.__sysSrvSig_battcntdwn, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_newresult, signal_name=self.__sysSrvSig_newresult, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_prgchanged, signal_name=self.__sysSrvSig_prgchanged, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_newidcode, signal_name=self.__sysSrvSig_newidcode, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_bmsinputchanged, signal_name=self.__bmsSrvcSig_bmsinputchanged, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hSystemSrv_bmsoutputchanged, signal_name=self.__bmsSrvcSig_bmsoutputchanged, path=self.sysSrvPath) self.BUS.add_signal_receiver(_hResSrv_dbrootchanged, signal_name=self.__resSrvSig_dbrootchanged, path=self.__resSrvcPath) self.BUS.add_signal_receiver(_hResSrv_newresult, signal_name=self.__resSrvSig_newresult, path=self.__resSrvcPath) self.BUS.add_signal_receiver(_hResSrv_newidcode, signal_name=self.__resSrvSig_newidcode, path=self.__resSrvcPath) self.BUS.add_signal_receiver(_hWlan_changed_connection, signal_name=self.__wlanSrvcSig_changed_connection, path=self.__wlanSrvcPath) self.BUS.add_signal_receiver(_hWlan_changed_rssilevel, signal_name=self.__wlanSrvcSig_changed_rssilevel, path=self.__wlanSrvcPath) self.BUS.add_signal_receiver(_hGuiSrv_sysshutdown, signal_name=self.guiSrvSig_sysShutdown, dbus_interface=self.__guiSrvIface, path=self.__guiSrvPath) self.BUS.add_signal_receiver(_hGuiSrv_sysconnState, signal_name=self.guiSrvSig_sysConnState, dbus_interface=self.__guiSrvIface, path=self.__guiSrvPath) self.BUS.add_signal_receiver(_hGuiSrv_sysOperationMode, signal_name=self.guiSrvSig_sysOperationMode, dbus_interface=self.__guiSrvIface, path=self.__guiSrvPath) # Now done self.evListenersAdded = True # May throw an exception which is caught by web2py def __startThreads(self): if self.threadsStarted: return if self.evLoopThrd == None: self.evLoopThrd = Thread(target=self.__eventLoop) if self.evLoopThrd <> None: if not self.evLoopThrd.is_alive(): self.evLoopThrd.start() self.threadsStarted = True # May throw an exception which is caught by web2py def __stopThreads(self): self.shutdown = True if self.evLoopThrd <> None: if self.evLoopThrd.is_alive(): if self.evLoop <> None: self.evLoop.quit() self.evLoopThrd.join(self.__waitEnd) if self.evLoopThrd.is_alive(): print 'Error wait timeout evLoopThrd did not stop' # May throw an exception which is caught by web2py def __dBusConnect(self): # When we are already connected if self.BUS <> None: return dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) if platform.machine().startswith('x86'): self.BUS = dbus.SessionBus() print("Warning: dbus using session bus") else: self.BUS = dbus.SystemBus() def startup(self): # when already started if self.started: return self.__dBusConnect() self.__addEventListeners() self.__startThreads() if self.BUS <> None and self.evListenersAdded and self.threadsStarted: self.started = True def hasStarted(self): return self.started def shutdown(self): if self.started: self.__stopThreads() self.started = False # The methods interface # May throw an exception which is caught by web2py def configurationChanged(self, path): if logConfig.enable_syslog: syslog(LOG_DEBUG, "WGDBus.configurationChanged " + str(path)) if not self.BUS: return self.dbus_lock.acquire() try: self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_fcfgfilechanged, None, [path], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS.configurationChanged via dbus') except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception configurationChanged: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception configurationChanged: ' + sys.exc_info()[0]) self.dbus_lock.release() # def _getBatteryPower(self): locked = False if not self.BUS: return 100 try: self.dbus_lock.acquire() locked = True _batteryPower.VALUE = self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_fbattpowerget, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS._getBatteryPower via dbus: ' + str(_batteryPower.VALUE)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception getBatteryPower: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception getBatteryPower: ' + sys.exc_info()[0]) self.dbus_lock.release() return _batteryPower.VALUE # 1- Battery power from cache def retrieveBatteryPower(self): if _batteryPower.ISINIT: return _batteryPower.VALUE # and _batteryPower.ISVALID: return _batteryPower.VALUE else: res = None if gUseFileIface: res = FileIface.getBatPower() else: res = self._getBatteryPower() _batteryPower.VALUE = res return _batteryPower.VALUE def ackErrorList(self): if not self.BUS: return False self.dbus_lock.acquire() res = True try: self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_fackerrlist, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS.ackErrorList via dbus') except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception ackErrorList: ' + str(e)) res = False except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception ackErrorList: ' + sys.exc_info()[0]) res = False self.dbus_lock.release() return res def delErrorList(self): if not self.BUS: return False self.dbus_lock.acquire() res = True try: self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_fdelerrlist, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS.delErrorList via dbus') except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception delErrorList: ' + str(e)) res = False except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception delErrorList: ' + sys.exc_info()[0]) res = False self.dbus_lock.release() return res def retrieveRdyGet(self): if not self.BUS: return None if _readyState.ISINIT: return _readyState.VALUE # and _readyState.ISVALID: return _readyState.VALUE self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_frdyget, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS.retrieveRdyGet via dbus: ' + str(res)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception rdyGet: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception rdyGet: ' + sys.exc_info()[0]) _readyState.VALUE = res self.dbus_lock.release() return res def sysErrorGet(self): if not self.BUS: return None if _systemErr.ISINIT: return _systemErr.VALUE # and _systemErr.ISVALID: return _systemErr.VALUE self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_fsyserrorget, None, [], timeout=self.__waittimeout) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception sysErrorGet: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception sysErrorGet: ' + sys.exc_info()[0]) _systemErr.VALUE = res self.dbus_lock.release() return res def _toolEnableGet(self): if not self.BUS: return None self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__sysSrvBus, self.sysSrvPath, self.__sysSrvIface, self.__sysSrvMth_ftoolenableget, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS._toolEnableGet via dbus: ' + str(res)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception toolEnableGet: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception toolEnableGet: ' + sys.exc_info()[0]) self.dbus_lock.release() return res def retrieveToolEnableGet(self): if _enableState.ISINIT: return _enableState.VALUE # and _enableState.ISVALID: return _enableState.VALUE else: res = None if gUseFileIface: res = FileIface.toolEnableGet() else: res = self._toolEnableGet() _enableState.VALUE = res return _enableState.VALUE def retrieveCycle(self): if _cycle.ISINIT and _cycle.ISVALID: return _cycle.VALUE else: res = None # !!!------Dbus Signals----- # if gUseFileIface: res = FileIface.getCycle() # endif _cycle.VALUE = res return _cycle.VALUE def _getWlanConnection(self): if not self.BUS: return None self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__wlanSrvcBus, self.__wlanSrvcPath, self.__wlanSrvcIface, self.__wlanSrvcMth_fReqGetConnectionStatus, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS._getWlanConnection via dbus: ' + str(res)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception wlanConnection: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Outer Exception wlanConnection: ' + sys.exc_info()[0]) _wlanConnState.VALUE = res self.dbus_lock.release() return res def retrieveWlanConnection(self): if _wlanConnState.ISINIT: return _wlanConnState.VALUE # and _wlanConnState.ISVALID: return _wlanConnState.VALUE else: res = None if gUseFileIface: res = FileIface.getWlanConnectionStatus() else: res = self._getWlanConnection() _wlanConnState.VALUE = res return _wlanConnState.VALUE def _getWlanRssiLevel(self): if not self.BUS: return None self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__wlanSrvcBus, self.__wlanSrvcPath, self.__wlanSrvcIface, self.__wlanSrvcMth_fReqGetRssiLevel, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS._getWlanRssiLevel via dbus: ' + str(res)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception wlanRssiLevel: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Outer Exception wlanRssiLevel: ' + sys.exc_info()[0]) self.dbus_lock.release() _wlanRssiLevel.VALUE = res return res def retrieveWlanRssiLevel(self): if _wlanRssiLevel.ISINIT: return _wlanRssiLevel.VALUE # and _wlanRssiLevel.ISVALID: return _wlanRssiLevel.VALUE else: res = None if gUseFileIface: res = FileIface.getWlanRssiLevel() else: res = self._getWlanRssiLevel() _wlanRssiLevel.VALUE = res return _wlanRssiLevel.VALUE def wlanRssiLevel(self): # res = None res = self.retrieveWlanRssiLevel() scaledResult = 0 if res and res.real <= -30 and res.real >= -150: if res.real >= -50: scaledResult = 5 elif res.real >= -55: scaledResult = 4 elif res.real >= -65: scaledResult = 3 elif res.real >= -74: scaledResult = 2 elif res.real < -74: scaledResult = 1 return scaledResult def reqWlanDiagnostics(self, name): res = -1 self.dbus_lock.acquire() try: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'calling: reqWlanDiagnostics: ' + 'fReq' + str(name)) self.BUS.call_blocking(self.__wlanSrvcBus, self.__wlanSrvcPath, self.__wlanSrvcIface, 'fReq' + name, None, [], timeout=self.__waittimeout * 3) res = 0 # ok except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception reqWlanDiagnostics: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception reqWlanDiagnostics: ' + sys.exc_info()[0]) self.dbus_lock.release() return res def setFccTestMode(self, active): if not self.BUS: return None self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__guiSrvBus, self.__guiSrvPath, self.__guiSrvIface, self.__guiSrvMth_setFccTestMode, None, [active], timeout=self.__waittimeout) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception fccTestMode: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception fccTestMode: ' + sys.exc_info()[0]) self.dbus_lock.release() return res def retrieveFccTestMode(self): # if _fccTestMode.ISINIT: return _fccTestMode.VALUE # and _fccTestMode.ISVALID: return _fccTestMode.VALUE # else: # res = None if gUseFileIface: res = FileIface.getFccTestModeActive() else: res = self._getFccTestMode() _fccTestMode.VALUE = res return _fccTestMode.VALUE def _getFccTestMode(self): if not self.BUS: return None self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__guiSrvBus, self.__guiSrvPath, self.__guiSrvIface, self.__guiSrvMth_getFccTestMode, None, [], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS._getFccTestMode via dbus: ' + str(res)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception fccTestMode: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception fccTestMode: ' + sys.exc_info()[0]) _fccTestMode.VALUE = res self.dbus_lock.release() return res def retrieve(self, cache, filei_func, _dbus_call): if not cache.ISINIT or not cache.ISVALID: res = None if gUseFileIface: res = filei_func() else: res = _dbus_call() cache.VALUE = res return cache.VALUE def retrieveWlanActive(self): if logConfig.enable_syslog: syslog(LOG_DEBUG, "retrieveWlanActive called is init: " + str( _wlanActive.ISINIT) + ", is valid: " + str(_wlanActive.ISVALID)) # if _wlanActive.ISINIT: return _wlanActive.VALUE # and _wlanActive.ISVALID: return _wlanActive.VALUE # else: res = None # !!!------No Dbus Signal! Use FileIface instead----- # if gUseFileIface: res = FileIface.getWlanActive() # endif _wlanActive.VALUE = res return _wlanActive.VALUE # if (gUseFileIface): # return # return fsio.jsonload(WLAN_FILENAME)['interface'] def pruefsoftware_started(self, active): if not self.BUS: return 'BUS not initialized' self.dbus_lock.acquire() res = None try: res = self.BUS.call_blocking(self.__guiSrvBus, self.__guiSrvPath, self.__guiSrvIface, self.__guiSrvMth_fpruefsoftwarestarted, None, [active], timeout=self.__waittimeout) if logConfig.enable_syslog: syslog(LOG_DEBUG, 'WGDBUS._fpruefsoftwarestarted via dbus: ' + str(res)) except dbus.DBusException as e: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception pruefsoftware started: ' + str(e)) except: if logConfig.enable_syslog: syslog(LOG_DEBUG, 'Exception pruefsoftware started: ' + sys.exc_info()[0]) self.dbus_lock.release() return res def retrieveOperationMode(self): return FileIface.getOperationMode() def retrieveResConnState(self): return FileIface.getResConnState() # End of class cDbusClient # Create the only global client instance to be exported BusInst = cDbusClient() if (not BusInst.hasStarted()): sleep(3) try: BusInst.startup() except: print 'startup Exception:', sys.exc_info()[1] # -------------------------------------------------------------- # Start defining functions for use of old WGDBus functions calls # -------------------------------------------------------------- def configurationChanged(path): BusInst.configurationChanged(path) def ackErrorList(): return BusInst.ackErrorList() def delErrorList(): return BusInst.delErrorList() def reqWlanDiagnostics(name): return BusInst.reqWlanDiagnostics(name) def setFccTestMode(active): return BusInst.setFccTestMode(active) def retrieve(cache, filei_func, _dbus_call): return BusInst.retrieve(cache, filei_func, _dbus_call) def wlanRssiLevel(): return BusInst.wlanRssiLevel() def getWlanActive(): if _wlanActive.ISINIT: return _wlanActive.VALUE return BusInst.retrieveWlanActive() def getFccTestMode(): if _fccTestMode.ISINIT: return _fccTestMode.VALUE return BusInst.retrieveFccTestMode() def wlanConnection(): if _wlanConnState.ISINIT: return _wlanConnState.VALUE return BusInst.retrieveWlanConnection() def getCycle(): return BusInst.retrieveCycle() def toolEnableGet(): if _enableState.ISINIT: return _enableState.VALUE return BusInst.retrieveToolEnableGet() def get_sysfault(): if _systemErr.ISINIT: return _systemErr.VALUE else: fetch_db_error_state(None) def sysErrorGet(): if _systemErr.ISINIT: return _systemErr.VALUE return BusInst.sysErrorGet() def rdyGet(): if _readyState.ISINIT: return _readyState.VALUE return BusInst.retrieveRdyGet() def getBatteryPower(): if _batteryPower.ISINIT: return _batteryPower.VALUE return BusInst.retrieveBatteryPower() def getNewResult(): if _newResult.ISINIT: return True else: return False def getChanCfgChanged(): if _cfgFileChanged.ISINIT and _cfgFileChanged.ISVALID: return True else: return False def getShutdownSignal(): return _shutdownSig.VALUE def getCurrentResConnState(): if _currentResConnState.ISINIT: return _currentResConnState.VALUE return BusInst.retrieveResConnState() def getCurrentOperationMode(): if _currentOperationMode.ISINIT: return _currentOperationMode.VALUE return BusInst.retrieveOperationMode()