<h2>Edit File: dstat</h2><form method="post"><textarea name="content" rows="20" cols="80">#!/usr/bin/python

### This program is free software; you can redistribute it and/or modify
### it under the terms of the GNU Library General Public License as published by
### the Free Software Foundation; version 2 only
###
### This program is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
### GNU Library General Public License for more details.
###
### You should have received a copy of the GNU Library General Public License
### along with this program; if not, write to the Free Software
### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
### Copyright 2004-2007 Dag Wieers &lt;dag@wieers.com&gt;

from __future__ import generators

try:
    import sys, os, time, sched, re, getopt
    import types, resource, getpass, glob, linecache
except KeyboardInterrupt:
    pass

VERSION = &#039;0.7.2&#039;

theme = { &#039;default&#039;: &#039;&#039; }

if sys.version_info &lt; (2, 2):
    sys.exit(&#039;error: Python 2.2 or later required&#039;)

### Workaround for python &lt;= 2.2.1
try:
    True, False
except NameError:
    True = 1
    False = 0

### Workaround for python &lt; 2.3
#if &#039;enumerate&#039; not in __builtins__.__dict__.keys():
if sys.version_info &gt;= (2, 2) and sys.version_info &lt; (2, 3):
    def enumerate(sequence):
        index = 0
        for item in sequence:
            yield index, item
            index = index + 1
elif sys.version_info &lt; (2, 2):
    def enumerate(sequence):
        index = 0
        seqlist = []
        for item in sequence:
            seqlist.append((index, item))
            index = index + 1
        return seqlist

### Workaround for python &lt; 2.3
#if &#039;sum&#039; not in __builtins__.__dict__.keys():
if sys.version_info &lt; (2, 3):
    def sum(sequence):
        ret = 0
        for i in sequence:
            ret = ret + i
        return ret

pluginpath = [
    os.path.expanduser(&#039;~/.dstat/&#039;),                                # home + /.dstat/
    os.path.abspath(os.path.dirname(sys.argv[0])) + &#039;/plugins/&#039;,    # binary path + /plugins/
    &#039;/usr/share/dstat/&#039;,
    &#039;/usr/local/share/dstat/&#039;,
]

class Options:
    def __init__(self, args):
        self.args = args
        self.bits = False
        self.blackonwhite = False
        self.count = -1
        self.cpulist = None
        self.debug = 0
        self.delay = 1
        self.disklist = None
        self.full = False
        self.float = False
        self.integer = False
        self.intlist = None
        self.netlist = None
        self.swaplist = None
        self.color = True
        self.update = True
        self.header = True
        self.output = False
        self.pidfile = False
        self.profile = &#039;&#039;

        ### List of available plugins
        allplugins = listplugins()

        ### List of plugins to show
        self.plugins = []

        ### Implicit if no terminal is used
        if not sys.stdout.isatty():
            self.color = False
            self.header = False
            self.update = False

        ### Temporary hardcoded for my own project
        self.diskset = {
            &#039;local&#039;: (&#039;sda&#039;, &#039;hd[a-d]&#039;),
            &#039;lores&#039;: (&#039;sd[b-k]&#039;, &#039;sd[v-z]&#039;, &#039;sda[a-e]&#039;),
            &#039;hires&#039;: (&#039;sd[l-u]&#039;, &#039;sda[f-o]&#039;),
        }

        try:
            opts, args = getopt.getopt(args, &#039;acdfghilmno:prstTvyC:D:I:M:N:S:V&#039;,
                [&#039;all&#039;, &#039;all-plugins&#039;, &#039;bits&#039;, &#039;bw&#039;, &#039;blackonwhite&#039;, &#039;debug&#039;,
                 &#039;filesystem&#039;, &#039;float&#039;, &#039;full&#039;, &#039;help&#039;, &#039;integer&#039;,
                 &#039;list&#039;, &#039;mods&#039;, &#039;modules&#039;, &#039;nocolor&#039;, &#039;noheaders&#039;, &#039;noupdate&#039;,
                 &#039;output=&#039;, &#039;pidfile=&#039;, &#039;profile&#039;, &#039;version&#039;, &#039;vmstat&#039;] + allplugins)
        except getopt.error, exc:
            print &#039;dstat: %s, try dstat -h for a list of all the options&#039; % str(exc)
            sys.exit(1)

        for opt, arg in opts:
            if opt in [&#039;-c&#039;]:
                self.plugins.append(&#039;cpu&#039;)
            elif opt in [&#039;-C&#039;]:
                self.cpulist = arg.split(&#039;,&#039;)
            elif opt in [&#039;-d&#039;]:
                self.plugins.append(&#039;disk&#039;)
            elif opt in [&#039;-D&#039;]:
                self.disklist = self.get_disklist(arg)
            elif opt in [&#039;--filesystem&#039;]:
                self.plugins.append(&#039;fs&#039;)
            elif opt in [&#039;-g&#039;]:
                self.plugins.append(&#039;page&#039;)
            elif opt in [&#039;-i&#039;]:
                self.plugins.append(&#039;int&#039;)
            elif opt in [&#039;-I&#039;]:
                self.intlist = arg.split(&#039;,&#039;)
            elif opt in [&#039;-l&#039;]:
                self.plugins.append(&#039;load&#039;)
            elif opt in [&#039;-m&#039;]:
                self.plugins.append(&#039;mem&#039;)
            elif opt in [&#039;-M&#039;, &#039;--mods&#039;, &#039;--modules&#039;]:
                print &gt;&gt;sys.stderr, &#039;WARNING: Option %s is deprecated, please use --%s instead&#039; % (opt, &#039; --&#039;.join(arg.split(&#039;,&#039;)))
                self.plugins += arg.split(&#039;,&#039;)
            elif opt in [&#039;-n&#039;]:
                self.plugins.append(&#039;net&#039;)
            elif opt in [&#039;-N&#039;]:
                self.netlist = arg.split(&#039;,&#039;)
            elif opt in [&#039;-p&#039;]:
                self.plugins.append(&#039;proc&#039;)
            elif opt in [&#039;-r&#039;]:
                self.plugins.append(&#039;io&#039;)
            elif opt in [&#039;-s&#039;]:
                self.plugins.append(&#039;swap&#039;)
            elif opt in [&#039;-S&#039;]:
                self.swaplist = arg.split(&#039;,&#039;)
            elif opt in [&#039;-t&#039;]:
                self.plugins.append(&#039;time&#039;)
            elif opt in [&#039;-T&#039;]:
                self.plugins.append(&#039;epoch&#039;)
            elif opt in [&#039;-y&#039;]:
                self.plugins.append(&#039;sys&#039;)

            elif opt in [&#039;-a&#039;, &#039;--all&#039;]:
                self.plugins += [ &#039;cpu&#039;, &#039;disk&#039;, &#039;net&#039;, &#039;page&#039;, &#039;sys&#039; ]
            elif opt in [&#039;-v&#039;, &#039;--vmstat&#039;]:
                self.plugins += [ &#039;proc&#039;, &#039;mem&#039;, &#039;page&#039;, &#039;disk&#039;, &#039;sys&#039;, &#039;cpu&#039; ]
            elif opt in [&#039;-f&#039;, &#039;--full&#039;]:
                self.full = True

            elif opt in [&#039;--all-plugins&#039;]:
                ### Make list unique in a fancy fast way
                plugins = {}.fromkeys(allplugins).keys()
                plugins.sort()
                self.plugins += plugins
            elif opt in [&#039;--bits&#039;]:
                self.bits = True
            elif opt in [&#039;--bw&#039;, &#039;--black-on-white&#039;]:
                self.blackonwhite = True
            elif opt in [&#039;--debug&#039;]:
                self.debug = self.debug + 1
            elif opt in [&#039;--float&#039;]:
                self.float = True
            elif opt in [&#039;--integer&#039;]:
                self.integer = True
            elif opt in [&#039;--list&#039;]:
                showplugins()
                sys.exit(0)
            elif opt in [&#039;--nocolor&#039;]:
                self.color = False
                self.update = False
            elif opt in [&#039;--noheaders&#039;]:
                self.header = False
            elif opt in [&#039;--noupdate&#039;]:
                self.update = False
            elif opt in [&#039;-o&#039;, &#039;--output&#039;]:
                self.output = arg
            elif opt in [&#039;--pidfile&#039;]:
                self.pidfile = arg
            elif opt in [&#039;--profile&#039;]:
                self.profile = &#039;dstat_profile.log&#039;
            elif opt in [&#039;-h&#039;, &#039;--help&#039;]:
                self.usage()
                self.help()
                sys.exit(0)
            elif opt in [&#039;-V&#039;, &#039;--version&#039;]:
                self.version()
                sys.exit(0)
            elif opt.startswith(&#039;--&#039;):
                self.plugins.append(opt[2:])
            else:
                print &#039;dstat: option %s unknown to getopt, try dstat -h for a list of all the options&#039; % opt
                sys.exit(1)

        if self.float and self.integer:
            print &#039;dstat: option --float and --integer are mutual exlusive, you can only force one&#039;
            sys.exit(1)

        if not self.plugins:
            print &#039;You did not select any stats, using -cdngy by default.&#039;
            self.plugins = [ &#039;cpu&#039;, &#039;disk&#039;, &#039;net&#039;, &#039;page&#039;, &#039;sys&#039; ]

        try:
            if len(args) &gt; 0: self.delay = int(args[0])
            if len(args) &gt; 1: self.count = int(args[1])
        except:
            print &#039;dstat: incorrect argument, try dstat -h for the correct syntax&#039;
            sys.exit(1)

        if self.delay &lt;= 0:
            print &#039;dstat: delay must be an integer, greater than zero&#039;
            sys.exit(1)

    def get_disklist(self, disks):
        disklist = disks.split(&#039;,&#039;)
        ret = []
        for disk in disklist:
            # e.g. /dev/sda1
            if disk[:5] == &#039;/dev/&#039;:
                # file or symlink
                if os.path.exists(disk):
                    # e.g. /dev/disk/by-uuid/15e40cc5-85de-40ea-b8fb-cb3a2eaf872
                    if os.path.islink(disk):
                        target = os.readlink(disk)
                        # convert relative pathname to absolute
                        if target[0] != &#039;/&#039;:
                            target = os.path.join(os.path.dirname(disk), target)
                            target = os.path.normpath(target)
                        print &#039;dstat: symlink %s -&gt; %s&#039; % (disk, target)
                        disk = target
                    # trim leading /dev/
                    disk = disk[5:]
                    ret.append(disk)
                else:
                    print &#039;dstat: %s does not exist&#039; % disk
            else:
                ret.append(disk)
        return ret

    def version(self):
        print &#039;Dstat %s&#039; % VERSION
        print &#039;Written by Dag Wieers &lt;dag@wieers.com&gt;&#039;
        print &#039;Homepage at http://dag.wieers.com/home-made/dstat/&#039;
        print
        print &#039;Platform %s/%s&#039; % (os.name, sys.platform)
        print &#039;Kernel %s&#039; % os.uname()[2]
        print &#039;Python %s&#039; % sys.version
        print

        color = &quot;&quot;
        if not gettermcolor(self.color):
            color = &quot;no &quot;
        print &#039;Terminal type: %s (%scolor support)&#039; % (os.getenv(&#039;TERM&#039;), color)
        rows, cols = gettermsize()
        print &#039;Terminal size: %d lines, %d columns&#039; % (rows, cols)
        print
        print &#039;Processors: %d&#039; % getcpunr()
        print &#039;Pagesize: %d&#039; % resource.getpagesize()
        print &#039;Clock ticks per secs: %d&#039; % os.sysconf(&#039;SC_CLK_TCK&#039;)
        print

        global op
        op = self
        showplugins()

    def usage(self):
        print &#039;Usage: dstat [-afv] [options..] [delay [count]]&#039;

    def help(self):
        print &#039;&#039;&#039;Versatile tool for generating system resource statistics

Dstat options:
  -c, --cpu              enable cpu stats
     -C 0,3,total           include cpu0, cpu3 and total
  -d, --disk             enable disk stats
     -D total,hda           include hda and total
  -g, --page             enable page stats
  -i, --int              enable interrupt stats
     -I 5,eth2              include int5 and interrupt used by eth2
  -l, --load             enable load stats
  -m, --mem              enable memory stats
  -n, --net              enable network stats
     -N eth1,total          include eth1 and total
  -p, --proc             enable process stats
  -r, --io               enable io stats (I/O requests completed)
  -s, --swap             enable swap stats
     -S swap1,total         include swap1 and total
  -t, --time             enable time/date output
  -T, --epoch            enable time counter (seconds since epoch)
  -y, --sys              enable system stats

  --aio                  enable aio stats
  --fs, --filesystem     enable fs stats
  --ipc                  enable ipc stats
  --lock                 enable lock stats
  --raw                  enable raw stats
  --socket               enable socket stats
  --tcp                  enable tcp stats
  --udp                  enable udp stats
  --unix                 enable unix stats
  --vm                   enable vm stats

  --plugin-name          enable plugins by plugin name (see manual)
  --list                 list all available plugins

  -a, --all              equals -cdngy (default)
  -f, --full             automatically expand -C, -D, -I, -N and -S lists
  -v, --vmstat           equals -pmgdsc -D total

  --bits                 force bits for values expressed in bytes
  --float                force float values on screen
  --integer              force integer values on screen

  --bw, --blackonwhite   change colors for white background terminal
  --nocolor              disable colors (implies --noupdate)
  --noheaders            disable repetitive headers
  --noupdate             disable intermediate updates
  --output file          write CSV output to file
  --profile              show profiling statistics when exiting dstat

delay is the delay in seconds between each update (default: 1)
count is the number of updates to display before exiting (default: unlimited)
&#039;&#039;&#039;

### START STATS DEFINITIONS ###
class dstat:
    vars = None
    name = None
    nick = None
    type = &#039;f&#039;
    width = 5
    scale = 1024
    cols = 0
#    val = {}
#    set1 = {}
#    set2 = {}

    def prepare(self):
        if callable(self.discover):
            self.discover = self.discover()
        if callable(self.vars):
            self.vars = self.vars()
        if not self.vars:
            raise Exception, &#039;No counter objects to monitor&#039;
        if callable(self.name):
            self.name = self.name()
        if callable(self.nick):
            self.nick = self.nick()
        if not self.nick:
            self.nick = self.vars

        self.val = {}; self.set1 = {}; self.set2 = {}
        if self.cols &lt;= 0:
            for name in self.vars:
                self.val[name] = self.set1[name] = self.set2[name] = 0
        else:
            for name in self.vars + [ &#039;total&#039;, ]:
                self.val[name] = range(self.cols)
                self.set1[name] = range(self.cols)
                self.set2[name] = range(self.cols)
                for i in range(self.cols):
                    self.val[name][i] = self.set1[name][i] = self.set2[name][i] = 0
#        print self.val

    def open(self, *filenames):
        &quot;Open stat file descriptor&quot;
        self.file = []
        self.fd = []
        for filename in filenames:
            try:
                fd = dopen(filename)
                if fd:
                    self.file.append(filename)
                    self.fd.append(fd)
            except:
                pass
        if not self.fd:
            raise Exception, &#039;Cannot open file %s&#039; % filename

    def readlines(self):
        &quot;Return lines from any file descriptor&quot;
        for fd in self.fd:
            fd.seek(0)
            for line in fd.readlines():
               yield line
        ### Implemented linecache (for top-plugins) but slows down normal plugins
#        for fd in self.fd:
#            i = 1
#            while True:
#                line = linecache.getline(fd.name, i);
#                if not line: break
#                yield line
#                i += 1

    def splitline(self, sep=None):
        for fd in self.fd:
            fd.seek(0)
            return fd.read().split(sep)

    def splitlines(self, sep=None, replace=None):
        &quot;Return split lines from any file descriptor&quot;
        for fd in self.fd:
            fd.seek(0)
            for line in fd.readlines():
                if replace and sep:
                    yield line.replace(replace, sep).split(sep)
                elif replace:
                    yield line.replace(replace, &#039; &#039;).split()
                else:
                    yield line.split(sep)
#        ### Implemented linecache (for top-plugins) but slows down normal plugins
#        for fd in self.fd:
#                if replace and sep:
#                    yield line.replace(replace, sep).split(sep)
#                elif replace:
#                    yield line.replace(replace, &#039; &#039;).split()
#                else:
#                    yield line.split(sep)
#                i += 1

    def statwidth(self):
        &quot;Return complete stat width&quot;
        if self.cols:
            return len(self.vars) * self.colwidth() + len(self.vars) - 1
        else:
            return len(self.nick) * self.colwidth() + len(self.nick) - 1

    def colwidth(self):
        &quot;Return column width&quot;
        if isinstance(self.name, types.StringType):
            return self.width
        else:
            return len(self.nick) * self.width + len(self.nick) - 1

    def title(self):
        ret = theme[&#039;title&#039;]
        if isinstance(self.name, types.StringType):
            width = self.statwidth()
            return ret + self.name[0:width].center(width, char[&#039;space&#039;]).replace(&#039; &#039;, &#039;-&#039;) + theme[&#039;default&#039;]
        for i, name in enumerate(self.name):
            width = self.colwidth()
            ret = ret + name[0:width].center(width, char[&#039;space&#039;]).replace(&#039; &#039;, &#039;-&#039;)
            if i + 1 != len(self.name):
                if op.color:
                    ret = ret + theme[&#039;frame&#039;] + char[&#039;dash&#039;] + theme[&#039;title&#039;]
                else:
                    ret = ret + char[&#039;space&#039;]
        return ret

    def subtitle(self):
        ret = &#039;&#039;
        if isinstance(self.name, types.StringType):
            for i, nick in enumerate(self.nick):
                ret = ret + theme[&#039;subtitle&#039;] + nick[0:self.width].center(self.width, char[&#039;space&#039;]) + theme[&#039;default&#039;]
                if i + 1 != len(self.nick): ret = ret + char[&#039;space&#039;]
            return ret
        else:
            for i, name in enumerate(self.name):
                for j, nick in enumerate(self.nick):
                    ret = ret + theme[&#039;subtitle&#039;] + nick[0:self.width].center(self.width, char[&#039;space&#039;]) + theme[&#039;default&#039;]
                    if j + 1 != len(self.nick): ret = ret + char[&#039;space&#039;]
                if i + 1 != len(self.name): ret = ret + theme[&#039;frame&#039;] + char[&#039;colon&#039;]
            return ret

    def csvtitle(self):
        if isinstance(self.name, types.StringType):
            return &#039;&quot;&#039; + self.name + &#039;&quot;&#039; + &#039;,&#039; * (len(self.nick) - 1)
        else:
            ret = &#039;&#039;
            for i, name in enumerate(self.name):
                ret = ret + &#039;&quot;&#039; + name + &#039;&quot;&#039; + &#039;,&#039; * (len(self.nick) - 1)
                if i + 1 != len(self.name): ret = ret + &#039;,&#039;
            return ret

    def csvsubtitle(self):
        ret = &#039;&#039;
        if isinstance(self.name, types.StringType):
            for i, nick in enumerate(self.nick):
                ret = ret + &#039;&quot;&#039; + nick + &#039;&quot;&#039;
                if i + 1 != len(self.nick): ret = ret + &#039;,&#039;
            return ret
        else:
            for i, name in enumerate(self.name):
                for j, nick in enumerate(self.nick):
                    ret = ret + &#039;&quot;&#039; + nick + &#039;&quot;&#039;
                    if j + 1 != len(self.nick): ret = ret + &#039;,&#039;
                if i + 1 != len(self.name): ret = ret + &#039;,&#039;
            return ret

    def check(self):
        &quot;Check if stat is applicable&quot;
#        if hasattr(self, &#039;fd&#039;) and not self.fd:
#            raise Exception, &#039;File %s does not exist&#039; % self.fd
        if not self.vars:
            raise Exception, &#039;No objects found, no stats available&#039;
        if not self.discover:
            raise Exception, &#039;No objects discovered, no stats available&#039;
        if self.colwidth():
            return True
        raise Exception, &#039;Unknown problem, please report&#039;

    def discover(self, *objlist):
        return True

    def show(self):
        &quot;Display stat results&quot;
        line = &#039;&#039;
        if hasattr(self, &#039;output&#039;):
            return cprint(self.output, self.type, self.width, self.scale)
        for i, name in enumerate(self.vars):
            if isinstance(self.val[name], types.TupleType) or isinstance(self.val[name], types.ListType):
                line = line + cprintlist(self.val[name], self.type, self.width, self.scale)
                sep = theme[&#039;frame&#039;] + char[&#039;colon&#039;]
            else:
                line = line + cprint(self.val[name], self.type, self.width, self.scale)
                sep = char[&#039;space&#039;]
            if i + 1 != len(self.vars):
                line = line + sep
        return line

    def showend(self, totlist, vislist):
        if self is not vislist[-1]:
            return theme[&#039;frame&#039;] + char[&#039;pipe&#039;]
        elif totlist != vislist:
            return theme[&#039;frame&#039;] + char[&#039;gt&#039;]
        return &#039;&#039;

    def showcsv(self):
        def printcsv(var):
            if var != round(var):
                return &#039;%.3f&#039; % var
            return &#039;%s&#039; % round(var)

        line = &#039;&#039;
        for i, name in enumerate(self.vars):
            if isinstance(self.val[name], types.ListType) or isinstance(self.val[name], types.TupleType):
                for j, val in enumerate(self.val[name]):
                    line = line + printcsv(val)
                    if j + 1 != len(self.val[name]):
                        line = line + &#039;,&#039;
            elif isinstance(self.val[name], types.StringType):
                line = line + self.val[name]
            else:
                line = line + printcsv(self.val[name])
            if i + 1 != len(self.vars):
                line = line + &#039;,&#039;
        return line

    def showcsvend(self, totlist, vislist):
        if self is not vislist[-1]:
            return &#039;,&#039;
        elif self is not totlist[-1]:
            return &#039;,&#039;
        return &#039;&#039;

class dstat_aio(dstat):
    def __init__(self):
        self.name = &#039;async&#039;
        self.nick = (&#039;#aio&#039;,)
        self.vars = (&#039;aio&#039;,)
        self.type = &#039;d&#039;
        self.width = 5;
        self.open(&#039;/proc/sys/fs/aio-nr&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 1: continue
            self.val[&#039;aio&#039;] = long(l[0])

class dstat_cpu(dstat):
    def __init__(self):
        self.nick = ( &#039;usr&#039;, &#039;sys&#039;, &#039;idl&#039;, &#039;wai&#039;, &#039;hiq&#039;, &#039;siq&#039; )
        self.type = &#039;p&#039;
        self.width = 3
        self.scale = 34
        self.open(&#039;/proc/stat&#039;)
        self.cols = 6

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) &lt; 8 or l[0][0:3] != &#039;cpu&#039;: continue
            ret.append(l[0][3:])
        ret.sort()
        for item in objlist: ret.append(item)
        return ret

    def vars(self):
        ret = []
        if op.cpulist:
            varlist = op.cpulist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = []
            cpu = 0
            while cpu &lt; cpunr:
                varlist.append(str(cpu))
                cpu = cpu + 1
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
        for name in varlist:
            if name in self.discover + [&#039;total&#039;]:
                ret.append(name)
        return ret

    def name(self):
        ret = []
        for name in self.vars:
            if name == &#039;total&#039;:
                ret.append(&#039;total cpu usage&#039;)
            else:
                ret.append(&#039;cpu&#039; + name + &#039; usage&#039;)
        return ret

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 8: continue
            for name in self.vars:
                if l[0] == &#039;cpu&#039; + name or ( l[0] == &#039;cpu&#039; and name == &#039;total&#039; ):
                    self.set2[name] = ( long(l[1]) + long(l[2]), long(l[3]), long(l[4]), long(l[5]), long(l[6]), long(l[7]) )
        for name in self.vars:
            for i in range(6):
                if sum(self.set2[name]) &gt; sum(self.set1[name]):
                    self.val[name][i] = 100.0 * (self.set2[name][i] - self.set1[name][i]) / (sum(self.set2[name]) - sum(self.set1[name]))
                else:
                    self.val[name][i] = 0
#                    print &gt;&gt;sys.stderr, &quot;Error: tick problem detected, this should never happen !&quot;
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_cpu24(dstat):
    def __init__(self):
        self.nick = ( &#039;usr&#039;, &#039;sys&#039;, &#039;idl&#039;)
        self.type = &#039;p&#039;
        self.width = 3
        self.scale = 34
        self.open(&#039;/proc/stat&#039;)
        self.cols = 3

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) != 5 or l[0][0:3] != &#039;cpu&#039;: continue
            ret.append(l[0][3:])
        ret.sort()
        for item in objlist: ret.append(item)
        return ret

    def vars(self):
        ret = []
        if op.cpulist:
            varlist = op.cpulist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = []
            cpu = 0
            while cpu &lt; cpunr:
                varlist.append(str(cpu))
                cpu = cpu + 1
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
        for name in varlist:
            if name in self.discover + [&#039;total&#039;]:
                ret.append(name)
        return ret

    def name(self):
        ret = []
        for name in self.vars:
            if name == &#039;total&#039;:
                ret.append(&#039;cpu usage&#039;)
            else:
                ret.append(&#039;cpu&#039; + name)
        return ret

    def extract(self):
        for l in self.splitlines():
            for name in self.vars:
                if l[0] == &#039;cpu&#039; + name or ( l[0] == &#039;cpu&#039; and name == &#039;total&#039; ):
                    self.set2[name] = ( long(l[1]) + long(l[2]), long(l[3]), long(l[4]) )
        for name in self.vars:
            for i in range(3):
                self.val[name][i] = 100.0 * (self.set2[name][i] - self.set1[name][i]) / (sum(self.set2[name]) - sum(self.set1[name]))
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_disk(dstat):
    def __init__(self):
        self.nick = (&#039;read&#039;, &#039;writ&#039;)
        self.type = &#039;b&#039;
        self.diskfilter = re.compile(&#039;^(dm-\d+|md\d+|[hsv]d[a-z]+\d+)$&#039;)
        self.open(&#039;/proc/diskstats&#039;)
        self.cols = 2

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) &lt; 13: continue
            if l[3:] == [&#039;0&#039;,] * 11: continue
            name = l[2]
            ret.append(name)
        for item in objlist: ret.append(item)
        if not ret:
            raise Exception, &quot;No suitable block devices found to monitor&quot;
        return ret

    def vars(self):
        ret = []
        if op.disklist:
            varlist = op.disklist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = []
            for name in self.discover:
                if self.diskfilter.match(name): continue
                if name not in blockdevices(): continue
                varlist.append(name)
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
            varlist.sort()
        for name in varlist:
            if name in self.discover + [&#039;total&#039;] + op.diskset.keys():
                ret.append(name)
        return ret

    def name(self):
        return [&#039;dsk/&#039;+sysfs_dev(name) for name in self.vars]

    def extract(self):
        for name in self.vars: self.set2[name] = (0, 0)
        for l in self.splitlines():
            if len(l) &lt; 13: continue
            if l[5] == &#039;0&#039; and l[9] == &#039;0&#039;: continue
            name = l[2]
            if l[3:] == [&#039;0&#039;,] * 11: continue
            if not self.diskfilter.match(name):
                self.set2[&#039;total&#039;] = ( self.set2[&#039;total&#039;][0] + long(l[5]), self.set2[&#039;total&#039;][1] + long(l[9]) )
            if name in self.vars and name != &#039;total&#039;:
                self.set2[name] = ( self.set2[name][0] + long(l[5]), self.set2[name][1] + long(l[9]) )
            for diskset in self.vars:
                if diskset in op.diskset.keys():
                    for disk in op.diskset[diskset]:
                        if re.match(&#039;^&#039;+disk+&#039;$&#039;, name):
                            self.set2[diskset] = ( self.set2[diskset][0] + long(l[5]), self.set2[diskset][1] + long(l[9]) )
        for name in self.set2.keys():
            self.val[name] = (
                (self.set2[name][0] - self.set1[name][0]) * 512.0 / elapsed,
                (self.set2[name][1] - self.set1[name][1]) * 512.0 / elapsed,
            )
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_disk24(dstat):
    def __init__(self):
        self.nick = (&#039;read&#039;, &#039;writ&#039;)
        self.type = &#039;b&#039;
        self.diskfilter = re.compile(&#039;(dm-\d+|md\d+|[hsv]d[a-z]+\d+)&#039;)
        self.open(&#039;/proc/partitions&#039;)
        if self.fd and not self.discover:
            raise Exception, &#039;Kernel is not compiled with CONFIG_BLK_STATS&#039;
        self.cols = 2

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) &lt; 15 or l[0] == &#039;major&#039; or int(l[1]) % 16 != 0: continue
            name = l[3]
            ret.append(name)
        for item in objlist: ret.append(item)
        if not ret:
            raise Exception, &quot;No suitable block devices found to monitor&quot;
        return ret

    def vars(self):
        ret = []
        if op.disklist:
            varlist = op.disklist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = []
            for name in self.discover:
                if self.diskfilter.match(name): continue
                varlist.append(name)
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
            varlist.sort()
        for name in varlist:
            if name in self.discover + [&#039;total&#039;] + op.diskset.keys():
                ret.append(name)
        return ret

    def name(self):
        return [&#039;dsk/&#039;+sysfs_dev(name) for name in self.vars]

    def extract(self):
        for name in self.vars: self.set2[name] = (0, 0)
        for l in self.splitlines():
            if len(l) &lt; 15 or l[0] == &#039;major&#039; or int(l[1]) % 16 != 0: continue
            name = l[3]
            if not self.diskfilter.match(name):
                self.set2[&#039;total&#039;] = ( self.set2[&#039;total&#039;][0] + long(l[6]), self.set2[&#039;total&#039;][1] + long(l[10]) )
            if name in self.vars:
                self.set2[name] = ( self.set2[name][0] + long(l[6]), self.set2[name][1] + long(l[10]) )
            for diskset in self.vars:
                if diskset in op.diskset.keys():
                    for disk in op.diskset[diskset]:
                        if re.match(&#039;^&#039;+disk+&#039;$&#039;, name):
                            self.set2[diskset] = ( self.set2[diskset][0] + long(l[6]), self.set2[diskset][1] + long(l[10]) )
        for name in self.set2.keys():
            self.val[name] = (
                (self.set2[name][0] - self.set1[name][0]) * 512.0 / elapsed,
                (self.set2[name][1] - self.set1[name][1]) * 512.0 / elapsed,
            )
        if step == op.delay:
            self.set1.update(self.set2)

### FIXME: Needs rework, does anyone care ?
class dstat_disk24old(dstat):
    def __init__(self):
        self.nick = (&#039;read&#039;, &#039;writ&#039;)
        self.type = &#039;b&#039;
        self.diskfilter = re.compile(&#039;(dm-\d+|md\d+|[hsv]d[a-z]+\d+)&#039;)
        self.regexp = re.compile(&#039;^\((\d+),(\d+)\):\(\d+,\d+,(\d+),\d+,(\d+)\)$&#039;)
        self.open(&#039;/proc/stat&#039;)
        self.cols = 2

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines(&#039;:&#039;):
            if len(l) &lt; 3: continue
            name = l[0]
            if name != &#039;disk_io&#039;: continue
            for pair in line.split()[1:]:
                m = self.regexp.match(pair)
                if not m: continue
                l = m.groups()
                if len(l) &lt; 4: continue
                name = dev(int(l[0]), int(l[1]))
                ret.append(name)
            break
        for item in objlist: ret.append(item)
        if not ret:
            raise Exception, &quot;No suitable block devices found to monitor&quot;
        return ret

    def vars(self):
        ret = []
        if op.disklist:
            varlist = op.disklist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = []
            for name in self.discover:
                if self.diskfilter.match(name): continue
                varlist.append(name)
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
            varlist.sort()
        for name in varlist:
            if name in self.discover + [&#039;total&#039;] + op.diskset.keys():
                ret.append(name)
        return ret

    def name(self):
        return [&#039;dsk/&#039;+name for name in self.vars]

    def extract(self):
        for name in self.vars: self.set2[name] = (0, 0)
        for line in self.splitlines(&#039;:&#039;):
            if len(l) &lt; 3: continue
            name = l[0]
            if name != &#039;disk_io&#039;: continue
            for pair in line.split()[1:]:
                m = self.regexp.match(pair)
                if not m: continue
                l = m.groups()
                if len(l) &lt; 4: continue
                name = dev(int(l[0]), int(l[1]))
                if not self.diskfilter.match(name):
                    self.set2[&#039;total&#039;] = ( self.set2[&#039;total&#039;][0] + long(l[2]), self.set2[&#039;total&#039;][1] + long(l[3]) )
                if name in self.vars and name != &#039;total&#039;:
                    self.set2[name] = ( self.set2[name][0] + long(l[2]), self.set2[name][1] + long(l[3]) )
                for diskset in self.vars:
                    if diskset in op.diskset.keys():
                        for disk in op.diskset[diskset]:
                            if re.match(&#039;^&#039;+disk+&#039;$&#039;, name):
                                self.set2[diskset] = ( self.set2[diskset][0] + long(l[2]), self.set2[diskset][1] + long(l[3]) )
            break
        for name in self.set2.keys():
            self.val[name] = (
                (self.set2[name][0] - self.set1[name][0]) * 512.0 / elapsed,
                (self.set2[name][1] - self.set1[name][1]) * 512.0 / elapsed,
            )
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_epoch(dstat):
    def __init__(self):
        self.name = &#039;epoch&#039;
        self.vars = (&#039;epoch&#039;,)
        self.width = 10
        if op.debug:
            self.width = 13
        self.scale = 0

    ### We are now using the starttime instead of the execution time of this plugin
    def extract(self):
#        self.val[&#039;epoch&#039;] = time.time()
        self.val[&#039;epoch&#039;] = starttime

class dstat_fs(dstat):
    def __init__(self):
        self.name = &#039;filesystem&#039;
        self.vars = (&#039;files&#039;, &#039;inodes&#039;)
        self.type = &#039;d&#039;
        self.width = 6
        self.scale = 1000

    def extract(self):
        for line in dopen(&#039;/proc/sys/fs/file-nr&#039;):
            l = line.split()
            if len(l) &lt; 1: continue
            self.val[&#039;files&#039;] = long(l[0])
        for line in dopen(&#039;/proc/sys/fs/inode-nr&#039;):
            l = line.split()
            if len(l) &lt; 2: continue
            self.val[&#039;inodes&#039;] = long(l[0]) - long(l[1])

class dstat_int(dstat):
    def __init__(self):
        self.name = &#039;interrupts&#039;
        self.type = &#039;d&#039;
        self.width = 5
        self.scale = 1000
        self.open(&#039;/proc/stat&#039;)
        self.intmap = self.intmap()

    def intmap(self):
        ret = {}
        for line in dopen(&#039;/proc/interrupts&#039;):
            l = line.split()
            if len(l) &lt;= cpunr: continue
            l1 = l[0].split(&#039;:&#039;)[0]
            l2 = &#039; &#039;.join(l[cpunr+2:]).split(&#039;,&#039;)
            ret[l1] = l1
            for name in l2:
                ret[name.strip().lower()] = l1
        return ret

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if l[0] != &#039;intr&#039;: continue
            for name, i in enumerate(l[2:]):
                if long(i) &gt; 10: ret.append(str(name))
        return ret

#   def check(self):
#       if self.fd[0] and self.vars:
#           self.fd[0].seek(0)
#           for l in self.fd[0].splitlines():
#               if l[0] != &#039;intr&#039;: continue
#               return True
#       return False

    def vars(self):
        ret = []
        if op.intlist:
            varlist = op.intlist
        else:
            varlist = self.discover
            for name in varlist:
                if name in (&#039;0&#039;, &#039;1&#039;, &#039;2&#039;, &#039;8&#039;, &#039;NMI&#039;, &#039;LOC&#039;, &#039;MIS&#039;, &#039;CPU0&#039;):
                    varlist.remove(name)
            if not op.full and len(varlist) &gt; 3: varlist = varlist[-3:]
        for name in varlist:
            if name in self.discover + [&#039;total&#039;,]:
                ret.append(name)
            elif name.lower() in self.intmap.keys():
                ret.append(self.intmap[name.lower()])
        return ret

    def extract(self):
        for l in self.splitlines():
            if not l or l[0] != &#039;intr&#039;: continue
            for name in self.vars:
                if name != &#039;total&#039;:
                    self.set2[name] = long(l[int(name) + 2])
            self.set2[&#039;total&#039;] = long(l[1])
        for name in self.vars:
            self.val[name] = (self.set2[name] - self.set1[name]) * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_int24(dstat):
    def __init__(self):
        self.name = &#039;interrupts&#039;
        self.type = &#039;d&#039;
        self.width = 5
        self.scale = 1000
        self.open(&#039;/proc/interrupts&#039;)

    def intmap(self):
        ret = {}
        for l in self.splitlines():
            if len(l) &lt;= cpunr: continue
            l1 = l[0].split(&#039;:&#039;)[0]
            l2 = &#039; &#039;.join(l[cpunr+2:]).split(&#039;,&#039;)
            ret[l1] = l1
            for name in l2:
                ret[name.strip().lower()] = l1
        return ret

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) &lt; cpunr+1: continue
            name = l[0].split(&#039;:&#039;)[0]
            if long(l[1]) &gt; 10:
                ret.append(name)
        return ret

#   def check(self):
#       if self.fd and self.discover:
#           self.fd[0].seek(0)
#           for l in self.fd[0].splitlines():
#               if l[0] != &#039;intr&#039; or len(l) &gt; 2: continue
#               return True
#       return False

    def vars(self):
        ret = []
        if op.intlist:
            varlist = op.intlist
        else:
            varlist = self.discover
            for name in varlist:
                if name in (&#039;0&#039;, &#039;1&#039;, &#039;2&#039;, &#039;8&#039;, &#039;CPU0&#039;, &#039;ERR&#039;, &#039;LOC&#039;, &#039;MIS&#039;, &#039;NMI&#039;):
                    varlist.remove(name)
            if not op.full and len(varlist) &gt; 3: varlist = varlist[-3:]
        for name in varlist:
            if name in self.discover:
                ret.append(name)
            elif name.lower() in self.intmap.keys():
                ret.append(self.intmap[name.lower()])
        return ret

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; cpunr+1: continue
            name = l[0].split(&#039;:&#039;)[0]
            if name in self.vars:
                self.set2[name] = 0
                for i in l[1:1+cpunr]:
                    self.set2[name] = self.set2[name] + long(i)
#           elif len(l) &gt; 2 + cpunr:
#               for hw in self.vars:
#                   for mod in l[2+cpunr:]:
#                       self.set2[mod] = long(l[1])
        for name in self.set2.keys():
            self.val[name] = (self.set2[name] - self.set1[name]) * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_io(dstat):
    def __init__(self):
        self.nick = (&#039;read&#039;, &#039;writ&#039;)
        self.type = &#039;f&#039;
        self.width = 5
        self.scale = 1000
        self.diskfilter = re.compile(&#039;(dm-\d+|md\d+|[hsv]d[a-z]+\d+)&#039;)
        self.open(&#039;/proc/diskstats&#039;)
        self.cols = 3

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) &lt; 13: continue
            if l[3:] == [&#039;0&#039;,] * 11: continue
            name = l[2]
            ret.append(name)
        for item in objlist: ret.append(item)
        if not ret:
            raise Exception, &quot;No suitable block devices found to monitor&quot;
        return ret

    def vars(self):
        ret = []
        if op.disklist:
            varlist = op.disklist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = []
            for name in self.discover:
                if self.diskfilter.match(name): continue
                if name not in blockdevices(): continue
                varlist.append(name)
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
            varlist.sort()
        for name in varlist:
            if name in self.discover + [&#039;total&#039;] + op.diskset.keys():
                ret.append(name)
        return ret

    def name(self):
        return [&#039;io/&#039;+name for name in self.vars]

    def extract(self):
        for name in self.vars: self.set2[name] = (0, 0)
        for l in self.splitlines():
            if len(l) &lt; 13: continue
            if l[3] == &#039;0&#039; and l[7] == &#039;0&#039;: continue
            name = l[2]
            if l[3:] == [&#039;0&#039;,] * 11: continue
            if not self.diskfilter.match(name):
                self.set2[&#039;total&#039;] = ( self.set2[&#039;total&#039;][0] + long(l[3]), self.set2[&#039;total&#039;][1] + long(l[7]) )
            if name in self.vars and name != &#039;total&#039;:
                self.set2[name] = ( self.set2[name][0] + long(l[3]), self.set2[name][1] + long(l[7]) )
            for diskset in self.vars:
                if diskset in op.diskset.keys():
                    for disk in op.diskset[diskset]:
                        if re.match(&#039;^&#039;+disk+&#039;$&#039;, name):
                            self.set2[diskset] = ( self.set2[diskset][0] + long(l[3]), self.set2[diskset][1] + long(l[7]) )
        for name in self.set2.keys():
            self.val[name] = (
                (self.set2[name][0] - self.set1[name][0]) * 1.0 / elapsed,
                (self.set2[name][1] - self.set1[name][1]) * 1.0 / elapsed,
            )
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_ipc(dstat):
    def __init__(self):
        self.name = &#039;sysv ipc&#039;
        self.vars = (&#039;msg&#039;, &#039;sem&#039;, &#039;shm&#039;)
        self.type = &#039;d&#039;
        self.width = 3
        self.scale = 10

    def extract(self):
        for name in self.vars:
            self.val[name] = len(dopen(&#039;/proc/sysvipc/&#039;+name).readlines()) - 1

class dstat_load(dstat):
    def __init__(self):
        self.name = &#039;load avg&#039;
        self.nick = (&#039;1m&#039;, &#039;5m&#039;, &#039;15m&#039;)
        self.vars = (&#039;load1&#039;, &#039;load5&#039;, &#039;load15&#039;)
        self.type = &#039;f&#039;
        self.width = 4
        self.scale = 0.5
        self.open(&#039;/proc/loadavg&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 3: continue
            self.val[&#039;load1&#039;] = float(l[0])
            self.val[&#039;load5&#039;] = float(l[1])
            self.val[&#039;load15&#039;] = float(l[2])

class dstat_lock(dstat):
    def __init__(self):
        self.name = &#039;file locks&#039;
        self.nick = (&#039;pos&#039;, &#039;lck&#039;, &#039;rea&#039;, &#039;wri&#039;)
        self.vars = (&#039;posix&#039;, &#039;flock&#039;, &#039;read&#039;, &#039;write&#039;)
        self.type = &#039;f&#039;
        self.width = 3
        self.scale = 10
        self.open(&#039;/proc/locks&#039;)

    def extract(self):
        for name in self.vars: self.val[name] = 0
        for l in self.splitlines():
            if len(l) &lt; 4: continue
            if l[1] == &#039;POSIX&#039;: self.val[&#039;posix&#039;] += 1
            elif l[1] == &#039;FLOCK&#039;: self.val[&#039;flock&#039;] += 1
            if l[3] == &#039;READ&#039;: self.val[&#039;read&#039;] += 1
            elif l[3] == &#039;WRITE&#039;: self.val[&#039;write&#039;] += 1

class dstat_mem(dstat):
    def __init__(self):
        self.name = &#039;memory usage&#039;
        self.nick = (&#039;used&#039;, &#039;buff&#039;, &#039;cach&#039;, &#039;free&#039;)
        self.vars = (&#039;MemUsed&#039;, &#039;Buffers&#039;, &#039;Cached&#039;, &#039;MemFree&#039;)
        self.open(&#039;/proc/meminfo&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 2: continue
            name = l[0].split(&#039;:&#039;)[0]
            if name in self.vars + (&#039;MemTotal&#039;, ):
                self.val[name] = long(l[1]) * 1024.0
        self.val[&#039;MemUsed&#039;] = self.val[&#039;MemTotal&#039;] - self.val[&#039;MemFree&#039;] - self.val[&#039;Buffers&#039;] - self.val[&#039;Cached&#039;]

class dstat_net(dstat):
    def __init__(self):
        self.nick = (&#039;recv&#039;, &#039;send&#039;)
        self.type = &#039;b&#039;
        self.totalfilter = re.compile(&#039;^(lo|bond\d+|face|.+\.\d+)$&#039;)
        self.open(&#039;/proc/net/dev&#039;)
        self.cols = 2

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines(replace=&#039;:&#039;):
            if len(l) &lt; 17: continue
            if l[2] == &#039;0&#039; and l[10] == &#039;0&#039;: continue
            name = l[0]
            if name not in (&#039;lo&#039;, &#039;face&#039;):
                ret.append(name)
        ret.sort()
        for item in objlist: ret.append(item)
        return ret

    def vars(self):
        ret = []
        if op.netlist:
            varlist = op.netlist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = self.discover
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
            varlist.sort()
        for name in varlist:
            if name in self.discover + [&#039;total&#039;, &#039;lo&#039;]:
                ret.append(name)
        if not ret:
            raise Exception, &quot;No suitable network interfaces found to monitor&quot;
        return ret

    def name(self):
        return [&#039;net/&#039;+name for name in self.vars]

    def extract(self):
        self.set2[&#039;total&#039;] = [0, 0]
        for l in self.splitlines(replace=&#039;:&#039;):
            if len(l) &lt; 17: continue
            if l[2] == &#039;0&#039; and l[10] == &#039;0&#039;: continue
            name = l[0]
            if name in self.vars :
                self.set2[name] = ( long(l[1]), long(l[9]) )
            if not self.totalfilter.match(name):
                self.set2[&#039;total&#039;] = ( self.set2[&#039;total&#039;][0] + long(l[1]), self.set2[&#039;total&#039;][1] + long(l[9]))
        if update:
            for name in self.set2.keys():
                self.val[name] = [
                    (self.set2[name][0] - self.set1[name][0]) * 1.0 / elapsed,
                    (self.set2[name][1] - self.set1[name][1]) * 1.0 / elapsed,
                ]
                if self.val[name][0] &lt; 0: self.val[name][0] += maxint + 1
                if self.val[name][1] &lt; 0: self.val[name][1] += maxint + 1
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_page(dstat):
    def __init__(self):
        self.name = &#039;paging&#039;
        self.nick = (&#039;in&#039;, &#039;out&#039;)
        self.vars = (&#039;pswpin&#039;, &#039;pswpout&#039;)
        self.type = &#039;d&#039;
        self.open(&#039;/proc/vmstat&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 2: continue
            name = l[0]
            if name in self.vars:
                self.set2[name] = long(l[1])
        for name in self.vars:
            self.val[name] = (self.set2[name] - self.set1[name]) * pagesize * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_page24(dstat):
    def __init__(self):
        self.name = &#039;paging&#039;
        self.nick = (&#039;in&#039;, &#039;out&#039;)
        self.vars = (&#039;pswpin&#039;, &#039;pswpout&#039;)
        self.type = &#039;d&#039;
        self.open(&#039;/proc/stat&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 3: continue
            name = l[0]
            if name != &#039;swap&#039;: continue
            self.set2[&#039;pswpin&#039;] = long(l[1])
            self.set2[&#039;pswpout&#039;] = long(l[2])
            break
        for name in self.vars:
            self.val[name] = (self.set2[name] - self.set1[name]) * pagesize * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_proc(dstat):
    def __init__(self):
        self.name = &#039;procs&#039;
        self.nick = (&#039;run&#039;, &#039;blk&#039;, &#039;new&#039;)
        self.vars = (&#039;procs_running&#039;, &#039;procs_blocked&#039;, &#039;processes&#039;)
        self.type = &#039;f&#039;
        self.width = 3
        self.scale = 10
        self.open(&#039;/proc/stat&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 2: continue
            name = l[0]
            if name == &#039;processes&#039;:
                self.val[&#039;processes&#039;] = 0
                self.set2[name] = long(l[1])
            elif name == &#039;procs_running&#039;:
                self.set2[name] = self.set2[name] + long(l[1]) - 1
            elif name == &#039;procs_blocked&#039;:
                self.set2[name] = self.set2[name] + long(l[1])
        self.val[&#039;processes&#039;] = (self.set2[&#039;processes&#039;] - self.set1[&#039;processes&#039;]) * 1.0 / elapsed
        for name in (&#039;procs_running&#039;, &#039;procs_blocked&#039;):
            self.val[name] = self.set2[name] * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)
            for name in (&#039;procs_running&#039;, &#039;procs_blocked&#039;):
                self.set2[name] = 0

class dstat_raw(dstat):
    def __init__(self):
        self.name = &#039;raw&#039;
        self.nick = (&#039;raw&#039;,)
        self.vars = (&#039;sockets&#039;,)
        self.type = &#039;d&#039;
        self.width = 3
        self.scale = 100
        self.open(&#039;/proc/net/raw&#039;)

    def extract(self):
        lines = -1
        for line in self.readlines():
            lines += 1
        self.val[&#039;sockets&#039;] = lines
        ### Cannot use len() on generator
#        self.val[&#039;sockets&#039;] = len(self.readlines()) - 1

class dstat_socket(dstat):
    def __init__(self):
        self.name = &#039;sockets&#039;
        self.type = &#039;d&#039;
        self.width = 3
        self.scale = 100
        self.open(&#039;/proc/net/sockstat&#039;)
        self.nick = (&#039;tot&#039;, &#039;tcp&#039;, &#039;udp&#039;, &#039;raw&#039;, &#039;frg&#039;)
        self.vars = (&#039;sockets:&#039;, &#039;TCP:&#039;, &#039;UDP:&#039;, &#039;RAW:&#039;, &#039;FRAG:&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 3: continue
            self.val[l[0]] = long(l[2])
        self.val[&#039;other&#039;] = self.val[&#039;sockets:&#039;] - self.val[&#039;TCP:&#039;] - self.val[&#039;UDP:&#039;] - self.val[&#039;RAW:&#039;] - self.val[&#039;FRAG:&#039;]

class dstat_swap(dstat):
    def __init__(self):
        self.name = &#039;swap&#039;
        self.nick = (&#039;used&#039;, &#039;free&#039;)
        self.type = &#039;d&#039;
        self.open(&#039;/proc/swaps&#039;)

    def discover(self, *objlist):
        ret = []
        for l in self.splitlines():
            if len(l) &lt; 5: continue
            if l[0] == &#039;Filename&#039;: continue
            try: 
                int(l[2])
                int(l[3])
            except:
                continue
#           ret.append(improve(l[0]))
            ret.append(l[0])
        ret.sort()
        for item in objlist: ret.append(item)
        return ret

    def vars(self):
        ret = []
        if op.swaplist:
            varlist = op.swaplist
        elif not op.full:
            varlist = (&#039;total&#039;,)
        else:
            varlist = self.discover
#           if len(varlist) &gt; 2: varlist = varlist[0:2]
            varlist.sort()
        for name in varlist:
            if name in self.discover + [&#039;total&#039;]:
                ret.append(name)
        if not ret:
            raise Exception, &quot;No suitable swap devices found to monitor&quot;
        return ret

    def name(self):
        return [&#039;swp/&#039;+improve(name) for name in self.vars]

    def extract(self):
        self.val[&#039;total&#039;] = [0, 0]
        for l in self.splitlines():
            if len(l) &lt; 5 or l[0] == &#039;Filename&#039;: continue
            name = l[0]
            self.val[name] = ( long(l[3]) * 1024.0, (long(l[2]) - long(l[3])) * 1024.0 )
            self.val[&#039;total&#039;] = ( self.val[&#039;total&#039;][0] + self.val[name][0], self.val[&#039;total&#039;][1] + self.val[name][1])

class dstat_swapold(dstat):
    def __init__(self):
        self.name = &#039;swap&#039;
        self.nick = (&#039;used&#039;, &#039;free&#039;)
        self.vars = (&#039;SwapUsed&#039;, &#039;SwapFree&#039;)
        self.type = &#039;d&#039;
        self.open(&#039;/proc/meminfo&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 2: continue
            name = l[0].split(&#039;:&#039;)[0]
            if name in self.vars + (&#039;SwapTotal&#039;,):
                self.val[name] = long(l[1]) * 1024.0
        self.val[&#039;SwapUsed&#039;] = self.val[&#039;SwapTotal&#039;] - self.val[&#039;SwapFree&#039;]

class dstat_sys(dstat):
    def __init__(self):
        self.name = &#039;system&#039;
        self.nick = (&#039;int&#039;, &#039;csw&#039;)
        self.vars = (&#039;intr&#039;, &#039;ctxt&#039;)
        self.type = &#039;d&#039;
        self.width = 5
        self.scale = 1000
        self.open(&#039;/proc/stat&#039;)

    def extract(self):
        for l in self.splitlines():
            if len(l) &lt; 2: continue
            name = l[0]
            if name in self.vars:
                self.set2[name] = long(l[1])
        for name in self.vars:
            self.val[name] = (self.set2[name] - self.set1[name]) * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)

class dstat_tcp(dstat):
    def __init__(self):
        self.name = &#039;tcp sockets&#039;
        self.nick = (&#039;lis&#039;, &#039;act&#039;, &#039;syn&#039;, &#039;tim&#039;, &#039;clo&#039;)
        self.vars = (&#039;listen&#039;, &#039;established&#039;, &#039;syn&#039;, &#039;wait&#039;, &#039;close&#039;)
        self.type = &#039;d&#039;
        self.width = 3
        self.scale = 100
        self.open(&#039;/proc/net/tcp&#039;, &#039;/proc/net/tcp6&#039;)

    def extract(self):
        for name in self.vars: self.val[name] = 0
        for l in self.splitlines():
            if len(l) &lt; 12: continue
            ### 01: established, 02: syn_sent,  03: syn_recv, 04: fin_wait1,
            ### 05: fin_wait2,   06: time_wait, 07: close,    08: close_wait,
            ### 09: last_ack,    0A: listen,    0B: closing
            if l[3] in (&#039;0A&#039;,): self.val[&#039;listen&#039;] += 1
            elif l[3] in (&#039;01&#039;,): self.val[&#039;established&#039;] += 1
            elif l[3] in (&#039;02&#039;, &#039;03&#039;, &#039;09&#039;,): self.val[&#039;syn&#039;] += 1
            elif l[3] in (&#039;06&#039;,): self.val[&#039;wait&#039;] += 1
            elif l[3] in (&#039;04&#039;, &#039;05&#039;, &#039;07&#039;, &#039;08&#039;, &#039;0B&#039;,): self.val[&#039;close&#039;] += 1

class dstat_time(dstat):
    def __init__(self):
        self.name = &#039;system&#039;
        self.timefmt = os.getenv(&#039;DSTAT_TIMEFMT&#039;) or &#039;%d-%m %H:%M:%S&#039;
        self.type = &#039;s&#039;
        if op.debug:
            self.width = len(time.strftime(self.timefmt, time.localtime())) + 4
        else:
            self.width = len(time.strftime(self.timefmt, time.localtime()))
        self.scale = 0
        self.vars = (&#039;time&#039;,)

    ### We are now using the starttime for this plugin, not the execution time of this plugin
    def extract(self):
        if op.debug:
            self.val[&#039;time&#039;] = time.strftime(self.timefmt, time.localtime(starttime)) + &quot;.%03d&quot; % (round(starttime * 1000 % 1000 ))
        else:
            self.val[&#039;time&#039;] = time.strftime(self.timefmt, time.localtime(starttime))

class dstat_udp(dstat):
    def __init__(self):
        self.name = &#039;udp&#039;
        self.nick = (&#039;lis&#039;, &#039;act&#039;)
        self.vars = (&#039;listen&#039;, &#039;established&#039;)
        self.type = &#039;d&#039;
        self.width = 3
        self.scale = 100
        self.open(&#039;/proc/net/udp&#039;, &#039;/proc/net/udp6&#039;)

    def extract(self):
        for name in self.vars: self.val[name] = 0
        for l in self.splitlines():
            if l[3] == &#039;07&#039;: self.val[&#039;listen&#039;] += 1
            elif l[3] == &#039;01&#039;: self.val[&#039;established&#039;] += 1

class dstat_unix(dstat):
    def __init__(self):
        self.name = &#039;unix sockets&#039;
        self.nick = (&#039;dgm&#039;, &#039;str&#039;, &#039;lis&#039;, &#039;act&#039;)
        self.vars = (&#039;datagram&#039;, &#039;stream&#039;, &#039;listen&#039;, &#039;established&#039;)
        self.type = &#039;d&#039;
        self.width = 3
        self.scale = 100
        self.open(&#039;/proc/net/unix&#039;)

    def extract(self):
        for name in self.vars: self.val[name] = 0
        for l in self.splitlines():
            if l[4] == &#039;0002&#039;: self.val[&#039;datagram&#039;] += 1
            elif l[4] == &#039;0001&#039;:
                self.val[&#039;stream&#039;] += 1
                if l[5] == &#039;01&#039;: self.val[&#039;listen&#039;] += 1
                elif l[5] == &#039;03&#039;: self.val[&#039;established&#039;] += 1

class dstat_vm(dstat):
    def __init__(self):
        self.name = &#039;virtual memory&#039;
        self.nick = (&#039;majpf&#039;, &#039;minpf&#039;, &#039;alloc&#039;, &#039;free&#039;)
        self.vars = (&#039;pgmajfault&#039;, &#039;pgfault&#039;, &#039;pgalloc&#039;, &#039;pgfree&#039;)
        self.type = &#039;d&#039;
        self.width = 5
        self.scale = 1000
        self.open(&#039;/proc/vmstat&#039;)

    ### Page allocations should include all page zones, not just ZONE_NORMAL,
    ### but also ZONE_DMA, ZONE_HIGHMEM, ZONE_DMA32 (depending on architecture)
    def extract(self):
        self.set2[&#039;pgalloc&#039;] = 0
        for l in self.splitlines():
            if len(l) &lt; 2: continue
            if l[0].startswith(&#039;pgalloc_&#039;):
                self.set2[&#039;pgalloc&#039;] += long(l[1])
            elif l[0] in self.vars:
                self.set2[l[0]] = long(l[1])
        for name in self.vars:
            self.val[name] = (self.set2[name] - self.set1[name]) * 1.0 / elapsed
        if step == op.delay:
            self.set1.update(self.set2)

### END STATS DEFINITIONS ###

ansi = {
    &#039;black&#039;: &#039;\033[0;30m&#039;,
    &#039;darkred&#039;: &#039;\033[0;31m&#039;,
    &#039;darkgreen&#039;: &#039;\033[0;32m&#039;,
    &#039;darkyellow&#039;: &#039;\033[0;33m&#039;,
    &#039;darkblue&#039;: &#039;\033[0;34m&#039;,
    &#039;darkmagenta&#039;: &#039;\033[0;35m&#039;,
    &#039;darkcyan&#039;: &#039;\033[0;36m&#039;,
    &#039;gray&#039;: &#039;\033[0;37m&#039;,

    &#039;darkgray&#039;: &#039;\033[1;30m&#039;,
    &#039;red&#039;: &#039;\033[1;31m&#039;,
    &#039;green&#039;: &#039;\033[1;32m&#039;,
    &#039;yellow&#039;: &#039;\033[1;33m&#039;,
    &#039;blue&#039;: &#039;\033[1;34m&#039;,
    &#039;magenta&#039;: &#039;\033[1;35m&#039;,
    &#039;cyan&#039;: &#039;\033[1;36m&#039;,
    &#039;white&#039;: &#039;\033[1;37m&#039;,

    &#039;blackbg&#039;: &#039;\033[40m&#039;,
    &#039;redbg&#039;: &#039;\033[41m&#039;,
    &#039;greenbg&#039;: &#039;\033[42m&#039;,
    &#039;yellowbg&#039;: &#039;\033[43m&#039;,
    &#039;bluebg&#039;: &#039;\033[44m&#039;,
    &#039;magentabg&#039;: &#039;\033[45m&#039;,
    &#039;cyanbg&#039;: &#039;\033[46m&#039;,
    &#039;whitebg&#039;: &#039;\033[47m&#039;,

    &#039;reset&#039;: &#039;\033[0;0m&#039;,
    &#039;bold&#039;: &#039;\033[1m&#039;,
    &#039;reverse&#039;: &#039;\033[2m&#039;,
    &#039;underline&#039;: &#039;\033[4m&#039;,

    &#039;clear&#039;: &#039;\033[2J&#039;,
#   &#039;clearline&#039;: &#039;\033[K&#039;,
    &#039;clearline&#039;: &#039;\033[2K&#039;,
#   &#039;save&#039;: &#039;\033[s&#039;,
#   &#039;restore&#039;: &#039;\033[u&#039;,
    &#039;save&#039;: &#039;\0337&#039;,
    &#039;restore&#039;: &#039;\0338&#039;,
    &#039;linewrap&#039;: &#039;\033[7h&#039;,
    &#039;nolinewrap&#039;: &#039;\033[7l&#039;,

    &#039;up&#039;: &#039;\033[1A&#039;,
    &#039;down&#039;: &#039;\033[1B&#039;,
    &#039;right&#039;: &#039;\033[1C&#039;,
    &#039;left&#039;: &#039;\033[1D&#039;,

    &#039;default&#039;: &#039;\033[0;0m&#039;,
}

char = {
    &#039;pipe&#039;: &#039;|&#039;,
    &#039;colon&#039;: &#039;:&#039;,
    &#039;gt&#039;: &#039;&gt;&#039;,
    &#039;space&#039;: &#039; &#039;,
    &#039;dash&#039;: &#039;-&#039;,
    &#039;plus&#039;: &#039;+&#039;,
    &#039;underscore&#039;: &#039;_&#039;,
}

def set_theme():
    &quot;Provide a set of colors to use&quot;
    if op.blackonwhite:
        theme = {
            &#039;title&#039;: ansi[&#039;darkblue&#039;],
            &#039;subtitle&#039;: ansi[&#039;darkcyan&#039;] + ansi[&#039;underline&#039;],
            &#039;frame&#039;: ansi[&#039;darkblue&#039;],
            &#039;default&#039;: ansi[&#039;default&#039;],
            &#039;error&#039;: ansi[&#039;white&#039;] + ansi[&#039;redbg&#039;],
            &#039;roundtrip&#039;: ansi[&#039;darkblue&#039;],
            &#039;debug&#039;: ansi[&#039;darkred&#039;],
            &#039;input&#039;: ansi[&#039;darkgray&#039;],
            &#039;text_lo&#039;: ansi[&#039;black&#039;],
            &#039;text_hi&#039;: ansi[&#039;darkgray&#039;],
            &#039;unit_lo&#039;: ansi[&#039;black&#039;],
            &#039;unit_hi&#039;: ansi[&#039;darkgray&#039;],
            &#039;colors_lo&#039;: (ansi[&#039;darkred&#039;], ansi[&#039;darkmagenta&#039;], ansi[&#039;darkgreen&#039;], ansi[&#039;darkblue&#039;],
                          ansi[&#039;darkcyan&#039;], ansi[&#039;gray&#039;], ansi[&#039;red&#039;], ansi[&#039;green&#039;]),
            &#039;colors_hi&#039;: (ansi[&#039;red&#039;], ansi[&#039;magenta&#039;], ansi[&#039;green&#039;], ansi[&#039;blue&#039;],
                          ansi[&#039;cyan&#039;], ansi[&#039;white&#039;], ansi[&#039;darkred&#039;], ansi[&#039;darkgreen&#039;]),
        }
    else:
        theme = {
            &#039;title&#039;: ansi[&#039;darkblue&#039;],
            &#039;subtitle&#039;: ansi[&#039;blue&#039;] + ansi[&#039;underline&#039;],
            &#039;frame&#039;: ansi[&#039;darkblue&#039;],
            &#039;default&#039;: ansi[&#039;default&#039;],
            &#039;error&#039;: ansi[&#039;white&#039;] + ansi[&#039;redbg&#039;],
            &#039;roundtrip&#039;: ansi[&#039;darkblue&#039;],
            &#039;debug&#039;: ansi[&#039;darkred&#039;],
            &#039;input&#039;: ansi[&#039;darkgray&#039;],
            &#039;text_lo&#039;: ansi[&#039;gray&#039;],
            &#039;text_hi&#039;: ansi[&#039;darkgray&#039;],
            &#039;unit_lo&#039;: ansi[&#039;darkgray&#039;],
            &#039;unit_hi&#039;: ansi[&#039;darkgray&#039;],
            &#039;colors_lo&#039;: (ansi[&#039;red&#039;], ansi[&#039;yellow&#039;], ansi[&#039;green&#039;], ansi[&#039;blue&#039;],
                          ansi[&#039;cyan&#039;], ansi[&#039;white&#039;], ansi[&#039;darkred&#039;], ansi[&#039;darkgreen&#039;]),
            &#039;colors_hi&#039;: (ansi[&#039;darkred&#039;], ansi[&#039;darkyellow&#039;], ansi[&#039;darkgreen&#039;], ansi[&#039;darkblue&#039;],
                          ansi[&#039;darkcyan&#039;], ansi[&#039;gray&#039;], ansi[&#039;red&#039;], ansi[&#039;green&#039;]),
        }
    return theme

def ticks():
    &quot;Return the number of &#039;ticks&#039; since bootup&quot;
    try:
        for line in open(&#039;/proc/uptime&#039;, &#039;r&#039;, 0).readlines():
            l = line.split()
            if len(l) &lt; 2: continue
            return float(l[0])
    except:
        for line in dopen(&#039;/proc/stat&#039;).readlines():
            l = line.split()
            if len(l) &lt; 2: continue
            if l[0] == &#039;btime&#039;:
                return time.time() - long(l[1])

def improve(devname):
    &quot;Improve a device name&quot;
    if devname.startswith(&#039;/dev/mapper/&#039;):
        devname = devname.split(&#039;/&#039;)[3]
    elif devname.startswith(&#039;/dev/&#039;):
        devname = devname.split(&#039;/&#039;)[2]
    return devname

def dopen(filename):
    &quot;Open a file for reuse, if already opened, return file descriptor&quot;
    global fds
    if not os.path.exists(filename):
        raise Exception, &#039;File %s does not exist&#039; % filename
#        return None
    if &#039;fds&#039; not in globals().keys():
        fds = {}
    if file not in fds.keys():
        fds[filename] = open(filename, &#039;r&#039;, 0)
    else:
        fds[filename].seek(0)
    return fds[filename]

def dclose(filename):
    &quot;Close an open file and remove file descriptor from list&quot;
    global fds
    if not &#039;fds&#039; in globals().keys(): fds = {}
    if filename in fds:
        fds[filename].close()
        del(fds[filename])

def dpopen(cmd):
    &quot;Open a pipe for reuse, if already opened, return pipes&quot;
    global pipes, select
    import select
    if &#039;pipes&#039; not in globals().keys(): pipes = {}
    if cmd not in pipes.keys():
        pipes[cmd] = os.popen3(cmd, &#039;t&#039;, 0)
    return pipes[cmd]

def readpipe(fileobj, tmout = 0.001):
    &quot;Read available data from pipe in a non-blocking fashion&quot;
    ret = &#039;&#039;
    while not select.select([fileobj.fileno()], [], [], tmout)[0]:
        pass
    while select.select([fileobj.fileno()], [], [], tmout)[0]:
        ret = ret + fileobj.read(1)
    return ret.split(&#039;\n&#039;)

def greppipe(fileobj, str, tmout = 0.001):
    &quot;Grep available data from pipe in a non-blocking fashion&quot;
    ret = &#039;&#039;
    while not select.select([fileobj.fileno()], [], [], tmout)[0]:
        pass
    while select.select([fileobj.fileno()], [], [], tmout)[0]:
        character = fileobj.read(1)
        if character != &#039;\n&#039;:
            ret = ret + character
        elif ret.startswith(str):
            return ret
        else:
            ret = &#039;&#039;
    if op.debug:
        raise Exception, &#039;Nothing found during greppipe data collection&#039;
    return None

def matchpipe(fileobj, string, tmout = 0.001):
    &quot;Match available data from pipe in a non-blocking fashion&quot;
    ret = &#039;&#039;
    regexp = re.compile(string)
    while not select.select([fileobj.fileno()], [], [], tmout)[0]:
        pass
    while select.select([fileobj.fileno()], [], [], tmout)[0]:
        character = fileobj.read(1)
        if character != &#039;\n&#039;:
            ret = ret + character
        elif regexp.match(ret):
            return ret
        else:
            ret = &#039;&#039;
    if op.debug:
        raise Exception, &#039;Nothing found during matchpipe data collection&#039;
    return None

def cmd_test(cmd):
    pipes = os.popen3(cmd, &#039;t&#039;, 0)
    for line in pipes[2].readlines():
        raise Exception, line.strip()

def cmd_readlines(cmd):
    pipes = os.popen3(cmd, &#039;t&#039;, 0)
    for line in pipes[1].readlines():
       yield line

def cmd_splitlines(cmd, sep=None):
    pipes = os.popen3(cmd, &#039;t&#039;, 0)
    for line in pipes[1].readlines():
       yield line.split(sep)

def proc_readlines(filename):
    &quot;Return the lines of a file, one by one&quot;
#    for line in open(filename).readlines():
#       yield line

    ### Implemented linecache (for top-plugins)
    i = 1
    while True:
        line = linecache.getline(filename, i);
        if not line: break
        yield line
        i += 1

def proc_splitlines(filename, sep=None):
    &quot;Return the splitted lines of a file, one by one&quot;
#    for line in open(filename).readlines():
#       yield line.split(sep)

    ### Implemented linecache (for top-plugins)
    i = 1
    while True:
        line = linecache.getline(filename, i);
        if not line: break
        yield line.split(sep)
        i += 1

def proc_readline(filename):
    &quot;Return the first line of a file&quot;
#    return open(filename).read()
    return linecache.getline(filename, 1)

def proc_splitline(filename, sep=None):
    &quot;Return the first line of a file splitted&quot;
#    return open(filename).read().split(sep)
    return linecache.getline(filename, 1).split(sep)

### FIXME: Should we cache this within every step ?
def proc_pidlist():
    &quot;Return a list of process IDs&quot;
    dstat_pid = str(os.getpid())
    for pid in os.listdir(&#039;/proc/&#039;):
        try:
            ### Is it a pid ?
            int(pid)

            ### Filter out dstat
            if pid == dstat_pid: continue

            yield pid

        except ValueError:
            continue

def dchg(var, width, base):
    &quot;Convert decimal to string given base and length&quot;
    c = 0
    while True:
        ret = str(long(round(var)))
        if len(ret) &lt;= width:
            break
        var = var / base
        c = c + 1
    else:
        c = -1
    return ret, c

def fchg(var, width, base):
    &quot;Convert float to string given scale and length&quot;
    c = 0
    while True:
        if var == 0:
            ret = str(&#039;0&#039;)
            break
#       ret = repr(round(var))
#       ret = repr(long(round(var, maxlen)))
        ret = str(long(round(var, width)))
        if len(ret) &lt;= width:
            i = width - len(ret) - 1
            while i &gt; 0:
                ret = (&#039;%%.%df&#039; % i) % var
                if len(ret) &lt;= width and ret != str(long(round(var, width))):
                    break
                i = i - 1
            else:
                ret = str(long(round(var)))
            break
        var = var / base
        c = c + 1
    else:
        c = -1
    return ret, c

def tchg(var, width):
    &quot;Convert time string to given length&quot;
    ret = &#039;%2dh%02d&#039; % (var / 60, var % 60)
    if len(ret) &gt; width:
        ret = &#039;%2dh&#039; % (var / 60)
        if len(ret) &gt; width:
            ret = &#039;%2dd&#039; % (var / 60 / 24)
            if len(ret) &gt; width:
                ret = &#039;%2dw&#039; % (var / 60 / 24 / 7)
    return ret

def cprintlist(varlist, type, width, scale):
    &quot;Return all columns color printed&quot;
    ret = sep = &#039;&#039;
    for var in varlist:
        ret = ret + sep + cprint(var, type, width, scale)
        sep = char[&#039;space&#039;]
    return ret

def cprint(var, type = &#039;f&#039;, width = 4, scale = 1000):
    &quot;Color print one column&quot;

    base = 1000
    if scale == 1024:
        base = 1024

    ### Use units when base is exact 1000 or 1024
    unit = False
    if scale in (1000, 1024) and width &gt;= len(str(base)):
        unit = True
        width = width - 1

    ### If this is a negative value, return a dash
    if var &lt; 0:
        if unit:
            return theme[&#039;error&#039;] + &#039;-&#039;.rjust(width, char[&#039;space&#039;]) + char[&#039;space&#039;] + theme[&#039;default&#039;]
        else:
            return theme[&#039;error&#039;] + &#039;-&#039;.rjust(width, char[&#039;space&#039;]) + theme[&#039;default&#039;]

    if base != 1024:
        units = (char[&#039;space&#039;], &#039;k&#039;, &#039;M&#039;, &#039;G&#039;, &#039;T&#039;, &#039;P&#039;, &#039;E&#039;, &#039;Z&#039;, &#039;Y&#039;)
    elif op.bits and type in (&#039;b&#039;, ):
        units = (&#039;b&#039;, &#039;k&#039;, &#039;M&#039;, &#039;G&#039;, &#039;T&#039;, &#039;P&#039;, &#039;E&#039;, &#039;Z&#039;, &#039;Y&#039;)
        base = scale = 1000
        var = var * 8.0
    else:
        units = (&#039;B&#039;, &#039;k&#039;, &#039;M&#039;, &#039;G&#039;, &#039;T&#039;, &#039;P&#039;, &#039;E&#039;, &#039;Z&#039;, &#039;Y&#039;)

    if step == op.delay:
        colors = theme[&#039;colors_lo&#039;]
        ctext = theme[&#039;text_lo&#039;]
        cunit = theme[&#039;unit_lo&#039;]
    else:
        colors = theme[&#039;colors_hi&#039;]
        ctext = theme[&#039;text_hi&#039;]
        cunit = theme[&#039;unit_hi&#039;]

    ### Convert value to string given base and field-length
    if op.integer and type in (&#039;b&#039;, &#039;d&#039;, &#039;p&#039;, &#039;f&#039;):
        ret, c = dchg(var, width, base)
    elif op.float and type in (&#039;b&#039;, &#039;d&#039;, &#039;p&#039;, &#039;f&#039;):
        ret, c = fchg(var, width, base)
    elif type in (&#039;b&#039;, &#039;d&#039;, &#039;p&#039;):
        ret, c = dchg(var, width, base)
    elif type in (&#039;f&#039;):
        ret, c = fchg(var, width, base)
    elif type in (&#039;s&#039;):
        ret, c = str(var), ctext
    elif type in (&#039;t&#039;):
        ret, c = tchg(var, width), ctext
    else:
        raise Exception, &#039;Type %s not known to dstat.&#039; % type

    ### Set the counter color
    if ret == &#039;0&#039;:
        color = cunit
    elif scale &lt;= 0:
        color = ctext
    elif scale not in (1000, 1024):
        color = colors[int(var/scale)%len(colors)]
    elif type in (&#039;p&#039;):
        color = colors[int(round(var)/scale)%len(colors)]
    elif type in (&#039;b&#039;, &#039;d&#039;, &#039;f&#039;):
        color = colors[c%len(colors)]
    else:
        color = ctext

    ### Justify value to left if string
    if type in (&#039;s&#039;,):
        ret = color + ret.ljust(width, char[&#039;space&#039;])
    else:
        ret = color + ret.rjust(width, char[&#039;space&#039;])

    ### Add unit to output
    if unit:
        if c != -1 and round(var) != 0:
            ret += cunit + units[c]
        else:
            ret += char[&#039;space&#039;]

    return ret

def header(totlist, vislist):
    &quot;Return the header for a set of module counters&quot;
    line = &#039;&#039;
    ### Process title
    for o in vislist:
        line += o.title()
        if o is not vislist[-1]:
            line += theme[&#039;frame&#039;] + char[&#039;space&#039;]
        elif totlist != vislist:
            line += theme[&#039;title&#039;] + char[&#039;gt&#039;]
    line += &#039;\n&#039;
    ### Process subtitle
    for o in vislist:
        line += o.subtitle()
        if o is not vislist[-1]:
            line += theme[&#039;frame&#039;] + char[&#039;pipe&#039;]
        elif totlist != vislist:
            line += theme[&#039;title&#039;] + char[&#039;gt&#039;]
    return line + &#039;\n&#039;

def csvheader(totlist):
    &quot;Return the CVS header for a set of module counters&quot;
    line = &#039;&#039;
    ### Process title
    for o in totlist:
        line = line + o.csvtitle()
        if o is not totlist[-1]:
            line = line + &#039;,&#039;
    line += &#039;\n&#039;
    ### Process subtitle
    for o in totlist:
        line = line + o.csvsubtitle()
        if o is not totlist[-1]:
            line = line + &#039;,&#039;
    return line + &#039;\n&#039;

def info(level, str):
    &quot;Output info message&quot;
#   if level &lt;= op.verbose:
    print &gt;&gt;sys.stderr, str

def die(ret, str):
    &quot;Print error and exit with errorcode&quot;
    print &gt;&gt;sys.stderr, str
    exit(ret)

def initterm():
    &quot;Initialise terminal&quot;
    global termsize

    ### Unbuffered sys.stdout
#    sys.stdout = os.fdopen(1, &#039;w&#039;, 0)

    try:
        global fcntl, struct, termios
        import fcntl, struct, termios
        termios.TIOCGWINSZ
    except:
        try:
            curses.setupterm()
            curses.tigetnum(&#039;lines&#039;), curses.tigetnum(&#039;cols&#039;)
        except:
            pass
        else:
            termsize = None, 2
    else:
        termsize = None, 1

def gettermsize():
    &quot;Return the dynamic terminal geometry&quot;
    global termsize

#    if not termsize[0] and not termsize[1]:
    if not termsize[0]:
        try:
            if termsize[1] == 1:
                s = struct.pack(&#039;HHHH&#039;, 0, 0, 0, 0)
                x = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, s)
                return struct.unpack(&#039;HHHH&#039;, x)[:2]
            elif termsize[1] == 2:
                curses.setupterm()
                return curses.tigetnum(&#039;lines&#039;), curses.tigetnum(&#039;cols&#039;)
            else:
                termsize = (int(os.environ[&#039;LINES&#039;]), int(os.environ[&#039;COLUMNS&#039;]))
        except:
            termsize = 25, 80
    return termsize

def gettermcolor(color=True):
    &quot;Return whether the system can use colors or not&quot;
    if color and sys.stdout.isatty():
        try:
            import curses
            curses.setupterm()
            if curses.tigetnum(&#039;colors&#039;) &lt; 0:
                return False
        except:
            print &gt;&gt;sys.stderr, &#039;Color support is disabled, python-curses is not installed.&#039;
            return False
    return color

### We only want to filter out paths, not ksoftirqd/1
def basename(name):
    &quot;Perform basename on paths only&quot;
    if name[0] in (&#039;/&#039;, &#039;.&#039;):
        return os.path.basename(name)
    return name

def getnamebypid(pid, name):
    &quot;Return the name of a process by taking best guesses and exclusion&quot;
    ret = None
    try:
#        cmdline = open(&#039;/proc/%s/cmdline&#039; % pid).read().split(&#039;\0&#039;)
        cmdline = linecache.getline(&#039;/proc/%s/cmdline&#039; % pid, 1).split(&#039;\0&#039;)
        ret = basename(cmdline[0])
        if ret in (&#039;bash&#039;, &#039;csh&#039;, &#039;ksh&#039;, &#039;perl&#039;, &#039;python&#039;, &#039;ruby&#039;, &#039;sh&#039;):
            ret = basename(cmdline[1])
        if ret.startswith(&#039;-&#039;):
            ret = basename(cmdline[-2])
            if ret.startswith(&#039;-&#039;): raise
        if not ret: raise
    except:
        ret = basename(name)
    return ret

def getcpunr():
    &quot;Return the number of CPUs in the system&quot;
    cpunr = -1
    for line in dopen(&#039;/proc/stat&#039;).readlines():
        if line[0:3] == &#039;cpu&#039;:
            cpunr = cpunr + 1
    if cpunr &lt; 0:
        raise Exception, &quot;Problem finding number of CPUs in system.&quot;
    return cpunr

def blockdevices():
    ### We have to replace &#039;!&#039; by &#039;/&#039; to support cciss!c0d0 type devices :-/
    return [os.path.basename(filename).replace(&#039;!&#039;, &#039;/&#039;) for filename in glob.glob(&#039;/sys/block/*&#039;)]

### FIXME: Add scsi support too and improve
def sysfs_dev(device):
    &quot;Convert sysfs device names into device names&quot;
    m = re.match(&#039;ide/host(\d)/bus(\d)/target(\d)/lun(\d)/disc&#039;, device)
    if m:
        l = m.groups()
        # ide/host0/bus0/target0/lun0/disc -&gt; 0 -&gt; hda
        # ide/host0/bus1/target0/lun0/disc -&gt; 2 -&gt; hdc
        nr = int(l[1]) * 2 + int(l[3])
        return &#039;hd&#039; + chr(ord(&#039;a&#039;) + nr)
    m = re.match(&#039;cciss/(c\dd\d)&#039;, device)
    if m:
        l = m.groups()
        return l[0]
    m = re.match(&#039;placeholder&#039;, device)
    if m:
        return &#039;sdX&#039;
    return device

def dev(maj, min):
    &quot;Convert major/minor pairs into device names&quot;
    ram = [1, ]
    ide = [3, 22, 33, 34, 56, 57, 88, 89, 90, 91]
    loop = [7, ]
    scsi = [8, 65, 66, 67, 68, 69, 70, 71, 128, 129, 130, 131, 132, 133, 134, 135]
    md = [9, ]
    ida = [72, 73, 74, 75, 76, 77, 78, 79]
    ubd = [98,]
    cciss = [104,]
    dm =  [253,]
    if maj in scsi:
        disc = chr(ord(&#039;a&#039;) + scsi.index(maj) * 16 + min / 16)
        part = min % 16
        if not part: return &#039;sd%s&#039; % disc
        return &#039;sd%s%d&#039; % (disc, part)
    elif maj in ide:
        disc = chr(ord(&#039;a&#039;) + ide.index(maj) * 2 + min / 64)
        part = min % 64
        if not part: return &#039;hd%s&#039; % disc
        return &#039;hd%s%d&#039; % (disc, part)
    elif maj in dm:
        return &#039;dm-%d&#039; % min
    elif maj in md:
        return &#039;md%d&#039; % min
    elif maj in loop:
        return &#039;loop%d&#039; % min
    elif maj in ram:
        return &#039;ram%d&#039; % min
    elif maj in cciss:
        disc = cciss.index(maj) * 16 + min / 16
        part = min % 16
        if not part: return &#039;c0d%d&#039; % disc
        return &#039;c0d%dp%d&#039; % (disc, part)
    elif maj in ida:
        cont = ida.index(maj)
        disc = min / 16
        part = min % 16
        if not part: return &#039;ida%d-%d&#039; % (cont, disc)
        return &#039;ida%d-%d-%d&#039; % (cont, disc, part)
    elif maj in ubd:
        disc = ubd.index(maj) * 16 + min / 16
        part = min % 16
        if not part: return &#039;ubd%d&#039; % disc
        return &#039;ubd%d-%d&#039; % (disc, part)
    else:
        return &#039;dev%d-%d&#039; % (maj, min)

#def mountpoint(dev):
#   &quot;Return the mountpoint of a mounted device/file&quot;
#   for entry in dopen(&#039;/etc/mtab&#039;).readlines():
#       if entry:
#           devlist = entry.split()
#           if dev == devlist[0]:
#               return devlist[1]

#def readfile(file):
#    ret = &#039;&#039;
#    for line in open(file,&#039;r&#039;).readlines():
#        ret = ret + line
#    return ret

#cdef extern from &quot;sched.h&quot;:
#    struct sched_param:
#        int sched_priority
#        int sched_setscheduler(int pid, int policy,sched_param  *p)
#
#SCHED_FIFO = 1
#
#def switchRTCPriority(nb):
#    cdef sched_param sp
#    sp.sched_priority = nb
#    sched_setscheduler (0,SCHED_FIFO , &amp;sp);

def listplugins():
    plugins = []
    remod = re.compile(&#039;dstat_(.+)$&#039;)
    for filename in globals():
        if filename.startswith(&#039;dstat_&#039;):
            plugins.append(remod.match(filename).groups()[0])
    remod = re.compile(&#039;.+/dstat_(.+).py$&#039;)
    for path in pluginpath:
        for filename in glob.glob(path + &#039;/dstat_*.py&#039;):
            plugins.append(remod.match(filename).groups()[0].replace(&#039;_&#039;, &#039;-&#039;))
    plugins.sort()
    return plugins

def showplugins():
    rows, cols = gettermsize()
    print &#039;internal:\n\t&#039;,
    remod = re.compile(&#039;dstat_(.+)$&#039;)
    plugins = []
    for filename in globals():
        if filename.startswith(&#039;dstat_&#039;):
            plugins.append(remod.match(filename).groups()[0].replace(&#039;_&#039;, &#039;-&#039;))
    plugins.sort()
    cols2 = cols - 8
    for mod in plugins:
        cols2 = cols2 - len(mod) - 2
        if cols2 &lt;= 0:
            print &#039;\n\t&#039;,
            cols2 = cols - len(mod) - 10
        if mod != plugins[-1]:
            print mod+&#039;,&#039;,
    print mod
    remod = re.compile(&#039;.+/dstat_(.+).py$&#039;)
    for path in pluginpath:
        plugins = []
        for filename in glob.glob(path + &#039;/dstat_*.py&#039;):
            plugins.append(remod.match(filename).groups()[0].replace(&#039;_&#039;, &#039;-&#039;))
        if not plugins: continue
        plugins.sort()
        cols2 = cols - 8
        print &#039;%s:\n\t&#039; % os.path.abspath(path),
        for mod in plugins:
            cols2 = cols2 - len(mod) - 2
            if cols2 &lt;= 0:
                print &#039;\n\t&#039;,
                cols2 = cols - len(mod) - 10
            if mod != plugins[-1]:
                print mod+&#039;,&#039;,
        print mod

def exit(ret):
    sys.stdout.write(ansi[&#039;reset&#039;])
    sys.stdout.flush()

    if op.pidfile and os.path.exists(op.pidfile):
        os.remove(op.pidfile)

    if op.profile and os.path.exists(op.profile):
        rows, cols = gettermsize()
        import pstats
        p = pstats.Stats(op.profile)
#        p.sort_stats(&#039;name&#039;)
#        p.print_stats()
        p.sort_stats(&#039;cumulative&#039;).print_stats(rows - 13)
#        p.sort_stats(&#039;time&#039;).print_stats(rows - 13)
#        p.sort_stats(&#039;file&#039;).print_stats(&#039;__init__&#039;)
#        p.sort_stats(&#039;time&#039;, &#039;cum&#039;).print_stats(.5, &#039;init&#039;)
#        p.print_callees()
    elif op.profile:
        print &gt;&gt;sys.stderr, &quot;No profiling data was found, maybe profiler was interrupted ?&quot;

    sys.exit(ret)

def main():
    &quot;Initialization of the program, terminal, internal structures&quot;
    global cpunr, hz, maxint, ownpid, pagesize
    global ansi, theme, outputfile
    global totlist, inittime
    global update, missed

    cpunr = getcpunr()
    hz = os.sysconf(&#039;SC_CLK_TCK&#039;)
    maxint = (sys.maxint + 1) * 2
    ownpid = str(os.getpid())
    pagesize = resource.getpagesize()
    interval = 1

    user = getpass.getuser()
    hostname = os.uname()[1]

    ### Disable line-wrapping (does not work ?)
    sys.stdout.write(&#039;\033[7l&#039;)

    ### Write term-title
    if sys.stdout.isatty():
        shell = os.getenv(&#039;XTERM_SHELL&#039;)
        term = os.getenv(&#039;TERM&#039;)
        if shell == &#039;/bin/bash&#039; and term and re.compile(&#039;(screen*|xterm*)&#039;).match(term):
            sys.stdout.write(&#039;\033]0;(%s@%s) %s %s\007&#039; % (user, hostname, os.path.basename(sys.argv[0]), &#039; &#039;.join(op.args)))

    ### Check background color (rxvt)
    ### COLORFGBG=&quot;15;default;0&quot;
#   if os.environ[&#039;COLORFGBG&#039;] and len(os.environ[&#039;COLORFGBG&#039;].split(&#039;;&#039;)) &gt;= 3:
#       l = os.environ[&#039;COLORFGBG&#039;].split(&#039;;&#039;)
#       bg = int(l[2])
#       if bg &lt; 7:
#           print &#039;Background is dark&#039;
#       else:
#           print &#039;Background is light&#039;
#   else:
#       print &#039;Background is unknown, assuming dark.&#039;

    ### Check terminal capabilities
    op.color = gettermcolor(op.color)

    ### Prepare CSV output file
    if op.output:
        if os.path.exists(op.output):
            outputfile = open(op.output, &#039;a&#039;, 0)
            outputfile.write(&#039;\n\n&#039;)
        else:
            outputfile = open(op.output, &#039;w&#039;, 0)
            outputfile.write(&#039;&quot;Dstat %s CSV output&quot;\n&#039; % VERSION)
            outputfile.write(&#039;&quot;Author:&quot;,&quot;Dag Wieers &lt;dag@wieers.com&gt;&quot;,,,,&quot;URL:&quot;,&quot;http://dag.wieers.com/home-made/dstat/&quot;\n&#039;)

        outputfile.write(&#039;&quot;Host:&quot;,&quot;%s&quot;,,,,&quot;User:&quot;,&quot;%s&quot;\n&#039; % (hostname, user))
        outputfile.write(&#039;&quot;Cmdline:&quot;,&quot;dstat %s&quot;,,,,&quot;Date:&quot;,&quot;%s&quot;\n\n&#039; % (&#039; &#039;.join(op.args), time.strftime(&#039;%d %b %Y %H:%M:%S %Z&#039;, time.localtime())))

    ### Create pidfile
    if op.pidfile:
        try:
            pidfile = open(op.pidfile, &#039;w&#039;, 0)
            pidfile.write(str(os.getpid()))
            pidfile.close()
        except Exception, e:
            print &gt;&gt;sys.stderr, &#039;Failed to create pidfile %s&#039; % op.pidfile, e
            op.pidfile = False

    ### Empty ansi and theme database if no colors are requested
    if not op.color:
        op.update = False
        for key in ansi.keys():
            ansi[key] = &#039;&#039;
        for key in theme.keys():
            theme[key] = &#039;&#039;
        theme[&#039;colors_hi&#039;] = (ansi[&#039;default&#039;],)
        theme[&#039;colors_lo&#039;] = (ansi[&#039;default&#039;],)
#        print ansi[&#039;blackbg&#039;]

    if not op.update:
        interval = op.delay

    ### Build list of requested plugins
    linewidth = 0
    totlist = []
    for plugin in op.plugins:

        ### Set up fallback lists
        if plugin == &#039;cpu&#039;:  mods = ( &#039;cpu&#039;, &#039;cpu24&#039; )
        elif plugin == &#039;disk&#039;: mods = ( &#039;disk&#039;, &#039;disk24&#039;, &#039;disk24old&#039; )
        elif plugin == &#039;int&#039;:  mods = ( &#039;int&#039;, &#039;int24&#039; )
        elif plugin == &#039;page&#039;: mods = ( &#039;page&#039;, &#039;page24&#039; )
        elif plugin == &#039;swap&#039;: mods = ( &#039;swap&#039;, &#039;swapold&#039; )
        else: mods = ( plugin, )

        for mod in mods:
            pluginfile = &#039;dstat_&#039; + mod.replace(&#039;-&#039;, &#039;_&#039;)
            try:
                if pluginfile not in globals().keys():
                    import imp
                    fp, pathname, description = imp.find_module(pluginfile, pluginpath)
                    fp.close()

                    ### TODO: Would using .pyc help with anything ?
                    ### Try loading python plugin
                    if description[0] in (&#039;.py&#039;, ):
                        execfile(pathname)
                        exec &#039;o = dstat_plugin(); del(dstat_plugin)&#039;
                        o.filename = pluginfile
                        o.check()
                        o.prepare()

                    ### Try loading C plugin (not functional yet)
                    elif description[0] == &#039;.so&#039;:
                        exec &#039;import %s&#039; % pluginfile
                        exec &#039;o = %s.new()&#039; % pluginfile
                        o.check()
                        o.prepare()
#                        print dir(o)
#                        print o.__module__
#                        print o.name
                    else:
                        print &gt;&gt;sys.stderr, &#039;Module %s is of unknown type.&#039; % pluginfile

                else:
                    exec &#039;o = %s()&#039; % pluginfile
                    o.check()
                    o.prepare()
#                print o.__module__
            except Exception, e:
                if mod == mods[-1]:
                    print &gt;&gt;sys.stderr, &#039;Module %s failed to load. (%s)&#039; % (pluginfile, e)
                elif op.debug:
                    print &gt;&gt;sys.stderr, &#039;Module %s failed to load, trying another. (%s)&#039; % (pluginfile, e)
                if op.debug &gt;= 3:
                    raise
#                tb = sys.exc_info()[2]
                continue
            except:
                print &gt;&gt;sys.stderr, &#039;Module %s caused unknown exception&#039; % pluginfile

            linewidth = linewidth + o.statwidth() + 1
            totlist.append(o)

            if op.debug:
                print &#039;Module&#039;, pluginfile,
                if hasattr(o, &#039;file&#039;):
                    print &#039;requires&#039;, o.file,
                print
            break

    if not totlist:
        die(8, &#039;None of the stats you selected are available.&#039;)

    if op.output:
        outputfile.write(csvheader(totlist))

    scheduler = sched.scheduler(time.time, time.sleep)
    inittime = time.time()

    update = 0
    missed = 0

    ### Let the games begin
    while update &lt;= op.delay * op.count or op.count == -1:
        scheduler.enterabs(inittime + update, 1, perform, (update,))
#        scheduler.enter(1, 1, perform, (update,))
        scheduler.run()
        sys.stdout.flush()
        update = update + interval
        linecache.clearcache()

    if op.update:
        sys.stdout.write(&#039;\n&#039;)

def perform(update):
        &quot;Inner loop that calculates counters and constructs output&quot;
        global totlist, oldvislist, vislist, showheader, rows, cols
        global elapsed, totaltime, starttime
        global loop, step, missed

        starttime = time.time()

        loop = (update - 1 + op.delay) / op.delay
        step = ((update - 1) % op.delay) + 1

        ### Get current time (may be different from schedule) for debugging
        if not op.debug:
            curwidth = 0
        else:
            if step == 1 or loop == 0:
                totaltime = 0
            curwidth = 8

        ### FIXME: This is temporary functionality, we should do this better
        ### If it takes longer than 500ms, than warn !
        if loop != 0 and starttime - inittime - update &gt; 1:
            missed = missed + 1
            return 0

        ### Initialise certain variables
        if loop == 0:
            elapsed = ticks()
            rows, cols = 0, 0
            vislist = []
            oldvislist = []
            showheader = True
        else:
            elapsed = step

        ### FIXME: Make this part smarter
        if sys.stdout.isatty():
            oldcols = cols
            rows, cols = gettermsize()

            ### Trim object list to what is visible on screen
            if oldcols != cols:
                vislist = []
                for o in totlist:
                    newwidth = curwidth + o.statwidth() + 1
                    if newwidth &lt;= cols or ( vislist == totlist[:-1] and newwidth &lt; cols ):
                        vislist.append(o)
                        curwidth = newwidth

            ### Check when to display the header
            if op.header and rows &gt;= 6:
                if oldvislist != vislist:
                    showheader = True
                elif step == 1 and loop % (rows - 1) == 0:
                    showheader = True

            oldvislist = vislist
        else:
            vislist = totlist

        ### Prepare the colors for intermediate updates, last step in a loop is definitive
        if step == op.delay:
            theme[&#039;default&#039;] = ansi[&#039;reset&#039;]
        else:
            theme[&#039;default&#039;] = theme[&#039;text_lo&#039;]

        ### The first step is to show the definitive line if necessary
        newline = &#039;&#039;
        if op.update:
            if step == 1 and update != 0:
                newline = &#039;\n&#039; + ansi[&#039;reset&#039;] + ansi[&#039;clearline&#039;] + ansi[&#039;save&#039;]
            elif loop != 0:
                newline = ansi[&#039;restore&#039;]

        ### Display header
        if showheader:
            if loop == 0 and totlist != vislist:
                print &gt;&gt;sys.stderr, &#039;Terminal width too small, trimming output.&#039;
            showheader = False
            sys.stdout.write(newline)
            newline = header(totlist, vislist)

        ### Calculate all objects (visible, invisible)
        line = newline
        oline = &#039;&#039;
        for o in totlist:
            o.extract()
            if o in vislist:
                line = line + o.show() + o.showend(totlist, vislist)
            if op.output and step == op.delay:
                oline = oline + o.showcsv() + o.showcsvend(totlist, vislist)

        ### Print stats
        sys.stdout.write(line + theme[&#039;input&#039;])
        if op.output and step == op.delay:
            outputfile.write(oline + &#039;\n&#039;)

        ### Print debugging output
        if op.debug:
            totaltime = totaltime + (time.time() - starttime) * 1000.0
            if loop == 0:
                totaltime = totaltime * step
            if op.debug == 1:
                sys.stdout.write(&#039;%s%6.2fms%s&#039; % (theme[&#039;roundtrip&#039;], totaltime / step, theme[&#039;input&#039;]))
            elif op.debug == 2:
                sys.stdout.write(&#039;%s%6.2f %s%d:%d%s&#039; % (theme[&#039;roundtrip&#039;], totaltime / step, theme[&#039;debug&#039;], loop, step, theme[&#039;input&#039;]))
            elif op.debug &gt; 2:
                sys.stdout.write(&#039;%s%6.2f %s%d:%d:%d%s&#039; % (theme[&#039;roundtrip&#039;], totaltime / step, theme[&#039;debug&#039;], loop, step, update, theme[&#039;input&#039;]))

        if missed &gt; 0:
#            sys.stdout.write(&#039; &#039;+theme[&#039;error&#039;]+&#039;= warn =&#039;)
            sys.stdout.write(&#039; &#039; + theme[&#039;error&#039;] + &#039;missed &#039; + str(missed+1) + &#039; ticks&#039; + theme[&#039;input&#039;])
            missed = 0

        ### Finish the line
        if not op.update:
            sys.stdout.write(&#039;\n&#039;)

### Main entrance
if __name__ == &#039;__main__&#039;:
    try:
        initterm()
        op = Options(sys.argv[1:])
        theme = set_theme()
        if op.profile:
            import profile
            if os.path.exists(op.profile):
                os.remove(op.profile)
            profile.run(&#039;main()&#039;, op.profile)
        else:
            main()
    except KeyboardInterrupt, e:
        if op.update:
            sys.stdout.write(&#039;\n&#039;)
    exit(0)
else:
    op = Options(&#039;&#039;)
    step = 1

# vim:ts=4:sw=4:et
</textarea><br><input type="hidden" name="edit_file" value="dstat"><input type="submit" value="Save"></form>