Munin contributed plugins

#!/usr/bin/python

# .- coding: utf-8 -.

#

# Artificial munin node that behaves in all the ways you would like

# ordinary nodes _not_ to behave.

#

# Intended use is for designing and debugging munin-server poller to handle 

# such problems.

#

# See the file MIT-LICENSE for licensing information.

#

# Copyright (C) 2011 Karstensen IT

# Written by Lasse Karstensen <lasse.karstensen@gmail.com>, Dec 2011.

import os, sys, time, random

import socket

import threading

import SocketServer

import ConfigParser

VERSION = "muninnode-from-hell v0.1"

modules = {}

class MuninPlugin:

    def __init__(self):

        self.current_load = None

        self.current_locks = None

    def sleep_fetch(self, conf):

        period = None

        if conf.get("mode") == "sleepy" and conf.get("sleepyness"):

            period = float(conf.get("sleepyness"))

        if conf.get("mode") == "exp" and conf.get("lambd"):

            period = random.expovariate(1 / float(conf.get("lambd")))

        if period:

            #print "will sleep %.3f seconds" % period

            time.sleep(period)

    def sleep_config(self, conf):

        return self.sleep_fetch(conf)

    def find_load(self):

        # At about a thousand node instances you get this:

        #IOError: [Errno 24] Too many open files: '/proc/loadavg'

        # cache it for a bit..

        if (not self.current_load) or random.randint(0,100) == 1:

            load = open("/proc/loadavg", "r").read()

            load, rest = load.split(" ", 1)

            self.current_load = float(load)

        return self.current_load

    def find_locks(self):

        if (not self.current_locks) or random.randint(0,100) == 1:

            fp = open("/proc/locks", "r")

            self.current_locks = len(fp.readlines())

        return self.current_locks 

class load(MuninPlugin):

    def fetch(self, conf):

        self.sleep_fetch(conf)

        return "load.value %.2f" % self.find_load()

    def config(self, conf):

        self.sleep_config(conf)

        return """graph_title Load average

graph_args --base 1000 -l 0

graph_vlabel load

graph_scale no

graph_category system

load.label load

graph_info The load average of the machine describes how many processes are in the run-queue (scheduled to run "immediately").

load.info 5 minute load average """

modules["load"] = load()

class locks(MuninPlugin):

    def fetch(self, conf):

        self.sleep_fetch(conf)

        return "locks.value %i" % self.find_locks()

    def config(self, conf):

        self.sleep_config(conf)

        return """graph_title Filesystem locks

graph_vlabel number of locks

graph_scale no

graph_info This graph shows file system lock info

graph_category system

locks.label number of locks

locks.info Number of active locks"""

modules["locks"] = locks()

class tarpit(MuninPlugin):

    "Nasty plugin that never responds"

    def fetch(self, conf):

        time.sleep(1000)

    def config(self, conf):

        time.sleep(1000)

modules["tarpit"] = tarpit()

class always_warning(MuninPlugin):

    conftext = """graph_title Always in LEVEL

graph_vlabel Level

graph_scale no

graph_info A simple graph that is always in LEVEL

graph_category always_LEVEL

generic.label Level

generic.info Level usually above warning level

generic.warning 5

generic.critical 10"""

    def fetch(self, conf):

        return "generic.value 10"

    def config(self, conf):

        return self.conftext.replace("LEVEL","warning")

modules["always_warning"] = always_warning()

class always_critical(always_warning):

    def fetch(self, conf):

        return "generic.value 20"

    def config(self, conf):

        return self.conftext.replace("LEVEL","critical")

modules["always_critical"] = always_critical()

class failing_plugin(MuninPlugin):

    "A really broken plugin"

    def fetch(self, conf):

        return "# Bad exit"

    def config(self, conf):

        return "# Bad exit"

modules["failing_plugin"] = failing_plugin()

class failing_plugin2(MuninPlugin):

    def fetch(self, conf):

        return "# Bad exit"

    def config(self, conf):

        return """graph_title Config works, fetch fails

graph_vlabel Level

graph_category failing

generic.label generic_label_here

generic.info never_really_used"""

