#!/usr/bin/ksh

###############################################################################
#                                                                             #
# MyPurgeLogs.sh : Script de purge automatisée des logs.                      #
#                                                                             #
#   +---------------------------------------------------------------------+   #
#   | Copyright (c) 2005/2006 Flyounet                                    |   #
#   +---------------------------------------------------------------------+   #
#   | This program is free software; you can redistribute it and/or       |   #
#   | modify it under the terms of the GNU General Public License (GPL)   |   #
#   | as published by the Free Software Foundation; either version 2      |   #
#   | of the License, or (at your option) any later version.              |   #
#   | The GPL can be found at http://www.gnu.org/licenses/gpl.html        |   #
#   +---------------------------------------------------------------------+   #
#   | Author: Flyounet <dev[at]flyou.net>                                 |   #
#   +---------------------------------------------------------------------+   #
#                                                                             #
###############################################################################
#                                                                             #
# v0.01 [28/08/2005] Flyounet :                                               #
#       > Initiale Release                                                    #
# v0.02 [17/10/2005] Flyounet :                                               #
#       * Modification pour prise en compte du fichier de conf.               #
#       + Vérifie le répertoire en cours pour trouver un fichier de conf      #
#         à éxecuter plutôt que celui en local.                               #
#         Vérifie si le fichier/flag de non fonctionnement est présent.       #
#       + Execute_Rotation : Ajout d'un _ dans les noms des archives pour le  #
#         test de présence fichier. Si on a dans access et access_log.        #
#       + Ajout du --FORK pour relancer bypassé le test de lancement.         #
# v0.03 [18/10/2005] Flyounet :                                               #
#       * Execute_Rotation : Si la place dispo dans le répertoire est infé-   #
#         rieure à la taille du fichier à traiter, alors on copie dans /tmp.  #
#       > Ajout de la TotoListe.                                              #
#       * help : Mise à jour avec les nouveaux paramètres et les flags.       #
# v0.04 [21/10/2005] Flyounet :                                               #
#       + Execute_Rotation : Supprime les fichiers indiqués dans la conf si   #
#         le flag TypeAction=purge est utilisé.                               #
#       + Verify_FileConf : Vérifie maintenant le TypeAction et les arguments #
#         correspondants.                                                     #
#       * Main : Sortie du Verify_FileConf du test de Flag (fait gagner 2     #
#         lignes : Wouhahaha).                                                #
# v0.05 [24/10/2005] Flyounet :                                               #
#       * Ajout de Debug dans les fonctions. Utilisable via un FLAG.          #
#       + Ajout du numéro de version avec le paramètre --version.             #
#                                                                             #
#                                                                             #
        VERSION="0.05 [24/10/2005] Flyounet"
###############################################################################
#                                                                             #
# Todo :                                                                      #
#  > Vérifier la taille restante du FS en utilisant FSMin. Si la taille n'est #
#    minimum n'est pas présente alors supprimer les archives mais en laisser  #
#    au minimum 2.                                                            #
#  > Envoyer un TRAP, si un problème survient. FSFull, Compresseur absent...  #
#  > Modifier le détécteur de lancement de l'application pour voir si le      #
#    script tourne depuis plus d'une heure. Dans ce cas le killer.            #
#  > Gérer un Flag d'arrêt urgence. Gérer un Flag de non démarrage.           #
#  > Utiliser un paramètre pour forcer l'application à s'arrêter (génère un   #
#    Flag d'arrêt utilisateur).                                               #
#  > Gérer une conf contenant juste un chemin et le fichier, ou un FS.        #
# -> Ajouter du Debug clair.                                                  #
#  > Mettre en fonction séparée la copie/compression et la purge FS.          #
#  > Faire une Doc ^__^ et un Dossier d'action pour le pilotage T__T          #
#  > Et si tu te remettais au PERL ?                                          #
# OK Revoir la fonction d'aide pour indiquer les flags et leur utilisation.   #
#  > Mettre le parsing des arguments dans une fonction.                       #
# OK Changer la lecture de la Conf pour avoir un type de configuration, le    #
#    mode Rotate comme celui implémenter actuellement et le mode purge qui    #
#    prendra juste un fichier et le nombre de jour de rétention le reste sera #
#    supprimer par un find ... -exec rm.                                      #
#  > Dans la lecture d'un fichier de conf dans un sous répertoire, prendre en #
#    charge les + et - devant les nomsde fichier.                             #
#                                                                             #
###############################################################################
#                                                                             #
# Légende :                                                                   #
# + --> Indique une nouveauté, un ajout de fonctionnalité.                    #
# * --> Indique une correction de bogue.                                      #
# - --> Indique la suppression d'une fonctionnalité/variable.                 #
# > --> Indique une information n'ayant pas forcément de rapport avec le code #
#                                                                             #
###############################################################################

