#!/usr/bin/perl -w
#
# Copyright (c) 2003-2004 Stefan Moeding <s.moeding@setuid.de>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#
#       $Id: dispatchlogs,v 1.10 2004/03/24 17:47:53 sm Exp $
#

# dispatchlogs: Ein Programm zur Verteilung von Apache-Logs auf Pakete
#
# Einsatz:
# - Die Apaches schreiben ihre Logs durch eine Pipe in das von der Apache
#   Group entwickelte 'rotatelogs'. In der Apache-Config wird nur ein
#   einziger Eintrag für ein Logfile erstellt:
#   CustomLog "| exec /usr/local/sbin/rotatelogs /var/log/httpd 300" common
# - Die dadurch alle 5 Minuten erzeugten Logs werden durch dieses Script
#   auf die Pakete in /home/pacs/*/var/web.log verteilt und danach gelöscht.
#
# Vorteile:
# - Rotatelogs ist laut Doku sicher und verliert keine Einträge
# - deutlich reduzierte Anzahl der offenen Files für die Logs
# - Cache für offene Filehandles
# - Dieses Script verarbeitet mehrere Logs und sortiert die Einträge
#   chronologisch, so daß die Logs mehrere Webserver zusammengeführt werden.
# - Geschwindigkeit: etwa 2000 Lines/sec
#
# Abhängigkeiten:
# - Synchronisation, damit nur eine Instanz dieses Scriptes zu einem
#   Zeitpunkt läuft und auch das nächtliche Splitten der Weblogs in den
#   Paketen nicht im Chaos endet.
#

use Getopt::Long;
use FileHandle;
use File::stat;
use strict;


umask(077);

##############################################################################
#
# Optionen auswerten
#
my ($do_errlog, $interval, $template, $defaultlog);
my %opt = ();

GetOptions(\%opt,
           "weblog", "errlog", "nice",
           "template=s", "defaultlog=s", "interval=i") ||
  die("$0: Illegal argument\n");

if (!defined($opt{'weblog'}) && !defined($opt{'errlog'})) {
  die("$0: One of '--weblog' or '--errlog' must be used\n");
}

if (defined($opt{'weblog'}) && defined($opt{'errlog'})) {
  die("$0: '--weblog' and '--errlog' are mutually exclusive\n");
}

#
# Defaultwerte setzten und ggfs. überschreiben, wenn beim Aufruf
# durch Parameter andere Werte vorgegeben werden.
#
if (defined($opt{'errlog'})) {
  $do_errlog  = 1;
  $template   = "/home/pacs/%s/var/web.err";
  $defaultlog = "/var/log/web.err";
  $interval   = 300;
}
else {
  $do_errlog  = 0;
  $template   = "/home/pacs/%s/var/web.log";
  $defaultlog = "/var/log/web.log";
  $interval   = 300;
}

if (defined($opt{'nice'})) {
  setpriority(0, 0, getpriority(0, 0) + 4) || die "setpriority: $!";
}
if (defined($opt{'template'})) {
  $template = $opt{'template'};
}

if (defined($opt{'defaultlog'})) {
  $defaultlog = $opt{'defaultlog'};
}

if (defined($opt{'interval'}) && ($opt{'interval'} > 0)) {
  $interval = $opt{'interval'};
}


##############################################################################
#
# Anlegen eines neuen Objektes für ein Logfile, falls dieses vor der durch
# $interval in Sekunden angegebenen Zeit angelegt wurde.
#
my $cache = new FileCache;
my @logarray;

foreach my $file (@ARGV) {
  if (-f $file) {
    my $now = time();
    my $st = stat($file);
    my ($log, $def);

    if ($st->ctime < $now - ($now % $interval)) {
      if ($do_errlog) {
        # Logfiles sind ErrorLogs
        $log = new WebErr($file);
      }
      else {
        # Logfiles sind AccessLogs
        $log = new WebLog($file);
      }

      if ((defined($log->openlog())) && ($log->fetch())) {
        # Logfile wurde erfolgreich geöffnet und kann verarbeitet werden
        push(@logarray, $log);

        # Default ist der Filename ohne Timestamp aber mit 'log':
        # /var/log/httpd/access.1071913200 -> /var/log/httpd/access.log
        ($def = $file) =~ s/[0-9]*$/log/;
        $log->default($def);
      }
    }
  }
}