modules["failing_plugin2"] = failing_plugin2()

class failing_plugin3(MuninPlugin):

    def config(self, conf):

        return """graph_title A plugin with two dses but only fetch value for one

graph_args --base 1000 -l 0

fivemin.label 1 minute load

onemin.label 5 minute load"""

    def fetch(self, conf):

        return "onemin.value 1"

modules["failing_plugin3"] = failing_plugin3()

class graph_area(MuninPlugin):

    "A plugin that uses STACK and AREA. From proc_pri. Use: testing the grapher"

    def fetch(self, conf):

        return """high.value 3

low.value 2

locked.value 1"""

    def config(self, conf):

        return """graph_title AREA and STACK

graph_order low high locked

graph_category graphtest

graph_info This graph shows nuber of processes at each priority

graph_args --base 1000 -l 0

graph_vlabel Number of processes

high.label high priority

high.draw STACK

high.info The number of high-priority processes (tasks)

low.label low priority

low.draw AREA

low.info The number of low-priority processes (tasks)

locked.label locked in memory

locked.draw STACK

locked.info The number of processes that have pages locked into memory (for real-time and custom IO)

"""

modules["graph_area"] = graph_area()

class utf8_graphcat(MuninPlugin):

    "A plugin with a graph category which has UTF-8 in it"

    def fetch(self, conf):

        return "apples.value %.2f" % self.find_load()

    def config(self, conf):

        return """graph_title Example UTF-8 graph

graph_vlabel apples

graph_category foo™

apples.label apples

graph_info Apples eaten

apples.info Apples eaten"""

modules["utf8_graphcat"] = utf8_graphcat()

class utf8_graphname(MuninPlugin):

    "A plugin with a UTF-8 name"

    def fetch(self, conf):

        return "apples.value %.2f" % self.find_load()

    def config(self, conf):

        return """graph_title Example UTF-8 graph

graph_vlabel apples

graph_category system

apples.label apples

graph_info Apples eaten

apples.info Apples eaten"""

modules["utf8_™graphname"] = utf8_graphname()

class ArgumentTCPserver(SocketServer.ThreadingTCPServer):

    def __init__(self, server_address, RequestHandlerClass, args):

        SocketServer.ThreadingTCPServer.__init__(self,server_address, RequestHandlerClass)

        self.args = args

class MuninHandler(SocketServer.StreamRequestHandler):

    """

    Munin server implementation.

    This is based on munin_node.py by Chris Holcombe / http://sourceforge.net/projects/pythonmuninnode/

    Possible commands:

    list, nodes, config, fetch, version or quit

    """

    def handle(self):

        if self.server.args.get("verbose"): print "%s: Connection from %s:%s. server args is %s" \

            % (self.server.args["name"], self.client_address[0], self.client_address[1], self.server.args)

        # slow path

        hostname = self.server.args["name"]

        full_hostname = hostname

        moduleprofile = self.server.args["pluginprofile"]

        modulenames = set(moduleprofile)

        self.wfile.write("# munin node at %s\n" % hostname)

        while True:

            line = self.rfile.readline().strip()

            try:

                cmd, args = line.split(" ", 1)

            except ValueError:

                cmd = line

                args = ""

            if not cmd or cmd == "quit":

                break

            if cmd == "list":

                # List all plugins that are available

                self.wfile.write(" ".join(self.server.args["plugins"].keys()) + "\n")

            elif cmd == "nodes":

                # We just support this host

                self.wfile.write("%s\n.\n" % full_hostname)

            elif cmd == "config":

                # display the config information of the plugin

                if not self.server.args["plugins"].has_key(args):

                    self.wfile.write("# Unknown service\n.\n" )

                else:

                    config = self.server.args["plugins"][args].config(self.server.args)

                    if config is None:

                        self.wfile.write("# Unknown service\n.\n")

                    else:

                        self.wfile.write(config + "\n.\n")

            elif cmd == "fetch":

                # display the data information as returned by the plugin

                if not self.server.args["plugins"].has_key(args):

                    self.wfile.write("# Unknown service\n.\n")

                else:

                    data = self.server.args["plugins"][args].fetch(self.server.args)

                    if data is None:

                        self.wfile.write("# Unknown service\n.\n")

                    else:

                        self.wfile.write(data + "\n.\n")

            elif cmd == "version":

                # display the server version

                self.wfile.write("munin node on %s version: %s\n" %

                                 (full_hostname, VERSION))

            else:

                self.wfile.write("# Unknown command. Try list, nodes, " \

                                 "config, fetch, version or quit\n")

