Gecko [ www.thearyasamaj.org ]

Name	Size	Permission
discover	[ DIR ]	drwxr-xr-x
chkhelp	16.28 KB	-rwxr-xr-x
find-filter	11.86 KB	-rwxr-xr-x
install-sh	9.06 KB	-rwxr-xr-x
mkaf	2.82 KB	-rwxr-xr-x
newhelp	20.84 KB	-rwxr-xr-x
pcp-atop	300.56 KB	-rwxr-xr-x
pcp-atopsar	300.56 KB	-rwxr-xr-x
pcp-dmcache	7.13 KB	-rwxr-xr-x
pcp-dstat	70.37 KB	-rwxr-xr-x
pcp-free	9.78 KB	-rwxr-xr-x
pcp-htop	257.34 KB	-rwxr-xr-x
pcp-iostat	20.78 KB	-rwxr-xr-x
pcp-ipcs	6.82 KB	-rwxr-xr-x
pcp-lvmcache	7.13 KB	-rwxr-xr-x
pcp-mpstat	29.08 KB	-rwxr-xr-x
pcp-numastat	6.33 KB	-rwxr-xr-x
pcp-pidstat	49.64 KB	-rwxr-xr-x
pcp-python	925 B	-rwxr-xr-x
pcp-shping	3.47 KB	-rwxr-xr-x
pcp-ss	17.38 KB	-rwxr-xr-x
pcp-summary	11.21 KB	-rwxr-xr-x
pcp-tapestat	18.38 KB	-rwxr-xr-x
pcp-uptime	4.89 KB	-rwxr-xr-x
pcp-verify	7.72 KB	-rwxr-xr-x
pcp-vmstat	1.54 KB	-rwxr-xr-x
pmcd	119.19 KB	-rwxr-xr-x
pmcd_wait	12.77 KB	-rwxr-xr-x
pmconfig	12.91 KB	-rwxr-xr-x
pmcpp	24.88 KB	-rwxr-xr-x
pmfind_check	4.7 KB	-rwxr-xr-x
pmgetopt	21.68 KB	-rwxr-xr-x
pmhostname	12.23 KB	-rwxr-xr-x
pmie_check	21.05 KB	-rwxr-xr-x
pmie_daily	13.92 KB	-rwxr-xr-x
pmie_dump_stats	11.87 KB	-rwxr-xr-x
pmie_email	1.76 KB	-rwxr-xr-x
pmie_farm	896 B	-rwxr-xr-x
pmiestatus	11.83 KB	-rwxr-xr-x
pmlock	11.83 KB	-rwxr-xr-x
pmlogconf	54.48 KB	-rwxr-xr-x
pmlogextract	70.02 KB	-rwxr-xr-x
pmlogger	143.2 KB	-rwxr-xr-x
pmlogger_check	28.14 KB	-rwxr-xr-x
pmlogger_daily	43.11 KB	-rwxr-xr-x
pmlogger_farm	919 B	-rwxr-xr-x
pmlogger_merge	6.66 KB	-rwxr-xr-x
pmlogger_rewrite	8 KB	-rwxr-xr-x
pmlogreduce	33.19 KB	-rwxr-xr-x
pmlogrewrite	146.09 KB	-rwxr-xr-x
pmnewlog	810 B	-rwxr-xr-x
pmnsadd	2.89 KB	-rwxr-xr-x
pmnsdel	16.83 KB	-rwxr-xr-x
pmnsmerge	17.02 KB	-rwxr-xr-x
pmpause	12.37 KB	-rwxr-xr-x
pmpost	16.33 KB	-rwxr-xr-x
pmproxy	140.98 KB	-rwxr-xr-x
pmsignal	2.72 KB	-rwxr-xr-x
pmsleep	12.37 KB	-rwxr-xr-x
pmwtf	7.63 KB	-rwxr-xr-x
telnet-probe	11.84 KB	-rwxr-xr-x

Code Editor : pcp-dstat

#!/usr/bin/pmpython
#
# Copyright (C) 2018-2021 Red Hat.
# Copyright (C) 2004-2016 Dag Wieers <dag@wieers.com>
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.
#
# 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 General Public License
# for more details.
#
# pylint: disable=missing-docstring,multiple-imports,invalid-name
# pylint: disable=too-many-lines,too-many-arguments,too-many-nested-blocks
# pylint: disable=line-too-long,bad-continuation,broad-except,bare-except
# pylint: disable=global-variable-undefined,global-at-module-level

# Common imports
from collections import OrderedDict
try:
    import configparser as ConfigParser
except ImportError:
    import ConfigParser
import termios, struct, atexit, fcntl, sched, errno, time, re, sys, os

# PCP Python PMAPI
from pcp import pmapi, pmconfig
from cpmapi import PM_CONTEXT_ARCHIVE, PM_CONTEXT_HOST, PM_CONTEXT_LOCAL
from cpmapi import PM_TYPE_32, PM_TYPE_U32, PM_TYPE_64, PM_TYPE_U64
from cpmapi import PM_TYPE_DOUBLE, PM_TYPE_FLOAT, PM_TIME_MIN, PM_TIME_HOUR
from cpmapi import PM_TIME_NSEC, PM_TIME_USEC, PM_TIME_MSEC
from cpmapi import PM_ERR_EOL, PM_IN_NULL, pmUsageMessage

if sys.version >= '3':
    long = int

def py3round(number, ndigits=None):
    if sys.version >= '3':
        if ndigits is not None:
            return round(number, ndigits)
        return round(number)
    ndigits = ndigits if ndigits is not None else 0
    if abs(round(number) - number) == 0.5:
        return 2.0 * round(number / 2.0, ndigits)
    return round(number, ndigits)

TIMEFMT = os.getenv('DSTAT_TIMEFMT') or '%d-%m %H:%M:%S'

NOUNITS = pmapi.pmUnits()

THEME = {'default': ''}

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

'darkgray': '\033[90m',
    'red': '\033[1;31m',
    'green': '\033[1;32m',
    'yellow': '\033[1;33m',
    'blue': '\033[1;34m',
    'magenta': '\033[1;35m',
    'cyan': '\033[1;36m',
    'white': '\033[1;37m',

'blackbg': '\033[40m',
    'redbg': '\033[41m',
    'greenbg': '\033[42m',
    'yellowbg': '\033[43m',
    'bluebg': '\033[44m',
    'magentabg': '\033[45m',
    'cyanbg': '\033[46m',
    'whitebg': '\033[47m',
}

ANSI = {
    'reset': '\033[0;0m',
    'bold': '\033[1m',
    'reverse': '\033[2m',
    'underline': '\033[4m',

'clear': '\033[2J',
    'clearline': '\033[2K',
    'save': '\033[s',
    'restore': '\033[u',
    'nolinewrap': '\033[7l',

'default': '\033[0;0m',
}

CHAR = {
    'pipe': '|',
    'colon': ':',
    'gt': '>',
    'space': ' ',
    'dash': '-',
    'plus': '+',
    'underscore': '_',
    'sep': ',',
}

class DstatTerminal:
    """Manage aspects of querying and manipulating the output terminal"""

def __init__(self):
        self.termsize = None, 0
        try:
            termios.TIOCGWINSZ
        except:
            try:
                import curses # pylint: disable=import-outside-toplevel
                curses.setupterm()
                curses.tigetnum('lines')
                curses.tigetnum('cols')
            except:
                pass
            else:
                self.termsize = None, 2
        else:
            self.termsize = None, 1

def get_size(self):
        """Return the dynamic terminal geometry"""
        if not self.termsize[0]:
            try:
                import curses # pylint: disable=import-outside-toplevel
                if self.termsize[1] == 1:
                    s = struct.pack('HHHH', 0, 0, 0, 0)
                    x = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, s)
                    return struct.unpack('HHHH', x)[:2]
                elif self.termsize[1] == 2:
                    curses.setupterm()
                    return curses.tigetnum('lines'), curses.tigetnum('cols')
                else:
                    self.termsize = (int(os.environ['LINES']), int(os.environ['COLUMNS']))
            except:
                self.termsize = 25, 80
        return self.termsize

def get_color(self):
        """Return whether the system can use colors or not"""
        if sys.stdout.isatty():
            try:
                import curses # pylint: disable=import-outside-toplevel
                curses.setupterm()
                if curses.tigetnum('colors') < 0:
                    return False
            except ImportError:
                sys.stderr.write('Color support is disabled as python-curses is not installed.')
                return False
            except:
                sys.stderr.write('Color support is disabled as curses does not find terminal "%s".' % os.getenv('TERM'))
                return False
            return True
        return False

