#!/usr/bin/perl
##########################################################################
# $Id$
##########################################################################
# $Log$
########################################################
## Copyright (c) 2011 Nathan Crawford
## Covered under the included MIT/X-Consortium License:
##    http://www.opensource.org/licenses/mit-license.php
## All modifications and contributions by other persons to
## this script are assumed to have been donated to the
## Logwatch project and thus assume the above copyright
## and licensing terms.  If you want to make contributions
## under your own copyright or a different license this
## must be explicitly stated in the contribution and the
## Logwatch project reserves the right to not accept such
## contributions.  If you have made significant
## contributions to this script and want to claim
## copyright please contact logwatch-devel@logwatch.org.
#########################################################

# Detail level
$Detail = $ENV{'LOGWATCH_DETAIL_LEVEL'} || 0;

# Config
my $offline = $ENV{'puppet_offline_ok'};

# Init counters
$FailedRuns = 0;
$SuccessfulRuns = 0;
$ResourceFailures = 0;
$DependencyFailures = 0;

while (defined($ThisLine = <STDIN>)) {
   chomp($ThisLine);
   if ( 
      ($ThisLine =~ /Using cached catalog/) or
      ($ThisLine =~ /Caching catalog for /) or
      ($ThisLine =~ /Caching node for /) or
      ($ThisLine =~ /Caught TERM; calling stop/) or
      ($ThisLine =~ /[sS]hutting down/) or
      ($ThisLine =~ /Reopening log files/) or
      ($ThisLine =~ /Starting Puppet client version /) or
      ($ThisLine =~ /Restarting with.+puppetd/) or
      ($ThisLine =~ /Caught HUP; calling restart/) or
      ($ThisLine =~ /Skipping because of failed dependencies/) or
      ($ThisLine =~ /Failed to generate additional resources/) or
      ($ThisLine =~ /Could not evaluate: getaddrinfo: Name or service not known/) or
      ($ThisLine =~ /replacing from source .+ with contents /) or
      ($ThisLine =~ /Starting catalog run/) or
      ($ThisLine =~ /Applying configuration version/) or
      ($ThisLine =~ /Loading facts in/) or
      ($ThisLine =~ /Retrieving plugin/) or
      ($ThisLine =~ /FileBucket adding/) or
      ($ThisLine =~ /^Caching certificate/) or
      ($ThisLine =~ /^Certificate Request fingerprint/) or
      ($ThisLine =~ /^Creating state file/) or
      ($ThisLine =~ /Provider useradd does not support features manages/)
   ) {
      # Ignore
   } elsif (($junk, $failure, $reason) = ($ThisLine =~ /^(\(.*\) |)Could not ([^:]*): (.*)/)) {
      if ($reason == "getaddrinfo: Name or service not known" && $offline) {
         $FailedRuns--;
      } else {
         $Failures{$failure}->{$reason}++;
      }
   } elsif ($ThisLine =~ /Finished catalog run in [0-9]+\.[0-9]+ seconds/) {
      $SuccessfulRuns++;
   } elsif ($ThisLine =~ /Applied catalog in [0-9]+\.[0-9]+ seconds/) {
      $SuccessfulRuns++;
   } elsif ($ThisLine =~ /skipping run/) {
      $FailedRuns++;
   } elsif ($ThisLine =~ /(Did not receive certificate)/) {
      $Errors{$1}++;
   } elsif (($file) = $ThisLine =~ /Reparsing (.*)/) {
      $Reparsed{$file}++;
   } elsif (($fileinfo) = ($ThisLine =~ /Filebucketed (.*)/)) {
      $FileBucketed{$1}++;
   } elsif ($ThisLine =~ /Dependency .+\[.+\] has ([0-9]+ |)failure/) {
      $DependencyFailures++;
   } elsif (
      ($ThisLine =~ /Failed to retrieve current state of resource/) or
      ($ThisLine =~ /Package.+ensure.+Could not find package/) or
      ($ThisLine =~ /File\[.+\].+ Could not describe /) or
      ($ThisLine =~ /File\[.+\].+ No specified sources exist/)
   ) {
      $ResourceFailures++;
   } elsif ($ThisLine =~ /Package\[(.+)\].+ensure changed/) {
      $ChangedPackages{$1}++;
   } elsif ($ThisLine =~ /Package\[(.+)\].+ensure\) created/) {
      $InstalledPackages{$1}++;
   } elsif ($ThisLine =~ /Package\[(.+)\].+ensure\) removed/) {
      $RemovedPackages{$1}++;
   } elsif ($ThisLine =~ /Exec\[(.+)\].+executed successfully/) {
      $ExecRuns{$1}++;
   } elsif ($ThisLine =~ /Exec\[(.+)\].+Trigger(?:ing|ed) 'refresh' from [0-9]+ (?:dependencies|events)/) {
      $ExecRuns{$1}++;
   } elsif ($ThisLine =~ /Exec\[(.+)\].+Triggered 'refresh' from [0-9]+ events/) {
      $ExecRuns{$1}++;
   } elsif ($ThisLine =~ /Service\[(.+)\].+ensure changed \'.+\' to \'running\'/) {
      $ServiceStarts{$1}++;
   } elsif ($ThisLine =~ /Service\[(.+)\].+Trigger(?:ing|ed) 'refresh' from [0-9]+ (?:dependencies|events)/) {
      $ServiceStarts{$1}++;
   } elsif ($ThisLine =~ /Service\[(.+)\].+Triggered 'refresh' from [0-9]+ events/) {
      $ServiceStarts{$1}++;
   } elsif ($ThisLine =~ /Service\[(.+)\].+ensure changed \'.+\' to \'stopped\'/) {
      $ServiceStops{$1}++;
   } elsif ($ThisLine =~ /User\[(.+)\].+changed password/) {
      $PasswordChanged{$1}++;
   } elsif ($ThisLine =~ /User\[(.+)\].+defined \'expiry\' as \'([0-9-]{10})\'/) {
      $ExpiryChanged{$1}{$2}++;

   # Generic rules need to be last
   } elsif (($type, $name, $attr) = $ThisLine =~ /([^\/]+)\[([^\]]+)\]\/([^\/]+)\) (created|defined content)/) {
      $Created{$type}->{$name}++;
   } elsif (($type, $name, $attr) = $ThisLine =~ /([^\/]+)\[([^\]]+)\]\/([^\/]+)\) removed/) {
      $Removed{$type}->{$name}++;
   } elsif (($type, $name, $attr, $from, $to) = $ThisLine =~ /([^\/]+)\[([^\]]+)\]\/([^\/]+)\) .+ changed '(.*)' to '(.*)/) {
      if ($attr eq 'content' or $attr eq 'checksum') {
         # Only count these types of changes
         $Changed{$type}->{$name}->{$attr}++;
      } else {
         # Get details for all other types of changes
         $Changed{$type}->{$name}->{$attr}->{'from'} = $from;
         $Changed{$type}->{$name}->{$attr}->{'to'} = $to;
      }
   } elsif (($type, $name, $attr, $from) = $ThisLine =~ /([^\/]+)\[([^\]]+)\]\/([^\/]+)\) undefined '.+' from '(.*)'/) {
      $Changed{$type}->{$name}->{$attr}->{'from'} = $from;
      $Changed{$type}->{$name}->{$attr}->{'to'} = 'undefined';
   } elsif (($type, $name, $content) = $ThisLine =~ /([^\/]+)\[([^\]]+)\]\/content\)(.*)/) {
      $content =~ s/#011/\t/g;
      $content =~ s/#012/\n            /g or $content .= "\n            ";
      $Changed{$type}->{$name}->{'contents'} .= $content;
   } elsif (($source, $target) = $ThisLine =~ /^\(\/(.*)\) Scheduling refresh of (.*)/) {
      $ScheduledRefresh{"$source -> $target"}++;
   } else {
      # Report any unmatched entries...
      $OtherList{$ThisLine}++;
   }
}

