#!/bin/bash
########################################################################################
#
# sccl_2_uls
#
# Aufruf: sccl_2_uls
# es werden alle Pakete des aktuellen Knotens ausgewertet und ans ULS geschickt.
#
########################################################################################

. $(dirname $0)/globals.settings

#echo "Lockdir:       " $LOCKDIR
#echo "Lockextention: " $LOCKEXTENSION
#echo "Cluster:       " $CLUSTER
#echo "Pakete:        " $PACKAGES
#echo "Resources:     " $RESOURCES
#echo "ThisHostname:  " $THISHOSTNAME


usage()
{
   echo "sccl_2_uls <config|status|enable|disable>"
   echo "           <config>  writes config files to ULS"
   echo "           <status>  writes SCCL status to ULS"
   echo "           <enable>  enable data reporting to ULS"
   echo "           <disable> disable data reporting to ULS"
   exit 1
}

check_paket()
{
# Aufgabe: prüft, ob das laufende Paket korrekt ist (lock)
# $1 = Name des Paketes
   local PKG=$1

   local DATEI_LOCK="${LOCKDIR}/${PKG}_lock"
   #ist für das Paket eine lock Datei OK?
   if [[ -f "$DATEI_LOCK" ]]; then
      local PKG_VORHANDEN="OK"
   else
      local PKG_VORHANDEN="ERROR"
   fi

   #Startzeitpunkt des Paketes auslesen
   local PKG_START=`awk -vsuch=$PKG 'such == $1 {printf("%s %s\n",$2,$3)}' $DATEI_LOCK | tail -1`
      #der tail -1 muss sein, weil es mehrere Zeilen in der Datei (durch SETSTATE) geben kann

   #                                            Sektion  Teststep              Detail        Date Time    Wert           Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Package Server        $ZEITSTEMPEL $THISHOSTNAME  "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Package Package_Lock  $ZEITSTEMPEL $PKG_VORHANDEN "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Package Package_Start $ZEITSTEMPEL "$PKG_START"   "{DT}"
#echo "Paket    " $PKG Lockdatei $PKG_VORHANDEN
}

