#!/usr/bin/perl -w
# ------------------------------------------------------------
# move_to_archive.pl
#   (c) 2000, Xtelligent IT Consulting GmbH
#   karin.wenzel@xtelligent.de
# ------------------------------------------------------------
# Uebergabeparameter: 
#   Optionen, absoluter/relativer Archivpfad, Dateiname(n)
# Umgebungsanpassung:
#   ArchivPfad anpassen   
# Funktion:
#   Die Datei(en) werden nach $Archivpfad kopiert, das Original
#   geloescht und die gezipte Kopie nach ADSM gesichert. Nach
#   erfolgreicher Sicherung wird auch das Zip-File geloescht!
#   Aufruf ohne oder mit falschen Parametern erzeugt Usage-
#   Information mit Erklaerung der moeglichen Parameter.
# Verwendete Admin-Skripte:
#   /usr/admin/bin/move_to_adsm.pl
#   (enthaelt serverspezifisches Passwort!)
# ------------------------------------------------------------
# Fehlerausgaben:
#   Exit-Code ist bei Fehlern != 0, aber sonst nicht spezifisch.
#   Ausserdem erfolgt die Ausgabe eines Fehlertextes nach
#   Standardout.
# ------------------------------------------------------------
# Stand und History:
#   xx.xx.xxxx - Version x.x : Neueste Aenderung...
#   25.02.2000 - Version 1.0 : Mission completed.
# ------------------------------------------------------------
# Anmerkungen
#   Die meisten Variablen werden global verwendet!
#   Die Variablen $Err und $ErrTxt werden jeweils nach Rueck-
#   sprung in MAIN fuer Fehlermeldungen ausgewertet!
#   An manchen Stellen werden Err2 und Err3 fuer weitere
#   Zwischenabfragen verwendet, um Err nicht zu veraendern
#   oder mit verschiedenen if-then-Schleifen nicht durch-
#   einander zu kommen.
# ------------------------------------------------------------
# ------------------------------------------------------------
#   SUBROUTINEN
# ------------------------------------------------------------
sub print_usage
  {
    # ----------
    #  Gibt Usage-Informationen aus.
    # ----------
    print "\n";
    print "Usage: [-v] [-c | -i | -q] {-r | -a Archivepath} File1 [...]\n";
    print "       Copies File(s) to Archivepath and moves them to ADSM. \n";
    print "       ! Removes Original File and copies, if successfully moved to ADSM. \n";
    print "       -v : verbose mode \n";
    print "       -y : yes-to-all: create Archivepath, if not existent  \n";
    print "                        save already existing Files with same name \n";
    print "                        in Archivepath to ADSM and delete them \n";
    print "       -i : interactive (ask what to do)  \n";
    print "       -q : quiet mode (exit with error) \n";
    print "       -r : relative Path (to $ArchivPfad) \n";
    print "       -a : absolute Path (from root) \n";
    print "\n";
      exit 1;
  } # END of print_usage
# -------------
sub to_adsm
  {
    # ----------
    #  Aufruf von move_to_adsm.pl und Fehlerchecks
    # ----------
      $OutPut=`/usr/admin/bin/move_to_adsm.pl $Neuer_Name`;
      $Err=$?;
      if ($Err > 256 ) { $Err= $Err / 256 }
      if ($Err ne 0) 
        { $ErrTxt = "! Fehler in move_to_adsm: $Err \n$OutPut \n"; 
          # move_to_adsm erzeugt ein zip-File, das urspruengliche File kann schon weg sein!
          if ( -f $Neuer_Name) {
            unlink($Neuer_Name) or $Err2=$?;
            if ($Err2 ne 0) { $ErrTxt="${ErrTxt}! Fehler beim Löschen der Kopie: $Err2\n"; return 1}
            }
          else { $ErrTxt="${ErrTxt}! Gegebenenfalls Zipfile im Archivpfad von Hand loeschen!\n" }
          return 9
        }
      else
        { $Err2=0;
          unlink($Neuer_Name) or $Err2=$?;
          if ($Err2 ne 0) { $ErrTxt="! Fehler beim Löschen der Kopie: $Err2\n"; return 1}
        }
  } # END of to_adsm
