########################################################################################
#                                                                                      #
# Script de sauvegarde des Machines virtuelles pour VmWare ESXi 4                      #
# 2010, Alter Systems                                                                  #
# Vincent Magnin - vincent.magnin@gmail.com                                            #
#                                                                                      #
########################################################################################



########################################################################################
#                                                                                      #
# I - Variables de configuration du script                                             #
#                                                                                      #
########################################################################################

#!!!!! NE JAMAIS METTRE "/" A LA FIN DU CHEMIN DUN DOSSIER


# Dossier des fichiers de logs du script
LOG_FILE_DIRECTORY=/opt/Sauvegardes_ESXi

# Envoi sur nas des fichiers Logs
NFS_LOGS_DIR=/vmfs/volumes/VM_Client/Scripts/Logs/Sauvegardes_VMs
FULL_LOGS_DIR=/`hostname -s`/Detail

# Repertoire de sauvegarde (chemin local pour ESXi)
# ! Le script de réplication ne marchera plus car il dépend du niveau dans larborescence de cette variable !
# ! Changer ce dossier est simple s'il conserve les 3 niveaux, sinon il faudra modifier le script de réplication !
# ! pour le tri :  awk -F "/" {print $5} !
VM_BACKUP_VOLUME=/vmfs/volumes/VM_Client/Sauvegardes_VMs

# Utiliser le système VmWare de découpage des VM en fichiers de 2Go ? 1=oui, 0=non
ENABLE_2GB_SPARSE=0

# Nombre de sauvegardes que lon souhaite conserver
VM_BACKUP_ROTATION_COUNT=1

# Tenter une extinction par le systeme des machines virtuelles en cours de fonctionnement
# (1 - oui , 0 -non)
#
# !!! ATTENTION !!!
# !!!     Cette fonctionnalité recquiert que les VmWare Tools soient installés sur le système virtuel
POWER_VM_DOWN_BEFORE_BACKUP=0

# Autoriser l'extinction "brutale" ( 1- oui, 0- non)
ENABLE_HARD_POWER_OFF=0

# Cette option permet de décider ce qu'on doit faire des VMs quand la sauvegarde est achevée (il faut avoir activé l'option POWER_VM_DOWN_BEFORE_BACKUP)
# 0 - On remet la VM dans l'état dans lequel elle était lorsqu'on a lancé le script
# 1 - On redémarre toutes les VMs sauvegardées
# 2 - On ne redémarre pas les VMs sauvegardées
VM_STATE_AFTER_BACKUP=0

# Si l'extinction "brutale" est activée, cette variable va representer le compteur d'attente de l'extinction de l'OS
# avant de forcer la fermeture de la machine.
# Ce nombre sera multiplié par 3 secondes, donc si on met 4, le script attendra 12secondes que l'OS s'eteigne lui-même
# avant d'éteindre la machine.
ITER_TO_WAIT_SHUTDOWN=40




########################################################################################
#                                                                                      #
#  II - Fonction "logs" qui gère les fichiers de logs du script                        #
#                                                                                      #
########################################################################################

logs() {
        # On récupère le mois en cours et on le traduit en français
        MONTH_NUMBER=`date +%m`
        case $MONTH_NUMBER in
          01) MONTH=JANVIER;;
          02) MONTH=FEVRIER;;
          03) MONTH=MARS;;
          04) MONTH=AVRIL;;
          05) MONTH=MAI;;
          06) MONTH=JUIN;;
          07) MONTH=JUILLET;;
          08) MONTH=AOUT;;
          09) MONTH=SEPTEMBRE;;
          10) MONTH=OCTOBRE;;
          11) MONTH=NOVEMBRE;;
          12) MONTH=DECEMBRE;;
        esac

        # On crée le dossier de stockage des fichiers de log
        mkdir -p ${LOG_FILE_DIRECTORY}
        LOG_FILE_NAME=Sauvegarde_VMs_${MONTH}.wri
        LOG_FILE=${LOG_FILE_DIRECTORY}/${LOG_FILE_NAME}

        # On teste si le fichier de logs précedent est encore présent
  	    if [ -e ${LOG_FILE} ]; then
  	       rm ${LOG_FILE}
  	    fi

        # On le recrée
        touch ${LOG_FILE}

        # On prépare le fichier de résultats
        RESULT_FILE_NAME=RESULTAT_sauvegarde_`hostname -s`_`date +%d-%m-%Y`.wri
        RESULT_FILE=${LOG_FILE_DIRECTORY}/${RESULT_FILE_NAME}

        # On teste si le fichier de resultat précédent est encore présent
        if [ -e ${RESULT_FILE} ]; then
          rm ${RESULT_FILE}
        fi

        # On le recrée
        touch ${RESULT_FILE}
}