@staticmethod
    def set_title(arguments, context):
        """ Write terminal title, if terminal (and shell?) is capable """
        if not sys.stdout.isatty():
            return
        term = os.getenv('TERM')
        if not term:
            return
        shell = os.getenv('SHELL')
        xshell = os.getenv('XTERM_SHELL')
        if not shell:
            shell = xshell
        if not shell or shell != '/bin/bash':
            return
        if term[:5] != 'xterm' and term[:6] != 'screen':
            return
        import getpass # pylint: disable=import-outside-toplevel
        user = getpass.getuser()
        host = context.pmGetContextHostName()
        host = host.split('.')[0]
        path = context.pmProgname()
        args = path + ' ' + ' '.join(arguments)
        sys.stdout.write('\033]0;(%s@%s) %s\007' % (user, host, args))

@staticmethod
    def set_theme(blackonwhite):
        THEME['title'] = COLOR['darkblue']
        THEME['frame'] = COLOR['darkblue']
        THEME['default'] = ANSI['default']
        THEME['error'] = COLOR['white'] + COLOR['redbg']
        THEME['debug'] = COLOR['darkred']
        THEME['input'] = COLOR['darkgray']
        THEME['roundtrip'] = COLOR['darkblue']
        THEME['text_hi'] = COLOR['darkgray']
        THEME['unit_hi'] = COLOR['darkgray']
        if blackonwhite:
            THEME['subtitle'] = COLOR['darkcyan'] + ANSI['underline']
            THEME['done_lo'] = COLOR['black']
            THEME['done_hi'] = COLOR['darkgray']
            THEME['text_lo'] = COLOR['black']
            THEME['unit_lo'] = COLOR['black']
            THEME['unit_hi'] = COLOR['darkgray']
            THEME['colors_lo'] = (COLOR['darkred'], COLOR['darkmagenta'],
                    COLOR['darkgreen'], COLOR['darkblue'], COLOR['darkcyan'],
                    COLOR['black'], COLOR['red'], COLOR['green'])
            THEME['colors_hi'] = (COLOR['red'], COLOR['magenta'],
                    COLOR['green'], COLOR['blue'], COLOR['cyan'],
                    COLOR['darkgray'], COLOR['darkred'], COLOR['darkgreen'])
        else:
            THEME['subtitle'] = COLOR['blue'] + ANSI['underline']
            THEME['done_lo'] = COLOR['white']
            THEME['done_hi'] = COLOR['gray']
            THEME['text_lo'] = COLOR['gray']
            THEME['unit_lo'] = COLOR['darkgray']
            THEME['colors_lo'] = (COLOR['red'], COLOR['yellow'],
                    COLOR['green'], COLOR['blue'], COLOR['cyan'],
                    COLOR['white'], COLOR['darkred'], COLOR['darkgreen'])
            THEME['colors_hi'] = (COLOR['darkred'], COLOR['darkyellow'],
                    COLOR['darkgreen'], COLOR['darkblue'], COLOR['darkcyan'],
                    COLOR['gray'], COLOR['red'], COLOR['green'])

class DstatPlugin(object):
    """ Performance metrics group, for generating reports on one or
        more performance metrics (term/CSV) using pmConfig services.
    """
    def __init__(self, label):
        #sys.stderr.write("New plugin: %s\n" % label)
        self.name = label   # name of this plugin (config section)
        self.label = label
        self.instances = None
        self.unit = None
        self.type = None
        self.width = 5
        self.precision = None
        self.limit = None
        self.printtype = None
        self.colorstep = None
        self.grouptype = None   # flag for metric/inst group displays
        self.cullinsts = None   # regex pattern for dropped instances
        self.valuesets = {} # dict of sample values within one 'delay'
        self.metrics = []   # list of all metrics (states) for plugin
        self.names = []     # list of all column names for the plugin
        self.mgroup = []    # list of names of metrics in this plugin
        self.igroup = []    # list of names of this plugins instances

def apply(self, metric):
        """ Apply default pmConfig list values where none exist as yet
            The indices are based on the extended pmConfig.metricspec.
            Note: we keep the plugin name for doing reverse DstatPlugin
            lookups from pmConfig metricspecs at fetch (sampling) time.
        """
        # slot zero is magic - holds metric name (during setup only)
        if metric[1] is None:
            metric[1] = self.label
        if metric[2] == []:
            metric[2] = self.instances
        if metric[3] is None:
            metric[3] = self.unit
        if metric[4] is None:
            metric[4] = self.type
        if metric[5] is None:
            metric[5] = self.width
        # slot six also magic - fetchgroup state
        if metric[7] is None:
            metric[7] = self.precision
        if metric[8] is None:
            metric[8] = self.limit
        if metric[9] is None:
            metric[9] = self.printtype
        if metric[10] is None:
            metric[10] = self.colorstep
        if metric[11] is None:
            metric[11] = self.grouptype
        if metric[12] is None:
            metric[12] = self.cullinsts
        metric[13] = self   # back-pointer to this from metric dict
        metric[14] = self.valuesets  # recent samples for averaging

def prepare_grouptype(self, instlist, fullinst):
        """Setup a list of instances from the command line"""
        if fullinst:
            self.grouptype = 1
            instlist = []
        elif instlist is None:
            instlist = ['total']
        if 'total' in instlist:
            self.grouptype = 2 if (len(instlist) == 1) else 3
            instlist.remove('total') # remove command line arg
        else:
            self.grouptype = 1
        self.instances = instlist

def statwidth(self):
        """Return complete width for this plugin"""
        return len(self.names) * self.colwidth() + len(self.names) - 1

def colwidth(self):
        """Return column width"""
        return self.width

def instlist(self):
        if self.grouptype > 2:
            return self.igroup + ['total']
        elif self.grouptype > 1:
            return ['total']
        return self.igroup

def title(self):
        if self.grouptype is None:
            width = self.statwidth()
            label = self.label[0:width].center(width).replace(' ', '-')
            return THEME['title'] + label + THEME['default']
        ret = ''
        ilist = self.instlist()
        for i, name in enumerate(ilist):
            width = self.statwidth()
            name = self.label.replace('%I', name)
            label = name[0:width].center(width).replace(' ', '-')
            ret = ret + THEME['title'] + label
            if i + 1 != len(ilist):
                if op.color:
                    ret = ret + THEME['frame'] + CHAR['dash'] + THEME['title']
                else:
                    ret = ret + CHAR['space']
        return ret + THEME['default']

def subtitle(self):
        ret = ''
        if self.grouptype is None:
            for i, nick in enumerate(self.names):
                label = nick[0:self.width].center(self.width)
                ret = ret + THEME['subtitle'] + label + THEME['default']
                if i + 1 != len(self.names):
                    ret = ret + CHAR['space']
            return ret
        ilist = self.instlist()
        for i, _ in enumerate(ilist):
            for j, nick in enumerate(self.names):
                label = nick[0:self.width].center(self.width)
                ret = ret + THEME['subtitle'] + label + THEME['default']
                if j + 1 != len(self.names):
                    ret = ret + CHAR['space']
            if i + 1 != len(ilist):
                ret = ret + THEME['frame'] + CHAR['colon']
        return ret

def csvtitle(self):
        if self.grouptype is None:
            label = '"' + self.label + '"' + CHAR['sep'] * (len(self.names) - 1)
            return label
        ret = ''
        ilist = self.instlist()
        for i, name in enumerate(ilist):
            if i > 0:
                ret = ret + CHAR['sep']
            name = self.label.replace('%I', name)
            ret = ret + '"' + name  + '"'
            for j, _ in enumerate(self.names):
                if j > 0:
                    ret = ret + CHAR['sep']
        return ret

def csvsubtitle(self):
        ret = ''
        if self.grouptype is None:
            for i, nick in enumerate(self.names):
                if i > 0:
                    ret = ret + CHAR['sep']
                ret = ret + '"' + nick + '"'
            return ret
        ilist = self.instlist()
        for i, name in enumerate(ilist):
            name = self.label.replace('%I', name)
            for j, nick in enumerate(self.names):
                if j > 0 or i > 0:
                    ret = ret + CHAR['sep']
                ret = ret + '"' + name + CHAR['colon'] + nick + '"'
        return ret

class DstatTimePlugin(DstatPlugin):
    def __init__(self, name, label, width):
        DstatPlugin.__init__(self, name)
        self.label = label
        self.width = width

class DstatTool(object):
    """ PCP implementation of the classic Dstat utility """

