Munin contributed plugins

#!/bin/sh

# weird shebang? See below: "interpreter selection"

#

# Collect basic information about the neighbours of an OLSR node:

#   * link quality

#   * neighbour link quality

#   * number of nodes reachable behind each neighbour

#   * ping times of direct neighbours

#

# This plugin works with the following python interpreters:

#   * Python 2

#   * Python 3

#   * micropython

#

# Environment variables:

#   * OLSRD_HOST: name or IP of the host running the txtinfo plugin (default: localhost)

#   * OLSRD_TXTINFO_PORT: the port that the txtinfo plugin is listening to (default: 2006)

#   * OLSRD_BIN_PATH: name of the olsrd binary (only used for 'autoconf', defaults to /usr/sbin/olsrd)

#   * MICROPYTHON_HEAP: adjust this parameter for micropython if your olsr network contains

#     more than a few thousand nodes (default: 512k)

#

#

# Copyright (C) 2015 Lars Kruse <devel@sumpfralle.de>

#

#    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 3 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.

#

#    You should have received a copy of the GNU General Public License

#    along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

# Magic markers

#%# capabilities=autoconf

#%# family=auto

"""true"

# ****************** Interpreter Selection ***************

# This unbelievable dirty hack allows to find a suitable python interpreter.

# This is specifically useful for OpenWRT where typically only micropython is available.

#

# Additionally we need to run micropython with additional startup options.

# This is necessary due to our demand for more than 128k heap (this default is sufficient for only 400 olsr nodes).

#

# This "execution hack" works as follows:

#   * the script is executed by busybox ash or another shell

#   * the above line (three quotes before and one quote after 'true') evaluates differently for shell and python:

#    * shell: run "true" (i.e. nothing happens)

#    * python: ignore everything up to the next three consecutive quotes

# Thus we may place shell code here that will take care for selecting an interpreter.

# prefer micropython if it is available - otherwise fall back to any python (2 or 3)

if which micropython >/dev/null; then

    /usr/bin/micropython -X "heapsize=${MICROPYTHON_HEAP:-512k}" "$0" "$@"

else

    python "$0" "$@"

fi

exit $?

# For shell: ignore everything starting from here until the last line of this file.

# This is necessary for syntax checkers that try to complain about invalid shell syntax below.

true <<EOF

"""

plugin_version = "0.3"

import os

import socket

import sys

LQ_GRAPH_CONFIG = """

graph_title     {title}

graph_vlabel    Link Quality (-) / Neighbour Link Quality (+)

graph_category  network

graph_info      OLSR estimates the quality of a connection by the ratio of successfully received (link quality) and transmitted (neighbour link quality) hello packets.

"""

LQ_VALUES_CONFIG = """

nlq{suffix}.label none

nlq{suffix}.type GAUGE

nlq{suffix}.graph no

nlq{suffix}.draw {draw_type}

nlq{suffix}.min 0

lq{suffix}.label {label}

lq{suffix}.type GAUGE

lq{suffix}.draw {draw_type}

lq{suffix}.negative nlq{suffix}

lq{suffix}.min 0

"""

NEIGHBOUR_COUNT_CONFIG = """

graph_title     Reachable nodes via neighbours

graph_vlabel    Number of Nodes

graph_category  network

graph_info      Count the number of locally known routes passing through each direct neighbour. This number is a good approximation of the number of mesh nodes reachable via this specific neighbour. MIDs (alternative addresses of an OLSR node) and HNAs (host network announcements) are ignored.

"""

NEIGHBOUR_COUNT_VALUE = """

neighbour_{host_fieldname}.label {host}

neighbour_{host_fieldname}.type GAUGE

neighbour_{host_fieldname}.draw {draw_type}

neighbour_{host_fieldname}.min 0

"""

NEIGHBOUR_PING_CONFIG = """

graph_title     {title}

graph_vlabel    roundtrip time (ms)

graph_category  network

graph_info      This graph shows ping RTT statistics.

graph_args      --base 1000 --lower-limit 0

graph_scale     no

"""

NEIGHBOUR_PING_VALUE = """neighbour_{host_fieldname}.label {host}"""

# micropython (as of 2015) does not contain "os.linesep"

LINESEP = getattr(os, "linesep", "\n")

