onewire-query-low

#!/usr/bin/perl -w

use strict;
use IO::Socket::INET;
use Getopt::Long;

my ($device, $command, $test, $statecheck, $StaleAge, $ConfigFile, $timeout, $verbose, $MinuteMin, $help);

$ConfigFile = '/etc/onewired/onewired.conf';
$timeout = 10;
$StaleAge = 30;

Getopt::Long::Configure('bundling');
GetOptions(
	"D=s"	=> \$device,		"device=s"	=> \$device,
	"C=s"	=> \$command,		"command=s"	=> \$command,
	"T=s"	=> \$test,		"test=s"	=> \$test,
	"s"	=> \$statecheck,	"state"		=> \$statecheck,
	"S=s"	=> \$StaleAge,		"stale=s"	=> \$StaleAge,
	"m"	=> \$MinuteMin,		"minute"	=> \$MinuteMin,
	"c=s"	=> \$ConfigFile,	"config=s"	=> \$ConfigFile,
	"t=s"	=> \$timeout,		"timeout=s"	=> \$timeout,
	"v"	=> \$verbose,		"verbose"	=> \$verbose,
	"h"	=> \$help,		"help"		=> \$help,
	);

my $DeviceFile = '/etc/onewired/devices';
my $LowStateFile = '/etc/onewired/low_state';
my $UseRRDs = 0;
my $RRDsDir = "/var/onewired";
my $hostname = 'localhost';
my $ListenPort = 2345;

if ($help) {
  print "Valid options:
	-D|--device=<DeviceName>	# REQUIRED unless -C used
	-C|--command=<command>		# All other options except -t ignored
	-T|--test=<TestName>		# Only used with -s|--state
	-s|--state			# Check state
	-S|--stale=<seconds>		# Maximimum age of data before it's considered stale (unknown), Default: $StaleAge
	-m|--minute			# Report 1 minute minimum value
	-c|--config=<ConfigFile>	# Default: $ConfigFile
	-t|--timeout=<number>		# Default: $timeout
	-v|--verbose
	-h|--help

";
  exit;
}

my $StateData;
my ($StateGood, $StateWarning, $StateError);

my ($option, $value);
open(CONFIG,  "<$ConfigFile") or die "Can't open config file ($ConfigFile): $!";
while (<CONFIG>) {
  chomp;
  s/\w*#.*//;
  next if (m/^\s*$/);
  if (m/^([A-Za-z0-9]+)\s*=\s*(.+)\s*$/) {
    $option = $1;
    $value = $2;
    if ($option eq 'DeviceFile') {
      $DeviceFile = $value;
    } elsif ($option eq 'LowStateFile') {
      $LowStateFile = $value;
    } elsif ($option eq 'UseRRDs') {
      $UseRRDs = $value;
      $UseRRDs = 0 if ($UseRRDs =~ m/^(no|false)$/i);
    } elsif ($option eq 'RRDsDir') {
      $RRDsDir = $value;
    } elsif ($option eq 'ListenPort') {
      if ($value =~ m/^\d+$/) {
        if ($ListenPort <= 65535 && $ListenPort > 1024) {
          $ListenPort = $value;
        } else {          die "Port defined in config file ($ListenPort) is not within the range 1025-65535. Exiting.\n";
        }
      } else {
        $ListenPort = $value;
        #die "Port defined in config file ($ListenPort) is not a number. Exiting.\n";           ### If this isn't a UNIX system then this should fail
      }
    }
  }
}
close(CONFIG);
$option = undef;
$value = undef;

if ($UseRRDs) {
  use RRDs;
  unless ( (-d $RRDsDir) && (-r $RRDsDir) ) {
    print "ERROR: Can't read from RRD dir '$RRDsDir'. Disabling using RRDs.\n";
    $UseRRDs = 0;
  }
}

if ($statecheck) {
  $test = "temperature" unless ($test);
  open(STATE,  "<$LowStateFile") or die "Can't open config file ($LowStateFile): $!";
  while (<STATE>) {
    chomp;
    s/\w*#.*//;
    next if (m/^\s*$/);
    if (m/^([A-Za-z0-9-_]+)\s+([A-Za-z0-9_]+)\s+(.*)\s*$/) {
      if (lc($device) eq lc($1) && lc($test) eq lc($2)) {
        $StateData = $3;
        if ($StateData =~ m/^([0-9<>=.,-]+);\s*([0-9<>=.,-]*);\s*([0-9<>=.,-]*)\s*$/) {
          $StateGood = $1;
          $StateWarning = $2;
          $StateError = $3;
        } elsif ($StateData =~ m/^((?:,?\d+min[0-9<>=.-]+)*);\s*((?:,?\d+min[0-9<>=.-]+)*);\s*((?:,?\d+min[0-9<>=.-]+)*)\s*$/i) {
          $StateGood = $1;
          $StateWarning = $2;
          $StateError = $3;
        } else {
          print "Couldn't parse state data: $StateData\n";
          $StateGood = '';
          $StateWarning = '';
          $StateError = '';
        }
        last;
      }
    }
  }
  close(STATE);
}