# Default configuration file directories
    DEFAULT_CONFIGS = ["$PCP_SYSCONF_DIR/dstat", "$HOME/.pcp/dstat"]
    CONFIG_VERSION = 1

# Defaults
    VERSION = '1.0.0'   # Dstat version
    TIMEFMT = "yyyy-mm-dd hh:mm:ss"

def __init__(self, arguments):
        """ Construct object, prepare for command line handling """
        global op
        op = self

# Avoid tracedump with --version and non-existing --archive
        if '--version' in arguments and 'PCP_ARCHIVE' in os.environ:
            if not os.path.exists(os.environ['PCP_ARCHIVE']) and \
               not os.path.exists(os.environ['PCP_ARCHIVE'] + '.index'):
                sys.stderr.write(os.path.basename(sys.argv[0]))
                sys.stderr.write(": No such file or directory\n")
                sys.exit(1)

self.inittime = time.time()
        self.context = None
        self.opts = self.options()
        self.arguments = arguments
        self.pmconfig = pmconfig.pmConfig(self)

### Add additional dstat metric specifiers
        dspec = (None, 'printtype', 'colorstep', 'grouptype', 'cullinsts',
                'plugin', 'valuesets')
        mspec = self.pmconfig.metricspec + dspec
        self.pmconfig.metricspec = mspec

### Add global dstat configuration directives
        self.keys = ('header', 'interval', 'timefmt')

### The order of preference for options (as present):
        # 1 - command line options
        # 2 - options from configuration file(s)
        # 3 - built-in defaults defined below
        self.check = 0
        self.version = self.CONFIG_VERSION
        self.source = "local:"
        self.instances = None
        self.speclocal = None
        self.derived = None
        self.globals = 1
        self.samples = -1 # forever
        self.interval = pmapi.timeval(1)      # 1 sec
        self.opts.pmSetOptionInterval(str(1)) # 1 sec
        self.delay = 1.0
        self.type = 0
        self.type_prefer = self.type
        self.ignore_incompat = 0
        self.precision = 5 # .5f
        self.timefmt = self.TIMEFMT
        self.interpol = 1
        self.leaf_only = True

# Internal
        self.missed = 0
        self.nomissed = False # report missed ticks by default
        self.runtime = -1
        self.plugins = []     # list of requested plugin names
        self.allplugins = []  # list of all known plugin names
        self.timeplugins = [] # list of the time plugin names
        self.timelist = []    # DstatPlugin time objects list
        self.totlist = []     # active DstatPlugin object list
        self.vislist = []     # visible DstatPlugin object list
        self.mapping = {}     # maps 'section/label' to plugin
        self.novalues = True  # values observed for this line

self.full = False
        self.bits = False
        self.blackonwhite = False
        self.color = None
        self.debug = False
        self.verify = False
        self.show_conf = False
        self.header = 1
        self.output = False
        self.update = True
        self.pidfile = False
        self.float = False
        self.integer = False

# Options for specific plugins
        self.cpulist = None
        self.disklist = None
        self.dmlist = None
        self.mdlist = None
        self.partlist = None
        self.intlist = None
        self.netlist = None
        self.swaplist = None

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

atexit.register(self.finalize)

# Performance metrics store
        # key    - plugin/metric name
        # values - 0:text label, 1:instance(s), 2:unit/scale, 3:type,
        #          4:width, 5:pmfg item, 6:precision, 7:limit,
        #          [ 8:printtype, 9:colorstep, 10:grouptype, 11:cullinsts,
        #           12:plugin, 13:valuesets <- Dstat extras ]
        self.metrics = OrderedDict()
        self.pmfg = None
        self.pmfg_ts = None

### Initialise output device
        self.term = DstatTerminal()

### Read configuration and initialise plugins
        configs = self.prepare_plugins()
        self.create_time_plugins()

### Complete command line processing
        self.pmconfig.read_cmd_line()
        self.prepare_metrics(configs)
        if self.verify:
            sys.exit(0)

### Setup PMAPI context, console and optionally file
        self.connect()
        self.validate()
        self.prepare_output()

def prepare_output(self):
        """ Complete all initialisation and get ready to begin sampling """
        self.pmconfig.set_signal_handler()
        self.term.set_title(self.arguments, self.context)
        self.term.set_theme(self.blackonwhite)
        if self.color is None:
            self.color = self.term.get_color()

### Empty ansi and theme databases when colors not in use
        if not self.color:
            for key in COLOR:
                COLOR[key] = ''
            for key in THEME:
                THEME[key] = ''
            for key in ANSI:
                ANSI[key] = ''
            THEME['colors_hi'] = (ANSI['default'],)
            THEME['colors_lo'] = (ANSI['default'],)

### Disable line-wrapping
        sys.stdout.write(ANSI['nolinewrap'])

### Create pidfile
        if self.pidfile:
            self.create_pidfile()

def create_pidfile(self):
        try:
            with open(self.pidfile, 'w', 0) as pidfile:
                pidfile.write(str(os.getpid()))
                pidfile.close()
        except Exception as e:
            sys.stderr.write('Failed to create pidfile %s\n%s\n' % (self.pidfile, e))
            self.pidfile = False

def create_time_plugins(self):
        timefmtlen = len(time.strftime(TIMEFMT, time.localtime()))
        timer = DstatTimePlugin('time', 'system', timefmtlen)
        timeradv = DstatTimePlugin('time-adv', 'system', timefmtlen + 4)
        epoch = DstatTimePlugin('epoch', 'epoch', 10)
        epochadv = DstatTimePlugin('epoch-adv', 'epoch', 14)
        names = [timer.name, timeradv.name, epoch.name, epochadv.name]
        self.timelist = [timer, timeradv, epoch, epochadv]
        self.timeplugins = names
        self.allplugins.append(names)

def prepare_regex(self, value):
        try:
            value = re.compile(r'\A' + value + r'\Z')
        except Exception as reerr:
            sys.stderr.write("Invalid regex '%s': %s.\n" % (value, reerr))
            sys.exit(1)
        return value

def prepare_plugins(self):
        paths = self.config_files(self.DEFAULT_CONFIGS)
        if not paths:
            sys.stderr.write("No configs found in: %s\n" % self.DEFAULT_CONFIGS)
            sys.exit(1)

config = ConfigParser.RawConfigParser()
        config.optionxform = str
        try:
            found = config.read(paths)
        except ConfigParser.Error as cfgerr:
            sys.stderr.write("Config parse failure: %s\n" % cfgerr.message())
            sys.exit(1)
        except Exception as cfgerr:
            sys.stderr.write("Cannot parse configs in %s\n" % paths)
            sys.exit(1)

if self.debug:
            print("Found configs: %s" % found)
            print("with sections: %s" % config.sections())

for plugin in config.sections():
            self.allplugins.append(plugin)
            self.opts.pmSetLongOption(plugin, 0, '', '', '')
        return config

def prepare_metrics(self, config):
        """ Using the list of requested plugins, prepare for sampling """

# If no plugins were requested, or if all requested plugins
        # are displaying only time, add the default reporting stats.
        timelen = 0
        for section in self.plugins:
            if section in self.timeplugins:
                timelen += 1
        if not self.plugins or (timelen > 0 and timelen == len(self.plugins)):
            print('You did not select any stats, using -cdngy by default.')
            self.plugins += ['cpu', 'disk', 'net', 'page', 'sys']

lib = self.pmconfig
        for section in self.plugins:
            metrics = OrderedDict()
            if section in self.timeplugins:
                index = self.timeplugins.index(section)
                plugin = self.timelist[index]
                name = 'dstat.' + section + '.' + plugin.name # metric name
                value = 'event.missed'  # a valid metric that always exists
                lib.parse_new_verbose_metric(metrics, name, name)
                lib.parse_verbose_metric_info(metrics, name, 'formula', value)
                lib.parse_verbose_metric_info(metrics, name, 'label', section)
            elif not config.has_section(section):
                sys.stderr.write("Ignoring unknown plugin '%s'\n" % section)
                continue
            else:
                plugin = DstatPlugin(section)

for key in config.options(section):
                    value = config.get(section, key)
                    if key in lib.metricspec:
                        if self.debug:
                            print("Default %s %s -> %s" % (section, key, value))
                        if key in ['width', 'precision', 'limit', 'grouptype']:
                            value = int(value)
                        elif key in ['colorstep']:
                            value = float(value)
                        elif key in ['printtype']:
                            value = value[0]    # first character suffices
                        elif key in ['instances']:
                            value = lib.parse_instances(value)
                        elif key in ['cullinsts']:
                            value = self.prepare_regex(value)
                        setattr(plugin, key, value)
                    else:
                        if '.' in key:
                            mkey, spec = key.split(".")
                        else:
                            mkey, spec = key, 'formula'
                        name = 'dstat.' + section + '.' + mkey  # metric name
                        if name not in metrics:
                            lib.parse_new_verbose_metric(metrics, name, name)
                            if spec != 'label':
                                lib.parse_verbose_metric_info(metrics, name, 'label', mkey)
                        lib.parse_verbose_metric_info(metrics, name, spec, value)