get_clean_fieldname = lambda name: "".join([(("a" <= char.lower() <= "z") or ((index == 0) or ("0" <= char <= "9"))) and char or "_" for index, char in enumerate(name)])

def query_olsrd_txtservice(section=""):

    host = os.getenv("OLSRD_HOST", "localhost")

    port = os.getenv("OLSRD_TXTINFO_PORT", "2006")

    conn = socket.create_connection((host, port), 1.0)

    try:

        # Python3

        request = bytes("/%s" % section, "ascii")

    except TypeError:

        # Python2

        request = bytes("/%s" % section)

    conn.sendall(request)

    fconn = conn.makefile()

    # "enumerate" is not suitable since it reads all lines at once (not a generator in micropython)

    index = 0

    for line in fconn.readlines():

        # skip the first five lines - they are headers

        if index < 5:

            index += 1

            continue

        line = line.strip()

        if line:

            yield line

    fconn.close()

    conn.close()

def get_address_device_mapping():

    mapping = {}

    for line in query_olsrd_txtservice("mid"):

        # example line content:

        #    192.168.2.171   192.168.22.171;192.168.12.171

        device_id, mids = line.split()

        for mid in mids.split(";"):

            mapping[mid] = device_id

    return mapping

def count_routes_by_neighbour(address_mapping, ignore_list):

    node_count = {}

    for line in query_olsrd_txtservice("routes"):

        # example line content:

        #    192.168.1.79/32 192.168.12.38   4       4.008   wlan0

        tokens = line.split()

        target = tokens[0]

        via = tokens[1]

        # we care only about single-host routes

        if target.endswith("/32"):

            if target[:-3] in address_mapping:

                # we ignore MIDs - we want only real nodes

                continue

            if target in ignore_list:

                continue

            # replace the neighbour's IP with its main IP (if it is an MID)

            via = address_mapping.get(via, via)

            # increase the counter

            node_count[via] = node_count.get(via, 0) + 1

    return node_count

def get_olsr_links():

    mid_mapping = get_address_device_mapping()

    hna_list = [line.split()[0] for line in query_olsrd_txtservice("hna")]

    route_count = count_routes_by_neighbour(mid_mapping, hna_list)

    result = []

    for line in query_olsrd_txtservice("links"):

        tokens = line.split()

        link = {}

        link["local"] = tokens.pop(0)

        remote = tokens.pop(0)

        # replace the neighbour's IP with its main IP (if it is an MID)

        link["remote"] = mid_mapping.get(remote, remote)

        for key in ("hysterese", "lq", "nlq", "cost"):

            link[key] = float(tokens.pop(0))

        # add the route count

        link["route_count"] = route_count.get(link["remote"], 0)

        result.append(link)

    result.sort(key=lambda link: link["remote"])

    return result

def _read_file(filename):

    try:

        return open(filename, "r").read().split(LINESEP)

    except OSError:

        return []

def get_ping_times(hosts):

    tempfile = "/tmp/munin-olsrd-{pid}.tmp".format(pid=os.getpid())

    command = 'for host in {hosts}; do echo -n "$host "; ping -c 1 -w 1 "$host" | grep /avg/ || true; done >{tempfile}'\

              .format(hosts=" ".join(hosts), tempfile=tempfile)

    # micropython supports only "os.system" (as of 2015) - thus we need to stick with it for openwrt

    returncode = os.system(command)

    if returncode != 0:

        return {}

    lines = _read_file(tempfile)

    os.unlink(tempfile)

    # example output for one host:

    #   192.168.2.41 round-trip min/avg/max = 4.226/4.226/4.226 ms

    result = {}

    for line in lines:

        tokens = line.split(None)

        if len(tokens) > 1:

            host = tokens[0]

            avg_ping = tokens[-2].split("/")[1]

            result[host] = float(avg_ping)

    return result

