def _parse(self, data):
result = Dict()
capture_values = False
for line in data.splitlines():
match = self.__re_section.match(line)
if match:
data = match.groupdict()
pathname = data.pop('pathname')
if pathname:
if pathname[1:-1] in ('heap', 'stack', 'vdso', 'vsyscall'):
pathname = pathname[1:-1]
for key in ('start', 'end', 'offset'):
data[key] = int(data[key], 16)
dev_major, dev_minor = data['device'].split(':', 1)
data['device'] = Dict(major=int(dev_major, 16),
minor=int(dev_minor, 16))
result[pathname] = Dict(data)
capture_values = True
else:
capture_values = False
else:
capture_values = False
elif capture_values:
key, value = line.split(':', 1)
value = int(value.split(' kB', 1)[0].strip())
result[pathname][key] = value
return result
def _parse(self, content):
lines = content.splitlines()
lines = lines[2:] # skip header
result = Dict()
for line in lines:
major, minor, blocks, name = line.split()
major, minor, blocks = int(major), int(minor), int(blocks)
result[name] = Dict(major=major, minor=minor, block_count=blocks)
return result
def _parse(self, content):
la1mn, la5mn, la15mn, entities, last_pid = content.split()
# Kernel scheduling entities (ie. Process/Thread)
current, total = map(int, entities.split('/', 1))
return Dict(average={
1: float(la1mn),
5: float(la5mn),
15: float(la15mn)
},
entities=Dict(current=current, total=total),
last_pid=int(last_pid))
def _parse(self, content):
lines = content.splitlines()[2:] # skip header
result = Dict()
for line in lines:
parts = line.split()
name = parts[0]
values = map(int, parts[1:6])
values += map(int, parts[8:11])
values += map(int, parts[13:16])
result[name] = Dict(zip(self.__keys, values))
return result
def _parse(self, data):
lines = data.splitlines()
result = Dict()
for line in lines:
data_type, data = line.split(': ', 1)
result[data_type] = Dict()
for index, value in enumerate(data.split()):
if not index % 2:
key = value
else:
result[data_type][key] = int(value)
return result
def _parse(self, content):
lines = content.splitlines()
cpus = [int(cpu.split('CPU', 1)[1]) for cpu in lines.pop(0).split()]
keys = cpus + ['total']
result = Dict()
for line in lines:
parts = line.split()
handler = parts.pop(0)[:-1]
values = map(int, parts)
values.append(sum(values))
result[handler] = Dict(zip(keys, values))
return result
def _parse(self, data):
lines = data.splitlines()
result = Dict()
for line in lines:
index, interface, users, gusers, address = line.split()
if interface in result:
result[interface]['addresses'].append(address)
else:
result[interface] = Dict(index=int(index),
users=int(users),
gusers=int(gusers),
addresses=[address])
return result
def _parse(self, data):
lines = data.splitlines()
result = Dict()
for index, line in enumerate(lines):
data_type, data = line.split(': ', 1)
if not index % 2:
# This is a header line
header = data.split()
else:
# This is a values line
values = map(int, data.split())
result[data_type] = Dict(zip(header, values))
return result
def _parse(self, content):
lines = content.splitlines()
result = Dict()
for line in lines:
values = line.split()
major, minor, device = values[:3]
major, minor = int(major), int(minor)
values = map(int, values[3:])
result[device] = Dict(read=Dict(), write=Dict(), io=Dict())
for index, value in enumerate(values):
key1, key2 = self.__keys[index].split('__', 1)
result[device][key1][key2] = value
return result
def _parse(self, data):
result = Dict()
for line in data.splitlines():
if ': ' in line:
key, value = line.split(': ', 1)
result[key] = int(value)
return result
def _parse(self, data):
header = "size resident shared trs _ drs _".split()
data = Dict(zip(header, data.split()))
del data['_']
for key, value in data.items():
data[key] = int(value)
return data
def _parse_fh(self, stale, total_lookups, anonlookups, dir_not_in_cache,
nondir_not_in_cache):
return Dict(stale=stale,
total_lookups=total_lookups,
anonlookups=anonlookups,
dir_not_in_cache=dir_not_in_cache,
nondir_not_in_cache=nondir_not_in_cache)
def _parse_proc3(self, cnt, null, getattr, setattr, lookup, access,
readlink, read, write, create, mkdir, symlink, mknod,
remove, rmdir, rename, link, readdir, readdirplus, fsstat,
fsinfo, pathconf, commit):
return Dict(null=null,
getattr=getattr,
setattr=setattr,
lookup=lookup,
access=access,
readlink=readlink,
read=read,
write=write,
create=create,
mkdir=mkdir,
symlink=symlink,
mknod=mknod,
remove=remove,
rmdir=rmdir,
rename=rename,
link=link,
readdir=readdir,
readdirplus=readdirplus,
fsstat=fsstat,
fsinfo=fsinfo,
pathconf=pathconf,
commit=commit)
def _parse(self, data):
lines = filter(bool, data.split('\x00'))
env = {}
for line in lines:
name, _, value = line.partition('=')
env[name] = value
return Dict(env)
def _parse(self, data):
lines = data.splitlines()
header = lines.pop(0).split()
header.pop(0) # skip "sl"
header.append('other')
result = {}
for line in lines:
parts = line.split()
(slot, local_address, rem_address, st, tx_rx_queue, tr_tm_when,
retrnsmt, uid, timeout, inode) = parts[:10]
local_addr, local_port = self._parse_addr(local_address)
remote_addr, remote_port = self._parse_addr(rem_address)
other = parts[10:]
slot = int(slot.split(':', 1)[0])
st = self.__tcp_states[st]
tx_queue, rx_queue = tx_rx_queue.split(':', 1)
tr, tm_when = tr_tm_when.split(':', 1)
uid = int(uid)
timeout = int(timeout)
inode = int(inode)
result[slot] = Dict(
zip(header,
((local_addr, local_port),
(remote_addr, remote_port), st, tx_queue, rx_queue, tr,
tm_when, retrnsmt, uid, timeout, inode, other)))
return result
def _parse(self, content):
lines = content.splitlines()
result = Dict()
for line in lines:
key, value = line.split(':', 1)
value = int(value.split(' kB', 1)[0])
result[key] = value
return result
def _parse_rpc(self, cnt, badcnt, badfmt, badauth, badclnt):
"""See <linux-src>/net/sunrpc/stats.c : svc_seq_show
"""
return Dict(cnt=cnt,
badcnt=badcnt,
badfmt=badfmt,
badauth=badauth,
badclnt=badclnt)
def _parse(self, content):
lines = content.splitlines()
result = {}
for line in lines:
values = line.split()
data = Dict(zip(self.__keys, values))
data['passno'] = int(data['passno'])
data['dump'] = int(data['dump'])
options = data['options'].split(',')
data['options'] = Dict()
for option in options:
option = option.split('=', 1)
data['options'][option[0]] = \
True if len(option) == 1 else option[1]
mount_point = data.pop('mount_point')
result[mount_point] = data
return result
def _parse(self, data):
lines = data.splitlines()
lines.pop(0)
header = lines.pop(0)
_, rcv_header, tx_header = header.split('|')
rcv_keys = rcv_header.split()
tx_keys = tx_header.split()
limit = len(rcv_keys)
result = Dict()
for line in lines:
interface, str_values = line.split(':', 1)
interface = interface.strip()
values = map(int, str_values.split())
rcv = Dict(zip(rcv_keys, values[:limit]))
tx = Dict(zip(tx_keys, values[limit:]))
result[interface] = Dict(receive=rcv, transmit=tx)
return result
def _parse(self, content):
lines = content.splitlines()
result = Dict(cpu=Dict())
cpu_lines, other_lines = [], []
for line in lines:
if line.startswith('cpu'):
cpu_lines.append(line)
else:
other_lines.append(line)
cpu_keys = ('user', 'nice', 'system', 'idle', 'iowait', 'irq',
'softirq', 'steal', 'guest', 'total')
for line in cpu_lines:
str_values = line.split()
cpu = str_values.pop(0)
values = []
total = 0
for value in str_values:
value = int(value)
total += value
value = timedelta(seconds=value / 100.)
values.append(value)
values.append(timedelta(seconds=total / 100.))
result[cpu] = Dict(zip(cpu_keys, values))
for line in other_lines:
key, value = line.split(' ', 1)
if ' ' in value:
result[key] = map(int, value.split())
else:
result[key] = int(value)
parsers = {
'intr': lambda value: self.__parse_list_with_total(value),
'softirq': lambda value: self.__parse_list_with_total(value),
'btime': datetime.fromtimestamp
}
for key, parser in parsers.iteritems():
value = result.get(key)
if value is not None:
result[key] = parser(value)
return result
def _parse_proc2(self, cnt, null, getattr, setattr, root, lookup,
readlink, read, writecache, write, create, remove,
rename, link, symlink, mkdir, rmdir, readdir, statfs):
return Dict(null=null, getattr=getattr, setattr=setattr,
root=root, lookup=lookup, readlink=readlink,
read=read, writecache=writecache, write=write,
create=create, remove=remove, rename=rename,
link=link, symlink=symlink, mkdir=mkdir,
rmdir=rmdir, readdir=readdir, statfs=statfs)
def _parse(self, content):
lines = content.splitlines()
count = 0
data = Dict()
for line in lines:
if line:
if line.startswith('processor\t:'):
data[count] = Dict()
else:
key, value = line.split(':', 1)
key = key.strip().replace(' ', '_').lower()
parser_name = '_parse_' + key
if hasattr(self, parser_name):
parser = getattr(self, parser_name)
value = parser(value)
data[count][key] = value
else:
count += 1
return data
def _parse_th(self, threads, fullcnt, *busy_times):
busy = {'10-20': busy_times[0],
'20-30': busy_times[1],
'30-40': busy_times[2],
'40-50': busy_times[3],
'50-60': busy_times[4],
'60-70': busy_times[5],
'70-80': busy_times[6],
'80-90': busy_times[7],
'90-100': busy_times[8]}
return Dict(threads=threads, fullcnt=fullcnt, busy=busy)
def _parse(self, data):
lines = data.splitlines()
header = lines.pop(0)
header = header.lower()
keys = header.split()
keys.pop(1)
result = Dict()
for line in lines:
values = line.split()
destination = values.pop(1)
entry = Dict(zip(keys, values))
if destination == "00000000":
if result.has_key(destination):
result[destination].append(entry)
else:
result[destination] = [entry]
else:
result[destination] = entry
return result
def _parse(self, content):
data = Dict()
for line in content.splitlines():
name, value = line.split(':\t')
value = value.strip()
if name.startswith('Vm'):
value = int(value.split(' kB')[0])
elif name in ('Uid', 'Gid'):
keys = ('real', 'effective', 'saved_set', 'fs')
values = map(int, value.split())
value = Dict(zip(keys, values))
elif name == 'SigQ':
queued, max_ = value.split('/', 1)
value = Dict(queued=int(queued), max=int(max_))
elif name == 'Groups':
groups = value.split()
value = map(int, groups)
elif name in ('Tgid', 'PPid', 'TracerPid', 'FDSize', 'Threads',
'Pid', 'nonvoluntary_ctxt_switches',
'voluntary_ctxt_switches'):
value = int(value)
data[name] = value
return data
def _parse(self, content):
lines = content.splitlines()
cpus = [int(cpu.split('CPU', 1)[1]) for cpu in lines.pop(0).split()]
keys = cpus + ['total', 'info']
result = Dict()
for line in lines:
parts = line.split()
interrupt = parts.pop(0)[:-1]
try:
interrupt = int(interrupt)
except ValueError:
pass
if interrupt not in ('ERR', 'MIS'):
values = parts[:len(cpus)]
values = map(int, values)
values.append(sum(values))
info = ' '.join(parts[len(cpus):])
values.append(info)
data = Dict(zip(keys, values))
else:
data = int(parts[0])
result[interrupt] = data
return result
def _parse(self, content):
data = Dict()
line_no = 0;
for line in content.splitlines():
line_no += 1
if line_no < 3:
continue
else:
name, value = line.split(':')
name = name.strip()
name = name.replace('.', '_')
value = value.strip()
data[name] = value
return data
def _parse_ra(self, cache_size, *depths):
not_found = depths[-1]
depth = {
10: depths[0],
20: depths[1],
30: depths[2],
40: depths[3],
50: depths[4],
60: depths[5],
70: depths[6],
80: depths[7],
90: depths[8],
100: depths[9]
}
return Dict(cache_size=cache_size, depth=depth, not_found=not_found)
def _parse(self, data):
header = """pid tcomm state ppid pgrp sid tty_nr tty_pgrp
flags min_flt cmin_flt maj_flt cmaj_flt utime stime cutime
cstime priority nice num_threads _ start_time vsize rss
rsslim start_code end_code start_stack esp eip pending
blocked sigign sigcatch wchan _ _ exit_signal task_cpu
rt_priority policy blkio_ticks gtime cgtime"""
header = header.split()
data = Dict(zip(header, data.split()))
del data['_']
for key, value in data.items():
if key.endswith('time'):
data[key] = timedelta(seconds=int(value))
elif key not in ('state', 'tcomm'):
data[key] = int(value)
return data
def _parse(self, data):
lines = data.splitlines()
result = Dict()
for line in lines:
str_values = line.split()
type_ = str_values.pop(0)
values = []
for value in str_values:
if '.' in value:
parser = float
else:
parser = int
values.append(parser(value))
parser_name = '_parse_%s' % type_
if hasattr(self, parser_name):
parser = getattr(self, parser_name)
values = parser(*values)
result[type_] = values
return result