# Instance logic for -C/-D/-L/-M/-P/-I/-N/-S options
                if section == 'cpu':
                    plugin.prepare_grouptype(self.cpulist, self.full)
                elif section in ['disk', 'disk-tps']:
                    plugin.prepare_grouptype(self.disklist, self.full)
                elif section in ['dm', 'dm-tps']:
                    plugin.prepare_grouptype(self.dmlist, self.full)
                elif section in ['md', 'md-tps']:
                    plugin.prepare_grouptype(self.mdlist, self.full)
                elif section in ['part', 'part-tps']:
                    plugin.prepare_grouptype(self.partlist, self.full)
                elif section == 'int':
                    plugin.prepare_grouptype(self.intlist, self.full)
                elif section == 'net':
                    plugin.prepare_grouptype(self.netlist, self.full)
                elif section == 'swap':
                    plugin.prepare_grouptype(self.swaplist, self.full)

for metric in metrics:
                name = metrics[metric][0]
                #print("Plugin[%s]: %s" % (name, metrics[metric]))
                plugin.apply(metrics[metric])
                state = metrics[metric][1:]
                plugin.metrics.append(state)
                self.metrics[name] = state
                #print("Appended[%s]: %s" % (name, state))

self.totlist.append(plugin)

def finalize_options(self):
        operands = self.opts.pmGetOperands()
        if not operands:
            operands = []
        else:
            try:
                self.interval = pmapi.timeval.fromInterval(operands[0])
                self.delay = float(self.interval)
            except:
                sys.stderr.write("Invalid sample delay '%s'\n" % operands[0])
                sys.exit(1)
        if len(operands) > 1:
            try:
                self.samples = int(operands[1]) + 1
            except:
                sys.stderr.write("Invalid sample count '%s'\n" % operands[1])
                sys.exit(1)
        if len(operands) > 2:
            sys.stderr.write("Incorrect argument list, try --help\n")
            sys.exit(1)

if not self.samples:
            self.samples = -1

def options(self):
        """ Setup default command line argument option handling """
        opts = pmapi.pmOptions()
        opts.pmSetOptionCallback(self.option)
        opts.pmSetOverrideCallback(self.option_override)
        opts.pmSetShortOptions("acC:dD:fghiI:lL:mM:nN:o:pP:qrsS:tTvVy?")
        opts.pmSetShortUsage("[-afv] [options...] [delay [count]]")
        opts.pmSetLongOptionText('Versatile tool for generating system resource statistics')

opts.pmSetLongOptionHeader("Dstat options")
        opts.pmSetLongOption('cpu', 0, 'c', '', 'enable cpu stats')
        opts.pmSetLongOptionText(' '*5 + '-C 0,3,total' + ' '*10 + 'include cpu0, cpu3 and total')
        opts.pmSetLongOption('disk', 0, 'd', '', 'enable disk stats')
        opts.pmSetLongOptionText(' '*5 + '-D total,sda' + ' '*10 + 'include sda and total')
        opts.pmSetLongOption('device-mapper', 0, None, '', '')
        opts.pmSetLongOptionText('  --dm, --device-mapper' + ' '*1 + 'enable device mapper stats')
        opts.pmSetLongOptionText(' '*5 + '-L root,home,total' + ' '*4 + 'include root, home and total')
        opts.pmSetLongOption('multi-device', 0, None, '', '')
        opts.pmSetLongOptionText('  --md, --multi-device' + ' '*2 + 'enable multi-device driver stats')
        opts.pmSetLongOptionText(' '*5 + '-M total,md-0' + ' '*9 + 'include md-0 and total')
        opts.pmSetLongOption('partition', 0, None, '', '')
        opts.pmSetLongOptionText('  --part, --partition' + ' '*3 + 'enable disk partition stats')
        opts.pmSetLongOptionText(' '*5 + '-P total,sdb2' + ' '*9 + 'include sdb2 and total')
        opts.pmSetLongOption('page', 0, 'g', '', 'enable page stats')
        opts.pmSetLongOption('int', 0, 'i', '', 'enable interrupt stats')
        opts.pmSetLongOptionText(' '*5 + '-I 9,CAL' + ' '*14 + 'include int9 and function call interrupts')
        opts.pmSetLongOption('load', 0, 'l', '', 'enable load stats')
        opts.pmSetLongOption('mem', 0, 'm', '', 'enable memory stats')
        opts.pmSetLongOption('net', 0, 'n', '', 'enable network stats')
        opts.pmSetLongOptionText(' '*5 + '-N eth1,total' + ' '*9 + 'include eth1 and total')
        opts.pmSetLongOption('proc', 0, 'p', '', 'enable process stats')
        opts.pmSetLongOption('io', 0, 'r', '', 'enable io stats (I/O requests completed)')
        opts.pmSetLongOption('swap', 0, 's', '', 'enable swap stats')
        opts.pmSetLongOptionText(' '*5 + '-S swap1,total' + ' '*8 + 'include swap1 and total')
        opts.pmSetLongOption('time', 0, 't', '', 'enable time/date output')
        opts.pmSetLongOption('time-adv', 0, None, '', 'enable time/date output (with milliseconds)')
        opts.pmSetLongOption('epoch', 0, 'T', '', 'enable time counter (seconds since epoch)')
        opts.pmSetLongOption('epoch-adv', 0, None, '', 'enable time counter (milliseconds since epoch)')
        opts.pmSetLongOption('sys', 0, 'y', '', 'enable system stats')
        opts.pmSetLongOptionText('')
        opts.pmSetLongOption('aio', 0, None, '', 'enable aio stats')
        opts.pmSetLongOption('fs', 0, None, '', '')
        opts.pmSetLongOption('filesystem', 0, None, '', '')
        opts.pmSetLongOptionText('  --fs, --filesystem' + ' '*4 + 'enable fs stats')
        for group in 'ipc', 'lock', 'raw', 'socket', 'tcp', 'udp', 'unix', 'vm':
            opts.pmSetLongOption(group, 0, None, '', 'enable '+ group + 'stats')
        opts.pmSetLongOption('vm-adv', 0, None, '', 'enable advanced vm stats')
#       opts.pmSetLongOption('zones', 0, None, '', 'enable zoneinfo stats')
        opts.pmSetLongOptionText('')
        opts.pmSetLongOption('list', 0, None, '', 'list all available plugins')
        opts.pmSetLongOption('plugin', 0, None, '', 'enable external plugin by name, see --list')
        opts.pmSetLongOptionText('')
        opts.pmSetLongOption('all', 0, 'a', '', 'equals -cdngy (default)')
        opts.pmSetLongOption('full', 0, 'f', '', 'automatically expand -C, -D, -I, -N and -S lists')
        opts.pmSetLongOption('vmstat', 0, 'v', '', 'equals -pmgdsc -D total')
        opts.pmSetLongOptionText('')
        opts.pmSetLongOption('bits', 0, '', '', 'force bits for values expressed in bytes')
        opts.pmSetLongOption('float', 0, '', '', 'force float values on screen')
        opts.pmSetLongOption('integer', 0, '', '', 'force integer values on screen')
        opts.pmSetLongOptionText('')
        opts.pmSetLongOption('bw', 0, '', '', '')
        opts.pmSetLongOption('blackonwhite', 0, '', '', '')
        opts.pmSetLongOption('black-on-white', 0, '', '', '')
        opts.pmSetLongOptionText('  --bw, --blackonwhite' + ' '*2 + 'change colors for white background terminal')
        opts.pmSetLongOption('color', 0, '', '', 'force colors')
        opts.pmSetLongOption('nocolor', 0, '', '', 'disable colors')
        opts.pmSetLongOption('noheaders', 0, '', '', 'disable repetitive headers')
        opts.pmSetLongOption('noupdate', 0, '', '', 'disable intermediate updates')
        opts.pmSetLongOption('nomissed', 0, '', '', 'disable missed ticks warnings')
        opts.pmSetLongOption('output', 1, 'o', 'file', 'write CSV output to file')
        opts.pmSetLongOption('version', 0, 'V', '', '')
        opts.pmSetLongOption('debug', 1, None, '', '')
        opts.pmSetLongOption('dbg', 0, None, '', '')
        opts.pmSetLongOption('help', 0, 'h', '', '')
        opts.pmSetLongOptionText('')
        opts.pmSetLongOptionText('delay is the delay in seconds between each update (default: 1)')
        opts.pmSetLongOptionText('count is the number of updates to display before exiting (default: unlimited)')
        return opts