#set -x

#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
# Les Variables Globales
# ######################
# Nom du fichier interdisant de traiter un répertoire.
FILE_TO_DROPDIR="_nopurgelogs"
# Nom du fichier pour une conf locale
FILE_LOCALECONF="_purgelogs.conf"

# Variables Internes utile au fonctionnement
# Pas toucher !
# Contient le nom du script en cours de fonctionnement.
ScriptName=`basename ${0}`
LeScript="${0}"
VERIFY=0; FORK=0
if [ "x`dirname ${0}`" = 'x.' ]
then
  FileConf="`pwd`/MyPurgeLogs.conf"
else
  FileConf="`dirname ${0}`/MyPurgeLogs.conf"
fi
MyTempDir="/tmp/MyPurgeLogs.conf-$$"

# Si DEBUG!=0 alors plus de pruge ni de rotation.
# Si DEBUG=2 alors d'autres debug + verbose
DEBUG=0

#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
# Fonction d'afficahge d'aide.
# ############################
function help {
  echo ''
  echo 'MyPurgeLogs.sh [-h] [--version] [--verify] [--FORK] [ Fichier_Config ]'
  echo ' -h ou --help    : Avoir une aide.'
  echo ' --version       : Affiche le numéro de version du script.'
  echo ' --verify        : Vérifie la syntaxe du fichier de conf.'
  echo " Fichier_Config  : Indique le nom d'un fichier de configuration à prendre en compte."
  echo "                   Par défaut le fichier ${FileConf} est utilisé."
  echo " --FORK          : Permet de lancer le script même si une autre instance tourne."
  echo ''
  echo " Il existe des fichiers  que vous pouvez utiliser pour contrôler le fonctionnement"
  echo " du script :"
  echo " _nopurgelogs    : Lorsque ce fichier est présent dans un répertoire, ce dernier n'est"
  echo "                   traité par le script. Aucune action n'est effectuée."
  echo " _purgelogs.conf : Est un fichier de configuration présent dans un répertoire, cette"
  echo "                   configuration est utilisée à la place de celle par défaut."
  echo ''
  exit 0
}

