packetMonitorImpl.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "GLAST ISOC Packet Monitor"
__author__   = "A. Kavelaars <aliciak@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "19/10/2005"
__version__  = "$Revision: 1.16 $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import sys, struct #, os
import traceback
import asyncore, psycopg
import threading
import time
from   binascii                                       import hexlify
from   qt                                             import *
import ConfigParser
import LICOS.util.gOptions                            as     gOptions
#~ from   LCAT_tlm_db                                    import TlmApidDict
from   LICOS.lib.cmdTlmDb.LCATtlmDb                   import LCATtlmDb 
from   LICOS.lib.cmdTlmDb.LCATtlmDb                   import LICOS_TlmPacketFactory
#~ from   LICOS.lib.cmdTlmDb.LCATtlmDb                   import LICOS_TlmPacketFactory
from   ISOC.ProductUtils                              import ProductSpan
from   ISOC.TlmUtils.SpecialDecom                     import *
from   ISOC.TlmUtils.TlmRdbInterface                  import TlmRdbDb
from   LICOS.lib.currValTable.CurrValClient           import CurrValClient
from   LICOS.core.thread.guiBridges                   import GUIbridge
from   LICOS.tools.monitor.packetMonitor              import packetMonitor
from   LICOS.tools.monitor.packetMonitorPrinter       import packetMonitorPrinter
from   LICOS.tools.monitor.packetMonitorPrefsImpl     import packetMonitorPrefsImpl
from   LICOS.tools.proxy.VscProxyPorts                import VscProxyPorts

# Define kill event.
killEvent = threading.Event()
killEvent.clear()

def asyncore_loop(timeout=1.0, use_poll=False, map=None):
  """replace the asyncore central loop and run it in its own thread.
     Valid for Python 2.3.x
     Python 2.4 has an extra agument for loop, count.
  """
  if map is None:
      map = asyncore.socket_map

  if use_poll:
    if hasattr(select, 'poll'):
      poll_fun = asyncore.poll3
    else:
      poll_fun = asyncore.poll2
  else:
    poll_fun = asyncore.poll

  while map and not killEvent.isSet():
    poll_fun(timeout, map)

class CvtPacketMonitorClient(CurrValClient):
  """ Class that connects to CVT as a client and passes packet 
      information to the PacketMonitor GUI. It uses SpecialDecom
      to decom the packet payload information.
      
      \param host       CVT host.
      \param port       CVT port.
      \param mnemList   List of apid mnemonics to look into.
      \param tlmdb      Postgress Telemetry database CVT is connected to.
      \param guiBridge  Qt Command Handler.
  """
      
  def __init__(self, host, port, mnemList, tlmdb, gui, guiBridge):
    CurrValClient.__init__(self, host, port, mnemList=mnemList)
    self.__items = {}
    self.__gui = gui
    self.__guiBridge = guiBridge
    self.__tlmdb = tlmdb
 
  def update(self, cv):
    self.__guiBridge.execGUImethodNR(self.__gui, self.__update, cv)

  def __update(self, cv):
    # Process all mnemonics from CVT. May be needed in the future
    #~ if cv.name not in self.__items:
      #~ self.__items[cv.name] = QListViewItem(self.__gui.telemView)
      #~ self.__items[cv.name].setText(0, cv.name)
    #self.__items[cv.name].setText( 1, str(len(raw)) )
    #~ egu = raw
    #~ mObj = self.__tlmdb.mnem(cv.name)
    #~ if mObj is not None:
      #~ egu = mObj.conversion().egu(raw)
      #~ self.__items[cv.name].setText( 2, str(egu) )
    raw = cv.rawValue()

    # Pick up apids 720 and 725 and process them with SpecialDecom
    appIdPkt = LICOS_TlmPacketFactory(raw)
    ts = appIdPkt.secs  
    tu = appIdPkt.usecs/1E6
    appTime = ProductSpan.utcfromtimestamp( ts, tu )
    appSeq = appIdPkt.seqNum
    appLen = appIdPkt.length
    try:
      pktHdr = struct.unpack('!HHH', raw[:6])
      appId = ( pktHdr[0] & 0x07FF )
    except:
      appId = 0
    #~ print appId
    if appId in (720, 725):
      if appId == 720:
        pktCli = CmdRespDecom(self.__gui.callBackCMDMon)
      elif appId == 725:
        pktCli = FswMsgDecom(self.__gui.callBackFSWMon)
      pktCli.decom(appId, raw)
    
    # Pick up ALL apids and show them for the CCSDS Monitor
    if not self.__gui.pauseCCSDSButton.isOn():
      if self.__gui.filterByAPIDButton.isOn():
        if str(appId) != str(self.__gui.apid.text()):
          return
      raw = hexlify(raw)
      rawList = list(raw)
      finalPos = len(rawList)
      pos = 0
      binList = []
      while pos < finalPos:
        item = rawList[pos] + rawList[pos+1]
        binList.append(item)
        pos += 2
      #~ print binList
      finalPos = len(binList)
      offset = 0
      pos = 0
      finalList = ""
      while offset < finalPos:
        item = binList[offset]
        line = "%08X" % (offset) + " "
        for i in range(0, 32):
          try:
            line += " " + binList[offset]
            offset += 1
          except:
            pass
        #~ print line
        finalList += line + "\n" 
      #~ print finalList
      self.__gui.CCSDSView.setText(str(finalList))  
      self.__gui.apid.setText(str(appId))
      self.__gui.time.setText(str(appTime))
      self.__gui.seqN.setText(str(appSeq))
      self.__gui.size.setText(str(appLen))


