TrxShell [ mangaberri.com ]

Name	Size	Permission
discover	[ DIR ]	drwxr-xr-x
chkhelp	14.02 KB	-rwxr-xr-x
find-filter	14.02 KB	-rwxr-xr-x
mkaf	2.82 KB	-rwxr-xr-x
newhelp	22.57 KB	-rwxr-xr-x
pcp-atop	374.23 KB	-rwxr-xr-x
pcp-atopsar	374.23 KB	-rwxr-xr-x
pcp-buddyinfo	8.03 KB	-rwxr-xr-x
pcp-dmcache	7.13 KB	-rwxr-xr-x
pcp-dstat	74.98 KB	-rwxr-xr-x
pcp-free	9.79 KB	-rwxr-xr-x
pcp-geolocate	2.6 KB	-rwxr-xr-x
pcp-htop	290.05 KB	-rwxr-xr-x
pcp-iostat	20.79 KB	-rwxr-xr-x
pcp-ipcs	6.82 KB	-rwxr-xr-x
pcp-lvmcache	7.13 KB	-rwxr-xr-x
pcp-meminfo	7.75 KB	-rwxr-xr-x
pcp-mpstat	31.26 KB	-rwxr-xr-x
pcp-netstat	18.55 KB	-rwxr-xr-x
pcp-numastat	6.33 KB	-rwxr-xr-x
pcp-pidstat	48.4 KB	-rwxr-xr-x
pcp-ps	39.43 KB	-rwxr-xr-x
pcp-python	925 B	-rwxr-xr-x
pcp-reboot-init	2.52 KB	-rwxr-xr-x
pcp-shping	3.47 KB	-rwxr-xr-x
pcp-slabinfo	8.7 KB	-rwxr-xr-x
pcp-ss	17.4 KB	-rwxr-xr-x
pcp-summary	11.21 KB	-rwxr-xr-x
pcp-tapestat	18.38 KB	-rwxr-xr-x
pcp-uptime	4.9 KB	-rwxr-xr-x
pcp-verify	7.72 KB	-rwxr-xr-x
pcp-vmstat	1.54 KB	-rwxr-xr-x
pcp-zoneinfo	18.81 KB	-rwxr-xr-x
pmcd	119.26 KB	-rwxr-xr-x
pmcd_wait	14.51 KB	-rwxr-xr-x
pmconfig	14.52 KB	-rwxr-xr-x
pmcpp	26.51 KB	-rwxr-xr-x
pmfind_check	4.29 KB	-rwxr-xr-x
pmgetopt	23.29 KB	-rwxr-xr-x
pmhostname	14.41 KB	-rwxr-xr-x
pmie_check	21.38 KB	-rwxr-xr-x
pmie_daily	14.42 KB	-rwxr-xr-x
pmie_dump_stats	14.02 KB	-rwxr-xr-x
pmie_email	1.76 KB	-rwxr-xr-x
pmie_farm	896 B	-rwxr-xr-x
pmie_webhook	1.79 KB	-rwxr-xr-x
pmiestatus	14.02 KB	-rwxr-xr-x
pmlock	14.02 KB	-rwxr-xr-x
pmlogconf	55.26 KB	-rwxr-xr-x
pmlogextract	74.88 KB	-rwxr-xr-x
pmlogger	159.62 KB	-rwxr-xr-x
pmlogger_check	30.62 KB	-rwxr-xr-x
pmlogger_daily	55.78 KB	-rwxr-xr-x
pmlogger_daily_report	12.47 KB	-rwxr-xr-x
pmlogger_farm	919 B	-rwxr-xr-x
pmlogger_janitor	20.87 KB	-rwxr-xr-x
pmlogger_merge	6.66 KB	-rwxr-xr-x
pmlogger_rewrite	8 KB	-rwxr-xr-x
pmlogredact	1.79 KB	-rwxr-xr-x
pmlogreduce	30.7 KB	-rwxr-xr-x
pmlogrewrite	158.76 KB	-rwxr-xr-x
pmnewlog	810 B	-rwxr-xr-x
pmnsadd	2.89 KB	-rwxr-xr-x
pmnsdel	22.45 KB	-rwxr-xr-x
pmnsmerge	22.57 KB	-rwxr-xr-x
pmpause	14.02 KB	-rwxr-xr-x
pmpost	14.14 KB	-rwxr-xr-x
pmproxy	140.61 KB	-rwxr-xr-x
pmsignal	2.72 KB	-rwxr-xr-x
pmsleep	14.02 KB	-rwxr-xr-x
pmwtf	7.63 KB	-rwxr-xr-x
runaspcp	14.45 KB	-rwxr-xr-x
telnet-probe	14.02 KB	-rwxr-xr-x