# Focntion qui vérifie la syntaxe des fichiers de Conf
# ####################################################
function Verify_FileConf {
#  set -xv
  if [ ! -f ${FileConf} -o ! -r ${FileConf} -o ! -s ${FileConf} ]
  then
    echo "Fichier de configuration ${FileConf} illisible, inexistant ou vide !"
    exit 10
  fi
  nblib=0; BEGIN=0
  while read lig
  do
    let nblig=$nblig+1
    echo "${lig}" | grep -E '(^ *#)|(^ *$)' > /dev/null
    ERR=$?
    if [ $ERR -ne 0 ]
    then
      # Test BEGIN #
      if [ "`echo "${lig}" | cut -c1-5`" = "BEGIN" ]
      then
        if [ ${BEGIN} -eq 1 ]
        then 
          echo "Ligne ${nblig} : BEGIN détécté, alors qu'un autre n'est pas fermé !"
          exit 10
        else
          BEGIN=1
          D1=0; D2=0; D3=0; D4=0; D5=0; D6=0; MyOK=0
          DirToWork=""; FSMin=""; LogDay=""; DirToComp=""; FileToWork=""; TypeAction=""
        fi
      fi # Fin Test BEGIN #

      # Test END #
      if [ "`echo "${lig}" | cut -c1-3`" = "END" ]
      then
        if [ ${BEGIN} -eq 0 ]
        then
          echo "Ligne ${nblig} : END détécté, alors qu'aucun BEGIN n'a été trouvé !"
          exit 10
        else
          BEGIN=0
          if [ ${D6} -ne 1 ]
          then
              echo "Ligne ${nblig} : TypeAction manquant ou non renseigné !"
              exit 10
          fi
          if [ "${TypeAction}" = "purge" ]
          then
            if [ ${D1} -ne 1 -o ${D3} -ne 1 -o ${D5} -ne 1 ]
            then
              echo "Ligne ${nblig} : Au moins une valeur manquante ou non renseignée !"
              exit 10
            fi
          else
            if [ ${D1} -ne 1 -o ${D2} -ne 1 -o ${D3} -ne 1 -o ${D4} -ne 1 -o ${D5} -ne 1 ]
            then
              echo "Ligne ${nblig} : Au moins une valeur manquante ou non renseignée !"
              exit 10
            fi
          fi
          MyOK=1
          if [ ${VERIFY} -eq 1 ]
          then
            echo "TypeAction : ${TypeAction}"
            echo "DirToWork  : ${DirToWork}"
            echo "FSMin      : ${FSMin}"
            echo "LogDay     : ${LogDay}"
            echo "DirToComp  : ${DirToComp}"
            echo "FileToWork : ${FileToWork}"
          fi
        fi
      fi # Fin Test END #

      # Test DirToWork #
      if [ "`echo "${lig}" | cut -c1-9`" = "DirToWork" ]
      then
        D1=0
        if [ "x${DirToWork}" != "x" ]
        then
          echo "Ligne ${nblig} : DirToWork détécté, et déjà paramétré !"
          exit 10
        else
          DirToWork=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
          if [ "x${DirToWork}" = "x" ]
          then
            echo "Ligne ${nblig} : DirToWork détécté, mais non renseigné !"
            exit 10
          else
            SAVEIFS=${IFS}
            IFS='|'
            for i in `echo "${DirToWork}"`
            do
              if [ ! -d ${i} -o ! -r ${i} ]
              then
                echo "Ligne ${nblig} : ${i} inexistant ou illisible !"
                exit 10
              fi
            done
            IFS=${SAVEIFS}
          fi
        fi
        D1=1
      fi # Fin Test DirToWork #

      # Test FSMin #
      if [ "`echo "${lig}" | cut -c1-5`" = "FSMin" ]
      then
        D2=0
        if [ "x${FSMin}" != "x" ]
        then
          echo "Ligne ${nblig} : FSMin détécté, et déjà paramétré !"
          exit 10
        else
          FSMin=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
          if [ "x${FSMin}" = "x" ]
          then
            echo "Ligne ${nblig} : FSMin détécté, mais non renseigné !"
            exit 10
          else
            echo "${FSMin}" | grep -E '[0-9]*' >/dev/null
            ERR=$?
            if [ ${ERR} -ne 0 ]
            then
              echo "Ligne ${nblig} : ${FSMin} n'est pas un nombre !"
              exit 10
            fi
          fi
        fi
        D2=1
      fi # Fin Test FSMin #

      # Test LogDay #
      if [ "`echo "${lig}" | cut -c1-6`" = "LogDay" ]
      then
        D3=0
        if [ "x${LogDay}" != "x" ]
        then
          echo "Ligne ${nblig} : LogDay détécté, et déjà paramétré !"
          exit 10
        else
          LogDay=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
          if [ "x${LogDay}" = "x" ]
          then
            echo "Ligne ${nblig} : LogDay détécté, mais non renseigné !"
            exit 10
          else
            echo "${LogDay}" | grep -E "[0-9]*" >/dev/null
            ERR=$?
            if [ ${ERR} -ne 0 ]
            then
              echo "Ligne ${nblig} : ${LogDay} n'est pas un nombre !"
              exit 10
            else
              if [ ${LogDay} -eq 0 ]
              then
                echo "Ligne ${nblig} : LogDay vaut 0 et sera initialisé à 2 !"
              fi
            fi
          fi
        fi
        D3=1
      fi # Fin Test LogDay #

      # Test DirToComp #
      if [ "`echo "${lig}" | cut -c1-9`" = "DirToComp" ]
      then
        D4=0
        if [ "x${DirToComp}" != "x" ]
        then
          echo "Ligne ${nblig} : DirToComp détécté, et déjà paramétré !"
          exit 10
        else
          DirToComp=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
          if [ "x${DirToComp}" = "x" ]
          then
            echo "Ligne ${nblig} : DirToComp détécté, mais non renseigné !"
            exit 10
          fi
        fi
        D4=1
      fi # Fin Test DirToComp #

      # Test FileToWork #
      if [ "`echo "${lig}" | cut -c1-10`" = "FileToWork" ]
      then
        D5=0
        if [ "x${FileToWork}" != "x" ]
        then
          echo "Ligne ${nblig} : FileToWork détécté, et déjà paramétré !"
          exit 10
        else
          FileToWork=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
          if [ "x${FileToWork}" = "x" ]
          then
            echo "Ligne ${nblig} : FileToWork détécté, mais non renseigné !"
            exit 10
          fi
        fi
        D5=1
      fi # Fin Test FileToWork #

      # Test TypeAction #
      if [ "`echo "${lig}" | cut -c1-10`" = "TypeAction" ]
      then
        D6=0
        if [ "x${TypeAction}" != "x" ]
        then
          echo "Ligne ${nblig} : TypeAction détécté, et déjà paramétré !"
          exit 10
        else
          TypeAction=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}' | tr A-Z a-z`
          if [ "x${TypeAction}" = "x" ]
          then
            echo "Ligne ${nblig} : TypeAction détécté, mais non renseigné !"
            exit 10
          else
            if [ "${TypeAction}" != "rotate" -a "${TypeAction}" != "purge" ]
            #if [ "${TypeAction}" != 'rotate' ]
            then
              echo "Ligne ${nblig} : TypeAction détécté, et non conforme !"
              echo "Ligne ${nblig} : TypeAction vaut soit 'Rotate' soit 'Purge'"
              exit 10
            fi
          fi
        fi
        D6=1
      fi # Fin Test TypeAction #

    fi # Fin du IF pour test commentaire.
  done < ${FileConf}
  if [ ${MyOK} -eq 0 ]
  then
    echo "Ligne ${nblig} : Un blog d'instruction n'est pas terminé !"
    exit 10
  else
    if [ ${VERIFY} -eq 1 ]
    then
      echo "Vérification Terminée et OK !"
    fi
  fi
}