if __name__ == "__main__":

    # parse arguments

    if len(sys.argv) > 1:

        if sys.argv[1]=="config":

            links = list(get_olsr_links())

            # link quality with regard to neighbours

            print("multigraph olsr_link_quality")

            print(LQ_GRAPH_CONFIG.format(title="OLSR Link Quality"))

            is_first = True

            for link in links:

                print(LQ_VALUES_CONFIG.format(label=link["remote"],

                                              suffix="_{host}".format(host=get_clean_fieldname(link["remote"])),

                                              draw_type=("AREA" if is_first else "STACK")))

                is_first = False

            is_first = True

            for link in links:

                print("multigraph olsr_link_quality.host_{remote}".format(remote=get_clean_fieldname(link["remote"])))

                print(LQ_GRAPH_CONFIG.format(title="Link Quality towards {host}".format(host=link["remote"])))

                print(LQ_VALUES_CONFIG.format(label="Link Quality", suffix="", draw_type="AREA"))

                is_first = False

            # link count ("number of nodes behind each neighbour")

            print("multigraph olsr_neighbour_link_count")

            print(NEIGHBOUR_COUNT_CONFIG)

            is_first = True

            for link in links:

                print(NEIGHBOUR_COUNT_VALUE

                      .format(host=link["remote"],

                              host_fieldname=get_clean_fieldname(link["remote"]),

                              draw_type=("AREA" if is_first else "STACK")))

                is_first = False

            # neighbour ping

            print("multigraph olsr_neighbour_ping")

            print(NEIGHBOUR_PING_CONFIG.format(title="Ping time of neighbours"))

            for link in links:

                print(NEIGHBOUR_PING_VALUE

                      .format(host=link["remote"],

                              host_fieldname=get_clean_fieldname(link["remote"])))

            # neighbour pings - single subgraphs

            for link in links:

                remote = get_clean_fieldname(link["remote"])

                print("multigraph olsr_neighbour_ping.host_{remote}".format(remote=remote))

                print(NEIGHBOUR_PING_CONFIG.format(title="Ping time of {remote}".format(remote=remote)))

                print(NEIGHBOUR_PING_VALUE.format(host=link["remote"], host_fieldname=remote))

            sys.exit(0)

        elif sys.argv[1] == "autoconf":

            if os.path.exists(os.getenv('OLSRD_BIN_PATH', '/usr/sbin/olsrd')):

                print('yes')

            else:

                print('no')

            sys.exit(0)

        elif sys.argv[1] == "version":

            print('olsrd Munin plugin, version %s' % plugin_version)

            sys.exit(0)

        elif sys.argv[1] == "":

            # ignore

            pass

        else:

            # unknown argument

            sys.stderr.write("Unknown argument{eol}".format(eol=LINESEP))

            sys.exit(1)

    # output values

    links = list(get_olsr_links())

    # overview graph for the link quality (ETX) of all neighbours

    print("multigraph olsr_link_quality")

    for link in links:

        print("lq_{remote}.value {lq:f}".format(lq=link["lq"],

                                                remote=get_clean_fieldname(link["remote"])))

        print("nlq_{remote}.value {nlq:f}".format(nlq=link["nlq"],

                                                  remote=get_clean_fieldname(link["remote"])))

    # detailed ETX graph for each single neighbour link

    for link in links:

        print("multigraph olsr_link_quality.host_{remote}"

              .format(remote=get_clean_fieldname(link["remote"])))

        print("lq.value {lq:f}".format(lq=link["lq"]))

        print("nlq.value {nlq:f}".format(nlq=link["nlq"]))

    # count the links/nodes behind each neighbour node

    print("multigraph olsr_neighbour_link_count")

    for link in links:

        print("neighbour_{host_fieldname}.value {value}"

              .format(value=link["route_count"],

                      host_fieldname=get_clean_fieldname(link["remote"])))

    # overview of ping roundtrip times

    print("multigraph olsr_neighbour_ping")

    ping_times = get_ping_times([link["remote"] for link in links])

    for link in links:

        ping_time = ping_times.get(link["remote"], None)

        if ping_time is not None:

            print("neighbour_{remote}.value {value:.4f}"

                  .format(value=ping_time,

                          remote=get_clean_fieldname(link["remote"])))

    # single detailed graphs for the ping time of each link

    for link in links:

        ping_time = ping_times.get(link["remote"], None)

        if ping_time is not None:

            remote = get_clean_fieldname(link["remote"])

            print("multigraph olsr_neighbour_ping.host_{remote}".format(remote=remote))

            print("neighbour_{remote}.value {value:.4f}".format(remote=remote, value=ping_time))

# final marker for shell / python hybrid script (see "Interpreter Selection")

EOF = True

EOF