# Just in case of problems, let's not hang
$SIG{'ALRM'} = sub {
        print ("No response from onewired server (alarm)\n");
        exit 3;
};
alarm($timeout);

my $query = 'temperature';
if (defined($ARGV[1])) {
  $query = lc($ARGV[1]);
}

unless ($command) {
  die "No device name specified!\n" unless ($device);
}

my $return;

my $retry = 0;

my $socket;
if ($ListenPort =~ m/^\d+$/) {
  my $retry = 0;
  $socket = IO::Socket::INET->new (
		PeerAddr => $hostname,
		PeerPort => $ListenPort,
		Proto    => 'tcp',
		);
  while (! $socket) {
    $retry++;
    if ($retry > 5) {
      print "Couldn't connect to monitoring daemon on $hostname:$ListenPort: $!\n";
      exit 3;
    }
    sleep ($retry * 5);
    $socket = IO::Socket::INET->new (
		PeerAddr => $hostname,
		PeerPort => $ListenPort,
		Proto    => 'tcp',
		);
  }
  unless ($socket) {
    print "Couldn't connect to monitoring daemon on $hostname:$ListenPort: $!\n";
    exit 3;
  }
} else {
  my $retry = 0;
  $socket = IO::Socket::UNIX->new (
		Peer    => $ListenPort,
		Type    => SOCK_STREAM,
		Timeout => 5,
		);
  while (! $socket) {
    $retry++;
    if ($retry > 5) {
      print "Couldn't connect to monitoring daemon on $hostname:$ListenPort: $!\n";
      exit 3;
    }
    sleep ($retry * 5);
    $socket = IO::Socket::UNIX->new (
		Peer    => $ListenPort,
		Type    => SOCK_STREAM,
		Timeout => 5,
		);
  }
  unless ($socket) {
    print "Couldn't connect to monitoring daemon on $ListenPort: $!\n";
    exit 3;
  }
}

$socket->recv($return,255);
chomp($return);
unless ($return eq '220 onewired') {
  print "Unexpected reply from monitoring daemon:\n$return\n";
  exit 2;
}


if ($command) {
  ### If a command has been given send it, print the results and exit
  $socket->send("$command\n");
  sleep 0.1;
  while (<$socket>) { print; }
  exit;
}


$socket->send("value $device\n");
sleep 0.1;
$socket->recv($return,1024);
chomp($return);

my ($name, $address, $type, $temperature, $voltage, $minute, $FiveMinute, $updated, $age, $iminute);
my %data;
my ($range, $min);
my $normal = '';