def usage(self):
        """ Special case the -h option, usually -h/--host in PCP """
        pmUsageMessage()
        sys.exit(0)

def option_override(self, opt):
        """ Override standard PCP options for Dstat utility """
        if opt in ('a', 'D', 'g', 'h', 'L', 'n', 'N', 'p', 's', 'S', 't', 'T', 'V'):
            return 1
        return 0

def append_plugins(self, plugins):
        """ Activate a list of plugins, checking if already active first """
        for plugin in plugins:
            self.append_plugin(plugin)

def append_plugin(self, plugin):
        """ Activate a single plugin, checking if already active first """
        if plugin not in self.plugins:
            self.plugins.append(plugin)

def option(self, opt, arg, index):
        """ Perform setup for an individual command line option """
        if opt in ['dbg']:
            self.debug = True
        elif opt in ['c']:
            self.append_plugin('cpu')
        elif opt in ['C']:
            insts = arg.split(',')
            self.cpulist = sorted(['cpu' + str(x) for x in insts if x != 'total'])
            if 'total' in insts:
                self.cpulist.append('total')
        elif opt in ['d']:
            self.append_plugin('disk')
        elif opt in ['D']:
            insts = arg.split(',')
            self.disklist = sorted([x for x in insts if x != 'total'])
            if 'total' in insts:
                self.disklist.append('total')
        elif opt in ['device-mapper']:
            self.append_plugin('dm')
        elif opt in ['L']:
            insts = arg.split(',')
            self.dmlist = sorted([x for x in insts if x != 'total'])
            if 'total' in insts:
                self.dmlist.append('total')
        elif opt in ['multi-device']:
            self.append_plugin('md')
        elif opt in ['M']:
            insts = arg.split(',')
            self.mdlist = sorted([x for x in insts if x != 'total'])
            if 'total' in insts:
                self.mdlist.append('total')
        elif opt in ['partition']:
            self.append_plugin('part')
        elif opt in ['P']:
            insts = arg.split(',')
            self.partlist = sorted([x for x in insts if x != 'total'])
            if 'total' in insts:
                self.partlist.append('total')
        elif opt in ['filesystem']:
            self.append_plugin('fs')
        elif opt in ['g']:
            self.append_plugin('page')
        elif opt in ['i']:
            self.append_plugin('int')
        elif opt in ['I']:
            insts = arg.split(',')
            self.intlist = sorted(['line' + str(x) for x in insts if x != 'total'])
            if 'total' in insts:
                self.intlist.append('total')
        elif opt in ['l']:
            self.append_plugin('load')
        elif opt in ['m']:
            self.append_plugin('mem')
        elif opt in ['n']:
            self.append_plugin('net')
        elif opt in ['N']:
            insts = arg.split(',')
            self.netlist = sorted([x for x in insts if x != 'total'])
            if 'total' in insts:
                self.netlist.append('total')
        elif opt in ['p']:
            self.append_plugin('proc')
        elif opt in ['r']:
            self.append_plugin('io')
        elif opt in ['s']:
            self.append_plugin('swap')
        elif opt in ['S']:
            # pylint: disable=consider-using-generator
            self.swaplist = list(['/dev/' + str(x) for x in arg.split(',')])
        elif opt in ['t']:
            self.append_plugin('time')
        elif opt in ['T']:
            self.append_plugin('epoch')
        elif opt in ['y']:
            self.append_plugin('sys')
        elif opt in ['a', 'all']:
            self.append_plugins(['cpu', 'disk', 'net', 'page', 'sys'])
        elif opt in ['v', 'vmstat']:
            self.append_plugins(['proc', 'mem', 'page', 'disk', 'sys', 'cpu'])
        elif opt in ['f', 'full']:
            self.full = True
        elif opt in ['all-plugins']:
            self.append_plugins(self.allplugins)
        elif opt in ['bits']:
            self.bits = True
        elif opt in ['bw', 'black-on-white', 'blackonwhite']:
            self.blackonwhite = True
        elif opt in ['color']:
            self.color = True
            self.update = True
        elif opt in ['float']:
            self.float = True
        elif opt in ['integer']:
            self.integer = True
        elif opt in ['list']:
            self.show_conf = True
            self.show_plugins()
            sys.exit(0)
        elif opt in ['nocolor']:
            self.color = False
        elif opt in ['noheaders']:
            self.header = False
        elif opt in ['noupdate']:
            self.update = False
        elif opt in ['nomissed']:
            self.nomissed = True
        elif opt in ['o', 'output']:
            self.output = arg
        elif opt in ['pidfile']:
            self.pidfile = arg
        elif opt in ['q']:
            self.verify = True
        elif opt in ['h', '?']:
            self.usage()
        elif opt in ['V', 'version']:
            self.show_conf = True
            self.show_version()
            self.show_plugins()
            sys.exit(0)
        elif opt != '':
            self.append_plugin(opt)
        else:
            raise pmapi.pmUsageErr()

def config_paths(self, conf):
        usrdir = os.path.expanduser('~')
        sysdir = pmapi.pmContext.pmGetConfig("PCP_SYSCONF_DIR")
        conf = conf.replace("$PCP_SYSCONF_DIR", sysdir)
        conf = conf.replace("$HOME", usrdir)
        return conf

def config_files(self, configs):
        paths = []
        for conf in configs:
            conf = self.config_paths(conf)
            try:
                if not os.path.isdir(conf):
                    continue
                for filename in sorted(os.listdir(conf)):
                    length = len(filename)
                    # skip rpm packaging files or '.'-prefixed
                    if length > 1 and filename[0] == '.':
                        continue
                    if length > 7 and filename[(length-7):] == '.rpmnew':
                        continue
                    if length > 8 and filename[(length-8):] == '.rpmsave':
                        continue
                    paths.append(conf + '/' + filename)
            except:
                pass
        return paths

def show_plugins(self):
        sys.stdout.write("timestamp plugins:\n\t")
        sep = ''
        for i, name in enumerate(sorted(self.timeplugins)):
            if i != 0:
                sep = ', '
            sys.stdout.write("%s%s" % (sep, name))
        sys.stdout.write("\n")
        _, columns = self.term.get_size()
        for i, path in enumerate(self.DEFAULT_CONFIGS):
            self.show_config_files(path, columns)

def show_config_files(self, path, columns):
        files = self.config_files([path])
        if files == []:
            return
        path = self.config_paths(path)
        config = ConfigParser.RawConfigParser()
        config.optionxform = str
        try:
            config.read(files)
            sys.stdout.write("%s plugins:\n\t" % path)
            self.show_config_plugins(config, columns)
        except:
            sys.stderr.write("%s: failed to read configuration file(s)" % path)

def show_config_plugins(self, config, columns):
        plugins = sorted(config.sections())
        cols2 = columns - 8
        mod = None
        for mod in plugins:
            cols2 = cols2 - len(mod) - 2
            if cols2 <= 0:
                sys.stdout.write('\n\t')
                cols2 = columns - len(mod) - 10
            if mod != plugins[-1]:
                sys.stdout.write("%s, " % mod)
        if mod is not None:
            sys.stdout.write("%s\n" % mod)

def show_version(self):
        self.connect()
        platform = self.pmfg.extend_item('kernel.uname.sysname')
        kernel = self.pmfg.extend_item('kernel.uname.release')
        hertz = self.pmfg.extend_item('kernel.all.hz')
        cpucount = self.pmfg.extend_item('hinv.ncpu')
        pagesize = self.pmfg.extend_item('hinv.pagesize')
        self.pmfg.fetch()
        print('pcp-dstat %s' % self.context.pmGetConfig('PCP_VERSION'))
        print('Written by the PCP team <pcp@groups.io> and Dag Wieers <dag@wieers.com>')
        print('Homepages at https://pcp.io/ and http://dag.wieers.com/home-made/dstat/')
        print('')
        print('Platform %s' % platform())
        print('Kernel %s' % kernel())
        print('Python %s' % sys.version)
        print('')
        color = ""
        if not self.term.get_color():
            color = "no "
        print('Terminal type: %s (%scolor support)' % (os.getenv('TERM'), color))
        row, col = self.term.get_size()
        print('Terminal size: %d lines, %d columns' % (row, col))
        print('')
        print('Processors: %d' % cpucount())
        print('Pagesize: %d' % pagesize())
        print('Clock ticks per second: %d' % hertz())
        print('')
        self.pmfg.clear()

