Munin contributed plugins

#!/usr/bin/perl

# This script is used to feed sensor information from Allnet-Devices like e.g.

# Allnet 4000 or 4500 into munin. It uses the XML-Interface of the devices to

# fetch data.

#

# written by Michael Meier <michael.meier@fau.de>, License GPLv2

#

# Usage:

# Put this script onto some server, either on your munin-server or onto some

# other server that can reach the actual device. Then symlink to it from the

# munin-node plugin dir (usually /etc/munin/plugins). The naming of the symlink

# is a critical part of the configuration, it needs to be:

#  SOMETHING_HOSTNAME_TYPE,  e.g. allnet_monitordevice42.yourdomain.com_temp

# SOMETHING really is just a random name containing no special chars, use

# whatever you like.

# HOSTNAME is the hostname of the Allnet-Device. This is also the hostname

# under which the sensors will show up in munin.

# TYPE is the type of sensors you're interested in, valid values are:

#                                                   temp, hum, amps

# If you want to monitor more than one type of sensor, create more than one

# symlink.

# The plugin will automatically feed all sensors of the selected type to munin,

# under the names that you set in the allnets config. Take care with special

# characters, in particular Umlauts and the such - munin will probably not like

# those in names.

#

# Note that the format of the XML output these devices deliver varies vastly

# between different firmware versions. This script currently understands 3

# completely different outputs, but there is no guarantee that's all the

# variations that exist. If the script doesn't understand the output of your

# device, set the beextratolerant parameter. You might also want to try a

# different firmware version.

#

# The behaviour of the script can be influenced by environment variables. The

# variables are (note this is case sensitive!):

#  username  Username for basic HTTP auth (if your device is password protected)

#  password  Password for basic HTTP auth (if your device is password protected)

#  beextratolerant   This needs to be set to 1 for some extremely old/stripped

#                    down devices. Note that this relaxes sanity checks and

#                    will lead to nonsense-sensors showing up on devices that

#                    do not require this.

#  DUMP      set to 1 to enable some debug output (only outside of munin!)

#  internalsensorname.warning   The warning-threshold for the sensor reported

#                               to munin. You need to replace

#                               "internalsensorname" with the munin-internal

#                               name of the sensor, usually sensor+somenumber.

#                               Can be seen in the webinterface.

#  internalsensorname.critical  Same as above, but for the critical-threshold.

#

# As an example, you could put the following file into /etc/munin/plugin-conf.d:

# [allnet_monitordevice42.yourdomain.com_*]

#       env.username horst

#       env.password topsecret

#       env.sensor14.warning 10.0

#       env.sensor14.critical 15.0

# One tuneable:

# Timeout for requests.

my $timeout = 3; # the LWP default of 180 secs would be way too long

# -----------------------------------------------------------------------------

# No need to change those, can be overridden from commandline.

my $hostname = 'localhost';

my $valtype = 'temp'; # or humidity or amps

# These are tried one after another.

my @xmlpaths = ('/xml/sensordata.xml', '/xml');

use LWP::UserAgent;

use XML::Simple;

# AuthAgent is simply LWP::UserAgent with a reimplemented version of the

# method basic auth. Theoretically/according to the documentation, the base

# implementation should be able to do everything that is needed as well, but

# it seems to broken and "the internet" suggests it has been for a long time.

{

  package AuthAgent;

  use base 'LWP::UserAgent';

  sub get_basic_credentials {

    if (defined($ENV{'username'}) && defined($ENV{'password'})) {

      return $ENV{'username'}, $ENV{'password'};

    } else {

      return 'admin', 'password';

    }

  }

}

# Par. 0: URL

# Returns: The contents of the website

sub geturl($) {

  my $url = shift();

  my $ua = AuthAgent->new();

  $ua->agent($0);

  $ua->timeout($timeout);

  # Create a request

  my $req = HTTP::Request->new(GET => $url);

  # Pass request to the user agent and get a response back

  my $res = $ua->request($req);

  # Check the outcome of the response

  unless ($res->is_success()) {

    #print("ERROR getting data from $url\n");

    return undef;

  }

  return $res->content();

}

if ((@ARGV > 0) && ($ARGV[0] eq "autoconf")) {

  print("No\n");

  exit(0);

}

my $progname = $0;

if      ($progname =~ m/[-_]temp$/) {

  $valtype = 'temp';

} elsif ($progname =~ m/[-_]temperature$/) {

  $valtype = 'temp';

} elsif ($progname =~ m/[-_]hum$/) {

  $valtype = 'humidity';

} elsif ($progname =~ m/[-_]humidity$/) {

  $valtype = 'humidity';

} elsif ($progname =~ m/[-_]amps$/) {

  $valtype = 'amps';

} elsif ($progname =~ m/[-_]ampere$/) {

  $valtype = 'amps';

}

if ($progname =~ m/.+_(.+?)_.+/) {

  $hostname = $1;

}

my $sensorxml;

foreach $xp (@xmlpaths) {

  $sensorxml = geturl('http://' . $hostname . $xp);

  if (defined($sensorxml)) { last; }

}

unless (defined($sensorxml)) {

  print("# Sorry, Failed to fetch data.");

  exit(1);

}

# VERY old firmware versions have HTML crap around the actual XML.

$sensorxml =~ s!.*<xml>(.*)</xml>.*!$1!sg;

if (defined($ENV{'DUMP'}) && ($ENV{'DUMP'} eq '1')) {

  print($sensorxml . "\n");

}