##############################################################################
#
# Verarbeitung aller per Kommandozeile übergebene Logfiles.
#
while ($#logarray >= 0) {
  my $minind = -1;		# Index für Eintrag mit minimalen Zeitpunkt
  my $minval = 9999999999;	# Bislang gefundener minimaler Zeitpunkt
  my $defhan = undef;

  # Aktuelles Minimum aus der aktuallen Zeile der Logfiles bestimmen
  foreach my $i (0 .. $#logarray) {
    my $val = $logarray[$i]->timestamp();
    if ($val < $minval) {
      $minval = $val;
      $minind = $i;
    }
  }

  # Eintrag mit minimalem Zeitstempel bearbeiten
  if ($minind >= 0) {
    # Filename für die Ausgabe generieren
    my $pac = $logarray[$minind]->packet();
    my $def = $logarray[$minind]->default();
    my $fh = undef;

    if (defined($pac) and ($pac =~ /^[a-z][a-z0-9][a-z0-9][0-9][0-9]$/) and (-d "/home/pacs/$pac") and index(`quota -qg $pac`, "Over block quota") == -1) {
      $fh = $cache->cache(sprintf($template, $pac));
    }
    else {
      $fh = $cache->cache($def);
    }

    if (!defined($fh)) {
      if (!defined($defhan)) {
        $defhan = new FileHandle $defaultlog, O_WRONLY|O_APPEND|O_CREAT;
        die $defaultlog.": $!" if (!defined($defhan));

        $fh = $defhan;
      }
    }

    # Zeile wegschreiben
    print $fh $logarray[$minind]->entry;

    # Nächste Zeile aus dem Logfile holen und ggfs. Logfile
    # verwerfen, falls keine weiteren Einträge vorhanden sind.
    # Das Logfile wird dabei gelöscht.
    if (!defined($logarray[$minind]->fetch())) {
      $logarray[$minind]->remove();
      splice(@logarray, $minind, 1);
    }
  }
}

exit;


##############################################################################
#
# Package zur (einfachen) Verarbeitung von Apache Logfiles
#
package ApacheLog;

use FileHandle;
use File::stat;
use Carp;

sub new {
  my $proto = shift;
  my $class = ref($proto) || $proto;
  my $self  = {};
  bless($self, $class);

  $self->init(@_);

  %ApacheLog::MonthCache = ('Jan', 0, 'Feb', 1, 'Mar', 2,
                            'Apr', 3, 'May', 4, 'Jun', 5,
                            'Jul', 6, 'Aug', 7, 'Sep', 8,
                            'Oct', 9, 'Nov', 10, 'Dec', 11);

  return $self;
}

sub init {
  my $self = shift;
  my $st;

  $self->{"FILENAME"}   = shift;
  $self->{"FILEHANDLE"} = undef;
  $self->{"PACKET"}     = undef;
  $self->{"ENTRY"}      = undef;
  $self->{"DEFAULT"}    = undef;

  # Initiale Zeit auf das Erstellungsdatum der Datei setzen
  $st = stat($self->{"FILENAME"});
  $self->{"TIME"}       = $st->ctime;

  #$self->loadcache();
}

#
# Öffnen des Logfiles
#
sub openlog {
  my $self = shift;

  $self->{"FILEHANDLE"} = new FileHandle;
  if (defined($self->{"FILEHANDLE"})) {
    if ($self->{"FILEHANDLE"}->open($self->{"FILENAME"})) {
      return $self;
    }
    undef $self->{"FILEHANDLE"};
  }

  return undef;
}

#
# Löschen des Logfiles
#
sub remove {
  my $self = shift;

  if (defined($self->{"FILEHANDLE"})) {
    undef $self->{"FILEHANDLE"};
  }

  if (defined($self->{"FILENAME"})) {
    if (!unlink($self->{"FILENAME"})) {
      carp $self->{"FILENAME"}, ": $!";
    }
  }
}

#
# Setzen/Auslesen des ganzen Logeintrages
#
sub entry {
  my $self = shift;
  if (@_) { $self->{"ENTRY"} = shift }
  return $self->{"ENTRY"};
}

#
# Setzen/Auslesen des Paketes
#
sub packet {
  my $self = shift;
  if (@_) { $self->{"PACKET"} = shift }
  return $self->{"PACKET"};
}

#
# Setzen/Auslesen des Zeitpunktes
#
sub timestamp {
  my $self = shift;
  if (@_) { $self->{"TIME"} = shift }
  return $self->{"TIME"};
}

#
# Setzen/Auslesen des Defaults
#
sub default {
  my $self = shift;
  if (@_) { $self->{"DEFAULT"} = shift }
  return $self->{"DEFAULT"};
}

#
# Einlesen der nächsten Zeile aus dem Logfile
#
sub fetch {
  my $self = shift;

  # Paket zurücksetzen; Zeitstempel behalten
  $self->packet(undef);

  if (defined($self->{"FILEHANDLE"})) {
    if (!$self->{"FILEHANDLE"}->eof()) {
      return $self->entry($self->{"FILEHANDLE"}->getline());
    }
  }

  return undef;
}

#
# Umwandung eines Monatsnamens (3 Buchstaben) in die entsprechende Nummer
#
sub month2num {
  my $self = shift;
  return $ApacheLog::MonthCache{$_[0]};
}