########################################################################################
#                                                                                      #
#  III - Fonction "syntaxe" qui vérifie si le script est correctement execute          #
#                                                                                      #
########################################################################################

syntaxe() {
  # On a passé en paramètre le nombre d'arguments
	NUM_OF_ARGS=$1
	# On appele la fonction logs pour créer le fichier de log
  logs
  # On vérifie qu'il y a bien le bon nombre d'arguments
	if [ ! ${NUM_OF_ARGS} == 1 ]; then
		aide
	fi

  # On vérifie si l'on est sous ESX ou ESXi
	if [ -f /usr/bin/vmware-vim-cmd ]; then
        	VMWARE_CMD=/usr/bin/vmware-vim-cmd
	elif [ -f /bin/vim-cmd ]; then
        	VMWARE_CMD=/bin/vim-cmd
	else
	        echo "Ce script ne fonctionne que sous VmWare ESX et ESXi !"
	        echo "Erreur Fatale, arrêt du script : Doit être executé sous VmWare ESX(i)"
	        exit
	fi

  # On teste la validité du fichier de VMs passé en paramètre
	if [ ! -f ${FILE_INPUT} ]; then
	  echo "Erreur : Le fichier de liste de VMs est invalide"
		echo -e "Erreur Fatale, arrêt du script: ${FILE_INPUT} est un fichier non valide !" >> $LOG_FILE
		aide
	fi

  # On vérifie que le script dispose bien des droits suffisants
	if [ ! "`whoami`" == "root" ]; then
  		echo "Ce script doit etre execute par \"root\"!"
  		echo "Erreur Fatale, arrêt du script : Doit impérativement être executé par root" >> $LOG_FILE
        	exit 1
	fi

	# On prépare les variables du jour et du mois pour le fichier de log de la baie
	TODAY_MONTH=`date +%b`
	TODAY_DAY=`date +%-d`

}




########################################################################################
#                                                                                      #
#  IV - Fonction "aide" qui affiche la commande a lancer pour utiliser le script       #
#                                                                                      #
########################################################################################

aide() {
  # On récupère le chemin du script pour afficher l'aide d'utilisation
	SCRIPT_PATH=$(basename $0)
	echo -e "Utilisation: ${SCRIPT_PATH} [VM_FILE_INPUT]"
	echo "ERREUR DE SYNTAXE!  Utilisation du script : ${SCRIPT_PATH} [VM_FILE_INPUT]" >> $LOG_FILE
	exit
}




##########################################################################################
#                                                                                        #
#  V - Fonction "dossiersvms" qui gère les dossiers de sauvegarde                        #
#         quotidienne des VMs                                                            #
#                                                                                        #
##########################################################################################