class packetMonitorImpl(packetMonitor):
  def __init__(self,cvtHost,cvtPort,tlmdb,parent = None,name = None,fl = 0):
    packetMonitor.__init__(self,parent,name,fl)
    
    # Define Configuration Parser and Preferences Dialog
    self.__confParser = ConfigParser.ConfigParser()
    self.__prefsGUI = packetMonitorPrefsImpl(self.__confParser, self)
    self.passRowValues()
    
    self.__guiBridge = GUIbridge(threading.currentThread())
    self.__items = {}
    
    self.CMDView.setSorting(-1)
    self.FSWView.setSorting(-1)
  
    # Define Packet Lists to be filled when Pause buttons are pressed
    self.__FSWPacketList = []
    self.__CMDPacketList = []

    # Load mnemonics list.
    self.obtainMnemonics()
    #~ self.__mnemList = ['CmdConfirm', 'LCMMSGOUTC']    
  
    # Launch CVT client
    self.__client = CvtPacketMonitorClient(cvtHost,cvtPort,self.__mnemList,tlmdb,self,self.__guiBridge)
    
    # Initialize Context Menu and Clipboard
    self.contextMenu = QPopupMenu(self)
    self.contextMenu.insertItem("Copy Ce&ll", self.copyToClipboard,    Qt.CTRL+Qt.Key_L)
    self.contextMenu.insertItem("Copy &Row",  self.copyRowToClipboard, Qt.CTRL+Qt.Key_R)
    self.clip = QApplication.clipboard()  
    
    #self.connect(self.refreshTelemButton, SIGNAL("clicked()"), self.plot)
    #self.connect(self.refreshCommButton,  SIGNAL("clicked()"), self.plot)
    self.connect(self.FSWView,SIGNAL("currentChanged(QListViewItem*)"),self.showFSWEntries)
    self.connect(self.CMDView,SIGNAL("currentChanged(QListViewItem*)"),self.showCMDEntries)
    
    self.connect(self.refreshFSWButton,   SIGNAL("clicked()"),       self.refreshFSWMon)
    self.connect(self.refreshCMDButton,   SIGNAL("clicked()"),       self.refreshCMDMon)
    self.connect(self.pauseFSWButton,     SIGNAL("clicked()"),       self.pauseFSWMon)
    self.connect(self.pauseCMDButton,     SIGNAL("clicked()"),       self.pauseCMDMon)
    self.connect(self.pauseCCSDSButton,   SIGNAL("clicked()"),       self.pauseCCSDSMon)
    self.connect(self.apid,               SIGNAL("returnPressed()"), self.filterByAPID)
    self.connect(self.apid,               SIGNAL("lostFocus()"),     self.filterByAPID)
    self.connect(self.filterByAPIDButton, SIGNAL("clicked()"),       self.filterByAPID)
    self.connect(self.printFSWButton,     SIGNAL("clicked()"),       self.printFSWMon)
    self.connect(self.printCMDButton,     SIGNAL("clicked()"),       self.printCMDMon)
    self.connect(self.commitButton,       SIGNAL("clicked()"),       self.closeGUI)
    
    # Access Preferences
    self.connect(self.menuPreferencesAction, SIGNAL("activated()"), self.accessPrefs)

    # Initialize Context Menu
    self.connect(self.FSWView,
                 SIGNAL("contextMenuRequested(QListViewItem*,const QPoint&,int)"),
                 self.FSWContextMenuShow)
    self.connect(self.CMDView,
                 SIGNAL("contextMenuRequested(QListViewItem*,const QPoint&,int)"),
                 self.CMDContextMenuShow)

  def FSWContextMenuShow(self, item, point, col):
    """ Show context menu for FSW Message Monitor.
        \param item   Current item.
        \param point  Current cursor position.
        \param col    Current col position.
    """
    self.contextMenuShow(self.telemView, item, point, col)
    
  def CMDContextMenuShow(self, item, point, col):
    """ Show context menu for CMD Message Monitor.
        \param item   Current item.
        \param point  Current cursor position.
        \param col    Current col position.
    """
    self.contextMenuShow(self.commView, item, point, col)

  def contextMenuShow(self, view, item, point, col):
    """ Pass current information to context menu and 
        execute it.
        \param view   Current view: FSW Message or CMD Response
                      Monitor.
        \param item   Current item.
        \param point  Current cursor position.
        \param col    Current col position.
    """
    if item is not None:
      self.__contextCell = item.text(col)
      text = ""
      numCols = view.columns()
      for j in range(0,numCols):
        text += str(item.text(j)) + " "
      self.__contextRow = text
      self.contextMenu.exec_loop(point, 0)

  def copyToClipboard(self):
    """ Pass selected item text to clipboard.
    """
    self.clip.setText(self.__contextCell)

  def copyRowToClipboard(self):
    """ Pass selected row text to clipboard.
    """
    self.clip.setText(self.__contextRow)

  def obtainMnemonics(self):
    """ Obtain Mnemonic appid dictionary.
    """
    LCAT = LCATtlmDb()
    self.__mnemList = LCAT.getNames()
    
    # Obsolete, obtain mnemonics from LICOS lib instead
    #~ apidDict = TlmApidDict()
    #~ self.__mnemList = []
    #~ for apid in apidDict.apids:
      #~ mnem = apidDict.apids[apid]
      #~ self.__mnemList.append(mnem)
  
  def decomPacket(self, packet):
    """ Not used at the moment.
    """
    # assuming packet is a packet from the CVT    
    pktStr = packet
    pktHdr = struct.unpack('!HHH', packet)
    apId = ( pktHdr[0] & 0x07FF )    
    # Decon packet using Bryson's 
    self.__sd.decom( apid, pktStr)
  
  def callBackFSWMon( self, dataDict ):
    """ Handle decom callback for FSW Response Packet.
    """
    if self.pauseFSWButton.isOn():
      self.appendFSWPacket(dataDict)
    else:
      self.displayFSWPacket(dataDict)
  
  def appendFSWPacket(self, dataDict):
    """ If pause FSW Message Monitor Button is on,
        append packet data to list.
    """    
    self.__FSWPacketList.append(dataDict)
  
  def displayFSWPacket(self, dataDict):
    """ If pause FSW Message Monitor Button is off, 
        display packet data in monitor.
    """
    listItem = QListViewItem(self.FSWView)  
    listItem.setText(0, "%s"           % dataDict['time'])
    listItem.setText(1, "%-4s"         % dataDict['node'])
    listItem.setText(2, "%-4s"         % dataDict['facility'])
    listItem.setText(3, "%-8s"         % dataDict['task'])
    listItem.setText(4, "%-32s"        % dataDict['function'])
    listItem.setText(5, "0x%08X"       % dataDict['code'])
    listItem.setText(6, "%-8s"         % dataDict['name'])
    listItem.setText(7, "%s"           % dataDict['text'])
    listItem.setText(8, "0x%04X"       % dataDict['trace'])
    listItem.setText(9, "0x%04X"       % dataDict['isr'])
    self.preventSaturation(self.FSWView, self.pauseFSWButton)

  def callBackCMDMon( self, dataDict ):
    """ Handle decom callback for CMD Response Packet.
    """
    if self.pauseCMDButton.isOn():
      #~ print "pause button is on"
      self.appendCMDPacket(dataDict)
    else:
      self.displayCMDPacket(dataDict)
  
  def appendCMDPacket(self, dataDict):
    """ If pause CMD Response Monitor Button is on, 
        append packet data to list.
    """
    self.__CMDPacketList.append(dataDict)
  
  def displayCMDPacket(self, dataDict):
    """ If pause CMD Response Monitor Button is off, 
        display packet data in monitor.
    """
    listItem = QListViewItem(self.CMDView)  
    listItem.setText(0, "%s"           % dataDict['exetime'])
    listItem.setText(1, "%s"           % dataDict['node'])
    listItem.setText(2, "%s"           % dataDict['task'])
    listItem.setText(3, "0x%03X(%04d)" % (dataDict['apid'],  dataDict['apid']))
    listItem.setText(4, "0x%04X(%05d)" % (dataDict['fcode'], dataDict['fcode']))
    listItem.setText(5, "0x%1X"        % dataDict['status'])
    listItem.setText(6, "%s"           % dataDict['payload'])
    self.preventSaturation(self.CMDView, self.pauseCMDButton)

  def preventSaturation(self, view, pauseButton):
    """ This function prevents the saturation of the FSWMsg and CMDResp list views.
        When the list view reaches MAX_ENTRIES, it will delete DELETE_ENTRIES list
        view items starting at the bottom. Since this is done at the bottom of the 
        list, the thread needs not to be paused.
        
        \param view    List View: FSWMsg view or CMDResp view.
    """
    #~ lastItem = view.lastChild()
    if view.childCount() >= self.maxRow:
      #~ pauseButton.setOn(1)
      iterator = QListViewItemIterator(view.lastItem())
      #~ print lastItem.text(0)
      iterator -= (self.delRow)
      item = iterator.current()
      while item is not None:
        saveItem = item.nextSibling()
        view.takeItem(item)
        item = saveItem
      #~ self.displayPacketList(view)
      #~ self.pauseButton.setOn(0)
  
  def passRowValues(self):
    """ Obtains Montior's maximum number of rows and number of rows deleted
        when this limit is reached from the user's preferences config file.
    """
    self.maxRow = int(str(self.__prefsGUI.maxRow.text()))
    self.delRow = int(str(self.__prefsGUI.delRow.text()))
    #~ print self.maxRow, self.delRow

  def customEvent(self, e):
    """This method overrides the QObject base class's.  There is generally
    no reason to call this method directly.  It is called by the Qt
    infrastructure whenever the custom event is posted, e.g. by the following
    three methods of this class: createGUI, execGUImethodNR and execGUImethod.
    """
    self.__guiBridge.handleCustomEvent(e)
    
  def quit(self):
    """ This method shuts down the gui bridge so that no update event is called
        once the QApp has quit. It is called in the __main__ portion of the 
        script.
    """
    self.__guiBridge.shutdown()
  
  def showFSWEntries(self):
    """ Displays in the status bar current number of packets 
        displayed in the FSW Message Monitor.
    """
    self.showEntries(self.FSWView, "FSW Message Monitor")

  def showCMDEntries(self):
    """ Displays in the status bar current number of packets 
        displayed in the CMD Message Monitor.
    """
    self.showEntries(self.CMDView, "CMD Response Monitor")
  
  def showEntries(self, view, viewName):
    """ Displays in the status bar current number of packets 
        displayed in the selected monitor.
        
        \param view           Selected Monitor: FSW Message or CMD Response.
        \param viewName       Monitor caption.
    """
    self.statusBar().message('Number of entries in ' + viewName + \
                             ': ' + str(view.childCount()), 2000)
  
  def accessPrefs(self):
    """ Excutes Preferences Dialog.
    """
    self.__prefsGUI.exec_loop()
  
  def fileOpen(self):
    """ Loads data from a file. TBD
    """
    self.statusBar().message('File Open not Implemented Yet.') 
    #self.obtainMnemonics()
    #~ path = os.path.join(os.environ['TOOLS_ROOT'],'Online/LICOS/lib/packetMonitor/Data')
    #~ self.__fn = str(QFileDialog.getOpenFileName(path, "(*.*)", self))

    #try:
    #~ pktCli = CmdRespDecom(self.callBackCmdList)
    #~ pktf = PktFile(self.__fn, pktCli, 1)
    # Obtain packets from file here, something that feeds into
    #~ pktCli.decom(apId, raw) 
    #~ instead of
    #~ pktf.dumpPkts()
    # Something like:
    # Plot data This will work for TelCom data instead of CVT way.
    #for packet in packetList:
      #self.decomPacket( packet )
  
  def refreshFSWMon(self):
    """ Clears rows in FSW Message Monitor.
    """
    self.FSWView.clear()

  def refreshCMDMon(self):
    """ Clears rows in CMD Response Monitor.
    """
    self.CMDView.clear()
  
  def pauseFSWMon(self):
    """Handles stored FSW Message Packets upon FSW Pause button click event.
    """
    pauseButton = self.pauseFSWButton
    if not pauseButton.isOn():
      for packet in self.__FSWPacketList:
        self.displayFSWPacket(packet)
      self.__FSWPacketList = []
      pauseButton.setText("P&ause")
    else:
      pauseButton.setText("&Resume")
  
  def pauseCMDMon(self):
    """Handles stored CMD Response Packets upon CMD Pause button click event.
    """
    pauseButton = self.pauseCMDButton
    if not pauseButton.isOn():
      for packet in self.__CMDPacketList:
        self.displayCMDPacket(packet)
      self.__CMDPacketList = []
      pauseButton.setText("Pa&use")
    else:
      pauseButton.setText("R&esume")
  
  def pauseCCSDSMon(self):
    """Handles stored FSW Message Packets upon FSW Pause button click event.
    """
    pauseButton = self.pauseCCSDSButton
    if not pauseButton.isOn():
      #~ for packet in self.__FSWPacketList:
        #~ self.displayFSWPacket(packet)
      #~ self.__FSWPacketList = []
      pauseButton.setText("Paus&e")
    else:
      pauseButton.setText("Resu&me")
  
  def filterByAPID(self):
    if self.filterByAPIDButton.isOn():
      self.apid.setReadOnly(0)
      self.time.clear()
      self.seqN.clear()
      self.size.clear()
      self.CCSDSView.clear()
    else:
      self.apid.setReadOnly(1)

  def filePrint(self):
    """ Prints to printer all monitors.
    """
    self.printFSWMon()
    self.printCMDMon()
  
  def printFSWMon(self):
    """ Pauses and Prints to printer FSW Message Monitor.
    """
    self.pauseFSWButton.setOn(1)
    self.printMon(self.FSWView, "FSW Message Monitor")
    self.pauseFSWButton.setOn(0)
  
  def printCMDMon(self):
    """ Pauses and Prints to printer CMD Response Monitor.
    """
    self.pauseCMDButton.setOn(1)
    self.printMon(self.CMDView, "CMD Response Monitor")
    self.pauseCMDButton.setOn(0)
  
  def printMon(self, view, viewName):
    """ Prints to printer selected Monitor.
    """
    printer = packetMonitorPrinter(parent = view)
    printer.secondHeader = None
    printer.printMon(viewName)

  def closeGUI(self):
    """ Closes GUI from Done Button.
    """
    self.close()
  
  def fileExit(self):
    """ Closes GUI from File Exit action.
    """
    self.close()
  
  def closeEvent(self, e):
    """ Manages close events, saving current window size.
    """
    self.__prefsGUI.saveMainWindowSize()
    e.accept()

  def keyPressEvent(self, ke):
    """ Manages special key press events.
    """
    if ke.key() == Qt.Key_Escape:
      self.close()
    elif ke.key() == Qt.Key_F5:
      self.refreshFSWMon()
      self.refreshCMDMon()