def start_servers(instances):

    # TODO: Listen to IPv6

    HOST = "0.0.0.0"

    servers = {}

    for iconf in instances:

            print "Setting up instance %s at port %s" \

                % (iconf["name"], iconf["expanded_port"])

            server = ArgumentTCPserver((HOST, iconf["expanded_port"]), MuninHandler, iconf)

            server_thread = threading.Thread(target=server.serve_forever)

            server_thread.daemon = True

            server_thread.start()

            servers[iconf["name"]] = server

    return servers

def usage():

    print "Usage: %s [--run] [--verbose] [--muninconf] <configfile> <configfileN>" % sys.argv[0]

def main():

    if len(sys.argv) <= 2:

        usage()

        sys.exit(1)

    verbose = False

    if "--verbose" in sys.argv:

        verbose = True

    config = ConfigParser.RawConfigParser()

    for configfile in sys.argv[1:]:

        if not configfile.endswith(".conf"):

            continue

        if verbose:

            print "Reading config file %s" % configfile

        config.read(configfile)

    instancekeys = [ key for key in config.sections() if key.startswith("instance:") ]

    servers = {}

    instances = []

    for key in instancekeys:

        instancename = key.split(":", 2)[1]

        portrange = []

        if config.has_option(key, "port"):

            portrange = [ config.getint(key, "port") ]

        if config.has_option(key, "portrange"):

            rangestr = config.get(key, "portrange")

            ranges = rangestr.split("-")

            range_expanded = range(int(ranges[0]), int(ranges[1])+1, 1)

            portrange += range_expanded

        if len(portrange) == 0:

            print "WARN: No port or portrange defined for instance %s" \

                % instancename

        pluginprofile = "pluginprofile:%s" % config.get(key, "pluginprofile")

        if not config.has_section(pluginprofile):

            print "WARN: Definition for pluginprofile %s not found, skipping" \

                % config.get(key, "pluginprofile")

            continue

        plugins = {}

        tentative_pluginlist = config.get(pluginprofile, "plugins").split(",")

        assert(len(tentative_pluginlist) > 0)

        for tentative_plugin in tentative_pluginlist:

            tentative_plugin = tentative_plugin.strip()

            if not modules.has_key(tentative_plugin):

                print "WARN: Pluginprofile %s specifies unknown plugin %s" \

                    % (pluginprofile, tentative_plugin)

                continue

            # support more than one instantiation of the same plugin.

            plugininstancename = tentative_plugin

            i=2

            while (plugins.has_key(plugininstancename)):

                plugininstancename = tentative_plugin + str(i)

                i += 1

            plugins[plugininstancename] = modules[tentative_plugin]

        for portinstance in portrange:

            instanceconfig = dict()

            for k,v in config.items(key):

                instanceconfig[k] = v

            instanceconfig["plugins"] = plugins

            instanceconfig["verbose"] = verbose

            instanceconfig["name"] = "%s-%s" % (instancename, portinstance)

            instanceconfig["expanded_port"] = portinstance

            instances.append(instanceconfig)

            # XXX: need to store what handlers we should have.

    print instances

    # output sample munin config for the poller

    if "--muninconf" in sys.argv:

        for i in instances:

            print "[%s;%s]\n\taddress %s\n\tuse_node_name yes\n\tport %s\n" \

                % ( "fromhell", i["name"], config.get("base","hostname"), i["port"])

    if "--run" in sys.argv:

        if verbose: print "Starting up.."

        servers = start_servers(instances)

        try:

            while True:

                time.sleep(0.5)

        except KeyboardInterrupt:

            print "Caught Ctrl-c, shutting down.."

            for port, server in servers.items():

                server.shutdown()

                sys.exit(0)

if __name__ == "__main__":

    main()