($name) = $return =~ m/name: ([^\n]*)/;
if ($name) {
  foreach (split(/\n/, $return)) {
    m/^([^:]+): ([^\n]*)$/;
    $data{$1} = $2;
  }
  ($address)     = $return =~ m/address: ([^\n]*)/;
  ($type)        = $return =~ m/type: ([^\n]*)/;
  ($temperature) = $return =~ m/temperature: ([^\n]*)/;
  ($voltage)     = $return =~ m/$type: ([^\n]*)/;
  if ($return =~ m/1MinuteMin: /) {
    ($minute)    = $return =~ m/1MinuteMin: ([^\n]*)/;
  } else {
    ($minute)    = $return =~ m/$test: ([^\n]*)/;
  }
  if ($return =~ m/5MinuteMin: /) {
    ($FiveMinute)    = $return =~ m/5MinuteMin: ([^\n]*)/;
  } else {
    $FiveMinute      = $voltage;
  }
  ($updated)     = $return =~ m/updated: ([^\n]*)/;
  ($age)         = $return =~ m/age: ([^\n]*)/;
  ($iminute)     = $return =~ m/Current1MinuteMin: ([^\n]*)/;
  #$temperature   = 0 unless ($temperature);
  #$voltage       = 0 unless ($voltage);
  #$minute        = 0 unless ($minute);
  #$FiveMinute    = 0 unless ($FiveMinute);
  #$iminute       = 0 unless ($iminute);

  #$temperature   = restrict_num_decimal_digits($temperature,2);
  #$voltage       = restrict_num_decimal_digits($voltage,2);
  #$minute        = restrict_num_decimal_digits($minute,2);
  #$FiveMinute    = restrict_num_decimal_digits($FiveMinute,2);
  $data{temperature} = $temperature;
  $data{$type}   = $minute;

  my ($start, $step, $names, $rrddata);		### RRD data

  if ($age > $StaleAge) {
    print "$name data stale (" . age_text($age) . " old > $StaleAge)\n";
    exit 3;
  }

  if ($statecheck) {
    if ($test eq 'dryness') {
      if ($iminute < 200) {
        print "$device reports as dry ($iminute < 200).\n";
        exit 0;
      } else {
        print "$device reports as possibly wet ($iminute >= 200).\n";
        exit 2;
      }
    }
    if (! defined($data{$test}) ) {
      print "No data for '$test' found $device\n";
      exit 3;
    }
    if ($data{$test} eq 'NA') {
      print "No data for $device:$test\n";
      exit 3;
    }
    if ($StateData) {
      print "Good state:    '$StateGood'\n" if ($verbose);
      print "Warning state: '$StateWarning'\n" if ($verbose);
      print "Error state:   '$StateError'\n" if ($verbose);
      $normal = "(ok: $StateGood)";
      print "\nChecking for GOOD state\n" if ($verbose);
      foreach (split(/,/, $StateGood)) {
        if (s/^(\d+)min//i) {
          if (! $UseRRDs) {
            print "Invalid state data for $device:$test specified without RRD configured.\n";
            exit 3;
          }
          $range = $1;
# Don't bother with the RRDs if
#	the check is for < x and current value is < x
#	or the check is for < x and the range is >= 5 min and the 5 min min is < x
          print "  Checking if in '$_' in '${range}min'\n" if ($verbose);
          if (m/^[><](.*)/) {
            print "    Checking current data " if ($verbose);
            if (checkrange($data{$test},$_)) {
              print "$test currently is $data{$test};  $normal\n";
              exit 0;
            }
          }
          if ( ($range >= 5) && (m/^[><](.*)/) && defined($FiveMinute) ) {
            print "    Checking FiveMinute minimum " if ($verbose);
            if (checkrange($FiveMinute,$_)) {
              print "$test 5 minute minimum is $FiveMinute;  $normal\n";
              exit 0;
            }
          }
          ($start, $step, $names, $rrddata) = check_rrds($name) if (! defined($rrddata));
          $min = restrict_num_decimal_digits(MinInRange($start, $step, $names, $rrddata, $range),1);
          $min = $data{$test} if ($data{$test} < $min);
          print "    Checking RRD minimum " if ($verbose);
          if (checkrange($min,$_)) {
            print "$test $range minute(s) minimum is $min;  $normal\n";
            exit 0;
          }
        } else {
          print "  Checking current data " if ($verbose);
          if (checkrange($data{$test},$_)) {
            print "$test is $data{$test} ($StateGood)\n";
            exit 0;
          }
        }
      }
      print "\nChecking for WARNING state\n" if ($verbose);
      foreach (split(/,/, $StateWarning)) {
        if (s/^(\d+)min//i) {
          if (! $UseRRDs) {
            print "Invalid state data for $device:$test specified without RRD configured.\n";
            exit 3;
          }
          $range = $1;
          print "  Checking if in '$_' in '${range}min'\n" if ($verbose);
          ($start, $step, $names, $rrddata) = check_rrds($name) if (! defined($rrddata));
          $min = restrict_num_decimal_digits(MinInRange($start, $step, $names, $rrddata, $range),1);
          $min = $data{$test} if ($data{$test} < $min);
          print "    Checking RRD minimum " if ($verbose);
          if (checkrange($min,$_)) {
            print "$test $range minute(s) minimum: $min;  $normal\n";
            exit 1;
          }
        } else {
          print "  Checking current data " if ($verbose);
          if (checkrange($data{$test},$_)) {
            print "$test is $data{$test};  $normal\n";
            exit 1;
          }
        }
      }
      print "\nChecking for ERROR state\n" if ($verbose);
      foreach (split(/,/, $StateError)) {
        if (s/^(\d+)min//i) {
          if (! $UseRRDs) {
            print "Invalid state data for $device:$test specified without RRD configured.\n";
            exit 3;
          }
          $range = $1;
          print "  Checking if in '$_' in '${range}min'\n" if ($verbose);
          ($start, $step, $names, $rrddata) = check_rrds($name) if (! defined($rrddata));
          $min = restrict_num_decimal_digits(MinInRange($start, $step, $names, $rrddata, $range),1);
          $min = $data{$test} if ($data{$test} < $min);
          print "    Checking RRD minimum " if ($verbose);
          if (checkrange($min,$_)) {
            print "$range minute(s) minimum $test: $min;  $normal\n";
            exit 2;
          }
        } else {
          print "  Checking current data " if ($verbose);
          if (checkrange($data{$test},$_)) {
            print "$test is $data{$test};  $normal\n";
            exit 2;
          }
        }
      }
      print "\nNO checks were within ANY defined ranges\n" if ($verbose);
      print "Value ($data{$test}) not within any ranges specified ($StateData).\n";
      exit 2;
    } else {
      print "No state data found for $device:$test\n";
      exit 3;
    }
  } elsif ($test) {
    if (defined($data{$test})) {
      print "$data{$test}\n";
    } else {
      print "$test is not a valid test for $device\n";
    }
  } else {
    if (($type eq 'temperature') || ($type eq 'tsense')) {
      print "$temperature\n";
      print "0\n";
    } else {
      print "$temperature\n";
      if ($MinuteMin) {
        print "$minute\n";
      } else {
        print "$voltage\n";
      }
    }
  }
} else {
  if ($statecheck) {
    print "No sensor found named \"$device\"\n";
    exit 3;
  } else {
    print "No sensor found named \"$device\"\n";
  }
}

