ProcessMonitorImpl.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
# Simple script to maintain a list of processes and pids in a file
# This script replaces one processes pid in the file.
# If the process isn't keyed in the file, this script  adds it.
#
# Usage:  

__version__ = "$Revision: 1.1 $"

from qt import *
import sys, os
from LICOS.tools.proc import *
from LICOS.tools.proc.ProcessMonitor   import ProcessMonitor


# do something with host later.  For now, everything runs on one machine.
# Probably want to do an xmlrpc server that registers the functions from
# linuxproc to return the dictionaries.
def getProcStat(host, pid):
  #! return the stat dict as defined in linuxproc
  return linuxproc.proc_stat(pid)
def getProcStatM(host, pid):
  #! return the statm dict as defined in linuxproc
  return linuxproc.proc_statm(pid)
def totalCPU(stat):
  #! return the cpu time in seconds used by a process.
  return (stat['utime'] + stat['stime']) * jiffyPerSec

def readPidFile(pidFile):
  processes = {}
  f = open(pidFile, 'r')
  for line in f.readlines():
    host,key,value = line.split()
    if (host,key) in processes:
      msg = "process %s:%s exists multiple times in process file" % (host,key)
      raise msg
    processes[(host,key)] = (value)
  f.close()
  return processes
  

class ProcessMonitorImpl(ProcessMonitor):
  def __init__(self, processDict, parent=None, name = None, fl = 0):
    ProcessMonitor.__init__(self, parent, name, fl)
    self.__pDict = processDict
    self.__procs = {}
    self.procBox = QGridLayout(self.mainFrame)
    self.mainFrame.setMargin(3)
    self.makeMonitor()
    self.updateMonitor()
    self.timer = QTimer(self)
    self.connect(self.timer, SIGNAL("timeout()"), self.updateMonitor)
    self.timer.start(5000)
    

  def makeMonitor(self):
    gridPos = 0
    for host,name in self.__pDict.keys():

      ps = ProcSet(self.mainFrame, self.procBox, gridPos)
      ps.name.setText(name)
      ps.host.setText(host)
      ps.cpu.setTime(0.0)
      
      self.__procs[(host,name)] =  ps
      gridPos += 1
      

  def updateMonitor(self):
  
    for (host,key),pid in self.__pDict.items():
      procSet = self.__procs[(host,key)]
      try:
        stat = getProcStat(host,pid)
      except IOError:
        #msg =  "Problem with getting process information for %s:%s:" % (host,key)
        #msg += "  Process id %s does not exist" % ( pid )
        #print >> sys.stderr, msg
        procSet.cpu.setTime(-1)
        procSet.led.setState(procSet.led.red)
        continue
        

      procSet.cpu.setTime(totalCPU(stat))
      procSet.led.setState(procSet.led.green)
      #print "%20s: %10.2f" \
      #       % (key, totalCPU(stat)) 

class ProcSet(object):
  def __init__(self, parent, container, gridPos):
    self.name = QLabel(parent)
    self.host = QLabel(parent)
    self.cpu  = ProcCpuTime(parent)
    self.led  = ProcLED(parent)
    self.gridPos = gridPos

    container.addWidget(self.name, gridPos, 0)
    container.addWidget(self.host, gridPos, 1)
    container.addWidget(self.cpu , gridPos, 2)
    container.addWidget(self.led , gridPos, 3)

    self.cpu.setAlignment(QWidget.AlignRight)


class ProcCpuTime(QLabel):
  def __init__(self, parent=None, name = None, fl = 0):
    QLabel.__init__(self, parent, name, fl)

  def setTime(self, time):
    self.setText( "%10.2f s" % time)

class ProcLED(QWidget):
  def __init__(self, parent=None, name=None, fl=0):
    QWidget.__init__(self, parent, name, fl)
    self.red = QColor('red')
    self.green = QColor('green')
    self.__state = self.red

    self.radius = 10
    self.minRadius = 10
    self.margin = 5
    self.size = QSize(self.radius+3*self.margin, self.radius+self.margin)
    self.minSize = QSize(self.minRadius+3*self.margin, self.minRadius+self.margin)
    self.sizePol = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

  def paintEvent(self, qe):

    paint = QPainter(self)
    paint.setBrush(self.__state)
    paint.setPen(QPen.NoPen)

    center = self.rect().center()
    r = self.radius
    paint.drawEllipse(center.x()-r/2, center.y()-r/2, r, r)
    
    pass

  def sizeHint(self):
    return self.size

  def minimumSizeHint(self):
    return self.minSize

  def sizePolicy(self):
    return self.sizePol

  def setState(self, color):
    self.__state = color
    self.update()


if __name__ == '__main__':
  
  pidFile = sys.argv[1]  

  if os.path.exists(pidFile):
    processes = readPidFile(pidFile)
  
  a = QApplication(sys.argv)

  p = ProcessMonitorImpl(processes)
  a.setMainWidget(p)

  p.show()
  a.exec_loop()

---