source: client/shared/scripts/createDiffImage @ 0a735488

#!/bin/bash

#/**
#         createDiffImage
#@brief   Script de ejemplo para crear una imagen diferencial de un sistema de archivos.
#@brief (puede usarse como base para el programa de creación de imágenes usado por OpenGnSys Admin).
#@param 1 disco 
#@param 2 particion 
#@param 3 REPO|CACHE
#@param 4 imagen_completa
#@param 5 imagen_diferencial
#@return  
#@exception OG_ERR_FORMAT     # 1 formato incorrecto.
#@exception OG_ERR_PARTITION  # 3 Error en partición de disco o en su sistema de archivos
#@exception OG_ERR_NOTFOUND   # Fichero de registro no encontrado.
#@exception OG_ERR_IMAGE      # 5 Error en funcion ogCreateImage o ogRestoreImage.
#@exception OG_ERR_NOTWRITE   # 14 error de escritura
#@exception OG_ERR_NOTCACHE   # 15 si cache no existe 15
#@exception OG_ERR_CACHESIZE  # 16 si espacio de la cache local o remota no tiene espacio 16
#@exception OG_ERR_LOCKED          # 4 Partición o fichero bloqueado.
#@exception OG_ERR_DONTMOUNT_IMAGE # 70 Error al montar una imagen sincronizada.
#@exception OG_ERR_DONTSYNC_IMAGE  # 71 Imagen no sincronizable (es monolitica)
#@note  Se toma como punto de partida el script createImage.
#@todo: que hacer, si el tamaño de la cache es sufciente, pero no tiene espacio libre
#@version 1.0 - creacion de la diferencial con rsync y btrfs
#@author  
#@date   2012-12-04
#*/ ##
trap "onexit $1 $2 $3 \"$4\" \"$5\"" 1 2 3 6 9 14 15 EXIT

function onexit() {
    local exit_status=$?
    ogUnmountImage $3 "$5" $DIFFTYPE &>/dev/null
    ogUnmountImage $3 "$4" $IMGEXT &>/dev/null
    if [ $exit_status -ne 4 ]; then
        ogUnlockImage "$3" "/$4.$IMGEXT" &>/dev/null
        ogUnlockImage "$3" "/$5.$DIFFEXT" &>/dev/null
        ogUnlock $1 $2 &>/dev/null
    fi
    exit $exit_status
}

#Carga el configurador del engine desde el fichero engine.cfg
[ -z $OGENGINECONFIGURATE ] &&  source /opt/opengnsys/etc/engine.cfg

TIME1=$SECONDS

PROG="$(basename $0)"
# Si se solicita, mostrar ayuda.
if [ "$*" == "help" ]; then
    ogHelp  "$PROG: $MSG_HELP_createDiffImage" \
            "$PROG ndisco nparticion REPO|CACHE base_image diff_image" \
            "$PROG 1 1 REPO Windows7 Win7aula23"
   exit 0
fi

