def unit_test(rootdir):
from pprint import pprint
class unittest_ConfigDummy(object):
def __init__(self, rootdir):
self.config = {'installdir': '%s/rteval'}
self.__update_vars()
def __update_vars(self):
for k in self.config.keys():
self.__dict__[k] = self.config[k]
try:
ProcessWarnings()
if os.getuid() != 0:
print "** ERROR ** Must be root to run this unit_test()"
return 1
cfg = unittest_ConfigDummy(rootdir)
d = DMIinfo(cfg)
x = xmlout.XMLOut('dmi_test', "0.0")
x.NewReport()
d.genxml(x)
x.close()
x.Write('-')
return 0
except Exception, e:
print "** EXCEPTION: %s" % str(e)
return 1
def show_report(self, xmlfile, xsltfile):
'''summarize a previously generated xml file'''
print "Loading %s for summarizing" % xmlfile
xsltfullpath = os.path.join(self.config.installdir, xsltfile)
if not os.path.exists(xsltfullpath):
raise RuntimeError, "can't find XSL template (%s)!" % xsltfullpath
xmlreport = xmlout.XMLOut('rteval', self.version)
xmlreport.LoadReport(xmlfile)
xmlreport.Write('-', xsltfullpath)
del xmlreport
def _report(self, measure_start, xslt_tpl):
"Create a screen report, based on a predefined XSLT template"
if measure_start is None:
raise Exception("No measurement runs have been attempted")
duration = datetime.now() - measure_start
seconds = duration.seconds
hours = seconds / 3600
if hours: seconds -= (hours * 3600)
minutes = seconds / 60
if minutes: seconds -= (minutes * 60)
# Start new XML report
self.__xmlreport = xmlout.XMLOut('rteval', self.__version)
self.__xmlreport.NewReport()
self.__xmlreport.openblock(
'run_info', {
'days': duration.days,
'hours': hours,
'minutes': minutes,
'seconds': seconds
})
self.__xmlreport.taggedvalue('date', self.__start.strftime('%Y-%m-%d'))
self.__xmlreport.taggedvalue('time', self.__start.strftime('%H:%M:%S'))
if self.__annotate:
self.__xmlreport.taggedvalue('annotate', self.__annotate)
self.__xmlreport.closeblock()
# Collect and add info about the system
self.__xmlreport.AppendXMLnodes(self._sysinfo.MakeReport())
# Add load info
self.__xmlreport.AppendXMLnodes(self._loadmods.MakeReport())
# Add measurement data
self.__xmlreport.AppendXMLnodes(self._measuremods.MakeReport())
# Close the report - prepare for return the result
self.__xmlreport.close()
# Write the XML to the report directory
if self.__xmlfname != None:
self.__xmlreport.Write(self.__xmlfname, None)
chown(self.__xmlfname)
# Write a text report to stdout as well, using the
# rteval_text.xsl template
self.__xmlreport.Write("-", xslt_tpl)
def genxml(self, duration, accum, samples, xslt=None):
seconds = duration.seconds
hours = seconds / 3600
if hours: seconds -= (hours * 3600)
minutes = seconds / 60
if minutes: seconds -= (minutes * 60)
(sys, node, release, ver, machine) = os.uname()
# Start new XML report
self.xmlreport = xmlout.XMLOut('rteval', self.version)
self.xmlreport.NewReport()
self.xmlreport.openblock(
'run_info', {
'days': duration.days,
'hours': hours,
'minutes': minutes,
'seconds': seconds
})
self.xmlreport.taggedvalue('date', self.start.strftime('%Y-%m-%d'))
self.xmlreport.taggedvalue('time', self.start.strftime('%H:%M:%S'))
if self.annotate:
self.xmlreport.taggedvalue('annotate', self.annotate)
self.xmlreport.closeblock()
self.xmlreport.openblock('uname')
self.xmlreport.taggedvalue('node', node)
isrt = 1
if ver.find(' RT ') == -1:
isrt = 0
self.xmlreport.taggedvalue('kernel', release, {'is_RT': isrt})
self.xmlreport.taggedvalue('arch', machine)
self.xmlreport.taggedvalue('baseos', self.baseos)
self.xmlreport.closeblock()
self.xmlreport.openblock("clocksource")
self.xmlreport.taggedvalue('current', self.current_clocksource)
self.xmlreport.taggedvalue('available', self.available_clocksource)
self.xmlreport.closeblock()
self.xmlreport.openblock('hardware')
self.xmlreport.AppendXMLnodes(self.cputopology)
self.xmlreport.taggedvalue('numa_nodes', self.numanodes)
self.xmlreport.taggedvalue('memory_size', "%.3f" % self.memsize[0],
{"unit": self.memsize[1]})
self.xmlreport.closeblock()
self.xmlreport.openblock('services', {'init': self.init})
for s in self.services:
self.xmlreport.taggedvalue("service", self.services[s],
{"name": s})
self.xmlreport.closeblock()
keys = self.kthreads.keys()
if len(keys):
keys.sort()
self.xmlreport.openblock('kthreads')
for pid in keys:
self.xmlreport.taggedvalue(
'thread', self.kthreads[pid]['name'], {
'policy': self.kthreads[pid]['policy'],
'priority': self.kthreads[pid]['priority'],
})
self.xmlreport.closeblock()
modlist = util.get_modules()
if len(modlist):
self.xmlreport.openblock('kernelmodules')
for mod in modlist:
self.xmlreport.openblock('module')
self.xmlreport.taggedvalue(
'info', mod['modname'], {
'size': mod['modsize'],
'state': mod['modstate'],
'numusers': mod['numusers']
})
if mod['usedby'] != '-':
self.xmlreport.openblock('usedby')
for ub in mod['usedby'].split(','):
if len(ub):
self.xmlreport.taggedvalue('module', ub, None)
self.xmlreport.closeblock()
self.xmlreport.closeblock()
self.xmlreport.closeblock()
#
# Retrieve configured IP addresses
#
self.xmlreport.openblock('network_config')
# Get the interface name for the IPv4 default gw
route = open('/proc/net/route')
defgw4 = None
if route:
rl = route.readline()
while rl != '':
rl = route.readline()
splt = rl.split("\t")
# Only catch default route
if len(splt) > 2 and splt[2] != '00000000' and splt[
1] == '00000000':
defgw4 = splt[0]
break
route.close()
# Make an interface tag for each device found
if hasattr(ethtool, 'get_interfaces_info'):
# Using the newer python-ethtool API (version >= 0.4)
for dev in ethtool.get_interfaces_info(ethtool.get_devices()):
if cmp(dev.device, 'lo') == 0:
continue
self.xmlreport.openblock('interface', {
'device': dev.device,
'hwaddr': dev.mac_address
})
# Protcol configurations
if dev.ipv4_address:
self.xmlreport.openblock(
'IPv4', {
'ipaddr': dev.ipv4_address,
'netmask': dev.ipv4_netmask,
'broadcast': dev.ipv4_broadcast,
'defaultgw': (defgw4 == dev.device) and '1' or '0'
})
self.xmlreport.closeblock()
for ip6 in dev.get_ipv6_addresses():
self.xmlreport.openblock(
'IPv6', {
'ipaddr': ip6.address,
'netmask': ip6.netmask,
'scope': ip6.scope
})
self.xmlreport.closeblock()
self.xmlreport.closeblock()
else: # Fall back to older python-ethtool API (version < 0.4)
ifdevs = ethtool.get_active_devices()
ifdevs.remove('lo')
ifdevs.sort()
for dev in ifdevs:
self.xmlreport.openblock('interface', {
'device': dev,
'hwaddr': ethtool.get_hwaddr(dev)
})
self.xmlreport.openblock(
'IPv4', {
'ipaddr': ethtool.get_ipaddr(dev),
'netmask': ethtool.get_netmask(dev),
'defaultgw': (defgw4 == dev) and '1' or '0'
})
self.xmlreport.closeblock()
self.xmlreport.closeblock()
self.xmlreport.closeblock()
self.xmlreport.openblock('loads',
{'load_average': str(accum / samples)})
for load in self.loads:
load.genxml(self.xmlreport)
self.xmlreport.closeblock()
self.cyclictest.genxml(self.xmlreport)
# now generate the dmidecode data for this host
d = dmi.DMIinfo(self.config.GetSection('rteval'))
d.genxml(self.xmlreport)
# Close the report - prepare for return the result
self.xmlreport.close()
# Write XML (or write XSLT parsed XML if xslt != None)
if self.xml != None:
self.xmlreport.Write(self.xml, xslt)
else:
# If no file is set, use stdout
self.xmlreport.Write(
"-", xslt) # libxml2 defines a filename as "-" to be stdout