# -------------
sub work_file
  {
    # ----------
    #  Bearbeitet einzelnes File
    # ----------
      unless (-f $ParamFile) {$ErrTxt="! Datei $ParamFile existiert nicht.\n"; return 1;}
      $Purer_Name=`basename $ParamFile`;
      chomp($Purer_Name);
      
      $Neuer_Name=$Neuer_Pfad.$Purer_Name;
      
    # --- Kopiere File
      if ( $flag_v == 1) { print "Pruefe, ob gleichnamiges File bereits vorhanden. \n" }
      if ( -f $Neuer_Name ) 
        { 
          if ($flag_i == 1) 
            { print "! File mit gleichem Namen existiert bereits: \n";
              print "  $Neuer_Name \n";
              $Answer="blub";
              while ($Answer ne "ja") {
                print "  Soll das bereits vorhandene File nach ADSM gesichert werden? (ja/nein)\n";
                print "  (Bei \"nein\" wird das zu kopierende File uebersprungen.) \n";
                $Answer = <STDIN>;
                chomp($Answer);
                if ( $Answer eq "nein" ) { 
                  $ErrTxt="! Wegen bereits vorhandenem gleichnamigen File nicht gesichert: $ParamFile \n";  
                  return 1; 
                  }
                }
                $Err3=&to_adsm;
                if ( $Err3 != 0 ) { 
                  $ErrTxt="Fehler bei ADSM-Sicherung bereits vorhandenen gleichnamigen Files.\n".$ErrTxt;
                  $ErrTxt=$ErrTxt."! $ParamFile NICHT gesichert.\n";
                  return 1;
                  }
            }
           elsif ($flag_y == 1) 
            { print "Sichere vorhandenes gleichnamiges File nach ADSM: $ParamFile\n";
                $Err3=&to_adsm;
                if ( $Err3 != 0 ) { 
                  $ErrTxt="Fehler bei ADSM-Sicherung bereits vorhandenen gleichnamigen Files.\n".$ErrTxt;
                  $ErrTxt=$ErrTxt."! $ParamFile NICHT gesichert.\n";
                  return 1;
                  }
            }
           else 
            { # d.h. flag_q ==1
                  $ErrTxt="! Wegen bereits vorhandenem gleichnamigen File nicht gesichert: $ParamFile \n";  
                  return 1;
            }
              
           # Loesche doppeltes File
           if ($Neuer_Name =~ /\.gz$/) { $dummy = $Neuer_Name } else { $dummy = "${Neuer_Name}.gz" }
           if ( $flag_v == 1 ) { print "Loesche bereits vorhandenes gleichnamiges File, bzw. gezipte Version.\n"}
           unlink($dummy);
           $Err=$?;
           if ( $Err != 0 ) { $ErrTxt="! Fehler beim Loeschen von vorhandenem gleichnamigen File.\n"; return 1;}
          
        } # END if -f Neuer_Name

      if ( $flag_v == 1) { print "Kopiere nach $Neuer_Name \n" }
      `cp $ParamFile $Neuer_Name`;
      $Err=$?;
      if ($Err ne 0) { $ErrTxt="! Fehler beim Kopieren des Files: $Err\n"; return 9}
      
      $BigAlt=`ls -l $ParamFile | awk '{print \$5}'`; chomp($BigAlt);
      $BigNeu=`ls -l $Neuer_Name | awk '{print \$5}'`; chomp($BigNeu);
      if ($BigAlt ne $BigNeu) 
        { print "! Kopie ist $BigNeu bytes gross, abweichend von Original. \n";
          print "! Keine Sicherung durchgeführt. Kopie geloescht. \n"; 
          unlink($Neuer_Name);
          exit 9}
      
    # --- Sichere Kopie nach ADSM, Fehlerausgabe 
    # -------------------------------------------
      if ( $flag_v == 1) { print "Sichere File nach ADSM.\n" }
      $Err3=&to_adsm;
      if ( $Err3 != 0 ) { return 1 }
    
    # --- Loesche Original
    # -------------------------------------------
      if ( $flag_v == 1) { print "Loesche Originalfile.\n" }
      unlink($ParamFile) or $Err=$?;
      if ($Err ne 0) { $ErrTxt="! Fehler beim Löschen des Originals: $Err\n"; return 9}

   } # End of sub work_file
# ------------------------------------------------------------
# ------------------------------------------------------------
#  MAIN
# ------------------------------------------------------------
#  Ini
# -----------------
  $ENV{PATH}="/bin:/usr/bin:/usr/admin/bin";
  $ParamDir="";
  $Err=0;
  $Err2=0;
  $flag_v=0;
  $flag_y=0;
  $flag_i=0;
  $flag_q=0;
  $flag_r=0;
  $flag_a=0;

  $ArchivPfad="/u1/backup/";

