def _getThreadsInfo__(self, hasListener):
self.threads = {}
if hasListener:
try:
alldirs = os.listdir(self.__pathPrefix__ + "task/")
for t in alldirs:
try:
wchan = procutils.readFullFile(self.__pathPrefix__ + "task/" + str(t) + "/wchan")
sched = procutils.readFullFile(self.__pathPrefix__ + "task/" + str(t) + "/sched")
wakeupcount = int(sched.split("\n")[23].split(":")[1]) #23 is wakeupcount
self.threads[t] = [wchan, wakeupcount]
except:
pass
except OSError:
pass
def __getNetworkCardUsage(self):
data = procutils.readFullFile(self._prefixDir + '/proc/net/dev').split("\n")[2:]
actTime = time.time()
for line in data:
cardName = line.split(":")[0].strip()
if len(cardName) > 0:
splittedLine = line.split(":")[1].split()
recv = int(splittedLine[0])
sent = int(splittedLine[8])
if self.__prevTimeStamp__ != None:
if self.__networkCards__[cardName]["actual"][2] == 0:
pass
else:
self.__networkCards__[cardName]["actual"][0] = (recv - self.__networkCards__[cardName]["actual"][2]) / (actTime - self.__prevTimeStamp__)
self.__networkCards__[cardName]["actual"][1] = (sent - self.__networkCards__[cardName]["actual"][3]) / (actTime - self.__prevTimeStamp__)
if self.__networkCards__[cardName]["actual"][0] <0:
self.__networkCards__[cardName]["actual"][0] = 0
if self.__networkCards__[cardName]["actual"][1] <0:
self.__networkCards__[cardName]["actual"][1] = 0
self.__networkCards__[cardName]["actual"][2] = recv
self.__networkCards__[cardName]["actual"][3] = sent
self.__networkCards__[cardName]["recerrors"] = int(splittedLine[2])
self.__networkCards__[cardName]["recdrops"] = int(splittedLine[3])
self.__networkCards__[cardName]["senderrors"] = int(splittedLine[10])
self.__networkCards__[cardName]["senddrops"] = int(splittedLine[11])
self.__networkCards__[cardName]["sendcoll"] = int(splittedLine[13])
self.__networkCards__[cardName]["recbytes"] = int(splittedLine[0])
self.__networkCards__[cardName]["recpackets"] = int(splittedLine[1])
self.__networkCards__[cardName]["sendbytes"] = int(splittedLine[8])
self.__networkCards__[cardName]["sendpackets"] = int(splittedLine[9])
def __getProcessDetails__(self):
for process in self.__processList__:
if self.__processList__[process]["hasListener"]:
try:
env = procutils.readFullFile(self._prefixDir + "/proc/"+str(process)+"/environ").split("\0")
self.__processList__[process]["env"] = env
except: #pylint:disable=W0702
pass
def _getThreadsInfo__(self, hasListener):
self.threads = {}
if hasListener:
try:
alldirs = os.listdir(self.__pathPrefix__ + "task/")
for t in alldirs:
try:
wchan = procutils.readFullFile(self.__pathPrefix__ +
"task/" + str(t) +
"/wchan")
sched = procutils.readFullFile(self.__pathPrefix__ +
"task/" + str(t) +
"/sched")
wakeupcount = int(sched.split("\n")[23].split(":")
[1]) #23 is wakeupcount
self.threads[t] = [wchan, wakeupcount]
except:
pass
except OSError:
pass
def __getMemoryInfo(self):
mem = procutils.readFullFile(self._prefixDir + "/proc/meminfo").split("\n")
mem = [l.replace("kB", "").split(":") for l in mem if l]
memDict = {}
for l in mem:
memDict[l[0].upper()] = int(l[1])
self.__totalMemKb = memDict["MEMTOTAL"]
self.__actualMemKb = memDict["MEMFREE"]
self.__buffersMemKb = memDict["BUFFERS"]
self.__cachedMemKb = memDict["CACHED"]
self.__swapUsed = memDict["SWAPTOTAL"]-memDict["SWAPFREE"]
self.__swapTotal = memDict["SWAPTOTAL"]
def __getFileDetails__(self, hasListener):
if hasListener:
try:
allfds = os.listdir(self.__pathPrefix__ + "fd")
self.openFiles = {}
for fd in allfds:
self.openFiles[fd] = {"path":os.readlink(self.__pathPrefix__ + "fd"+"/"+fd)}
#get fileinfo : kernel 2.6.22 and higher
try:
fileInfo = procutils.readFullFile(self.__pathPrefix__ + "fdinfo/"+fd)
self.openFiles[fd]["fdinfo"] = fileInfo
except:
self.openFiles[fd]["fdinfo"] = "??"
except OSError:
pass
def __getFileDetails__(self, hasListener):
if hasListener:
try:
allfds = os.listdir(self.__pathPrefix__ + "fd")
self.openFiles = {}
for fd in allfds:
self.openFiles[fd] = {
"path":
os.readlink(self.__pathPrefix__ + "fd" + "/" + fd)
}
#get fileinfo : kernel 2.6.22 and higher
try:
fileInfo = procutils.readFullFile(self.__pathPrefix__ +
"fdinfo/" + fd)
self.openFiles[fd]["fdinfo"] = fileInfo
except:
self.openFiles[fd]["fdinfo"] = "??"
except OSError:
pass
self.cpuUsageKernelHistory = self.cpuUsageKernelHistory[1:]
self.rssUsageHistory = self.rssUsageHistory[1:]
self.IOHistory = self.IOHistory[1:]
try:
self.cwd = os.readlink(self.__pathPrefix__ + "cwd")
except OSError, val:
self.cwd = "<" + val.strerror + ">"
except:
raise
if self.cmdline == None:
#do below only once
try:
self.cmdline = procutils.readFullFile(self.__pathPrefix__ +
"cmdline").replace(
"\x00", " ")
except OSError, val:
self.cmdline = "<" + val.strerror + ">"
except procutils.FileError:
self.cmdline = "---"
except:
raise
try:
self.exe = os.readlink(self.__pathPrefix__ + "exe")
except OSError, val:
self.exe = "<" + val.strerror + ">"
except:
raise
self.cpuUsageKernelHistory = self.cpuUsageKernelHistory[1:]
self.rssUsageHistory = self.rssUsageHistory[1:]
self.IOHistory = self.IOHistory[1:]
try:
self.cwd = os.readlink(self.__pathPrefix__ + "cwd")
except OSError, val:
self.cwd = "<"+val.strerror+">"
except :
raise
if self.cmdline == None:
#do below only once
try:
self.cmdline = procutils.readFullFile(self.__pathPrefix__ + "cmdline").replace("\x00"," ")
except OSError, val:
self.cmdline = "<"+val.strerror+">"
except procutils.FileError:
self.cmdline = "---"
except:
raise
try:
self.exe = os.readlink(self.__pathPrefix__ + "exe")
except OSError, val:
self.exe = "<"+val.strerror+">"
except :
raise
#started time of a process
def update(self):
jiffyStr = procutils.readFullFile(self._prefixdir+'/proc/stat').split("\n")[self.__cpu__+1]
userMode = int(jiffyStr.split()[1])
userNiceMode = int(jiffyStr.split()[2])
systemMode = int(jiffyStr.split()[3])
idleMode = int(jiffyStr.split()[4])
ioWait = int(jiffyStr.split()[5])
irqMode = int(jiffyStr.split()[6])
softIrqMode = int(jiffyStr.split()[7])
self.__newjiffies = userMode + userNiceMode + systemMode + idleMode + ioWait + irqMode + softIrqMode
if self.__deltaUserMode__ == None:
self.__prevUserMode__ = userMode
self.__prevUserNiceMode__ = userNiceMode
self.__prevSystemMode__ = systemMode
self.__prevIdleMode__ = idleMode
self.__prevIoWait__ = ioWait
self.__prevIrqMode__ = irqMode
self.__prevSoftIrqMode__ = softIrqMode
self.__deltaUserMode__ = 0
self.__deltaUserNiceMode__ = 0
self.__deltaSystemMode__ = 0
self.__deltaIdleMode__ = 0
self.__deltaIoWait__ = 0
self.__deltaIrqMode__ = 0
self.__deltaSoftIrqMode__ = 0
else:
self.__deltaUserMode__ = userMode - self.__prevUserMode__
self.__deltaUserNiceMode__ = userNiceMode - self.__prevUserNiceMode__
self.__deltaSystemMode__ = systemMode - self.__prevSystemMode__
self.__deltaIdleMode__ = idleMode - self.__prevIdleMode__
self.__deltaIoWait__ = ioWait - self.__prevIoWait__
self.__deltaIrqMode__ = irqMode - self.__prevIrqMode__
self.__deltaSoftIrqMode__ = softIrqMode - self.__prevSoftIrqMode__
self.__prevUserMode__ = userMode
self.__prevUserNiceMode__ = userNiceMode
self.__prevSystemMode__ = systemMode
self.__prevIdleMode__ = idleMode
self.__prevIoWait__ = ioWait
self.__prevIrqMode__ = irqMode
self.__prevSoftIrqMode__ = softIrqMode
total = float(self.__deltaUserMode__ +
self.__deltaUserNiceMode__ +
self.__deltaSystemMode__ +
self.__deltaIdleMode__ +
self.__deltaIoWait__ +
self.__deltaIrqMode__ +
self.__deltaSoftIrqMode__)
self.__overallUserCpuUsage__ = round(((self.__deltaUserMode__ + self.__deltaUserNiceMode__)*1.0 / total)*100, 1) if total > 0 else 0
self.__overallSystemCpuUsage__ = round((self.__deltaSystemMode__ *1.0 / total)*100, 1) if total > 0 else 0
self.__overallIoWaitCpuUsage__ = round((self.__deltaIoWait__*1.0 / total)*100, 1) if total > 0 else 0
self.__overallIrqCpuUsage__ = round(((self.__deltaIrqMode__ + self.__deltaSoftIrqMode__) *1.0 / total)*100, 1) if total > 0 else 0
def __getAverageLoad(self):
load = procutils.readFullFile(self._prefixDir + "/proc/loadavg").split()
self.__loadavg__ = (load[0],load[1],load[2])
self.__noofprocs__ = load[3].split("/")[1]
self.__noofrunningprocs__ = load[3].split("/")[0]
self.__lastpid__ = load[4]
def __getAllUDPInfo__(self):
self.__allUDP__ = {} #list of connections, organized by inode
data = procutils.readFullFile(self._prefixDir + "/proc/net/udp").split("\n")
for udp in data:
if len(udp) > 1:
self.__allUDP__[udp.split()[9]] = udp.split()
def __getAllSocketInfo__(self):
self.__allConnections__ = {} #list of connections, organized by inode
data = procutils.readFullFile(self._prefixDir + "/proc/net/tcp").split("\n")
for connection in data:
if len(connection) > 1:
self.__allConnections__[connection.split()[9]] = connection.split()
def __getProcessCpuDetails__(self):
for process in self.__processList__:
procStat = None
try:
procStat = procutils.readFullFile(self._prefixDir + "/proc/"+str(process)+"/stat")
if self.__processList__[process]["cmdline"] == UNKNOWN:
cmdLine = procutils.readFullFile(self._prefixDir + "/proc/"+str(process)+"/cmdline")
self.__processList__[process]["cmdline"] = cmdLine.replace("\x00"," ")
#get UID of process
if self.__processList__[process]["uid"] == UNKNOWN:
uid = str(os.stat(self._prefixDir + "/proc/"+str(process))[4])
self.__processList__[process]["uid"] = self.__getUIDName__(uid)
except:
pass #pylint:disable=W0702
try:
statm = procutils.readFullFile(self._prefixDir + "/proc/"+str(process)+"/statm")
totalRssMem = int(statm.split(' ')[1])*4 #in 4k pages
#smaps = procutils.readFullFile("/proc/"+str(process)+"/smaps").split("kB\nRss:")
#totalRssMem = 0
#for line in smaps:
#if line.startswith(" "):
#totalRssMem += int(line.split("kB")[0].strip())
except: #pylint:disable=W0702
totalRssMem = 0
if self.__processList__[process]["hasListener"]:
try:
wchan = procutils.readFullFile(self._prefixDir + "/proc/"+str(process)+"/wchan")
self.__processList__[process]["wchan"] = wchan
except: #pylint:disable=W0702
self.__processList__[process]["wchan"] = UNKNOWN
else:
self.__processList__[process]["wchan"] = UNKNOWN
if procStat != None:
procStatSplitted = procStat.split()
nextJiffy = int(procStatSplitted[13]) + int(procStatSplitted[14])
try:
cpuUsage = round(((nextJiffy - self.__processList__[process]["prevJiffy"]) / (self.__deltaJiffies__ * 1.0)) * 100, 1)
except ZeroDivisionError:
cpuUsage = 0.0
nextJiffyKernel = int(procStatSplitted[14])
try:
cpuUsageKernel = round(((nextJiffyKernel - self.__processList__[process]["prevJiffyKernel"]) / (self.__deltaJiffies__ * 1.0)) * 100, 1)
except ZeroDivisionError:
cpuUsageKernel = 0
#IO accounting
try:
io = procutils.readFullFile(self._prefixDir + "/proc/"+str(process)+"/io").split("\n")
iototal = int(io[0].split(": ")[1]) + int(io[1].split(": ")[1])
except: #pylint:disable=W0702
iototal = 0
if self.__processList__[process]["prevIO"] == 0: #first time
deltaio = 0
else:
deltaio = iototal - self.__processList__[process]["prevIO"]
self.__processList__[process]["prevIO"] = iototal
self.__processList__[process]["cpuUsage"] = cpuUsage
self.__processList__[process]["prevJiffy"] = nextJiffy
self.__processList__[process]["cpuUsageKernel"] = cpuUsageKernel
self.__processList__[process]["prevJiffyKernel"] = nextJiffyKernel
self.__processList__[process]["PPID"] = int(procStatSplitted[3])
self.__processList__[process]["name"] = procStatSplitted[1][1:].replace(")","")
self.__processList__[process]["Rss"] = totalRssMem
self.__processList__[process]["history"].update(cpuUsage, cpuUsageKernel, totalRssMem, deltaio/1024,self.__processList__[process]["hasListener"])
self.__processList__[process]["nfThreads"] = procStatSplitted[19]
else:
self.__processList__[process]["PPID"] = 1
def __init__(self, timerValue, historyCount, prefixDir = ""):
self._prefixDir = prefixDir
self.__initReader__()
self.__uidFilter__ = None
self.__updateTimer__ = timerValue
self.__historyCount__ = historyCount
self.__allcpu__ = cpuhistoryreader(-1, prefixDir=prefixDir)
self.__overallUserCpuUsage__ = 0
self.__overallSystemCpuUsage__ = 0
self.__processList__ = {}
self.__deltaJiffies__ = 0
self.__prevJiffies__ = 0
self.__closedProcesses__ = set()
self.__newProcesses__ = set()
self.__passwdfile = procutils.readFullFile("/etc/passwd").split("\n")
self.__allConnections__ = {}
cpuinfo = procutils.readFullFile(self._prefixDir+"/proc/cpuinfo").split("\n")
self.__cpuCount__ = 0
self.__networkCards__= {}
self.__cpuArray__ = []
self.__prevTimeStamp__ = None
self.__allUDP__ = {}
self.__totalMemKb = 0
self.__actualMemKb = 0
self.__buffersMemKb = 0
self.__cachedMemKb = 0
self.__swapUsed = 0
self.__swapTotal = 0
self.__loadavg__ = 0
self.__noofprocs__ = 0
self.__noofrunningprocs__ = 0
self.__lastpid__ = 0
for line in cpuinfo:
if line.startswith("processor"):
self.__cpuArray__.append(cpuhistoryreader(self.__cpuCount__, prefixDir=prefixDir))
self.__cpuCount__ += 1
#network cards
data = procutils.readFullFile(self._prefixDir+'/proc/net/dev').split("\n")[2:]
for line in data:
cardName = line.split(":")[0].strip()
if len(cardName) > 0:
self.__networkCards__[cardName] = {"actual":[0, 0, 0, 0], #in/s out/s previn, prevout]
"speed":None}
#try to find speeds if ethtool is available and accessible
procutils.log("network card speed detection results")
procutils.log("------------------------------------")
ethtoolerror = False
for card in self.__networkCards__:
speed = None
try:
ethtool = subprocess.Popen(["ethtool", card], stdout=subprocess.PIPE, stderr=subprocess.PIPE )
data = ethtool.communicate()
except (OSError, ValueError):
ethtoolerror = True
if data[0] is not None:
for line in data[0].split("\n"):
if line.find("Speed") != -1:
try:
speed = int(line.split(":")[1].split("Mb/s")[0])
except:
speed = None
if speed is not None:
procutils.log(" ethernet device %s has speed %s Mb/s according to ethtool" %(card, speed))
self.__networkCards__[card]["speed"] = speed
else:
procutils.log(" ethernet device %s has unknown speed" %card)
procutils.log(" network graph scaling for %s is set to autoscale" %card)
if ethtoolerror:
procutils.log(" ** ethtool not found, or access denied. For better results, allow access to ethtool")