# Fonction qui vérifie le compresseur présent sur la machine
# ##########################################################
function Verify_Compressor {
  which bzip2 > /dev/null
  if [ $? -eq 0 ]
  then
    MyCompress="bzip2 -9 -c "
    MyExtension=".bz"
  else
    which gzip > /dev/null
    if [ $? -eq 0 ]
    then
      MyCompress="gzip -9 -c "
      MyExtension=".gz"
    else
      MyCompress="compress -c "
      MyExtension=".z"
    fi
  fi
  export MyCompress
}

# Fonction qui vérifie si le programme fonctionne déjà.
# #####################################################
function Verify_Working {
#  set -xv
  MyRunningPID=$$
#  ps -o "%p %t %c %a" | grep ${ScriptName} | grep -v grep | grep -v  ${MyRunningPID}|grep -v vi
  TmpnbProc=`ps -o "%p %t %c %a" | grep ${ScriptName} | grep -v grep | grep -v  ${MyRunningPID}|grep -v vi|wc -l |awk '{print $1}'`
#  TmpnbProc=`ps -o "%p %t %c %a" | grep ${ScriptName} | grep -v grep | grep -v  ${MyRunningPID}|wc -l |awk '{print $1}'`
  if [ ${TmpnbProc} -ne 0 ]
  then
    echo "Application en cours de fonctionnement. Je m'arrête."
    exit 10
  fi
}

