Munin contributed plugins

#!/usr/bin/python

# -*- coding: utf-8 -*-

A munin plugin that prints archive and their upgradable packets

TODO: make it usable and readable as commandline tool

   sorting a packet to the newest archive

   (WONTFIX unless someone asks for)

 • addinge alternative names for archives "stable -> squeeze"

      foo.colour 000000

      to 'now', '', '', '', '', 'Debian dpkg status file'

TODO: update only if system was updated (aptitutde update has been run)

      • check modification date of /var/cache/apt/pkgcache.bin

      • cache file must not be older than mod_date of pkgcache.bin + X

      • i have no clever idea to do this without 100 lines of code

     these new deps will not be counted. WONTFIX

"""

import sys

import apt_pkg

from apt.progress.base import OpProgress

from time import time, strftime

import StringIO

import string

import re

class EnvironmentConfigBroken(Exception): pass

# for k,v in os.environ.iteritems(): print >> sys.stderr, "%r : %r" % (k,v)

def getEnv(name, default=None, cast=None):

STATE_DIR = getEnv('MUNIN_PLUGSTATE', default='.')

CACHE_FILE = os.path.join(STATE_DIR, "deb_packages.state")

   There is no need to execute this script every 5 minutes.

   The Results are put to this file, next munin-run can read from it

   CACHE_FILE is usually /var/lib/munin/plugin-state/debian_packages.state

"""

CACHE_FILE_MAX_AGE = getEnv('CACHE_FILE_MAX_AGE', default=3540, cast=int)

   Age in seconds an $CACHE_FILE can be. If it is older, the script updates

"""

        doc = "apt_pkg.Cache instance, lazy instantiated"

        def fget(self):

            class NullProgress(OpProgress):

                    python-apt 0.7

                """

                def __init__(self):

                def update(*args,**kwords):

                    pass

            return self._cache

        return locals()

        doc = "apt_pkg.DepCache object"

        def fget(self):

                self._depcache = apt_pkg.DepCache(self.cache)

            return self._depcache

        apt.installedPackages

        apt.upgradablePackages

"""

def weightOfPackageFile(detail_tuple, option_tuple):

class TreeTwig(defaultdict):

    def __init__(self, defaultFactory):

    def printAsTree(self, indent=0):

        for k, tree in self.iteritems():

def getShortestConfigOfOptions(optionList = ['label', 'archive', 'site']):

        tries to find the order to print a tree of the optionList

        possible options are:

          'component'

          'label'

          'site'

          'archive'

        Architecture values are usually the same and can be ignored.

        tells you which representation of a tree as line is shortest.

        to write the shortest readable output.

    """

    l = optionList # just because l is much shorter

    # creating possible iterations

    fieldCount = len(optionList)

    if fieldCount == 1:

        selection = l

    elif fieldCount == 2:

                     for y in l if x!=y ]

    elif fieldCount == 3:

                     for z in l if z!=y and z!=x]

    else:

        raise Exception("NotImplemented for size %s" % fieldCount)

    r = min( d.items(), key=lambda x: x[1] )

    return list(r[0]), r[1]

def getOptionsTree(cache, keys=None):

    """

    t = getOptionsTree(cache, ['archive', 'site', 'label'])

    """

    if type(key) in StringTypes:

        return file.__getattribute__(key)

        nKey = tuple()

        for pKey in key:

            nKey = nKey.__add__((file.__getattribute__(pKey),))

        return nKey

    else:

def getOptionsTree2(cache, primary=None, secondary=None):

    primary muss ein iterable oder StringType sein

    secondary muss iterable oder StringType sein

    t1 = getOptionsTree2(apt.cache, 'origin', ['site', 'archive'])

                dKey = file.__getattribute__(sKey)

                d = d[dKey]

    return t

#def getAttributeSet(iterable, attribute):

#    return set(f.__getattribute__(attribute) for f in iterable)

#

#def getOrigins(cache):

#

#def getArchives(cache):

#

#def getComponents(cache):

#