Code Editor : pcp-free

#!/usr/bin/env pmpython
#
# Copyright (C) 2014-2018 Red Hat.
#
# 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,bad-continuation,bad-whitespace
#
""" Display amount of free and used memory in the system """

import sys
from pcp import pmapi
from cpmapi import PM_TYPE_U64, PM_CONTEXT_ARCHIVE, PM_SPACE_KBYTE

if sys.version >= '3':
    long = int  # python2 to python3 portability (no long() in python3)

class Free(object):
    """ Gives a short summary of kernel virtual memory information,
        in a variety of formats, possibly sampling in a loop.

Knows about some of the default PCP arguments - can function
        using remote hosts or historical data, using the timezone of
        the metric source, at an offset within an archive, and so on.
    """

def __init__(self):
        """ Construct object - prepare for command line handling """
        self.count = 0       # number of samples to report
        self.pause = None    # time interval to pause between samples
        self.shift = 10      # bitshift conversion between B/KB/MB/GB
        self.show_wide = 0
        self.show_high = 0
        self.show_total = 0
        self.show_compat = 0
        self.opts = self.options()
        self.interval = pmapi.timeval()
        self.context = None

def options(self):
        """ Setup default command line argument option handling """
        opts = pmapi.pmOptions()
        opts.pmSetOptionCallback(self.option)
        opts.pmSetOverrideCallback(self.override)
        opts.pmSetShortOptions("bc:gklmrots:Vw?")
        opts.pmSetLongOptionHeader("Options")
        opts.pmSetLongOption("bytes", 0, 'b', '', "show output in bytes")
        opts.pmSetLongOption("kilobytes", 0, 'k', '', "show output in KB")
        opts.pmSetLongOption("megabytes", 0, 'm', '', "show output in MB")
        opts.pmSetLongOption("gigabytes", 0, 'g', '', "show output in GB")
        opts.pmSetLongOption("terabytes", 0, 'r', '', "show output in TB")
        opts.pmSetLongOption("", 0, 'o', '',
                             "use old format (-/+buffers/cache line)")
        opts.pmSetLongOption("lohi", 0, 'l', '',
                             "show detailed low and high memory statistics")
        opts.pmSetLongOption("total", 0, 't', '',
                             "display total for RAM + swap")
        opts.pmSetLongOption("count", 1, 'c', "COUNT",
                             "repeat printing COUNT times, then exit")
        opts.pmSetLongOption("samples", 1, 'c', "COUNT",
                             "number of samples (alias for --count)")
        opts.pmSetLongOption("seconds", 1, 's', "DELTA",
                             "repeat printing every DELTA seconds")
        opts.pmSetLongOption("interval", 1, 's', "DELTA",
                             "sampling interval (alias for --seconds)")
        opts.pmSetLongOptionVersion()
        opts.pmSetLongOptionHelp()
        return opts

def override(self, opt):
        """ Override a few standard PCP options to match free(1) """
        # pylint: disable=R0201
        if opt in ('g', 's', 't'):
            return 1
        return 0

def option(self, opt, optarg, index):
        """ Perform setup for an individual command line option """
        # pylint: disable=W0613
        if opt == 'b':
            self.shift = 0
        elif opt == 'k':
            self.shift = 10
        elif opt == 'm':
            self.shift = 20
        elif opt == 'g':
            self.shift = 30
        elif opt == 'r':
            self.shift = 40
        elif opt == 'o':
            self.show_compat = 1
        elif opt == 'w':
            self.show_wide = 1
        elif opt == 'l':
            self.show_high = 1
        elif opt == 't':
            self.show_total = 1
        elif opt == 's':
            self.pause = optarg
            self.opts.pmSetOptionInterval(optarg)
            self.interval = self.opts.pmGetOptionInterval()
        elif opt == 'c':
            self.opts.pmSetOptionSamples(optarg)
            self.count = self.opts.pmGetOptionSamples()

def scale(self, value):
        """ Convert a given value in kilobytes into display units """
        return long(value << 10) >> self.shift

def extract(self, descs, result):
        """ Extract the set of metric values from a given pmResult """
        values = []
        for index, desc in enumerate(descs):
            if result.contents.get_numval(index) > 0:
                atom = self.context.pmExtractValue(
                                result.contents.get_valfmt(index),
                                result.contents.get_vlist(index, 0),
                                desc.contents.type, PM_TYPE_U64)
                atom = self.context.pmConvScale(PM_TYPE_U64, atom, descs, index,
                                pmapi.pmUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0))
                values.append(long(atom.ull))
            else:
                values.append(long(0))
        return values