#######################################

if ($SuccessfulRuns > 0 && $Detail > 0) {
   print "\nSuccessful runs: $SuccessfulRuns\n";
}

if ($FailedRuns > 0) {
   print "\nFailed runs: $FailedRuns\n";
}

if (keys %Errors) {
   print "\nERRORS:\n";
   foreach $ThisOne (keys %Errors) {
      print "    $ThisOne: $Errors{$ThisOne} Time(s)\n";
   }
}

foreach $failure (sort(keys %Failures)) {
   print "\nERROR: Could not $failure:\n";
   foreach $ThisOne (keys %{$Failures{$failure}}) {
      print "    $ThisOne: $Failures{$failure}->{$ThisOne} Time(s)\n";
   }
}

if ($ResourceFailures > 0) {
   print "\nResource failures: $ResourceFailures\n";
}

if ($DependencyFailures > 0) {
   print "\nDependency failures: $DependencyFailures\n";
}

if (keys %Reparsed) {
   print "\nReparsed:\n";
   foreach $ThisOne (keys %Reparsed) {
      print "    $ThisOne: $Reparsed{$ThisOne} Time(s)\n";
   }
}

if (keys %FileBucketed and $Detail >= 5) {
   print "\nFileBucketed files:\n";
   foreach $ThisOne (keys %FileBucketed) {
      print "    $ThisOne\n";
   }
}