check_prg()
{
# Aufgabe: prüft, ob ein Programm für das laufende Paket korrekt ist (OK, lock)
# $1 = Name des Paketes
# $2 = Name des Programmes
   local PKG=$1 
   local PRG_NAME=$(cut -d: -f 2 <<<$2)
   if [[ "${2%%:*}" = "PRGP" ]]; then
     local PKG_LOCK=PRGP_${PKG}_$(md5sum | cut -d ' ' -f 1 <<<$2)
   else
     local PKG_LOCK=PRG_$PKG${PRG_NAME//\//_}
   fi

   #ist die Datei OK?
   if [[ -f $PRG_NAME ]]; then
      local PRG_VORHANDEN="OK"
   else
      local PRG_VORHANDEN="ERROR"
   fi

   #ist für das Script eine lock Datei OK?
   if [[ -f "$LOCKDIR/${PKG_LOCK}_lock" ]]; then
      local LOCK_VORHANDEN="OK"
   else
      local LOCK_VORHANDEN="ERROR"
   fi

   #                                            Sektion  Teststep               Detail     Date Time    Wert            Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Programs Server     $ZEITSTEMPEL $THISHOSTNAME   "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Programs PRG_Name   $ZEITSTEMPEL $PRG_NAME       "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Programs PRG_Status $ZEITSTEMPEL $PRG_VORHANDEN  "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Programs PRG_Lock   $ZEITSTEMPEL $LOCK_VORHANDEN "_"
#echo "PROGRAMM " $PKG $PRG_NAME $PRG_VORHANDEN Lockdatei $LOCK_VORHANDEN
}

check_IP()
{
# Aufgabe: prüft, ob eine IP für das laufende Paket korrekt ist (OK, lock)
# $1 = Name des Paketes
# $2 = IP-String
   local PKG=$1 
   local IP=$(cut -d: -f 3 <<<$2)

   #ist die IP Adresse geladen?
   if /bin/ip addr | grep -q "^ *inet $IP"; then
      local IP_VORHANDEN="OK"
   else
      local IP_VORHANDEN="ERROR"
   fi

   #ist für das Script eine lock Datei OK?
   if [[ -f "$LOCKDIR/IP_${IP}_lock" ]]; then
      local LOCK_VORHANDEN="OK"
   else
      local LOCK_VORHANDEN="ERROR"
   fi

   #                                            Sektion  Teststep         Detail     Date Time    Wert            Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:IP Server     $ZEITSTEMPEL $THISHOSTNAME   "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:IP IP_Address $ZEITSTEMPEL $IP             "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:IP IP_Status  $ZEITSTEMPEL $IP_VORHANDEN   "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:IP IP_Lock    $ZEITSTEMPEL $LOCK_VORHANDEN "_"
#echo "IP       " $PKG $IP $IP_VORHANDEN Lockdatei $LOCK_VORHANDEN
}

check_filesystem()
{
# Aufgabe: prüft, ob eine Mountpoint für das laufende Paket korrekt ist (OK, lock)
# $1 = Name des Paketes
# $2 = IP-String
   local PKG=$1 
   local MOUNTTYP=${2%%:*}
   local MOUNTPOINT=$(cut -d: -f 2 <<<$2)

   if grep -q " $MOUNTPOINT " /proc/mounts; then
      local MOUNTPOINT_VORHANDEN="OK"
   else
      local MOUNTPOINT_VORHANDEN="ERROR"
   fi

   #Name der Lockdatei zusammenbauen (in Abhäigkeit vom Resourcentyp)
   #vielleicht geht das auch einfacher, mal sehen;-)
   case $MOUNTTYP in
      FS)   local DATEI_LOCK="$LOCKDIR/FS_${MOUNTPOINT//\//.}_lock";;
      FSG)  local DATEI_LOCK="$LOCKDIR/FSG_${MOUNTPOINT//\//.}_lock";;
      NFS)  local DATEI_LOCK="$LOCKDIR/NFS_${MOUNTPOINT//\//.}_lock";;
      NFSG) local DATEI_LOCK="$LOCKDIR/NFSG_${MOUNTPOINT//\//.}_lock";;
      VG)   local DATEI_LOCK="$LOCKDIR/VG_${MOUNTPOINT//\//.}_lock";;
   esac

   #ist für die Partition eine lock Datei OK?
   if [[ -f $DATEI_LOCK ]]; then
      local LOCK_VORHANDEN="OK"
   else
      local LOCK_VORHANDEN="ERROR"
   fi

   #                                            Sektion  Teststep                Detail            Date Time    Wert                  Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$MOUNTTYP Server            $ZEITSTEMPEL $THISHOSTNAME         "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$MOUNTTYP Mountpoint        $ZEITSTEMPEL $MOUNTPOINT           "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$MOUNTTYP Mountpoint_Status $ZEITSTEMPEL $MOUNTPOINT_VORHANDEN "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$MOUNTTYP Mountpoint_Lock   $ZEITSTEMPEL $LOCK_VORHANDEN       "_"

#echo $PKG $MOUNTPOINT $MOUNTPOINT_VORHANDEN Lock $LOCK_VORHANDEN
}