#def getLabels(cache):

#

#def getSites(cache):

#

class PackageStat(defaultdict):

        with some abilities to print output munin likes

    """

                                        ''      :  1,

                                        'Debian Security' : 90,

                                        'Debian Backports': 90}),

                 'archive': defaultdict( lambda :  5,

                                  'experimental':      10,

                                  'testing':           70,

                                  'wheezy':            70,

                                  'squeeze-backports': 80,

    }

    """

        Values to sort options (label, archive, origin ...)

        (this is needed for other graphs to calc aggregated weights)

    """

    dpkgStatusValue = { 'site': '', 'origin': '', 'label': '', 'component': '', 'archive': 'now' }

                       'component' : 10**2,

    }

    """

        to compile a sorting value for each archivefile

    """

    def addPackage(self, sourceFile, package):

        if self.packetHandler.decider(package):

            self.packetHandler.adder(package, self)

    @classmethod

    def configD(cls, key, value):

        i = { 'rrdName': cls.generate_rrd_name_from(key),

            print "{rrdName}.draw AREASTACK".format(**i)

    def optionIsDpkgStatus(self, details, options=None):

            a 'Debian dpkg status file'.

        """

        # setting defaults

        return isNow

    def printValues(self):

                                                             type=self.packetHandler.type)

        for options, item in self.options_sorted:

            if not self.packetHandler.includeNow and self.optionIsDpkgStatus(details=options):

class PacketHandler(object):

    """

    """

    type = None

        return weightOfPackageFile(details, options)

class PacketHandlerUpgradable(PacketHandler):

    type='upgradable'

    includeNow = False

    extInfoItemString = "  {i[0].name} <{i[1]} -> {i[2]}>"

        # this item (as i) is used for input in extInfoItemString

        item = package

        packageStat[keys].append(item)

# registering PackageHandler for Usage

packetHandlerD[PacketHandlerInstalled.type] = PacketHandlerInstalled

    def __init__(self, commandLineArgs=None):

        self.commandLineArgs = commandLineArgs

        self.argParser = self._argParser()

            'config': self.config,

            'run'   : self.run,

            'autoconf' : self.autoconf,

        else:

            raise Exception('DPKG-statusfile %r not found, really strange!!!'%dpkgStatusFile)

        newestFileTimestamp = max(timeL)

        if age > 0:

            return True

        else:

        #         cacheNeedUpdate = True

        if self._cacheIsOutdated() or self.args.nocache:

            stdoutDef = sys.stdout

            try:

                out =  StringIO.StringIO()

    def _argParser(self):

        parser = argparse.ArgumentParser(description="Show some statistics "\

                            "about debian packages installed on system by archive",

        parser.set_defaults(command='run', debug=True, nocache=True)

        parser.add_argument('--nocache', '-n', default=False, action='store_true',

            run ........ munin run (writes values)

            autoconf ... writes 'yes'

        """

                            choices=['config', 'run', 'autoconf', 'drun'],

                            help='mode munin wants to use. "run" is default' + helpCommand)

        return parser

    def _envParser(self):

        """

            reads environVars from [deb_packages] and generate

            munin config.

                'sort_by' = ['label', 'archive'],

                'show_ext' = ['origin', 'site'],

              },

                configPart['show_ext'][m.group('optNumber')] = os.getenv(var)

            else:

                print >> sys.stderr, "configuration option %r was ignored" % (var)

        # changing them to lists

        for graphConfig in config.itervalues():

            graphConfig['sort_by'] = [val for key, val in sorted(graphConfig['sort_by'].items())]

                      "Graph must be sorted by anything"

                raise EnvironmentConfigBroken("Environment Config broken")

            # check for valid options for sort_by

                print >> sys.stderr, \

                      "%r are not valid options for 'sort_by'" % (unusableOptions)

                raise EnvironmentConfigBroken("Environment Config broken")

            # check for valid options for sort_by

            if unusableOptions:

                print >> sys.stderr, \

                      "%r are not valid options for 'show_ext'" % (x)