if (keys %InstalledPackages) {
   print "\nInstalled packages:\n";
   foreach $ThisOne (keys %InstalledPackages) {
      print "    $ThisOne: $InstalledPackages{$ThisOne} Time(s)\n";
   }
}

if (keys %ChangedPackages) {
   print "\nChanged packages:\n";
   foreach $ThisOne (keys %ChangedPackages) {
      print "    $ThisOne: $ChangedPackages{$ThisOne} Time(s)\n";
   }
}

if (keys %RemovedPackages) {
   print "\nRemoved packages:\n";
   foreach $ThisOne (keys %RemovedPackages) {
      print "    $ThisOne: $RemovedPackages{$ThisOne} Time(s)\n";
   }
}

if (keys %ExecRuns) {
   print "\nExec runs:\n";
   foreach $ThisOne (keys %ExecRuns) {
      print "    $ThisOne: $ExecRuns{$ThisOne} Time(s)\n";
   }
}

if (keys %ServiceStarts) {
   print "\nService starts:\n";
   foreach $ThisOne (keys %ServiceStarts) {
      print "    $ThisOne: $ServiceStarts{$ThisOne} Time(s)\n";
   }
}

if (keys %ServiceStops) {
   print "\nService stops:\n";
   foreach $ThisOne (keys %ServiceStops) {
      print "    $ThisOne: $ServiceStops{$ThisOne} Time(s)\n";
   }
}

if (keys %PasswordChanged) {
   print "\nPassword changed:\n";
   foreach $ThisOne (keys %PasswordChanged) {
      print "    $ThisOne: $PasswordChanged{$ThisOne} Time(s)\n";
   }
}

if (keys %ExpiryChanged) {
   print "\nExpiry changed:\n";
   foreach $ThisOne (keys %ExpiryChanged) {
      print "    $ThisOne:\n";
      foreach $date (keys %{${ExpiryChanged}{$ThisOne}}) {
         print "        $date: $ExpiryChanged{$ThisOne}{$date} Time(s)\n";
      }
   }
}

foreach $Type (sort(keys %Created)) {
   print "\n$Type created:\n";
   foreach $Name (sort(keys %{$Created{$Type}})) {
      print "    $Name: $Created{$Type}->{$Name} Time(s)\n";
   }
}

foreach $Type (sort(keys %Changed)) {
   print "\n$Type changed:\n";
   foreach $Name (sort(keys %{$Changed{$Type}})) {
      print "    $Name:\n";
      foreach $Attr (sort(keys %{$Changed{$Type}->{$Name}})) {
         if ($Attr eq 'contents') {
            if ($Detail >= 3) {
                print "        $Attr:";
                print "$Changed{$Type}->{$Name}->{$Attr}\n";
            }
         } else {
            print "        $Attr: ";
            if (defined($Changed{$Type}->{$Name}->{$Attr}->{'from'})) {
               print "from '$Changed{$Type}->{$Name}->{$Attr}->{from}' to '$Changed{$Type}->{$Name}->{$Attr}->{to}'\n";
            } else {
               print "$Changed{$Type}->{$Name}->{$Attr} Time(s)\n";
            }
         }
      }
   }
}

foreach $Type (sort(keys %Removed)) {
   print "\n$Type removed:\n";
   foreach $Name (sort(keys %{$Removed{$Type}})) {
      print "    $Name: $Removed{$Type}->{$Name} Time(s)\n";
   }
}

if (keys %ScheduledRefresh) {
   print "\nScheduled refresh:\n";
   foreach $ThisOne (keys %ScheduledRefresh) {
      print "    $ThisOne: $ScheduledRefresh{$ThisOne} Time(s)\n";
   }
}

if (keys %OtherList) {
   print "\n**Unmatched Entries**\n";
   foreach $ThisOne (keys %OtherList) {
      print "    $ThisOne: $OtherList{$ThisOne} Time(s)\n";
   }
}

exit(0);

# vi: shiftwidth=3 tabstop=3 syntax=perl et