check_abhaengig()
{
# Aufgabe: prüft, ob ein Paket läuft
# $1 = Name des Paketes
# $2 = Name des zu prüfenden Paketes, Aufbau: Parameter:Paket:[Aufrufparameter]
   local PKG=$1 
   local PARAMETER_NAME=${2%%:*}
   local PARAMETER_PAKET=$(cut -d: -f 2 <<<$2)
   local PARAMETER_WERT=$(cut -d: -f 3 <<<$2)

   if grep -q "^$PARAMETER_PAKET[[:blank:]]" $RESOURCES; then
      local PARAMETER_VORHANDEN="OK"
   else
      local PARAMETER_VORHANDEN="missing"
   fi

   #                                            Sektion  Teststep           Detail             Date Time    Wert                  Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$PARAMETER_NAME Server             $ZEITSTEMPEL $THISHOSTNAME         "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$PARAMETER_NAME Package_Name       $ZEITSTEMPEL $PARAMETER_PAKET      "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$PARAMETER_NAME Package_Exists     $ZEITSTEMPEL $PARAMETER_VORHANDEN  "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:$PARAMETER_NAME Package_Parameter  $ZEITSTEMPEL "$PARAMETER_WERT"     "_"

}

check_RST()
{
# Aufgabe: prüft, ob ein Paket restartet wird
# $1 = Name des Paketes
# $2 = Name des zu prüfenden Paketes, Aufbau: RST:Paket[,Paket][:CLUSTER]
   local PKG=$1 
   local RST_PAKETE=$(cut -d: -f 2 <<<${2//,/ })
   local RST_PARAMETER=${2#*:*:}

   for RST_PAKET in $RST_PAKETE; do
      if grep -q "^$RST_PAKET[[:blank:]]" $RESOURCES; then
         local RST_VORHANDEN="OK"
      else
         local RST_VORHANDEN="missing"
      fi
      #                                            Sektion  Teststep          Detail               Date Time    Wert                  Einheit
      send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RST Server               $ZEITSTEMPEL $THISHOSTNAME         "_"
      send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RST Package_Name         $ZEITSTEMPEL $RST_PAKET            "_"
      send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RST Package_Exists       $ZEITSTEMPEL $RST_VORHANDEN        "_"
      send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RST Package_Parameter    $ZEITSTEMPEL "$RST_PARAMETER"      "_"
   done
}

check_RS()
{
# Aufgabe: prüft, ob ein Paket restartet wird
# $1 = Name des Paketes
# $2 = Name der zu prüfenden Resource
   local PKG=$1 
   local RS_NAME=$(cut -d: -f 2 <<<$2)

   if grep -q "^$RS_NAME[[:blank:]]" $RESOURCES; then
      local RS_VORHANDEN="OK"
   else
      local RS_VORHANDEN="missing"
   fi

   #                                            Sektion  Teststep         Detail               Date Time    Wert                  Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RS Server               $ZEITSTEMPEL $THISHOSTNAME         "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RS Resource_Name        $ZEITSTEMPEL $RS_NAME              "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:RS Resource_Exists      $ZEITSTEMPEL $RS_VORHANDEN         "_"
}

check_TST()
{
# Aufgabe: Testpaket zum Automatischen Clusterschwenk
# $1 = Name des Paketes
# $2 = zu prüfende Resource, Aufbau: TST:<secs>:<program>
   local PKG=$1 
   local TST_SECONDS=$(cut -d: -f 2 <<<$2)
   local TST_PROGRAM=$(cut -d: -f 3 <<<$2)

   #                                            Sektion  Teststep          Detail          Date Time    Wert               Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:TST Server          $ZEITSTEMPEL $THISHOSTNAME      "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:TST Test_Seconds    $ZEITSTEMPEL $TST_SECONDS       "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:TST Test_Program    $ZEITSTEMPEL $TST_PROGRAM       "_"
}

check_MINPKGS()
{
# Aufgabe: Beim Stoppen prüfen, ob noch genügend Pakete laufen
# $1 = Name des Paketes
# $2 = zu prüfende Resource, Aufbau: MINPKGS:<regexp>:<num>
   local PKG=$1 
   local MINPKGS_REGEXP=$(cut -d: -f 2 <<<$2)
   local MINPKGS_NUMBER=$(cut -d: -f 3 <<<$2)

   #                                            Sektion  Teststep              Detail         Date Time    Wert               Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:MINPGKS Server         $ZEITSTEMPEL $THISHOSTNAME      "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:MINPGKS Minpgks_Regexp $ZEITSTEMPEL $MINPKGS_REGEXP    "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:MINPGKS Minpgks_Number $ZEITSTEMPEL $MINPKGS_NUMBER    "_"
}

check_ERROR()
{
   #hier werden alle Resourcen ausgegeben, für die noch keine Prüfung OK ist
   local PKG=$1
   local RES=$2

   #                                            Sektion  Teststep              Detail  Date Time    Wert          Einheit
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Unknown Server  $ZEITSTEMPEL $THISHOSTNAME "_"
   send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PKG:Unknown Unknown $ZEITSTEMPEL $RES          "_"
#echo "Fehler   " $PKG $RES nicht geprüft
}

do_config()
{
   #mach nur was, wenn die ULS Dokumentation aktiviert ist
   if [[ -n "$ULS" ]]; then
      #und wenn die Dokumentation verschickt werden kann
      if  which send_test_value > /dev/null 2>&1
      then
         #Zeitstempel der Werte im ULS
         ZEITSTEMPEL=`date '+%Y-%m-%d %H:%M:00'`

         #Config schreiben (als Dateien)
         #                                            Sektion  Teststep             Detail    Date Time    Pfad
         send_file_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Config:$THISHOSTNAME SCCL      $ZEITSTEMPEL $SCCLCONFIG
         send_file_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Config:$THISHOSTNAME Packages  $ZEITSTEMPEL $PACKAGES
         send_file_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Config:$THISHOSTNAME Resources $ZEITSTEMPEL $RESOURCES
         if sccl_check_config -v &>/tmp/sccl_check_config.log; then
           send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Config:$THISHOSTNAME Check $ZEITSTEMPEL OK "_"
         else
           send_test_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Config:$THISHOSTNAME Check $ZEITSTEMPEL Error "_"
           send_file_value -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Config:$THISHOSTNAME Check.log $ZEITSTEMPEL /tmp/sccl_check_config.log
         fi
      fi
   fi
}

do_status()
{
   #mach nur was, wenn die ULS Dokumentation aktiviert ist
   if [[ -n "$ULS" ]]; then
      #und wenn die Dokumentation verschickt werden kann
      if  which send_test_value &>/dev/null; then
         PAKETBUCH=/tmp/sccl_2_uls.$$.PAKET_AUF_NOTE

         #Zeitstempel der Werte im ULS
         ZEITSTEMPEL=`date '+%Y-%m-%d %H:%M:00'`

         #Summary erstellen
         #Summary wird zweimal geschicket:
         # - einmal für den Schnellübersicht
         # - einmal aus Sicht dieses Hosts
         #                                               Sektion  Teststep              Detail Date Time    Wert                  Einheit
         send_test_value -u -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Summary               Status $ZEITSTEMPEL "`sccl_show_cluster -m -V`" "_N"
         send_test_value -h    DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Summary:$THISHOSTNAME Status $ZEITSTEMPEL "`sccl_show_cluster -m -V`" "_"

         #Paketdaten sammeln und zwischenspeichern
         for KNOTEN in $NODES; do
            echo $KNOTEN $(./sccl_list_packages_on_node $KNOTEN) >>$PAKETBUCH
         done

         # jedes Paket prüfen
         for PAKET in `awk '!/^[[#]|^$/ {print $1}' $PACKAGES`; do
            DEFAULT=`awk -vsuch=$PAKET 'such == $1 {print $2}' $PACKAGES`
            LAEUFT_AUF=`awk -vsuch=$PAKET '{for( i = 2; i <= NF; i++ ) {if( such == $i ) {printf(" %s", $1)}}}' $PAKETBUCH |cut -c 2-`
            DARF_LAUFEN_AUF=`awk -vsuch=$PAKET '!/^[[#]|^$/ {if (such==$1) {for (i=2;i<=NF;i++) {if ($i!="-") {printf(" %s", $i)}}}}' $PACKAGES| cut -c 2-`
            #                                               Sektion  Teststep        Detail   Date Time    Wert               Einheit
            send_test_value    -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PAKET Server   $ZEITSTEMPEL $THISHOSTNAME      "_"
            send_test_value -u -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PAKET default  $ZEITSTEMPEL $DEFAULT           "_"
            if [[ -n "$LAEUFT_AUF" ]]; then
              send_test_value -u -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PAKET running  $ZEITSTEMPEL "$LAEUFT_AUF"      "[HOSTNAME]"
            fi
            send_test_value -u -h DOMAIN:$THISHOSTNAME:SCCL $CLUSTER Packages:$PAKET possible $ZEITSTEMPEL "$DARF_LAUFEN_AUF" "_"


            if [[ `echo $LAEUFT_AUF | awk -vsuch=$THISHOSTNAME '{for(i=1;i<=NF;i++) {if (such==$i) {print $i}}}' | wc -l` -eq 1 ]]; then
               # ist das Paket korrekt initialisiert?
               check_paket $PAKET
               # alle Rescourcen des Pakets OK?
               for RECOURCE in `grep  -v "^#" $RESOURCES | awk -vsuch=$PAKET 'such == $1 {for (i=3;i<=NF;i++) {printf("%s ",$i)}}'`; do
                  case ${RECOURCE%%:*} in
                     "MULTI")    ;;
                     "SETSTATE") ;;
                     "EXECUTE")  ;;
                     "SWITCH")   ;;
                     "PRG")      check_prg        $PAKET $RECOURCE;;
                     "PRGP")     check_prg        $PAKET $RECOURCE;;
                     "IP")       check_IP         $PAKET $RECOURCE;;
                     "FS")       check_filesystem $PAKET $RECOURCE;;
                     "FSG")      check_filesystem $PAKET $RECOURCE;;
                     "NFS")      check_filesystem $PAKET $RECOURCE;;
                     "NFSG")     check_filesystem $PAKET $RECOURCE;;
                     "VG")       check_filesystem $PAKET $RECOURCE;;
                     "CPKG")     check_abhaengig  $PAKET $RECOURCE;;
                     "PKG")      check_abhaengig  $PAKET $RECOURCE;;
                     "!PKG")     check_abhaengig  $PAKET $RECOURCE;;
                     "!CPKG")    check_abhaengig  $PAKET $RECOURCE;;
                     "!SRES")    check_abhaengig  $PAKET $RECOURCE;;
                     "!SCPKG")   check_abhaengig  $PAKET $RECOURCE;;
                     "RST")      check_RST        $PAKET $RECOURCE;;
                     "RS")       check_RS         $PAKET $RECOURCE;;
                     "TST")      check_TST        $PAKET $RECOURCE;;
                     "MINPKGS")  check_MINPKGS    $PAKET $RECOURCE;;
                     *)          check_ERROR      $PAKET $RECOURCE;;
                  esac
               done
            fi
         done
         rm $PAKETBUCH 2>/dev/null
      fi
   fi
}

to_ULS_enable()
{

   if [[ -z "$ULS" ]]; then
      sed -i 's/^ULS=""/ULS="sccl_2_uls enable"/g' $SCCLCONFIG
      ./sccl_dist_config $SCCLCONFIG
   fi
}

to_ULS_disable()
{
   if [[ -n "$ULS" ]]; then
      sed -i 's/^ULS="sccl_2_uls enable"/ULS=""/g' $SCCLCONFIG
      ./sccl_dist_config $SCCLCONFIG
   fi
}

#Main
if [[ $# -ne 1 ]]; then
   usage
else
   case $1 in
      config)  do_config ;;
      status)  do_status;;
      enable)  to_ULS_enable;;
      disable) to_ULS_disable;;
            *) usage;;
   esac
fi