def execute(self):
        """ Using a PMAPI context (could be either host or archive),
            fetch and report a fixed set of values related to memory.
        """
        metrics = ('mem.physmem',
                   'mem.util.free',  'mem.util.shmem',
                   'mem.util.bufmem',  'mem.util.cached',
                   'mem.util.highFree',  'mem.util.highTotal',
                   'mem.util.lowFree',  'mem.util.lowTotal',
                   'mem.util.swapFree',  'mem.util.swapTotal',
                   'mem.util.available',  'mem.util.slabReclaimable')

pmids = self.context.pmLookupName(metrics)
        descs = self.context.pmLookupDescs(pmids)

if self.pause is None and self.count == 0:
            self.count = 1
        if self.pause is not None and self.count == 0:
            self.count = -1

while self.count != 0:
            result = self.context.pmFetch(pmids)
            values = self.extract(descs, result)
            self.context.pmFreeResult(result)
            self.report(values)
            if self.pause is not None:
                print('') # empty line
                sys.stdout.flush()
                if self.count > 0:
                    self.count -= 1
                if self.count == 0:
                    break
                if self.context.type != PM_CONTEXT_ARCHIVE:
                    self.context.pmtimevalSleep(self.interval)
            elif self.count == 1 and self.pause is None:
                break
            elif self.count > 0:
                self.count -= 1

def report(self, values):
        """ Given the set of metric values report them in free(1) form """
        physmem = values[0]
        free = values[1]
        shared = values[2]
        buffers = values[3]
        cached = values[4]
        highfree = values[5]
        hightotal = values[6]
        lowfree = values[7]
        lowtotal = values[8]
        swapfree = values[9]
        swaptotal = values[10]
        available = values[11]
        slabreclaim = values[12]

used = physmem - free - buffers - cached - slabreclaim
        cache = cached + slabreclaim
        swapused = swaptotal - swapfree

# low == main memory, except with large-memory support
        if lowtotal == 0:
            lowtotal = physmem
            lowfree = free

if self.show_wide:
            columns = ('total', 'used', 'free', 'shared', 'buffers', 'cache', 'available')
            print("%19s %11s %11s %11s %11s %11s %11s" % columns)
            print("%-7s %11Lu %11Lu %11Lu %11Lu %11Lu %11Lu %11Lu" % ('Mem:',
                self.scale(physmem), self.scale(used), self.scale(free),
                self.scale(shared), self.scale(buffers), self.scale(cache),
                self.scale(available)))
        else:
            columns = ('total', 'used', 'free', 'shared', 'buff/cache', 'available')
            print("%19s %11s %11s %11s %11s %11s" % columns)
            print("%-7s %11Lu %11Lu %11Lu %11Lu %11Lu %11Lu" % ('Mem:',
                self.scale(physmem), self.scale(used), self.scale(free),
                self.scale(shared), self.scale(buffers + cache),
                self.scale(available)))

if self.show_high:
            print("%-7s %11Lu %11Lu %11Lu" % ('Low:', self.scale(lowtotal),
                    self.scale(lowtotal - lowfree), self.scale(lowtotal)))
            print("%-7s %11Lu %11Lu %11Lu" % ('High:', self.scale(hightotal),
                    self.scale(hightotal - highfree), self.scale(highfree)))
        if self.show_compat != 0:
            cache = buffers + cached
            print("%s:  %11Lu %11Lu" % ('-/+ buffers/cache',
                    self.scale(used - cache), self.scale(free + cache)))

print("%-7s %11Lu %11Lu %11Lu" % ('Swap', self.scale(swaptotal),
                self.scale(swapused), self.scale(swapfree)))

if self.show_total == 1:
            print("%-7s %11Lu %11Lu %11Lu" % ('Total',
                    self.scale(physmem + swaptotal),
                    self.scale(used + swapused), self.scale(free + swapfree)))

def connect(self):
        """ Establish a PMAPI context to archive, host or local, via args """
        self.context = pmapi.pmContext.fromOptions(self.opts, sys.argv)

if __name__ == '__main__':
    try:
        FREE = Free()
        FREE.connect()
        FREE.execute()
    except pmapi.pmErr as error:
        print("%s: %s" % (error.progname(), error.message()))
    except pmapi.pmUsageErr as usage:
        usage.message()
    except KeyboardInterrupt:
        pass

${this.title}

Code Editor : pcp-free