if ((@ARGV > 0) && ($ARGV[0] eq "config")) {

  if ($valtype eq 'humidity') {

    print("graph_title Humidity sensors\n");

    print("graph_args --lower-limit 0 --upper-limit 100.0\n");

    print("graph_vlabel percent\n");

  } elsif ($valtype eq 'temp') {

    print("graph_title Temperature sensors\n");

    print("graph_vlabel degC\n");

  } elsif ($valtype eq 'amps') {

    print("graph_title Electric current sensors\n");

    print("graph_args --lower-limit 0\n");

    print("graph_vlabel Ampere\n");

  }

  print("graph_category sensors\n");

  print("host_name $hostname\n");

}

my $sensordata = XMLin($sensorxml, KeyAttr => { }, ForceArray => [ 'data' ] );

my $beextratolerant = 0;

if (defined($ENV{'beextratolerant'})) {

  if (($ENV{'beextratolerant'} =~ m/^y/) || ($ENV{'beextratolerant'} eq '1')) {

    $beextratolerant = 1;

  }

}

#print($sensordata->[0]);

foreach $k (keys($sensordata)) {

  if ($k =~ m/^n(\d+)$/) { # Special handling: Could be output from the OLD XML interface.

    my $nr = $1;

    if (defined($sensordata->{'s'.$nr})

     && defined($sensordata->{'t'.$nr})

     && defined($sensordata->{'min'.$nr})

     && defined($sensordata->{'max'.$nr})) {

      # OK, all values available, really is from the old XML interface.

      if ($sensordata->{'s'.$nr} eq '0') { next; } # 0 means no sensor.

      # OK, lets map the sensortype.

      my $st = 'temp';

      if ($sensordata->{'s'.$nr} eq '65') { $st = 'humidity'; }

      if ($sensordata->{'s'.$nr} eq '101') {

        # potential FIXME: 101 is actually "water/contact sensor", but since it

        # returns 0.0 and 100.0 as values, we can treat it just like humidity

        # for simplicity.

        $st = 'humidity';

      }

      if ($valtype ne $st) { next; } # these aren't the droids you're looking for

      if ((@ARGV > 0) && ($ARGV[0] eq "config")) {

        print("sensor${nr}.label " . $sensordata->{'n'.$nr} . "\n");

        print("sensor${nr}.type GAUGE\n");

        if (defined($ENV{"sensor${nr}.warning"})) { printf("sensor%s.warning %s\n", $nr, $ENV{"sensor${nr}.warning"}); }

        if (defined($ENV{"sensor${nr}.critical"})) { printf("sensor%s.critical %s\n", $nr, $ENV{"sensor${nr}.critical"}); }

      } else {

        print("sensor${nr}.value " . $sensordata->{'t'.$nr}. "\n");

      }

    }

    # Fall through - probably wasn't the old XML anyways.

  }

  my $onesens = $sensordata->{$k};

  unless (defined($onesens->{'value_float'})

       && defined($onesens->{'name'})

       && defined($onesens->{'min_abs_float'})

       && defined($onesens->{'max_abs_float'})

       && defined($onesens->{'unit'})) {

    # Not all values available -> no sane sensor data (or the "system" block in the XML)

    unless ($beextratolerant) { next; }

    # Maybe yet another firmware version that does not deliver all of these values,

    # so lets check for the absolute MINIMUM set.

    unless (defined($onesens->{'value_float'}) && defined($onesens->{'name'})) {

      next; # Minimum set not available either.

    }

    if ($onesens->{'value_float'} < -20000.0) { next; } # Invalid value

    # OK, so fill in the blanks

    unless (defined($onesens->{'unit'})) { $onesens->{'unit'} = 'C'; }

    unless (defined($onesens->{'min_abs_float'})) {

      $onesens->{'min_abs_float'} = $onesens->{'value_float'} - 0.01;

    }

    unless (defined($onesens->{'max_abs_float'})) {

      $onesens->{'max_abs_float'} = $onesens->{'value_float'} + 0.01;

    }

  }

  if (($onesens->{'min_abs_float'} == 0.0)

   && ($onesens->{'max_abs_float'} == 0.0)

   && ($onesens->{'value_float'} == 0.0)) {

    next; # If the sensor never showed anything but 0.0, we do not care about it.

  }

  if ($onesens->{'unit'} eq 'A AC') { $onesens->{'unit'} = 'A'; }

  if ($onesens->{'unit'} =~ m/C$/) {

    $onesens->{'unit'} = 'C'; # Remove WTF8-Fuckup

  }

  if (($valtype eq 'temp') && ($onesens->{'unit'} ne 'C')) { next; }

  if (($valtype eq 'humidity') && ($onesens->{'unit'} ne '%')) { next; }

  if (($valtype eq 'amps') && ($onesens->{'unit'} ne 'A')) { next; }

  if ((@ARGV > 0) && ($ARGV[0] eq "config")) {

    print("${k}.label " . $onesens->{'name'} . "\n");

    #print("${k}.info " . $onesens->{'name'} . "\n");

    print("${k}.type GAUGE\n");

    if (defined($ENV{"${k}.warning"})) { printf("%s.warning %s\n", $k, $ENV{"${k}.warning"}); }

    if (defined($ENV{"${k}.critical"})) { printf("%s.critical %s\n", $k, $ENV{"${k}.critical"}); }

  } else {

    if ($onesens->{'value_float'} < -20000.0) { # Invalid readings return -20480.0

      print("${k}.value U\n");

    } else {

      print("${k}.value " . $onesens->{'value_float'} . "\n");

    }

  }

}