"""Read the current system load from /proc/loadavg."""

loadavg = open("/proc/loadavg").readline()

loadavg = loadavg[:-1]

# Contents are space separated:

# 5, 10, 15 min avg. load, running proc/total threads, last pid

stats = loadavg.split()

running = stats[3].split("/")

load_stats = {}

load_stats['loadAvg1min'] = stats[0]

load_stats['loadAvg5min'] = stats[1]

load_stats['loadAvg15min'] = stats[2]

load_stats['running'] = running[0]

load_stats['tasks'] = running[1]

"""Read the current system cpu usage from /proc/stat."""

lines = open("/proc/stat").readlines()

for line in lines:

#print "l = %s" % line

l = line.split()

if len(l) < 5:

continue

if l[0].startswith('cpu'):

# cpu = sum of usr, nice, sys

cpu = long(l[1]) + long(l[2]) + long(l[3])

idl = long(l[4])

return {'CPUTotalJiffies': cpu,

'IDLTotalJiffies': idl,

}

"""Read the current status of memory from /proc/meminfo."""

meminfo_fields = ["MemTotal", "MemFree", "SwapTotal", "SwapFree"]

meminfo = open("/proc/meminfo")

if kernel_rev <= 2.4:

# Kernel 2.4 has extra lines of info, duplicate of later info

meminfo.readline()

meminfo.readline()

meminfo.readline()

lines = meminfo.readlines()

meminfo.close()

meminfo_stats = {}

for line in lines:

line = line[:-1]

stats = line.split()

field = stats[0][:-1]

if field in meminfo_fields:

meminfo_stats[field[0].lower()+field[1:]] = stats[1]

"""Read the stats from an interface."""

ifaces = open( "/proc/net/dev" )

# Skip the information banner

ifaces.readline()

ifaces.readline()

# Read the rest of the lines

lines = ifaces.readlines()

ifaces.close()

# Process the interface lines

net_stats = {}

for line in lines:

# Parse the interface line

# Interface is followed by a ':' and then bytes, possibly with

# no spaces between : and bytes

line = line[:-1]

(device, data) = line.split(':')

# Get rid of leading spaces

device = device.lstrip()

# get the stats

stats = data.split()

if device == interface:

net_stats['receiveBytes'] = stats[0]

net_stats['receivePackets'] = stats[1]

net_stats['transmitBytes'] = stats[8]

net_stats['transmitPackets'] = stats[9]

"""A simple class to collect info."""

def __init__(self, host, kernel_rev, interface):

self.time = time()

self.host = host

self.interface = interface

for infos in (read_cpu_usage(),

read_load_info(),

read_mem_info(kernel_rev),

read_net_info(interface)):

for key, value in infos.items():

setattr(self, key, value)

def __repr__(self, extra_key=None):

text = "<monitor "

if extra_key is not None:

text += 'key="%s" ' % extra_key

for key, value in self.__dict__.items():

text += '%s="%s" ' % (key, value)

text += ' />'

"""The monitor thread that collect information."""

def __init__(self, records, host=None, interval=None, interface=None):

Thread.__init__(self)

self.records = records

self._recorder_count = 0 # number of recorder

self._running = False # boolean running mode

self._interface = None # net interface

self._interval = None # interval between monitoring

self._host = None # name of the monitored host

self.setInterval(interval)

self.setInterface(interface)

self.setHost(host)

self._kernel_rev = None

self.checkKernelRev()

# this makes threads endings if main stop with a KeyboardInterupt

self.setDaemon(1)

def setInterval(self, interval):

"""Set the interval between monitoring."""

self._interval = interval

def setInterface(self, interface):

"""Set the network interface to monitor."""

self._interface = interface

def setHost(self, host):

"""Set the monitored host."""

self._host = host

def checkKernelRev(self):

"""Check the linux kernel revision."""

version = open("/proc/version").readline()

kernel_rev = float(re.search(r'version (\d+\.\d+)\.\d+',

version).group(1))

if (kernel_rev > 2.6) or (kernel_rev < 2.4):

sys.stderr.write(

"Sorry, kernel v%0.1f is not supported\n" % kernel_rev)

sys.exit(-1)

self._kernel_rev = kernel_rev

def run(self):

"""Thread jobs."""

self._running = True

while self._running:

sleep(self._interval)

if self._recorder_count > 0:

self.monitor()

def stop(self):

"""Stop the thread."""

self._running = False

def monitor(self):

"""The monitor task."""

self.records.append(MonitorInfo(self._host,

self._kernel_rev,

self._interface))

def startRecord(self):

"""Enable recording."""

self._recorder_count += 1

def stopRecord(self):

"""Stop recording."""

self._recorder_count -= 1

def countRecorders(self):

"""Return the number of recorder."""

"""The XML RPC monitor server."""

server_name = "monitor"

method_names = XmlRpcBaseServer.method_names + [

'startRecord', 'stopRecord', 'getResult', 'getXmlResult']

def __init__(self, argv=None):

self.interval = None

self.interface = None

self.records = []

self._keys = {}

XmlRpcBaseServer.__init__(self, argv)

self._monitor = MonitorThread(self.records,

self.host,

self.interval,

self.interface)

self._monitor.start()

def _init_cb(self, conf, options):

"""init callback."""

self.interval = conf.getfloat('server', 'interval')

self.interface = conf.get('server', 'interface')

def startRecord(self, key):

"""Start to monitor if it is the first key."""

self.logd('startRecord %s' % key)

if not self._keys.has_key(key) or self._keys[key][1] is not None:

self._monitor.startRecord()

self._keys[key] = [len(self.records), None]

return 1

def stopRecord(self, key):

"""Stop to monitor if it is the last key."""

self.logd('stopRecord %s' % key)

if not self._keys.has_key(key) or self._keys[key][1] is not None:

return 0

self._keys[key] = [self._keys[key][0], len(self.records)]

self._monitor.stopRecord()

return 1

def getResult(self, key):

"""Return stats for key."""

self.logd('getResult %s' % key)

if key not in self._keys.keys():

return []

ret = self.records[self._keys[key][0]:self._keys[key][1]]

return ret

def getXmlResult(self, key):

"""Return result as xml."""

self.logd('getXmlResult %s' % key)

ret = self.getResult(key)

ret = [stat.__repr__(key) for stat in ret]

return '\n'.join(ret)

def test(self):

"""auto test."""

key = 'internal_test_monitor'

self.startRecord(key)

sleep(3)

self.stopRecord(key)

self.log(self.records)

self.log(self.getXmlResult(key))

"""Monitor controller."""

server_class = MonitorServer

def test(self):

"""Testing monitor server."""

server = self.server

key = 'internal_test_monitor'

server.startRecord(key)

sleep(2)

server.stopRecord(key)

self.log(server.getXmlResult(key))