def connect(self):
        """ Establish a PMAPI context, default is 'local:' with a fallback
            to using local context mode if pmcd(1) is not running locally.
        """
        context, self.source = pmapi.pmContext.set_connect_options(self.opts, self.source, self.speclocal)

if context == PM_CONTEXT_ARCHIVE:
            self.update = False
        if context == PM_CONTEXT_HOST:
            try:
                self.pmfg = pmapi.fetchgroup(context, self.source)
            except pmapi.pmErr:
                if self.source != 'local:':
                    raise
                context = PM_CONTEXT_LOCAL
        if self.pmfg is None:
            self.pmfg = pmapi.fetchgroup(context, self.source)
        self.pmfg_ts = self.pmfg.extend_timestamp()
        self.context = self.pmfg.get_context()

if pmapi.c_api.pmSetContextOptions(self.context.ctx, self.opts.mode, self.opts.delta):
            raise pmapi.pmUsageErr()

def validate(self):
        """ Validate configuration options """
        if self.version != self.CONFIG_VERSION:
            sys.stderr.write("Incompatible configuration file version (read v%s, need v%d).\n" % (self.version, self.CONFIG_VERSION))
            sys.exit(1)

self.pmconfig.validate_common_options()
        self.pmconfig.validate_metrics()

for i, plugin in enumerate(self.totlist):
            for name in self.metrics:
                metric = self.metrics[name]
                if plugin != metric[12]:
                    continue
                plugin.mgroup.append(name)   # metric names

for i, metric in enumerate(self.metrics):
            plugin = self.metrics[metric][12]
            insts = self.pmconfig.insts[i]
            for j in range(0, len(insts[0])):
                inum, inst = insts[0][j], insts[1][j]
                if inst not in plugin.igroup:
                    plugin.igroup.append(inst)
                name = self.metrics[metric][0]
                if inum != PM_IN_NULL:
                    name = name.replace('%d', str(inum)).replace('%s', inst)
                    name = name.replace('%i', str(inum)).replace('%I', inst)
                if name not in plugin.names:
                    plugin.names.append(name)   # instance names

self.pmconfig.finalize_options()
        self.finalize_options()

@staticmethod
    def dchg(var, width, base):
        "Convert decimal to string given base and length"
        c = 0
        var = float(var) # avoid loss of precision below
        while True:
            ret = str(long(py3round(var)))
            if len(ret) <= width:
                break
            var = var / base
            c = c + 1
        else:
            c = -1
        return ret, c

@staticmethod
    def fchg(var, width, base):
        "Convert float to string given scale and length"
        c = 0
        while True:
            if var == 0:
                ret = str('0')
                break
            ret = str(long(py3round(var, width)))
            if len(ret) <= width:
                i = width - len(ret) - 1
                while i > 0:
                    ret = ('%%.%df' % i) % var
                    if len(ret) <= width and ret != str(long(py3round(var, width))):
                        break
                    i = i - 1
                else:
                    ret = str(long(py3round(var)))
                break
            var = var / base
            c = c + 1
        else:
            c = -1
        return ret, c

@staticmethod
    def showtime(plugin, stamp):
        "Format a sample time stamp"
        value = ''
        if plugin.name in ['epoch', 'epoch-adv']:    # time in seconds
            value = str(int(stamp.value))
        elif plugin.name in ['time', 'time-adv']:    # formatted time
            value = stamp().strftime(TIMEFMT)
        if plugin.name in ['epoch-adv', 'time-adv']: # with milliseconds
            value = value + '.' + str(stamp.value.tv_usec * 1000)[:3]
        return value

@staticmethod
    def tchg(var, width):
        "Convert time string to given length"
        ret = '%2dh%02d' % (var / 60, var % 60)
        if len(ret) > width:
            ret = '%2dh' % (var / 60)
            if len(ret) > width:
                ret = '%2dd' % (var / 60 / 24)
                if len(ret) > width:
                    ret = '%2dw' % (var / 60 / 24 / 7)
        return ret

def tshow(self, plugin, stamp):
        "Display sample time stamp"
        value = self.showtime(plugin, stamp)
        line = self.cprint(value, NOUNITS, 's', None, plugin.width, None)
        #sys.stderr.write("tshow result:\n%s%s\n" % (line, THEME['default']))
        return line

def mgetkey(self, label, instid):
        "Get valueset lookup key for a given metric instance"
        return label + '[' + str(instid) + ']'

def mlookup(self, valuesets, key):
        "Perform valueset lookup for a given metric instance"
        try:
            valueset = valuesets[key]
        except KeyError:
            valueset = []
        return valueset

def mappend(self, valuesets, key, pmtype, value):
        "Add value into the given valueset for a later averaging calculation"
        valueset = self.mlookup(valuesets, key)
        if value is None or pmtype not in [PM_TYPE_32, PM_TYPE_U32, PM_TYPE_64,
                                    PM_TYPE_U64, PM_TYPE_FLOAT, PM_TYPE_DOUBLE]:
            valueset = []
        valueset.append(value)
        return valueset

def maverage(self, valueset, key):
        "Perform valueset averaging calculation, return current average"
        value = sum(valueset) / len(valueset)
        #sys.stderr.write("average[%s] %s = %s / %s%s\n" %
        #(key, value, sum(valueset), len(valueset), THEME['default']))
        return value

def mupdate(self, valuesets, valueset, key):
        "Store latest values in a set in the valueset array"
        if valueset:
            valuesets[key] = valueset

def mcleanup(self, valuesets, key):
        "Reset a valueset for storing values for the next sample"
        if step == op.delay:
            valueset = self.mlookup(valuesets, key)
            del valueset[:]
            return valueset
        return None

def mshow(self, plugin, index, result):
        "Display stat results"
        metric = op.metrics[plugin.mgroup[index]]
        #sys.stderr.write("Result metric: %s\n" % metric)
        label = metric[0]
        units = metric[2][1]
        width = metric[4]
        pmtype = metric[5].pmtype
        printtype = metric[8]
        colorstep = metric[9]
        valuesets = metric[13]

line = ''
        count = 0
        sep = CHAR['space']
        for instid, _, value in result:
            if count > 0:
                line = line + sep
            key = self.mgetkey(label, instid)
            valueset = self.mappend(valuesets, key, pmtype, value)
            value = self.maverage(valueset, key)
            self.mcleanup(valuesets, key)
            self.mupdate(valuesets, valueset, key)
            #sys.stderr.write("mshow result value:\n%s%s\n" % (value, THEME['default']))
            line = line + self.cprint(value, units, printtype, pmtype, width, colorstep)
            count += 1
        if count == 0:
            line = line + self.cprint(None, units, printtype, pmtype, width, colorstep)
        #sys.stderr.write("mshow result line:\n%s%s\n" % (line, THEME['default']))
        return line

@staticmethod
    def roundcsv(var):
        "Value rounding for comma-separated-value output"
        if var is None:
            return ''
        if var != round(var):
            return '%.3f' % var
        return '%d' % round(var)

def mshowcsv(self, plugin, index, result):
        "Return stat results for CSV file"
        line = ''
        count = 0
        sep = CHAR['sep']
        for _, _, value in result:
            if count > 0:
                line = line + sep
            line = line + self.roundcsv(value)
            count += 1
        #sys.stderr.write("mshowcsv result:\n%s%s\n" % (line, THEME['default']))
        return line

def tshowcsv(self, plugin, stamp):
        value = self.showtime(plugin, stamp)
        line = value.ljust(plugin.width)
        #sys.stderr.write("tshowcsv result:\n%s%s\n" % (line, THEME['default']))
        return line

@staticmethod
    def instance_match(inst, plugin):
        if plugin.instances and inst in plugin.instances:
            return True
        return plugin.grouptype == 1

def gshow(self, plugin, results):
        "Display stat group results"
        metric = op.metrics[plugin.mgroup[0]]
        #sys.stderr.write("Result metric: %s\n" % metric)
        units = metric[2][1]
        width = metric[4]
        pmtype = metric[5].pmtype
        printtype = metric[8]
        colorstep = metric[9]

line = ''
        count = 0
        col = THEME['frame'] + CHAR['colon']