sub checkrange {
  # ARG1 = current value
  # ARG2 = test range
  my $value = shift;
  $_ = shift;
  print "'$value' in '$_': " if ($verbose);
  if (m/^([^><]+?)-(.*)$/) {
    if ($value >= $1 && $value <= $2) {
      print "yes\n" if ($verbose);
      return 1;
    } else {
      print "no\n" if ($verbose);
      return 0;
    }
  } elsif (m/^<=(.*)$/) {
    if ($value <= $1) {
      print "yes\n" if ($verbose);
      return 1;
    } else {
      print "no\n" if ($verbose);
      return 0;
    }
  } elsif (m/^<(.*)$/) {
    if ($value < $1) {
      print "yes\n" if ($verbose);
      return 1;
    } else {
      print "no\n" if ($verbose);
      return 0;
    }
  } elsif (m/^>=(.*)$/) {
    if ($value >= $1) {
      print "yes\n" if ($verbose);
      return 1;
    } else {
      print "no\n" if ($verbose);
      return 0;
    }
  } elsif (m/^>(.*)$/) {
    if ($value > $1) {
      print "yes\n" if ($verbose);
      return 1;
    } else {
      print "no\n" if ($verbose);
      return 0;
    }
  } elsif ($value = $1) {
    print "yes\n" if ($verbose);
    return 1;
  } else {
    print "Couldn't evaluate $_";
    return 0;
  }
}


sub restrict_num_decimal_digits {
  my $num=shift;
  my $digs_to_cut=shift;
  if ( ( defined($num) ) && ( $num=~/\d+\.(\d){$digs_to_cut,}/ ) ) {
    $num=sprintf("%.".($digs_to_cut)."f", $num);
  }
  return $num;
}

sub check_rrds {
  my $name = shift;
  my $resolution = 60;			# interval you want the values to have
  my $cur_time = time();

  # The following forces the end time to be a multiple of $resolution
  my $end_time = int($cur_time/$resolution) * $resolution;
  my $start_time = $end_time - 43200;	# We want the previous 12 hours data

  my $rrdfile = "$RRDsDir/" . lc($name) . ".rrd";

  return () if (! -r $rrdfile);

  my ($start, $step, $names, $rrddata) =
	RRDs::fetch($rrdfile, "MIN", "-r", "$resolution", "-s", "$start_time", "-e", "$end_time");
  my $error=RRDs::error;
  return () if $error;

  return ($start, $step, $names, $rrddata);
}

sub MinInRange {
  # ($start, $step, $data, $range);
  my $start = shift;
  my $step = shift;
  my $names = shift;
  my $rrddata = shift;
  my $range = shift;
  my $ds;

  my $i = 0;
  foreach my $dsname (@$names) {
    if ( $test eq $dsname) {
      $ds = $i;
      last;
    }
    $i++;
  }
  if (! defined($ds)) {
    print "No data for '$test' found in RRD for $device\n";
  }

  my $row;
  my $min;
  my $timestamp = $start;
  my $cur_time = time();
  my $start_time = $cur_time - ($range * 60);

  foreach $row (@$rrddata) {
    $timestamp += $step;
    next if ($timestamp < $start_time);
    last if ($timestamp > $cur_time);
    next if (! defined(@$row[$ds]));
    $min = @$row[$ds] if ! defined($min);
    if (@$row[$ds] < $min) {
      $min = @$row[$ds];
    }
  }

  return $min;
}

sub age_text {
	my $time = shift;
	return '' unless ($time);
	my $duration = '';
	$duration = $time % 60 . "s" if (($time % 60) && ($time < 60));
	$time = ($time - ($time % 60)) / 60;
	$duration = $time % 60 . "m $duration" if ($time % 60);
	$time = ($time - ($time % 60)) / 60;
	$duration = $time % 24 . "h $duration" if ($time % 60);
	$time = ($time - ($time % 24)) / 24;
	$duration = $time . "d $duration" if ($time % 60);
	$duration =~ s/ $//;
	return $duration;
}