# Fonction Principale
# ###################
function Execute_Rotation {
#  set -xv
  while read lig
  do
    BEGIN=0
    echo "${lig}" | grep -E '(^ *#)|(^ *$)' > /dev/null
    ERR=$?
    if [ $ERR -ne 0 ]
    then
      # Test BEGIN #
      if [ "`echo "${lig}" | cut -c1-5`" = "BEGIN" ]
      then
        D1=0; D2=0; D3=0; D4=0; D5=0; MyOK=0
        DirToWork=""; FSMin=""; LogDay=""; DirToComp=""; FileToWork=""; TypeAction=""
      fi # Fin Test BEGIN #

      # Test END #
      if [ "`echo "${lig}" | cut -c1-3`" = "END" ]
      then
        mkdir ${MyTempDir}
        if [ $? -ne 0 ]
        then
          echo "Impossible de créer le répertoire temporaire !"
          exit 10
        fi
if [ ${DEBUG} -ne 0 ]
then
        echo "---------------------"
        echo "TypeAction: $TypeAction"
        echo "DirToWork: $DirToWork"
        echo "DirToComp: $DirToComp"
        echo "FileToWork: $FileToWork"
        echo "LogDay: $LogDay"
        echo "FSMin: $FSMin"
        echo "---------------------"
fi
#set -xv
        echo "${DirToWork}" | awk '{ gsub("\|","\n");print}' > ${MyTempDir}/Rep.dat
        echo "${FileToWork}" | awk '{ gsub("\|","\n");print}' > ${MyTempDir}/File.dat
        if [ "${TypeAction}" = "rotate" ]
        then
          echo "${DirToComp}" | awk '{ gsub("\|","\n");print}' > ${MyTempDir}/ssRep.dat
#set +xv
[[ ${DEBUG} -eq 2 ]] && cat ${MyTempDir}/*
          while read rep
          do
[[ ${DEBUG} -ne 0 ]] && echo "rep : ${rep}"
            while read ssrep
            do 
              for wkdir in `ls -d ${rep}/${ssrep}/`
              do
[[ ${DEBUG} -ne 0 ]] && echo "rep/ssrep/ : ${rep}/${ssrep}/"
                tmpdir=`echo "${wkdir}/" | sed "s;////;/;g" | sed "s;///;/;g" | sed "s;//;/;g"` >/dev/null 2>/dev/null
                if [ -d ${tmpdir} -a -r ${tmpdir} ]
                then
[[ ${DEBUG} -ne 0 ]] && echo "${wkdir} --> ${tmpdir}"
                  cd ${tmpdir}
                  if [ $? -eq 0 ]
                  then
                    if [ ! -f ${FILE_TO_DROPDIR} ]
                    then
                      if [ -f ${FILE_LOCALECONF} ]
                      then
                        if [ -r ${FILE_LOCALECONF} ]
                        then
                          ${LeScript} --FORK "${tmpdir}${FILE_LOCALECONF}"
                        fi
                      else # Sur LocaleConf
                        while read fil
                        do
                          if [ -s ${fil} ]
                          then
                            NbFile=`ls ${fil}_[0-9]*_[0-9]*.*.comp | wc -l | awk '{ print $1 }'` >/dev/null 2>/dev/null
                            if [ ${DEBUG} -ne 0 ]
                            then
                              echo "Nombre de Fichiers compressés : ${NbFile} (Max souhaité : ${LogDay})"
                            else # Else de Debug
                              if [ ${NbFile} -gt ${LogDay} -o ${NbFile} -eq ${LogDay} ]
                              then
                                while [ ${NbFile} -gt ${LogDay} -o ${NbFile} -eq ${LogDay} ]
                                do
                                  filtodel=`ls -tr ${fil}_[0-9]*_[0-9]*.*.comp | head -1` >/dev/null 2>/dev/null
                                  rm -f ${filtodel}
                                  filtodel=""
                                  NbFile=`ls ${fil}_[0-9]*_[0-9]*.*.comp | wc -l | awk '{ print $1 }'` >/dev/null 2>/dev/null
                                done
                              fi # Fin de suppression
                            fi # Fin de Debug
                            DTH="`date "+%Y%m%d_%H%M%S"`"
                            if [ -f "${fil}" -a -r "${fil}" -a -s "${fil}" ]
                            then
                              InDirSize=`df -k ./ | tail -1 | awk '{print $3}'`
                              let InDirSize=$InDirSize*1024
                              InTmpSize=`df -k /tmp/ | tail -1 | awk '{print $3}'`
                              let InTmpSize=$InTmpSize*1024
                              FileSize=`ls -s "${fil}" | awk '{ print $1}'`
                              let FileSize=$FileSize*1024+$FileSize*1024/10
[[ ${DEBUG} -ne 0 ]] && echo "${tmpdir} : ${FileSize} - ${InDirSize} - ${InTmpSize}"
                              if [ ${FileSize} -lt ${InDirSize} ]
                              then
[[ ${DEBUG} -ne 0 ]] && echo "InDirSize : ${InDirSize}"
                                cp "${fil}" "${fil}_${DTH}"
                                if [ $? -eq 0 ]
                                then
                                  [[ ${DEBUG} -eq 0 ]] && > "${fil}"
                                  ${MyCompress} "${fil}_${DTH}" > "${fil}_${DTH}${MyExtension}.comp"
                                  [[ ${DEBUG} -ne 0 ]] && rm -f "${fil}_${DTH}${MyExtension}.comp"
                                  rm -f "${fil}_${DTH}"
                                else
                                  rm -f "${fil}_${DTH}"
                                fi
                              else # Test taille fichier / Directory
                                if [ ${FileSize} -lt ${InTmpSize} ]
                                then
[[ ${DEBUG} -ne 0 ]] && echo "InTmpSize : ${InTmpSize}"
                                  cp "${fil}" "/tmp/${fil}_${DTH}"
                                  if [ $? -eq 0 ]
                                  then
                                    [[ ${DEBUG} -eq 0 ]] && > "${fil}"
                                    ${MyCompress} "/tmp/${fil}_${DTH}" > "${fil}_${DTH}${MyExtension}.comp"
                                    [[ ${DEBUG} -ne 0 ]] && rm -f "${fil}_${DTH}${MyExtension}.comp"
                                    rm -f "/tmp/${fil}_${DTH}"
                                  else
                                    rm -f "/tmp/${fil}_${DTH}"
                                  fi
                                else # Test taille fichier / /tmp
                                  # Je en sais pas encore...
                                  # Peut être attendre la fin du script puis relancer la commadne pour ce fichier...
                                  sleep 1
                                fi # Test taille fichier / /tmp
                              fi # Test taille fichier / Directory
                            fi
                          fi # Fichier > 0
                        done < ${MyTempDir}/File.dat
                      fi # Sur LocaleConf
                    fi # Sur FileDrop
                  else # Sur Test du cd wkdir
                    echo "Impossible de se déplacer dans : ${tmpdir}"
                  fi
                fi
              done
            done < ${MyTempDir}/ssRep.dat
          done < ${MyTempDir}/Rep.dat
        fi # Fin FI sur TypeAction = rotate
        if [ "${TypeAction}" = "purge" ]
        then
#set -xv
          LogDay=`echo "${OldLogDay}"`
          while read rep
          do
            while read fil
            do
              if [ ${DEBUG} -ne 0 ]
              then
                echo "In Find : LogDay=${LogDay} - rep=${rep} - fil=${fil}"
                [[ ${DEBUG} -eq 2 ]] && find ${rep} -name "${fil}" -mtime +${LogDay} -type f -exec ls -l {} \;
              else
                find ${rep} -name "${fil}" -mtime +${LogDay} -type f -exec rm -f {} \;
              fi # Fin Debug
            done < ${MyTempDir}/File.dat
          done < ${MyTempDir}/Rep.dat
        fi
#set +xv
        rm -rf ${MyTempDir}
      fi # Fin Test END #

      # Test DirToWork #
      if [ "`echo "${lig}" | cut -c1-9`" = "DirToWork" ]
      then
        DirToWork=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
      fi # Fin Test DirToWork #

      # Test FSMin #
      if [ "`echo "${lig}" | cut -c1-5`" = "FSMin" ]
      then
        FSMin=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
      fi # Fin Test FSMin #

      # Test LogDay #
      if [ "`echo "${lig}" | cut -c1-6`" = "LogDay" ]
      then
        LogDay=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
        OldLogDay=`echo "${LogDay}"`
        if [ ${LogDay} -eq 0 ]
        then
          LogDay=2
        fi
      fi # Fin Test LogDay #

      # Test DirToComp #
      if [ "`echo "${lig}" | cut -c1-9`" = "DirToComp" ]
      then
        DirToComp=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
      fi # Fin Test DirToComp #

      # Test FileToWork #
      if [ "`echo "${lig}" | cut -c1-10`" = "FileToWork" ]
      then
        FileToWork=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}'`
      fi # Fin Test FileToWork #

      # Test TypeAction #
      if [ "`echo "${lig}" | cut -c1-10`" = "TypeAction" ]
      then
          TypeAction=`echo "${lig}" | awk -F'::' '{print $2}' | awk '{print $1}' | tr A-Z a-z`
      fi # Fin Test TypeAction #

    fi
  done < ${FileConf}

}


#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#
# Début de traitement
# ###################
if [ $# -gt 3 ]
then
  help
fi
#echo "Parsing des arguments"
param=1
NbParamValid=0
for i in "$@"
do
#  echo "Param ${param} : ${i}" 
  # Gestion -h
  if [ "${i}" = '-h' -o "${i}" = '--help' ]
  then
    help
  fi
  # Gestion --FORK
  if [ "${i}" = '--FORK' ]
  then
    export FORK=1
  fi
  # Gestion --version
  if [ "${i}" = '--version' ]
  then
    echo "Script en version : ${VERSION}"
    exit 0
  fi
  # Gestion --verify
  if [ "${i}" = '--verify' ]
  then
    export VERIFY=1
  fi
  if [ ${param} -eq $# -a ${i} != '--verify' -a ${i} != '--FORK' ]
  then
    FileConf=${i}
  fi
  let param=param+1
done

Verify_FileConf
if [ ${VERIFY} -eq 1 ]
then
  exit 0
fi

Verify_Compressor

if [ ${FORK} -eq 0 ]
then
  Verify_Working
fi

Execute_Rotation

exit 0