# first iterate over the result and update all metric instance valuesets
        for i, name in enumerate(plugin.mgroup):        # e.g. [usr, sys, idl]
            metric = op.metrics[plugin.mgroup[i]]
            result = results[name]
            valuesets = metric[13]
            label = metric[0]
            for instid, _, value in result:
                key = self.mgetkey(label, instid)
                valueset = self.mappend(valuesets, key, pmtype, value)
                self.mupdate(valuesets, valueset, key)

# next, iterate over specific instances requested and report values
        for inst in plugin.igroup:      # e.g. [cpu0, cpu1, total]
            for i, name in enumerate(plugin.mgroup):        # e.g. [usr, sys, idl]
                metric = op.metrics[plugin.mgroup[i]]
                result = results[name]
                valuesets = metric[13]
                label = metric[0]
                value = None

for instid, instname, _ in result:
                    if instname == inst:
                        key = self.mgetkey(label, instid)
                        valueset = self.mlookup(valuesets, key)
                        value = self.maverage(valueset, key)
                #sys.stderr.write("[%s] inst=%s value=%s\n" % (name, inst, str(value)))
                if not self.instance_match(inst, plugin):
                    continue
                if plugin.grouptype == 2:   # total only
                    continue
                if count > 0 and (count % len(plugin.mgroup)) == 0:
                    line = line + col
                elif count > 0:
                    line = line + CHAR['space']
                line = line + self.cprint(value, units, printtype, pmtype, width, colorstep)
                count += 1

# next, handle the total column (if requested) and report a value
        if plugin.grouptype > 1:   # report 'total' (sum) calculation
            totals = [0] * len(plugin.mgroup)
            for i, name in enumerate(plugin.mgroup):        # e.g. [usr, sys, idl]
                metric = op.metrics[name]
                values = 0
                result = results[name]
                valuesets = metric[13]
                label = metric[0]

for instid, instname, _ in result:
                    if plugin.cullinsts is not None and re.match(plugin.cullinsts, instname):
                        continue
                    key = self.mgetkey(label, instid)
                    valueset = self.mlookup(valuesets, key)
                    totals[i] += self.maverage(valueset, key)
                    values += 1

if values == 0:
                totals = [None] * len(plugin.mgroup)
            if values and plugin.printtype == 'p':
                for i in range(0, len(plugin.mgroup)):
                    totals[i] /= values
            if line != '':
                line = line + col
            line = line + self.cprintlist(totals, units, printtype, pmtype, width, colorstep)

# finally, throw away any values that are no longer needed
        for i, name in enumerate(plugin.mgroup):        # e.g. [usr, sys, idl]
            metric = op.metrics[name]
            valuesets = metric[13]
            label = metric[0]
            for instid, _, _ in result:
                key = self.mgetkey(label, instid)
                valueset = self.mcleanup(valuesets, key)
                self.mupdate(valuesets, valueset, key)

#sys.stderr.write("gshow result line:\n%s%s\n" % (line, THEME['default']))
        return line

def gshowcsv(self, plugin, results):
        "Return stat group results for CSV file"
        line = ''
        count = 0
        totals = [0] * len(plugin.mgroup)

for inst in plugin.igroup:      # e.g. [cpu0, cpu1, total]
            for i, name in enumerate(plugin.mgroup):        # e.g. [usr, sys, idl]
                result = results[name]
                value = None
                for _, instname, val in result:
                    if instname == inst:
                        value = val
                #sys.stderr.write("[%s] inst=%s name=%s value=%s\n" % (name, instid, instname, str(value)))
                if not self.instance_match(inst, plugin):
                    continue
                if plugin.grouptype == 2:   # total only
                    continue
                if count > 0:
                    line = line + CHAR['sep']
                line = line + self.roundcsv(value)
                count += 1

if plugin.grouptype > 1:   # report 'total' (sum) calculation
            for i, name in enumerate(plugin.mgroup):        # e.g. [usr, sys, idl]
                values = 0
                result = results[name]
                for _, instname, val in result:
                    if plugin.cullinsts is not None and re.match(plugin.cullinsts, instname):
                        continue
                    totals[i] += val
                    values += 1
            if values == 0:
                totals = [None] * len(plugin.mgroup)
            if values and plugin.printtype == 'p':
                for i in range(0, len(plugin.mgroup)):
                    totals[i] /= values
            for value in totals:
                if line != '':
                    line = line + CHAR['sep']
                line = line + self.roundcsv(value)
        #sys.stderr.write("gshowcsv result line:\n%s%s\n" % (line, THEME['default']))
        return line

@staticmethod
    def scale_time(value, scale):
        """ convert to canonical time units of seconds """
        div = 1.0
        mul = 1.0
        if scale == PM_TIME_NSEC:
            div = 1000000000.0
        elif scale == PM_TIME_USEC:
            div = 1000000.0
        elif scale == PM_TIME_MSEC:
            div = 1000.0
        elif scale == PM_TIME_MIN:
            mul = 60.0
        elif scale == PM_TIME_HOUR:
            mul = 3600.0
        return (float(value) / div) * mul

@staticmethod
    def scale_space(value, scale):
        """ convert to canonical space units of bytes """
        if scale == 0:
            return value
        return value * pow(1024, scale)

def cprintlist(self, values, units, prtype, pmtype, width, colorstep):
        """Return all columns color printed"""
        ret = sep = ''
        for value in values:
            ret = ret + sep + self.cprint(value, units, prtype, pmtype, width, colorstep)
            sep = CHAR['space']
        return ret

def cprint(self, value, units, printtype, pmtype, width, colorstep):
        """Color print one column.  Note that @value may be None indicating
           there were no values available at sampling time in which case we
           print a blank section in the report.  If the entire line ends up
           blank, we filter it out later.
        """
        if value is not None:
            self.novalues = False
        else:
            value = ''
            printtype = 's'
            colorstep = None

if printtype is None:
            if pmtype in [PM_TYPE_32, PM_TYPE_U32, PM_TYPE_64, PM_TYPE_U64]:
                printtype = 'd'
            elif pmtype in [PM_TYPE_DOUBLE, PM_TYPE_FLOAT]:
                printtype = 'f'
            else:
                printtype = 's'
        base = 1000
        if units.dimTime and printtype != 's':
            value = self.scale_time(value, units.scaleTime)
        if units.dimSpace and printtype != 's':
            base = 1024
            value = self.scale_space(value, units.scaleSpace)
        if units.dimCount and units.scaleCount and printtype != 's':
            value *= units.scaleCount

### Display units when base is exact 1000 or 1024
        showunit = False
        if colorstep is None:
            if width >= len(str(base)) and not isinstance(value, str):
                showunit = True
                width = width - 1

### If this is a negative value, return a dash
        if printtype in ('b', 'd', 'f') and value < 0:
            if showunit:
                return THEME['error'] + '-'.rjust(width) + CHAR['space'] + THEME['default']
            else:
                return THEME['error'] + '-'.rjust(width) + THEME['default']

