def _startstorage(self):
""" start postgresql db and nidus storage manager & connect to db """
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# start necessary storage components
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if not flags['store']:
self.logwrite("Starting PostgreSQL...", gui.LOG_NOTE)
if not startpsql(self._pwd):
self.logwrite("Failed to start PostgreSQL", gui.LOG_ERR)
return
else:
self.logwrite("PostgreSQL started")
# connect to db
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if not flags['conn'] and flags['store']:
self.logwrite("Connected to database...", gui.LOG_NOTE)
self._conn, msg = cmdline.psqlconnect(self._conf['strore'])
if self._conn is None:
self.logwrite(msg, gui.LOG_ERR)
return
else:
self.logwrite("Connected to database")
self._updatestate()
self._menuenable()
def _stopstorage(self):
""" stop posgresql db, nidus storage manager & disconnect """
# if DySKT is running, prompt for clearance
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['dyskt']:
ans = self.ask('DySKT Running','Quit and lose queued data?')
if ans == 'no': return
# return if no storage component is running
if not (flags['store'] or flags['conn'] or flags['nidus']): return
# disconnect from db
if flags['conn']: self._psqldisconnect()
# before shutting down nidus & postgresql, confirm auto shutdown is enabled
if not self._conf['policy']['shutdown']: return
# shutdown nidus
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['nidus']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",gui.LOG_WARN)
return
self._pwd = pwd
self.logwrite("Stopping Nidus...",gui.LOG_NOTE)
if not stopnidus(self._pwd):
self.logwrite("Failed to stop Nidus",gui.LOG_WARN)
else: self.logwrite("Nidus stopped")
# shutdown postgresql (check first if polite)
if self._conf['policy']['polite'] and self._bSQL: return
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['store']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",gui.LOG_WARN)
return
self._pwd = pwd
self.logwrite("Stopping PostgreSQL...",gui.LOG_NOTE)
if not stoppsql(self._pwd):
self.logwrite("Failed to stop PostgreSQL",gui.LOG_WARN)
else: self.logwrite("PostgreSQL stopped")
self._updatestate()
self._menuenable()
def _startsensor(self):
""" starts the Iyri sensor """
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['store'] and not flags['iyri']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# start the sensor
try:
self.logwrite("Starting Iyri...", gui.LOG_NOTE)
cmdline.service('iyrid', self._pwd)
time.sleep(0.5)
if not cmdline.runningservice(wraith.IYRIPID):
raise RuntimeError('unknown')
except RuntimeError as e:
self.logwrite("Error starting Iyri: {0}".format(e),
gui.LOG_ERR)
else:
self.logwrite("Iyri Started")
self._setstate(_STATE_IYRI_)
def psqldelall(self):
""" delete all data in nidus database """
# should not be enabled unless postgres is running, we are connected
# and a sensor is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['store'] and flags['conn'] and not flags['iyri']:
ans = self.ask('Delete Records', 'Delete all DB records?')
self.update()
if ans == 'no': return
curs = None
try:
# get a cursor and execute the delete_all procedure
self.logwrite("Deleting all records in database...",
gui.LOG_NOTE)
curs = self._conn.cursor()
curs.callproc('delete_all')
self._conn.commit()
self.logwrite("Deleted all records")
except psql.Error as e:
self._conn.rollback()
self.logwrite(
"Delete Failed<{0}: {1}>".format(e.pgcode, e.pgerror),
gui.LOG_ERR)
finally:
if curs: curs.close()
def psqlfix(self):
"""
fix any open-ended periods left over by errors. An error or kill -9
may leave periods in certain tables as NULL-ended which will throw an
error during insert of new records
"""
# should not be enabled unless postgres is running, we are connected
# and no sensors are running
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['store'] and flags['conn'] and not flags['iyri']:
curs = None
try:
self.logwrite("Fixing null-ended records in database...",
gui.LOG_NOTE)
curs = self._conn.cursor()
curs.callproc("fix_nullperiod")
self._conn.commit()
self.logwrite("Fixed all null-ended records")
except psql.Error as e:
self._conn.rollback()
self.logwrite(
"Error fixing records <{0}:{1}>".format(
e.pgcode, e.pgerror), gui.LOG_ERR)
finally:
if curs: curs.close()
def _startsensor(self):
""" starts the DySKT sensor """
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['store'] and flags['nidus'] and not flags['dyskt']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# start the sensor
try:
self.logwrite("Starting DySKT...", gui.LOG_NOTE)
cmdline.service('dysktd', self._pwd)
time.sleep(0.5)
if not cmdline.dysktrunning(wraith.DYSKTPID):
raise RuntimeError('unknown')
except RuntimeError as e:
self.logwrite("Error starting DySKT: %s" % e, gui.LOG_ERR)
else:
self.logwrite("DySKT Started")
self._setstate(_STATE_DYSKT_)
def disconnect(self):
""" connects to postgresql """
# NOTE: should not be enabled if already disconnected but check anyway
# TODO: what to do once we have data being pulled?
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['conn']:
self._psqldisconnect()
self._updatestate()
self._menuenable()
def connect(self):
""" connects to postgresql """
# NOTE: this should not be enabled unless psql is running and we are
# not connected, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['conn']:
psqlconnect(self._conf['store'])
self._updatestate()
self._menuenable()
def _startstorage(self):
""" start postgresql db and nidus storage manager & connect to db """
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",gui.LOG_WARN)
return
self._pwd = pwd
# start necessary storage components
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['store']:
self.logwrite("Starting PostgreSQL...",gui.LOG_NOTE)
if not startpsql(self._pwd):
self.logwrite("Failed to start PostgreSQL",gui.LOG_ERR)
return
else:
self.logwrite("PostgreSQL started")
# start nidus
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['nidus'] and flags['store']:
self.logwrite("Starting Nidus...",gui.LOG_NOTE)
if not startnidus(self._pwd):
self.logwrite("Failed to start Nidus",gui.LOG_ERR)
return
else:
self.logwrite("Nidus started")
# connect to db
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['conn'] and flags['store']:
self.logwrite("Connected to database...",gui.LOG_NOTE)
self._conn,msg = psqlconnect(self._conf['strore'])
if self._conn is None:
self.logwrite(msg,gui.LOG_ERR)
return
else:
self.logwrite("Connected to database")
self._updatestate()
self._menuenable()
def _startstorage(self):
""" start postgresql db and nidus storage manager & connect to db """
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",gui.LOG_WARN)
return
self._pwd = pwd
# start necessary storage components
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['store']: self._startpsql()
# start nidus
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['nidus'] and flags['store']: self._startnidus()
# connect to db
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['conn'] and flags['store']: self._psqlconnect()
def _startstorage(self):
""" start postgresql db and nidus storage manager & connect to db """
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# start necessary storage components
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if not flags['store']: self._startpsql()
# start nidus
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if not flags['nidus'] and flags['store']: self._startnidus()
# connect to db
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if not flags['conn'] and flags['store']: self._psqlconnect()
def nidusstop(self):
""" stops nidus storage manager """
# should not be enabled if nidus is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['nidus']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
self._stopnidus()
self._updatestate()
self._menuenable()
def nidusstop(self):
""" stops nidus storage manager """
# should not be enabled if nidus is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['nidus']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
self._stopnidus()
self._updatestate()
self._menuenable()
def psqlstop(self):
""" starts postgresql """
# should not be enabled if postgresql is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['store'] and not flags['dyskt']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
self._stoppsql()
self._updatestate()
self._menuenable()
def psqlstop(self):
""" starts postgresql """
# should not be enabled if postgresql is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['store'] and not flags['dyskt']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
self._stoppsql()
self._updatestate()
self._menuenable()
def nidusstart(self):
""" starts nidus storage manager """
# NOTE: should not be enabled if postgresql is not running but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['nidus']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
if startnidus(self._pwd):
self._updatestate()
self._menuenable()
else:
self.logwrite("Failed to start Nidus",gui.LOG_ERR)
def psqlstart(self):
""" starts postgresql """
# NOTE: should not be enabled if postgresql is already running but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if not flags['store']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
self.logwrite("Starting Postgresql...",gui.LOG_NOTE)
if startpsql(self._pwd):
self.logwrite('Postgresql started')
self._updatestate()
self._menuenable()
else:
self.logwrite("Postgresql failed to start")
def psqldelall(self):
""" delete all data in nidus database """
# should not be enabled unless postgres is running, we are connected
# and a sensor is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['store'] and flags['conn'] and not flags['dyskt']:
ans = self.ask('Delete Records','Delete all DB records?')
if ans == 'no': return
curs = None
try:
# get a cursor and execute the delete_all procedure
self.logwrite("Deleting all records in database...",gui.LOG_NOTE)
curs = self._conn.cursor()
curs.callproc('delete_all')
self._conn.commit()
self.logwrite("Deleted all records")
except psql.Error as e:
self._conn.rollback()
self.logwrite("Delete Failed<%s: %s>" % (e.pgcode,e.pgerror),gui.LOG_ERR)
finally:
if curs: curs.close()
def _stopsensor(self):
""" stops the DySKT sensor """
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['dyskt']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# stop the sensor
try:
self.logwrite("Shutting down DySKT...",gui.LOG_NOTE)
cmdline.service('dysktd',self._pwd,False)
except RuntimeError as e:
self.logwrite("Error shutting down DySKT: %s" % e,gui.LOG_ERR)
else:
self._setstate(_STATE_DYSKT_,False)
self.logwrite("DySKT shut down")
def psqlfix(self):
"""
fix any open-ended periods left over by errors. An error or kill -9
may leave periods in certain tables as NULL-ended which will throw an
error during insert of new records
"""
# should not be enabled unless postgres is running, we are connected
# and a sensor is not running, but check anyway
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['store'] and flags['conn'] and not flags['dyskt']:
curs = None
try:
self.logwrite("Fixing null-ended records in database...",gui.LOG_NOTE)
curs = self._conn.cursor()
curs.callproc("fix_nullperiod")
self._conn.commit()
self.logwrite("Fixed all null-ended records")
except psql.Error as e:
self._conn.rollback()
self.logwrite("Error fixing records <%s: %s>" % (e.pgcode,e.pgerror),
gui.LOG_ERR)
finally:
if curs: curs.close()
def _stopsensor(self):
""" stops the Iyri sensor """
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
if flags['iyri']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# stop the sensor
try:
self.logwrite("Shutting down Iyri...", gui.LOG_NOTE)
cmdline.service('iyrid', self._pwd, False)
except RuntimeError as e:
self.logwrite("Error shutting down Iyri: {0}".format(e),
gui.LOG_ERR)
else:
self._setstate(_STATE_IYRI_, False)
self.logwrite("Iyri shut down")
def _startsensor(self):
""" starts the DySKT sensor """
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
if flags['store'] and flags['nidus'] and not flags['dyskt']:
# do we have a password
if not self._pwd:
pwd = self._getpwd()
if pwd is None:
self.logwrite("Password entry canceled. Cannot continue",
gui.LOG_WARN)
return
self._pwd = pwd
# start the sensor
try:
self.logwrite("Starting DySKT...",gui.LOG_NOTE)
cmdline.service('dysktd',self._pwd)
time.sleep(0.5)
if not cmdline.dysktrunning(wraith.DYSKTPID): raise RuntimeError('unknown')
except RuntimeError as e:
self.logwrite("Error starting DySKT: %s" % e,gui.LOG_ERR)
else:
self.logwrite("DySKT Started")
self._setstate(_STATE_DYSKT_)
def psqlisrunning(self):
return bits.bitmask_list(_STATE_FLAGS_, self._state)['store']
def isconnected(self):
return bits.bitmask_list(_STATE_FLAGS_, self._state)['conn']
def _menuenable(self):
""" enable/disable menus as necessary """
# get all flags
flags = bits.bitmask_list(_STATE_FLAGS_,self._state)
# adjust storage menu
# easiest for storage is to disable all and then only enable relevant
# always allow Nidus->config, Nidus->View Log
self.mnuStorage.entryconfig(0,state=tk.DISABLED) # all start
self.mnuStorage.entryconfig(1,state=tk.DISABLED) # all stop
self.mnuStoragePSQL.entryconfig(0,state=tk.DISABLED) # psql start
self.mnuStoragePSQL.entryconfig(1,state=tk.DISABLED) # psql stop
self.mnuStoragePSQL.entryconfig(3,state=tk.DISABLED) # connect 2 psql
self.mnuStoragePSQL.entryconfig(4,state=tk.DISABLED) # disconnect from psql
self.mnuStoragePSQL.entryconfig(6,state=tk.DISABLED) # psql fix
self.mnuStoragePSQL.entryconfig(7,state=tk.DISABLED) # psql delete all
self.mnuStorageNidus.entryconfig(0,state=tk.DISABLED) # nidus start
self.mnuStorageNidus.entryconfig(1,state=tk.DISABLED) # nidus stop
self.mnuNidusLog.entryconfig(1,state=tk.DISABLED) # nidus log clear
if flags['store']:
# storage is running enable stop all, stop postgresql (if dyskt is
# not running)
self.mnuStorage.entryconfig(1,state=tk.NORMAL)
if not flags['dyskt']: self.mnuStoragePSQL.entryconfig(1,state=tk.NORMAL)
else:
# storage is not running, enable start all, start postgresql
self.mnuStorage.entryconfig(0,state=tk.NORMAL)
self.mnuStoragePSQL.entryconfig(0,state=tk.NORMAL)
if flags['nidus']:
# nidus is running, enable stop all, stop nidus
self.mnuStorage.entryconfig(1,state=tk.NORMAL)
self.mnuStorageNidus.entryconfig(1,state=tk.NORMAL)
else:
# nidus is not running, enable start all & clear nidus log
# enable start nidus only if postgres is running
self.mnuStorage.entryconfig(0,state=tk.NORMAL)
self.mnuStorageNidus.entryconfig(0,state=tk.NORMAL)
self.mnuNidusLog.entryconfig(1,state=tk.NORMAL)
if flags['conn']:
# connected to psql, enable stop all and disconnect
# if no DysKT is running, enable fix psql and delete all
self.mnuStorage.entryconfig(1,state=tk.NORMAL)
self.mnuStoragePSQL.entryconfig(4,state=tk.NORMAL)
if not flags['dyskt']:
self.mnuStoragePSQL.entryconfig(6,state=tk.NORMAL) # psql fix
self.mnuStoragePSQL.entryconfig(7,state=tk.NORMAL) # psql delete all
else:
# disconnected, enable start all, enable connect if postgres is running
self.mnuStorage.entryconfig(0,state=tk.NORMAL)
if flags['store']: self.mnuStoragePSQL.entryconfig(3,state=tk.NORMAL)
# adjust dyskt menu
if not flags['store'] and not flags['nidus']:
# cannot start/stop/control dyskt unless nidus & postgres is running
self.mnuDySKT.entryconfig(0,state=tk.DISABLED) # start
self.mnuDySKT.entryconfig(1,state=tk.DISABLED) # stop
self.mnuDySKT.entryconfig(3,state=tk.DISABLED) # ctrl panel
self.mnuDySKTLog.entryconfig(1,state=tk.NORMAL) # clear log
self.mnuDySKT.entryconfig(7,state=tk.NORMAL) # configure
else:
if flags['dyskt']:
# DySKT sensor is running
self.mnuDySKT.entryconfig(0,state=tk.DISABLED) # start
self.mnuDySKT.entryconfig(1,state=tk.NORMAL) # stop
self.mnuDySKT.entryconfig(3,state=tk.NORMAL) # ctrl panel
self.mnuDySKTLog.entryconfig(1,state=tk.DISABLED) # clear log
self.mnuDySKT.entryconfig(7,state=tk.NORMAL) # configure
else:
# DySKT sensor is not running
self.mnuDySKT.entryconfig(0,state=tk.NORMAL) # start
self.mnuDySKT.entryconfig(1,state=tk.DISABLED) # stop
self.mnuDySKT.entryconfig(3,state=tk.DISABLED) # ctrl panel
self.mnuDySKTLog.entryconfig(1,state=tk.NORMAL) # clear log
self.mnuDySKT.entryconfig(7,state=tk.NORMAL) # configure
def iyriisrunning(self):
return bits.bitmask_list(_STATE_FLAGS_, self._state)['iyri']
def isexiting(self):
return bits.bitmask_list(_STATE_FLAGS_, self._state)['exit']
def mcsknown_list(mn): return bitmask_list(_MCS_KNOWN_,mn) def mcsknown_get(mn,f):
def present_list(mn): return bitmask_list(_PRESENT_,mn) def present_get(mn,f):
def getstateflags(self): return bits.bitmask_list(_STATE_FLAGS_,self._state)
#### OVERRIDES
def _initialize(self):
def vhtcoding_list(mn): return bitmask_list(_VHT_CODING_,mn) def vhtcoding_get(mn,f):
def vhtknown_list(mn): return bitmask_list(_VHT_KNOWN_,mn) def vhtknown_get(mn,f):
def ampduflags_list(mn): return bitmask_list(_AMPDU_FLAGS_,mn) def ampduflags_get(mn,f):
def _menuenable(self):
""" enable/disable menus as determined by the current state """
# get all flags
flags = bits.bitmask_list(_STATE_FLAGS_, self._state)
# view sessions
if flags['conn']: self._mnuData.entryconfig(4, state=tk.NORMAL)
else: self._mnuData.entryconfig(4, state=tk.DISABLED)
# start/stop postgres
if flags['store']:
# disable start, enable stop (if Iyri is not running)
self._mnuStorage.entryconfig(0, state=tk.DISABLED)
if not flags['iyri']:
self._mnuStorage.entryconfig(1, state=tk.NORMAL)
else:
# enable start and disable stop
self._mnuStorage.entryconfig(0, state=tk.NORMAL)
self._mnuStorage.entryconfig(1, state=tk.DISABLED)
# connect/disconnect 2 postgres
if flags['conn']:
# disable connect and enable disconnect
self._mnuStorage.entryconfig(3, state=tk.DISABLED)
self._mnuStorage.entryconfig(4, state=tk.NORMAL)
else:
# enable connect and disable disconnect
self._mnuStorage.entryconfig(3, state=tk.NORMAL)
self._mnuStorage.entryconfig(4, state=tk.DISABLED)
# fix db and delete all (only allowed if connected and Iyri is not running)
if flags['conn']:
if flags['iyri']:
self._mnuStorage.entryconfig(6, state=tk.DISABLED)
self._mnuStorage.entryconfig(7, state=tk.DISABLED)
else:
self._mnuStorage.entryconfig(6, state=tk.NORMAL)
self._mnuStorage.entryconfig(7, state=tk.NORMAL)
else:
self._mnuStorage.entryconfig(6, state=tk.DISABLED)
self._mnuStorage.entryconfig(7, state=tk.DISABLED)
# Iyri
if not flags['store']:
# cannot start/stop/control Iyri unless postgres is running
self._mnuIyri.entryconfig(0, state=tk.DISABLED) # start
self._mnuIyri.entryconfig(1, state=tk.DISABLED) # stop
#### TODO: uncomment below after test ctrl panel
#self._mnuIyri.entryconfig(3,state=tk.DISABLED) # ctrl panel
self._mnuIyriLog.entryconfig(1, state=tk.NORMAL) # clear log
self._mnuIyri.entryconfig(7, state=tk.NORMAL) # configure
else:
if flags['iyri']:
# Iyri sensor is running
self._mnuIyri.entryconfig(0, state=tk.DISABLED) # start
self._mnuIyri.entryconfig(1, state=tk.NORMAL) # stop
self._mnuIyri.entryconfig(3, state=tk.NORMAL) # ctrl panel
self._mnuIyriLog.entryconfig(1, state=tk.DISABLED) # clear log
self._mnuIyri.entryconfig(7, state=tk.NORMAL) # configure
else:
# Iyri sensor is not running
self._mnuIyri.entryconfig(0, state=tk.NORMAL) # start
self._mnuIyri.entryconfig(1, state=tk.DISABLED) # stop
#### TODO: uncomment below after test ctrl panel
#self._mnuIyri.entryconfig(3,state=tk.DISABLED) # ctrl panel
self._mnuIyriLog.entryconfig(1, state=tk.NORMAL) # clear log
self._mnuIyri.entryconfig(7, state=tk.NORMAL) # configure
def chflags_list(mn): return bitmask_list(_CHANNEL_FLAGS_,mn) def chflags_get(mn,f):
def rxflags_list(mn): return bitmask_list(_RX_FLAGS_,mn) def rxflags_get(mn,f):