#
# Mapping einer Domain auf ein Paket. Dazu wird über das Ziel des Links
# in /home/doms das entsprechende Paketverzeichnis ermittelt. Benutzt
# eine globale Variable $ApacheLog::PacCache zum Caching bereits gelesener
# Daten.
#
sub domain2packet {
  my $self = shift;
  my $dom  = lc(shift);
  my $subdom;

  # Schleife zum schrittweisen Abtrennen des ersten Teils des Namens:
  # foo.bar.baz.com => bar.baz.com => baz.com => com
  # Die Schleife wird beendet, sobald der erste Treffer für einen
  # gültigen Domainnamen gefunden wird (best match). Damit können Sub-
  # domains anders zugeordnet werden, als ihre übergeordneten Domains.
  do {
    # Fertig, falls schon im Cache vorhanden
    return $ApacheLog::PacCache{$dom} if (defined($ApacheLog::PacCache{$dom}));

    # Ansonsten Ziel vom Link in /home/doms prüfen
    if (-l "/home/doms/$dom") {
      my $link = readlink("/home/doms/$dom");
      my ($pac) = ($link =~ m:^/home/pacs/([^/]+)/.*$:);

      if (defined($pac)) {
        $ApacheLog::PacCache{$dom} = $pac;
        return $pac;
      }
    }

    # Am (ersten) Punkt '.' trennen
    ($subdom, $dom) = split('\.', $dom, 2);
  } while (defined($dom) && ($dom ne ""));

  return undef;
}

##############################################################################
#
# Package für AccessLogs. Wird von ApacheLog abgeleitet.
#
package WebLog;

use base qw(ApacheLog);
use Time::Local;

sub fetch {
  my $self = shift;
  my $entry = $self->SUPER::fetch();

  return(undef) unless (defined($entry));

  # replace invalid date
  $entry =~ s/00\/Jan\/1900/01\/Jan\/1900/;

  if ($entry =~ /^(\S+\.[^. ]+) [^[]*\[([^\]]*)/) {
    my $dom = $1;
    my $info = $2;
    my $pac = $self->domain2packet($dom);
    if (defined($pac) and ($pac =~ /^[a-z][a-z0-9][a-z0-9][0-9][0-9]$/) and (-d "/home/pacs/$pac")) {
       $self->packet($pac);
    } else {
       $self->packet(undef);
    }
    if ($info =~ m#(\d\d)/(\w+)/(\d\d\d\d):(\d\d):(\d\d):(\d\d) ([+-]?\d+)#) {
      $self->timestamp(timelocal($6, $5, $4, $1, $self->month2num($2), $3));
    }
  }

  return $entry;
}

##############################################################################
#
# Package für ErrorLogs. Wird von ApacheLog abgeleitet.
#
package WebErr;

use base qw(ApacheLog);
use Time::Local;

sub fetch {
  my $self = shift;
  my $entry = $self->SUPER::fetch();

  return(undef) unless (defined($entry));

  if ($entry =~ /^\[\w+ (\w+) (\d\d) (\d\d):(\d\d):(\d\d) (\d\d\d\d)\]/) {
    $self->timestamp(timelocal($5, $4, $3, $2, $self->month2num($1), $6));
  }

  if ($entry =~ m#/home/doms/([^/]*)/#) {
    $self->packet($self->domain2packet($1));
  }

  if ($entry =~ m#/home/pacs/([^/]*)/#) {
    $self->packet($1);
  }

  return $entry;
}


##############################################################################
#
# Cache für offen Files
#
# Hauptsächlich aus File::Cache übernommen. Anpassung notwendig, da alle
# Files immer im Append-Mode ('>>') geöffnet werden.
#
package FileCache;

use FileHandle;
use Carp;

sub new {
  my $proto = shift;
  my $class = ref($proto) || $proto;
  my $self  = {};

  $self->{"CACHELIMIT"} = 30;
  $self->{"CACHESIZE"}  = 0;
  $self->{"CACHE"}      = ();

  bless($self, $class);
  return $self;
}

sub cache {
  my $self = shift;
  my $file = shift;

  if (!defined($self->{"CACHE"}{$file})) {
    if ($self->{"CACHESIZE"} > $self->{"CACHELIMIT"}) {
      my @lru = sort {$self->{"CACHE"}{$a} <=> $self->{"CACHE"}{$b};} keys(%{$self->{"CACHE"}});

      # Einige Files wieder schließen
      splice(@lru, $self->{"CACHELIMIT"}/3);
      for (@lru) {
        $self->{"CACHE"}{$_}->close();
        delete $self->{"CACHE"}{$_};
        $self->{"CACHESIZE"}--;
      }
    }
    my $fh = new FileHandle($file, O_WRONLY|O_APPEND|O_CREAT|O_NOFOLLOW, 0600);
    if (!defined($fh)) {
      carp $file, ": $!";
      return undef;
    }
    $self->{"CACHE"}{$file} = $fh;
    $self->{"CACHESIZE"}++;
  }
  return $self->{"CACHE"}{$file};
}