if __name__ == "__main__":
  # Obtain options
  options = gOptions.Options(['cvtHost', 'vscConfig'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(str(msg))
    #usage()
    sys.exit()

  config = ConfigParser.ConfigParser()
  config.read(options.vscConfig)

  # CVT connection
  cvtHost = options.cvtHost
  
  portTool = VscProxyPorts(config.getint('vsc', 'proxyPortBase'))
  cvtPort  = portTool.cvtOut()

  # TlmDB connection
  DSN = config.get('postgres', 'dsn')
  db = psycopg.connect( DSN )
  dbc = db.cursor()
  tlmdb = TlmRdbDb(dbc)
  tlmdb.populate( source = int(config.get("tlmdb", "source")),
                  build  = config.get("tlmdb", "build") )
  
  
  # Launch GUI
  a = QApplication(sys.argv)
  QObject.connect(a,SIGNAL("lastWindowClosed()"),a,SLOT("quit()"))
  w = packetMonitorImpl(cvtHost, cvtPort, tlmdb)
  a.setMainWidget(w)
  # Make sure no update is processed once the QApp is closed.
  w.show()
  QObject.connect(a,SIGNAL("lastWindowClosed()"),w.quit)
  
  # Start the asyncore loop.  Termination is set by killEvent
  # Must be started after the QApp is defined, before its
  # loop is executed.
  threading.Thread(target=asyncore_loop).start()
  a.exec_loop() 
  
  # Kill thread once QApp is closed.
  killEvent.set()
  

---