# -----------------
#   Parameterauswertung
#

  $Err=0;
  if ( @ARGV < 3 ) { &print_usage; }

  while ( $teil = shift @ARGV )
    {
      if    ( $teil eq "-v" ) { $flag_v = 1; }
      elsif ( $teil eq "-y" ) { $flag_y = 1; }
      elsif ( $teil eq "-i" ) { $flag_i = 1; }
      elsif ( $teil eq "-q" ) { $flag_q = 1; }
      elsif ( $teil eq "-r" ) { $flag_r = 1; 
                                $ParamDir = shift @ARGV;
                              }
      elsif ( $teil eq "-a" ) { $flag_a = 1; 
                                $ParamDir = shift @ARGV;
                              }
      elsif ( $teil =~ m§^-§ ) { print "illegal option: $teil\n"; &print_usage; }
      else { push(@Files,$teil); while ( $f = shift @ARGV ) { push(@Files,$f); } };
    }

  $Err= $flag_y + $flag_i + $flag_q;
  if ( $Err > 1 ) { &print_usage; }
  if ( $Err == 0 ) { $flag_i = 1; }
  
  $Err= $flag_r + $flag_a;
  if ( $Err != 1 ) { &print_usage; }
  
  if ( $ParamDir =~ m§^-§ ) { &print_usage; }
  if ( $ParamDir eq "" ) { &print_usage; }

  # Pruefe Pfadnamen
  # Dieser Pfad ist im Skript verdrahtet! Fehler in Variablensetzung
  # oder beim Mounten, wenn nicht vorhanden! 
  $ArchivPfad = $ArchivPfad."/" unless ($ArchivPfad =~ m§/$§);
  if ( ! -d $ArchivPfad ) 
     {
     print "! Archiv-Stammpfad nicht gefunden, pruefe: \n";
     print "  $ArchivPfad \n";
     exit 1;
     }

  $ParamDir = $ParamDir."/" unless ($ParamDir =~ m§/$§);
  if ( $flag_r == 1 ) {
    if ($ParamDir =~ m§^[/\.]§)  
     {
     print "! Kein korrekter Archivpfad: Angabe (ohne Punkte) relativ zu \n";
     print "  $ArchivPfad \n";
     exit 1;
     }
    }
  else {
    if ( ! $ParamDir =~ m§^/§ )  
     {
     print "! Kein korrekter Archivpfad: absoluten Pfad angeben. \n";
     exit 1;
     }
    } 

  # ------------------
  # Setze vollen Archivpfad, erzeuge, wenn nicht existent.
  #
  if ( $flag_r == 1 ) { $Neuer_Pfad=$ArchivPfad.$ParamDir; }
  else                { $Neuer_Pfad=$ParamDir; }
  
  print "Zielverzeichnis: $Neuer_Pfad \n";
  if ( ! -d $Neuer_Pfad ) 
    { if    ( $flag_q == 1 ) { print "! Zielverzeichnis existiert nicht.\n"; exit 1; }
      elsif ( $flag_i == 1 ) { print "! Zielverzeichnis existiert nicht.\n";
                              print "  $Neuer_Pfad \n";
                              $Answer="blub";
                              while ($Answer ne "ja") {
                                print "  Soll es erzeugt werden? (ja/nein) \n";
                                $Answer = <STDIN>;
                                chomp($Answer);
                                if ( $Answer eq "nein" ) { exit 1; }
                                }
                             }
      if ( $flag_v == 1 ) { print "Zielverzeichnis nicht vorhanden, wird erzeugt."; }
      `mkdir -p $Neuer_Pfad 1>/dev/null 2>&1`;
      $Err=$?;
      if ($Err ne 0) { print "! Fehler beim Anlegen des Archiv-Verzeichnisses: $Err\n"; exit 1}
    }

#  --- Loop ueber alle Files
# --------------------------------
    $ErrNmb=0;
    $ErrX=0;
  while ($ParamFile = shift @Files)
    { 
     if ( $flag_v == 1 ) { print "\nBearbeite: $ParamFile \n"; }
     $ErrX=&work_file;
     if ($ErrX != 0) { print "! Fehler bei Bearbeitung von $ParamFile : \n$ErrTxt"; ++$ErrNmb; } 
     else { print "OK: $ParamFile \n"; }
    }
  unless ($ErrNmb == 0) { print "\n! $ErrNmb Datei(en) nicht gesichert. \n" }

# ----- ENDE -----