[ $# -lt 5 ] && exit $(ogRaiseError session $OG_ERR_FORMAT "$MSG_FORMAT: $PROG ndisco nparticion REPO|CACHE base_image diff_image"; echo $?)

# Valores por defecto en etc/engine.cfg
IMGEXT="img"
DIFFEXT="img.diff"
DIFFTYPE="diff"
REPOIP=$(ogGetRepoIp)

# Limpiamos los archivo de log
echo -n "" >$OGLOGCOMMAND
[ "$(ogGetCaller)" == "RestaurarSoftIncremental" ] ||  echo -n "" > $OGLOGSESSION

ogEcho log session  "[1] $MSG_SCRIPTS_START $0 $*"

# Comprobamos si la imagen diferencial o la particion estan bloqueada:
ogIsImageLocked "$3" "$5.$DIFFEXT" && exit $(ogRaiseError session $OG_ERR_LOCKED "$3 $5.$DIFFEXT"; echo $?)
ogIsLocked "$1" "$2" && exit $(ogRaiseError session $OG_ERR_LOCKED  "$1 $2"; echo $?)

# Comprobar si la imagen completa existe.
IMGFILE="$(ogGetPath "$3" "$4.$IMGEXT")" || exit $(ogRaiseError session $OG_ERR_NOTFOUND "$3 $4.$IMGEXT"; echo $?)

# Comprobar que la imagen completa es sincronizable
ogIsSyncImage "$3" "$4" "img" || exit $(ogRaiseError session $OG_ERR_DONTSYNC_IMAGE "$3 $4"; echo $?)
# Comprobar que no está bloqueada
ogIsImageLocked "$3" "$4.$IMGEXT" && exit $(ogRaiseError session $OG_ERR_LOCKED "$3 $4.$IMGEXT"; echo $?)

# Si el repositorio es CACHE comprobamos que exista
if [ "$3" == "CACHE" -o "$3" == "cache" ]; then
        ! ogFindCache >/dev/null && exit $(ogRaiseError session $OG_ERR_NOTCACHE "CACHE "; echo $?)
fi

echo " " > $OGLOGCOMMAND

# Obtener información de los parámetros de entrada.
PART=$(ogDiskToDev "$1" "$2" 2>/dev/null) || exit $(ogRaiseError session $OG_ERR_PARTITION "$1 $2"; echo $?)
#Comprobamos que la partición se puede montar.
ORIG=$(ogMount $1 $2) ||   exit $(ogRaiseError session $OG_ERR_PARTITION "$1 $2"; echo $?)

DIFFDIR="$(ogGetParentPath "$3" "/$5")"
DIFFFILE="$DIFFDIR/$5.$DIFFEXT"

ogLockImage "$3"  "/$4.$IMGEXT"
ogLockImage "$3"  "/$5.$DIFFEXT"

# Comprobar consistencia del sistema de archivos.
echo " " > $OGLOGCOMMAND
SIZEFS=$(ogGetFsSize  $1 $2)
ogEcho log session "[20] $MSG_HELP_ogCheckFs  $1 $2 $SIZEFS (KB) "
ogUnmount $1 $2
ogCheckFs $1 $2 >$OGLOGCOMMAND || exit $(ogRaiseError session $OG_ERR_PARTITION "ogCheckFs $1 $2" ; echo $?)

# Borramos ficheros de paginacion y configuracion
ogCleanOs $1 $2

# Crear la imagen.
echo " " > $OGLOGCOMMAND
TIME2=$SECONDS
ogEcho log session "[40] $MSG_HELP_createDiffImage: $1 $2 $3 $4"
# Creamos la lista del contenido y lo situamos en la particion a copiar.

# Montamos imagen completa (con la que vamos a comparar)
ogMountImage $3 "$4" $IMGEXT >/dev/null

# Comprobar que la imagen completa se ha montado 
ogWaitSyncImage $3 "$4" $IMGEXT "mounted" || exit $(ogRaiseError session $OG_ERR_DONTMOUNT_IMAGE "$3 $4 $IMGEXT: time_out."; echo $?)

# Creamos la informacion de la imagen.
ogEcho log session "[45] $MSG_HELP_ogCreateInfoImage "
ogCreateInfoImage $1 $2 $3 "$4" "${DIFFTYPE}"
[ $? -eq $OG_ERR_NOTDIFFERENT ] &&  exit $(ogRaiseError session $OG_ERR_NOTDIFFERENT; echo $?)

#Comprobar espacio que requerira la imagen para ser almacenada
read SIZEDATA SIZEREQUIRED ISENOUGHSPACE <<< $(ogGetSizeParameters $1 $2 "$3" DIFF)

ogEcho log session "[50] $PROG: $MSG_SCRIPTS_CREATE_SIZE  $SIZEREQUIRED"
[ "$ISENOUGHSPACE" == "TRUE" ] || exit $(ogRaiseError session $OG_ERR_CACHESIZE "$3"; echo $?)

#Calculamos el tamaño de la imagen:
ogMount $1 $2 >/dev/null
ogLock $1 $2

TIMEAUX3=$[SECONDS-TIME2]
ogEcho log session "      $MSG_SCRIPTS_TASK_END $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX3/60]m $[TIMEAUX3%60]s"

# Del fichero de acl de la partición extraemos las acl de los ficheros de la diferencial
if [ "$FSTYPE" == "NTFS" ]; then
        ogEcho log session "[55] $MSG_HELP_ogAclFilter "
        ogAclFilter
        TIMEAUX4=$[SECONDS-TIMEAUX3]
        ogEcho log session "      $MSG_SCRIPTS_TASK_END $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX4/60]m $[TIMEAUX4%60]s"
fi
TIMEAUX5=$[SECONDS-TIMEAUX3]

# Configuro la informacion del tamaño de los datos en /tmp/ogimg.info
sed -i s/SIZEDATA/"$SIZEDATA"/g /tmp/ogimg.info

# Creamos o redimensionamos la imagen
ogEcho log session "[60] $MSG_HELP_ogCreateFileImage." 
ogCreateFileImage $3 "$5" $DIFFTYPE $SIZEREQUIRED

# Esperamos que se monte la imagen despues de crarla en el servidor
ogWaitSyncImage "$3" "$5" "$DIFFTYPE" "mounted" $SIZEREQUIRED  || exit $(ogRaiseError session $OG_ERR_DONTMOUNT_IMAGE "$3 $5 $DIFFTYPE: time_out."; echo $?)

ogEcho log session  "[70] $MSG_HELP_ogSyncCreate"
# Copio los datos a la imagen diferecial :
ogSyncCreate $1 $2 $3 "$5" $DIFFTYPE
RETVAL=$?
[ $RETVAL == 0 ] || ogEcho session warning "$MSG_ERR_SYNCHRONIZING"
TIMEAUX6=$[SECONDS-TIMEAUX5]
ogEcho log session   "      $MSG_SCRIPTS_TASK_END, $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX6/60]m $[TIMEAUX6%60]s"

# Reducimos la imagen diferencial -> solo para kernel <= 3.7, imagenes con FS ext4
ogEcho log session "[80] $MSG_HELP_ogReduceImage: $3 /$4.$IMGEXT"
ogReduceImage  $3 "$5" $DIFFTYPE
# Esperamos que el servidor termine de reducir la imagen
ogWaitSyncImage "$3" "$5" $DIFFTYPE "reduced" $SIZEREQUIRED || exit $(ogRaiseError session $OG_ERR_DONTMOUNT_IMAGE "$3 $4 $IMGEXT: time_out."; echo $?)
# TODO: necesaria funcion que espere a que se reduzca la imagen para continuar el script

echo " " > $OGLOGCOMMAND
# Comprobamos que la imagen esta bien
ogEcho log session "[95] $MSG_HELP_ogCheckSyncImage"
ogCheckSyncImage $3 "$5" diff ||  exit $(ogRaiseError session $OG_ERR_IMAGE "$3 $5 diff"; echo $?)

#resumen de la operacion
IMGSIZE=$(ls -l --block-size=1024 "${DIFFFILE}"| cut -f5 -d" ")
TIME=$[SECONDS-TIME1]
ogEcho log session "[100] $MSG_SCRIPTS_TIME_TOTAL $[TIME/60]m $[TIME%60]s"
ogEcho log session "      FileSystem $PART with $SIZEDATA KB data created onto file-image as $5 and used $IMGSIZE KB acros DFS rsync "

# Si ha habido problema al sincronizar nos salimos con error 
[ $RETVAL == 0 ] || exit $OG_ERR_SYNCHRONIZING