if op.bits and printtype in ('b', ):
            units = ('b', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
            base = 1000
            value = value * 8.0
        elif base != 1024:
            units = (CHAR['space'], 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
        else:
            units = ('B', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')

if step == op.delay:
            colors = THEME['colors_lo']
            ctext = THEME['text_lo']
            cunit = THEME['unit_lo']
            cdone = THEME['done_lo']
        else:
            colors = THEME['colors_hi']
            ctext = THEME['text_hi']
            cunit = THEME['unit_hi']
            cdone = THEME['done_hi']

#sys.stderr.write("printtype: %s\n" % str(printtype))
        #sys.stderr.write("colorstep: %s\n" % str(colorstep))

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

### Set the metrics color
        if ret == '0':
            color = cunit
        elif printtype in ('p') and py3round(value) >= 100.0:
            color = cdone
        elif colorstep is not None:
            color = colors[int(value/colorstep) % len(colors)]
        elif printtype in ('b', 'd', 'f'):
            color = colors[c % len(colors)]
        else:
            color = ctext

### Justify value to left if string
        if printtype in ('s',):
            ret = color + ret.ljust(width)
        else:
            ret = color + ret.rjust(width)

### Add unit to output
        if showunit:
            if c != -1 and py3round(value) != 0:
                ret += cunit + units[c]
            else:
                ret += CHAR['space']

return ret

def show_header(self, visible):
        "Return the header for a set of module counters"
        line = ''
        ### Process title
        for o in visible:
            line += o.title()
            if o is not visible[-1]:
                line += THEME['frame'] + CHAR['space']
            elif self.totlist != visible:
                line += THEME['title'] + CHAR['gt']
        line += '\n'
        ### Process subtitle
        for o in visible:
            line += o.subtitle()
            if o is not visible[-1]:
                line += THEME['frame'] + CHAR['pipe']
            elif self.totlist != visible:
                line += THEME['title'] + CHAR['gt']
        return line + '\n'

def show_csvheader(self, visible):
        "Return the header for CSV file"
        line = ''
        ### CSV Header
        if not os.path.exists(self.output):
            line += '"pcp-dstat ' + self.context.pmGetConfig('PCP_VERSION') + ' CSV Output"\n'
            line += '"Author:","PCP team <pcp@groups.io> and Dag Wieers <dag@wieers.com>",,,,"URL:","https://pcp.io/ and http://dag.wieers.com/home-made/dstat/"\n'
        import getpass # pylint: disable=import-outside-toplevel
        line += '"Host:","' + self.context.pmGetContextHostName() + '",,,,"User:","' + getpass.getuser() + '"\n'
        line += '"Cmdline:","' + self.context.pmProgname() + ' ' + ' '.join(self.arguments) + '",,,,"Date:","' + time.strftime('%d %b %Y %H:%M:%S %Z') + '"\n'
        ### Process title
        for o in visible:
            line += o.csvtitle()
            if o is not visible[-1]:
                line += CHAR['sep']
            elif self.totlist != visible:
                pass #line += THEME['title'] + CHAR['gt']
        line += '\n'
        ### Process subtitle
        for o in visible:
            line += o.csvsubtitle()
            if o is not visible[-1]:
                line += CHAR['sep']
            elif self.totlist != visible:
                pass #line += THEME['title'] + CHAR['gt']
        return line + '\n'

@staticmethod
    def finalize():
        """ Finalize and clean up (atexit) """
        try:
            sys.stderr.close() # avoid python-generated warnings
            if not op.verify and not op.show_conf:
                if op.update:
                    sys.stdout.write('\n')
                if sys.stdout.isatty():
                    sys.stdout.write(ANSI['reset'])
            sys.stdout.flush()
            if op.pidfile:
                os.remove(op.pidfile)
        except:
            pass

def perform(self, update):
        "Inner loop that calculates counters and constructs output"
        global oldvislist, vislist, showheader, showcsvheader, rows, cols
        global totaltime, starttime
        global loop, step

starttime = time.time()
        loop = int((update - 1 + op.delay) / op.delay)
        step = int(((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

# If it takes longer than 500ms, then warn!
        if loop != 0 and starttime - self.inittime - update > 1:
            self.missed = self.missed + 1
            return

# Initialise certain variables
        if loop == 0:
            rows, cols = 0, 0
            vislist = []
            oldvislist = []
            showheader = True
            showcsvheader = True

if sys.stdout.isatty():
            oldcols = cols
            rows, cols = self.term.get_size()

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

# Check when to display the header
            if self.header and rows >= 6:
                if oldvislist != vislist:
                    showheader = True
                elif not op.update and loop % (rows - 2) == 0:
                    showheader = True
                elif op.update and step == 1 and loop % (rows - 1) == 0:
                    showheader = True

oldvislist = vislist
        else:
            vislist = self.totlist

# Fetch values
        try:
            self.pmfg.fetch()
        except pmapi.pmErr as fetcherr:
            raise fetcherr

# Calculate all objects (visible, invisible)
        onovalues = self.novalues
        self.novalues = True
        line = oline = ''
        i = 0

# Walk the result dict reporting on visible plugins.
        # In conjuntion, we walk through the ordered results
        # dictionary - matching up to each plugin as we go.
        # Note that some plugins (time-based) will not have
        # any corresponding entry in the results.

results = self.pmconfig.get_ranked_results()
        for i, plugin in enumerate(self.totlist):
            if i == 0:
                sep = ''
            else:
                sep = THEME['frame'] + CHAR['pipe']
            if plugin not in vislist:
                pass
            elif plugin in self.timelist:
                line = line + sep + self.tshow(plugin, self.pmfg_ts)
            elif plugin.grouptype is None:
                for m, name in enumerate(plugin.mgroup):
                    line = line + sep + self.mshow(plugin, m, results[name])
                    sep = CHAR['space']
            elif plugin.mgroup:
                line = line + sep + self.gshow(plugin, results)
            if self.totlist == vislist:
                continue
            if plugin in self.totlist and plugin not in vislist:
                line = line + THEME['frame'] + CHAR['gt']
                break

if self.output:
            for i, plugin in enumerate(self.totlist):
                if i == 0:
                    sep = ''
                else:
                    sep = CHAR['sep']
                if plugin in self.timelist:
                    oline = oline + sep + self.tshowcsv(plugin, self.pmfg_ts)
                elif plugin.grouptype is None:
                    for m, name in enumerate(plugin.mgroup):
                        oline = oline + sep + self.mshowcsv(plugin, m, results[name])
                        sep = CHAR['sep']
                elif plugin.mgroup:
                    oline = oline + sep + self.gshowcsv(plugin, results)

# Prepare the colors for intermediate updates
        # (last step in a loop is definitive)
        if step == op.delay:
            THEME['default'] = ANSI['reset']
        else:
            THEME['default'] = THEME['text_lo']

# The first step is to show the definitive line if necessary
        newline = ''
        if op.update and not self.novalues:
            if step == 1 and update != 0 and not onovalues:
                newline = '\n'
                newline += ANSI['reset'] + ANSI['clearline'] + ANSI['save']
            elif loop != 0:
                newline = ANSI['restore']

# Display header
        if showheader:
            if loop == 0 and self.totlist != vislist:
                sys.stderr.write('Terminal width too small, trimming output.\n')
            showheader = False
            sys.stdout.write(newline)
            newline = self.show_header(vislist)
            newline += ANSI['reset'] + ANSI['clearline'] + ANSI['save']

# Display CSV header
        newoline = ''
        if op.output:
            if showcsvheader:
                showcsvheader = False
                if os.path.exists(self.output):
                    newoline += '\n\n'
                newoline += self.show_csvheader(vislist)

if self.novalues:
            line = newline
        else:
            line = newline + line
        if self.novalues:
            oline = newoline
        else:
            oline = newoline + oline

# Print stats
        sys.stdout.write(line + THEME['input'])

if self.output and step == self.delay:
            if not os.path.exists(self.output) or not os.path.isfile(op.output):
                omode = 'wt'
            else:
                omode = 'at'
            outputfile = open(self.output, omode)
            outputfile.write(oline)

if self.missed > 0 and self.nomissed is False:
            line = 'missed ' + str(self.missed + 1) + ' ticks'
            sys.stdout.write(' ' + THEME['error'] + line + THEME['input'])
            if self.output and step == self.delay:
                outputfile.write(',"' + line + '"')
        self.missed = 0
        # Finish the line
        if not op.update and self.novalues is False:
            sys.stdout.write('\n')
        if self.output and step == self.delay and self.novalues is False:
            outputfile.write('\n')

def execute(self):
        """ Fetch and report """
        if self.debug:
            sys.stdout.write("Config file keywords: " + str(self.keys) + "\n")
            sys.stdout.write("Metric spec keywords: " + str(self.pmconfig.metricspec) + "\n")

# Set delay mode for live sampling
        if self.context.type != PM_CONTEXT_ARCHIVE:
            scheduler = sched.scheduler(time.time, time.sleep)
            self.inittime = time.time()

# Common preparations
        self.context.prepare_execute(self.opts, False, self.interpol, self.interval)

update = 0.0
        interval = 1.0
        if not self.update:
            interval = op.delay

while update <= self.delay * (self.samples - 1) or self.samples == -1:
            if self.context.type != PM_CONTEXT_ARCHIVE:
                scheduler.enterabs(self.inittime + update, 1, perform, (update,))
                scheduler.run()
            else:
                self.perform(update)
            sys.stdout.flush()
            update = update + interval

def perform(update):
    """Helper function for interfacing to the scheduler"""
    op.perform(update)

if __name__ == '__main__':
    global update
    try:
        dstat = DstatTool(sys.argv[1:])
        dstat.execute()
    except pmapi.pmErr as error:
        if error.args[0] == PM_ERR_EOL:
            sys.exit(0)
        sys.stderr.write('%s: %s\n' % (error.progname(), error.message()))
        sys.exit(1)
    except pmapi.pmUsageErr as usage:
        usage.message()
        sys.exit(1)
    except IOError as error:
        if error.errno != errno.EPIPE:
            sys.stderr.write("%s\n" % str(error))
            sys.exit(1)
    except KeyboardInterrupt:
        sys.stdout.write("\n")

${this.title}

Code Editor : pcp-dstat