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