dossiersvms() {
    # On récupère le chemin du dossier de sauvegarde de la VM et le chemin direct complet correspondant
    # à la sauvegarde en cours (avec le sous dossier contenant la date)
    local VM_BACKUPs_DIR=$1
    local CURRENT_BACKUP_VM_BACKUP_DIR=$2

    # On vérifie la bonne présence du nombre de versions à conserver, si ce nest pas le cas on le met a 1
    if [ -z ${VM_BACKUP_ROTATION_COUNT} ]; then
      VM_BACKUP_ROTATION_COUNT=1
    fi

    # On crée une liste classé par ordre decroissant dancienneté des dossiers de version de chaque VM, ainsi que leur nombre
    VM_BACKUP_DIRs_LIST=$(ls -tr ${VM_BACKUPs_DIR})
    # On dénombre les versions d'archives actuellement stockées
    VM_BACKUPs_NUMBER=$(ls ${VM_BACKUPs_DIR} | wc -w)

    CPT=${VM_BACKUPs_NUMBER};

    # On va passer sur chacun des répertoires des versions d'archives
    for DIR in ${VM_BACKUP_DIRs_LIST};
    do
      VM_BACKUPs_NUMBER=$(ls ${VM_BACKUPs_DIR} | wc -w)
      # Si le nombre de dossiers de versions est supérieur au nombre choisi et que le compteur l'est également, alors on supprime le dossier le plus ancien
      if [ ${VM_BACKUPs_NUMBER} -gt ${VM_BACKUP_ROTATION_COUNT} ] && [ ${CPT} -gt ${VM_BACKUP_ROTATION_COUNT} ]; then
        rm -rf ${VM_BACKUPs_DIR}/${DIR}
      # Si le dossier en cours a le meme nom qu'un dossier existant ou que le compteur est à 1 (donc le dernier dossier de la liste) et que le nombre de dossiers
      # de versions est égal au nombre choisi, alors on renomme le dossier en préparation à la suppression, qui ne s'effectuera qu'une fois la sauvegarde en cours achevée
      elif [ ${DIR} = ${CURRENT_BACKUP_VM_BACKUP_DIR#${VM_BACKUPs_DIR}/} ] || [ ${CPT} -eq 1 ] && [ ${VM_BACKUPs_NUMBER} -eq ${VM_BACKUP_ROTATION_COUNT} ]; then
        BACKUP_DIR_TO_DELETE=${VM_BACKUPs_DIR}/${DIR}_old
        mv ${VM_BACKUPs_DIR}/${DIR} ${BACKUP_DIR_TO_DELETE}
      fi
      CPT=$(($CPT-1))
    done
}




########################################################################################
#                                                                                      #
#  VI  - Fonction "altersystemsVCB", fonction dorsale du script                        #
#                                                                                      #
########################################################################################

altersystemsVCB()
{
  VM_INPUT=$1
  START_TIME=`date`
  S_TIME=`date +%s`

  echo -e "####################################################################" >> ${LOG_FILE}
  echo -e " ===>> Sauvegarde du `date +%d-%m-%y:%Hh%M` pour `uname -n`" >> ${LOG_FILE}
  echo -e "####################################################################" >> ${LOG_FILE}
  echo -e "####################################################################" >> ${RESULT_FILE}
  echo -e " ===>> Sauvegarde du `date +%d-%m-%y:%Hh%M` pour `uname -n`" >> ${RESULT_FILE}
  echo -e "####################################################################" >> ${RESULT_FILE}
  # Récupère la liste des VMs présentes sur le serveur ESX(i) - meme si leur nom contient un espace - et stocke le résultat
  # dans un fichier temporaire et formate l'affichage pour séparer les informations par ";" et non plus des espaces
  ${VMWARE_CMD} vmsvc/getallvms | sed 's/[[:blank:]]\{3,\}/   /g' | awk -F'   ' '{print "\""$1"\";\""$2"\";\""$3"\""}' |  sed 's/\] /\]\";\"/g' | sed '1,1d' > /tmp/vms_list

  IFS='
  '

  # On crée le répertoire de sauvegarde s'il n'existe pas
  if [ ! -d "${VM_BACKUP_VOLUME}" ]; then
    mkdir -p "${VM_BACKUP_VOLUME}"
  fi

  # Le nom de chaque VM du fichier liste est récupéré, et le script va boucler pour chacune d'elles
  for VM_NAME in `cat "${VM_INPUT}" | sed '/^$/d' | sed -e 's/^[[:blank:]]*//;s/[[:blank:]]*$//'`;
  do
    # On récupère l'id de la VM dans le fichier temporaire que l'on vient de créer, en cherchant la ligne correspondant au nom du fichier liste
    VM_ID=`grep -E "\"${VM_NAME}\"" /tmp/vms_list | awk -F ";" '{print $1}' | sed 's/"//g'`

    # On récupère le nom du datastore dans lequel est stocké le disque virtuel de la machine
    VMFS_VOLUME=`grep -E "\"${VM_NAME}\"" /tmp/vms_list | awk -F ";" '{print $3}' | sed 's/\[//;s/\]//;s/"//g'`
    # On récupère le dossier et le nom du fichier de configuration de la machine
    VMX_CONF=`grep -E "\"${VM_NAME}\"" /tmp/vms_list | awk -F ";" '{print $4}' | sed 's/\[//;s/\]//;s/"//g'`
    VMX_PATH="/vmfs/volumes/${VMFS_VOLUME}/${VMX_CONF}"
    VMX_DIR=`dirname "${VMX_PATH}"`

    # Pour gérer la configuration souhaitée sur l'extinction des machines, on récupère leur état d'execution au début du script
    if [ "${POWER_VM_DOWN_BEFORE_BACKUP}" -eq 1 ]; then
      if "${VMWARE_CMD}" vmsvc/power.getstate ${VM_ID} | sed '1d' | grep "Powered off" > /dev/null 2>&1; then
        ETAT_VM="off"
      else
        ETAT_VM="on"
      fi
    fi

    # On essaie d'obtenir l'ID de la machine virtuelle
    if [ -z "${VM_ID}" ]; then
      echo "Erreur: Impossible de récupérer l'ID de ${VM_NAME}!"
      echo "Erreur Fatale : Impossible de récupérer l'ID de ${VM_NAME}, sa sauvegarde est annulée" >> "$LOG_FILE"
      echo "Impossible de récupèrer l'id de ${VM_NAME}    [ECHEC]" >> "$RESULT_FILE"

    # Vérifie si la VM ne dispose pas déjà d'un snapshot
    elif ls "${VMX_DIR}" | grep -q delta > /dev/null 2>&1; then
      echo "Instantane trouve pour ${VM_NAME}, la sauvegarde est annulee'"
      echo "${VM_NAME} utilise un disque snapshot, sa sauvegarde est annulée" >> $LOG_FILE
      echo "${VM_NAME} utilise un disque snapshot       [ECHEC]" >> $RESULT_FILE

    # Verifie que la machine virtuelle n'utilise pas de RawDeviceMapping
    elif ${VMWARE_CMD} vmsvc/device.getdevices ${VM_ID} | grep "RawDiskMapping" > /dev/null 2>&1; then
      echo "Le RawDeviceMapping est actif sur ${VM_NAME}, la sauvegarde est annulee"
 			echo "${VM_NAME} utilise le RawDeviceMapping, sa sauvegarde est annulée" >> $LOG_FILE
 			echo "${VM_NAME} utilise un disque RDM        [ECHEC]" >> $RESULT_FILE

    # Verifie que le fichier de conf vmx est bien présent
    elif [[ -f "${VMX_PATH}" ]] && [[ ! -z "${VMX_PATH}" ]]; then
      BACKUP_DIR="${VM_BACKUP_VOLUME}/${VM_NAME}"
      if [[ -z "${VM_BACKUP_VOLUME}" ]]; then
        echo "Impossible d'atteindre le chemmin de sauvegarde, verifiez les variables saisies"
        echo "Erreur d'accès au datastore ${VM_BACKUP_VOLUME}, vérifiez la configuration" >> $LOG_FILE
        echo "Erreur d'accès au datastore ${VM_BACKUP_VOLUME}     [ECHEC]" >> $RESULT_FILE
        exit 1
      fi

    # On crée le répertoire de sauvegarde de la VM s'il n'existe pas
    if [ ! -d "${BACKUP_DIR}" ]; then
      mkdir -p "${BACKUP_DIR}"
    fi

    # Nom de répertoire de sauvegarde de la VM
    VM_BACKUP_DIR="${BACKUP_DIR}/${VM_NAME}"

    # On passe par la fonction dossiersvms pour la gestion de l'archivage des VMs
		dossiersvms "${BACKUP_DIR}" "${VM_BACKUP_DIR}"
    mkdir -p "${VM_BACKUP_DIR}"

    # On copie le fichier de configuration de la VM dans son dossier de sauvegarde
    cp "${VMX_PATH}" "${VM_BACKUP_DIR}"

    # On récupère tous les disques virtuels trouvés dans le fichier de configuration
    VMDKS_FOUND=`grep scsi "${VMX_PATH}" | grep fileName | awk -F " " '{print $1}'`

    # Teste chaque VMDK trouvé dans le vmx et s'il est valide on le garde
    for DISK in "${VMDKS_FOUND}";
    do
      # On récupère l'ID SCSI de chaque disque pour vérifier qu'il est bien valide
      SCSI_ID=`echo "${DISK%%.*}"`
      grep "${SCSI_ID}.present" "${VMX_PATH}" | grep -i "true" > /dev/null 2>&1
      # Si oui, on stocke le vmdk valide
      if [ $? -eq 0 ]; then
        DISK=`grep "${SCSI_ID}".fileName "${VMX_PATH}" | awk -F "\"" '{print $2}'`
        VMDKS="${DISK}":"${VMDKS}"
      fi
    done

    # Cette partie du script va chercher à éteindre le systeme de la machine virtuelle, et si cela ne répond pas
    # la machine est éteinte "brutalement", si on l'a autorisé au début du script
    if [ "${POWER_VM_DOWN_BEFORE_BACKUP}" -eq 1 ]; then
      START_ITERATION=0
      echo "Système en cours d'extinction sur ${VM_NAME}, la sauvegarde sera lancée une fois l'opération achevée..."
      echo "${VM_NAME} en cours d'extinction, la sauvegarde sera lancée une fois l'operation achevée" >> $LOG_FILE
      ${VMWARE_CMD} vmsvc/power.shutdown "${VM_ID}" > /dev/null 2>&1
      # Le script va attendre la durée prévue au début du script et va forcer l'arret si la machine reste allumée a la fin du compteur
      while ${VMWARE_CMD} vmsvc/power.getstate "${VM_ID}" | grep "Powered on" > /dev/null 2>&1;
      do
        # Si le système ne parvient pas à s'éteindre assez rapidement, on lance la fermeture de la machine
        if [ "${ENABLE_HARD_POWER_OFF}" -eq 1 ]; then
          START_ITERATION=$((START_ITERATION + 1))
          if [ "${START_ITERATION}" -gt "${ITER_TO_WAIT_SHUTDOWN}" ]; then
            echo "Extinction forcée de ${VM_NAME}, après attente de $((ITER_TO_WAIT_SHUTDOWN*3)) secondes"
						echo "${VM_NAME} éteinte brutalement après $((ITER_TO_WAIT_SHUTDOWN*3)) secondes d'attente" >> $LOG_FILE
            ${VMWARE_CMD} vmsvc/power.off "${VM_ID}" > /dev/null 2>&1
            # Cette pause est obligatoire sous ESXi sinon le système n'a pas le temps de prendre en compte que la VM est éteinte
            sleep 5
            break
          fi
        fi
        echo "La machine est encore en marche. Tentative : ${START_ITERATION} - Attendre l'extinction encore 3 secondes..."
        sleep 3
      done
      echo "La machine est éteinte"
      echo "${VM_NAME} s'est correctement éteinte" >> $LOG_FILE
    fi

    # Cette partie concerne le cas où l'on ne souhaiterait pas éteindre les VM avant sauvegarde, ce qui impose de passer par des snapshots
    # notamment pour pouvoir déverrouiller et donc copier le disque virtuel en cours d'execution.
    if [ ! "${POWER_VM_DOWN_BEFORE_BACKUP}" -eq 1 ]; then
      echo "################## Prise d'un snapshot pour ${VM_NAME} ... ###################"
		  echo "################## Prise d'un snapshot pour ${VM_NAME} ... ###################" >> $LOG_FILE
      ${VMWARE_CMD} vmsvc/snapshot.create "${VM_ID}" vcb_snap VCB_BACKUP_"${VM_NAME}"_`date +%F` > /dev/null 2>&1
    else
      echo "################## Sauvegarde de ${VM_NAME} en cours ... #####################"
			echo "################## Sauvegarde de ${VM_NAME} en cours ... #####################" >> $LOG_FILE
			echo -e "###  Sauvegarde de ${VM_NAME}" >> ${RESULT_FILE}
    fi

    # Selon le type de stockage du systeme de fichier définit au début du script les disques virtuels sont copiés sur le partage de sauvegarde
    OLD_IFS=${IFS}
    IFS=":"
    for j in ${VMDKS};
    do
      VMDK="${j}"
      # On lance le clonage du disque
      if [ "${ENABLE_2GB_SPARSE}" -eq 1 ]; then
        /sbin/vmkfstools -i "${VMX_DIR}"/"${VMDK}" -d 2gbsparse "${VM_BACKUP_DIR}"/"${VMDK}"
      else
        /sbin/vmkfstools -i "${VMX_DIR}"/"${VMDK}" "${VM_BACKUP_DIR}"/"${VMDK}"
      fi
      # On vérifie que le clonage s'est déroulé avec succès, si c'est le cas on supprime le dossier (sil y a lieu) de la plus ancienne sauvegarde
      if [ ! $? -eq 0 ]; then
        echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
        echo "XXXXXXXXXXXXXXXXX !!! La copie du disque ${VMDK} a échoué !!! XXXXXXXXXXXXXXXX"
        echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
        echo "!!! Verifiez l'espace disque disponible et le bon fonctionnement du tri des dossiers !!!"
        echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" >> $LOG_FILE
        echo "XXXXXXXXXXXXXXXXX !!! La copie du disque ${VMDK} a échoué !!! XXXXXXXXXXXXXXXX" >> $LOG_FILE
        echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" >> $LOG_FILE
        echo "!!! Verifiez l'espace disque disponible et le bon fonctionnement du tri des dossiers !!!" >> $LOG_FILE
        echo -e ">> Sauvegarde du disque ${VMDK} de ${VM_NAME}      [ECHEC]" >> ${RESULT_FILE}
      else
        echo -e ">> Sauvegarde du disque ${VMDK} de ${VM_NAME}      [REUSSIE]" >> ${RESULT_FILE}
        if [ ! -z "${BACKUP_DIR_TO_DELETE}" ]; then
          echo "=> Suppression de la plus ancienne version de sauvegarde de ${VM_NAME}"
          rm -rf "${BACKUP_DIR_TO_DELETE}"
        fi
      fi
    done

    IFS="${OLD_IFS}"

    # Concerne uniquement les VMs non éteintes
    if [ ! "${POWER_VM_DOWN_BEFORE_BACKUP}" -eq 1 ]; then
      ${VMWARE_CMD} vmsvc/snapshot.remove "${VM_ID}" > /dev/null 2>&1
      # Le script ne continue pas tant que tous les instantanés ne sont pas supprimés
      echo "Suppresion des instantanés de ${VM_NAME} ..."
      echo "Suppression du snapshot crée pour la sauvegarde de ${VM_NAME}..." >> $LOG_FILE
      while ls "${VMX_DIR}" | grep -q delta;
      do
        sleep 3
      done
    else
      #Prise en charge de l'état de la VM avant le script, et remise en l'état selon configuration
      #Voir variable VM_STATE_AFTER_BACKUP en debut de script
      if [ "${VM_STATE_AFTER_BACKUP}" -eq 0 ]; then
        if [ "${ETAT_VM}" != "off" ]; then
          echo "Remise en route de ${VM_NAME}"
          echo "Remise en route de ${VM_NAME}" >> $LOG_FILE
          ${VMWARE_CMD} vmsvc/power.on "${VM_ID}" > /dev/null 2>&1
          # Le script attend que la VM soit correctement redémarrée pour poursuivre
          echo "Attente de redémarrage de ${VM_NAME}......"
          echo "Attente de redémarrage de ${VM_NAME}......" >> $LOG_FILE
          sleep 20
          if "${VMWARE_CMD}" vmsvc/power.getstate "${VM_ID}" | sed '1d' | grep "Powered off"; then
            echo -e "=======> ERREUR ${VM_NAME} n'a pas redémarré dans les temps !!!!!!"
            echo -e "=======> ERREUR ${VM_NAME} n'a pas redémarré dans les temps !!!!!!" >> $LOG_FILE
            echo -e "=======> ERREUR ${VM_NAME} n'a pas redémarré dans les temps !!!!!!" >> ${RESULT_FILE}
          fi
        fi
      elif [ "${VM_STATE_AFTER_BACKUP}" -eq 1 ]; then
        echo "Remise en route de ${VM_NAME}"
        echo "Remise en route de ${VM_NAME}" >> $LOG_FILE
        ${VMWARE_CMD} vmsvc/power.on "${VM_ID}" > /dev/null 2>&1
        echo "Attente de redémarrage de ${VM_NAME}......"
        echo "Attente de redémarrage de ${VM_NAME}......" >> $LOG_FILE
        sleep 20
        if "${VMWARE_CMD}" vmsvc/power.getstate "${VM_ID}" | sed '1d' | grep "Powered off"; then
          echo -e "=======> ERREUR ${VM_NAME} n'a pas redémarré dans les temps !!!!!!"
          echo -e "=======> ERREUR ${VM_NAME} n'a pas redémarré dans les temps !!!!!!" >> $LOG_FILE
          echo -e "=======> ERREUR ${VM_NAME} n'a pas redémarré dans les temps !!!!!!" >> ${RESULT_FILE}
        fi
      fi
    fi

    VMDKS=""
    echo -e "#################### Sauvegarde achevée pour ${VM_NAME}! #####################\n"
    echo -e "#################### Sauvegarde achevée pour ${VM_NAME}! #####################\n" >> $LOG_FILE
  else
    echo "Erreur : La VM ${VM_NAME} est introuvable !"
    echo "Erreur fatale: La VM ${VM_NAME} est introuvable" >> $LOG_FILE
    echo " > ERREUR : ${VM_NAME} est introuvable, vérifier le fichier liste de VMs" >> ${RESULT_FILE}
  fi
done

unset IFS

END_TIME=`date`
E_TIME=`date +%s`
echo "Heure de début : ${START_TIME}"
echo "Heure de fin   : ${END_TIME}"
DURATION=`echo $((E_TIME - S_TIME))`

# Affichage du calcul de la durée totale d'execution du script
if [ "${DURATION}" -le 60 ]; then
  echo "Durée  : ${DURATION} Secondes"
  echo "Durée  : ${DURATION} Secondes" >> $LOG_FILE
  echo -e "\nDurée  : ${DURATION} Secondes" >> ${RESULT_FILE}
else
  echo "Durée  : `awk 'BEGIN{ printf "%.2f\n", '${DURATION}'/60}'` Minutes"
  echo "Durée  : `awk 'BEGIN{ printf "%.2f\n", '${DURATION}'/60}'` Minutes" >> $LOG_FILE
  echo -e "\nDurée  : `awk 'BEGIN{ printf "%.2f\n", '${DURATION}'/60}'` Minutes" >> ${RESULT_FILE}
fi

echo -e "\nSauvegarde achevée pour les VMs sélectionnées\n"
echo -e "\n===>>Fin d'execution de la tache de sauvegarde ${END_TIME}\n\n\n\n\n\n\n" >> $LOG_FILE
echo -e "####################################################################" >> ${RESULT_FILE}
echo -e " <<=== Fin de la tache de sauvegarde le `date +%d-%m-%y:%Hh%M`" >> ${RESULT_FILE}
echo -e "####################################################################\n\n\n\n\n\n\n\n" >> ${RESULT_FILE}

# On envoie les fichiers de logs générés sur le dossier de logs centralisé, et on le crée s'il n'existe pas
if [ ! -d  ${NFS_LOGS_DIR}/${FULL_LOGS_DIR} ]; then
  mkdir -p ${NFS_LOGS_DIR}/${FULL_LOGS_DIR}
fi

# On copie le fichier de logs et de résultat en cours sur le NFS
cat ${LOG_FILE} >> ${NFS_LOGS_DIR}/${FULL_LOGS_DIR}/${LOG_FILE_NAME}
cat ${RESULT_FILE} > ${NFS_LOGS_DIR}/${RESULT_FILE_NAME}

}




########################################################################################
#                                                                                      #
#  VII - Lancement du script                                                           #
#                                                                                      #
########################################################################################


# Verifie le nombre d'arguments passés en paramètres et si le fichier passé est bien valide
syntaxe $#

# Lance la fonction dorsale du script
altersystemsVCB $1