source: client/engine/Rsync.lib @ ee4beb4

918-git-images-111dconfigfileconfigure-oglivegit-imageslgromero-new-oglivemainmaint-cronmount-efivarfsmultivmmultivm-ogboot-installerogClonningEngineogboot-installer-jenkinsoglive-ipv6test-python-scriptsticket-301ticket-50ticket-50-oldticket-577ticket-585ticket-611ticket-612ticket-693ticket-700ubu24tplunification2use-local-agent-oglivevarios-instalacionwebconsole3
Last change on this file since ee4beb4 was 332bbb1, checked in by irina <irinagomez@…>, 11 years ago

#565 Compatibilidad con el comando file de Ubuntu 14.04 para obtener correctamente la versión del Kernel del cliente ogLive.

git-svn-id: https://opengnsys.es/svn/branches/version1.0@4252 a21b9725-9963-47de-94b9-378ad31fedc9
  • Property mode set to 100755
File size: 27.5 KB
RevLine 
[d2b8d24]1#!/bin/bash
2#/**
3# ogCreateFileImage  [ REPO | CACHE ] image_name extension size
4#@brief   Crear el archivo
5#@param 1 Repositorio  [ REPO | CACHE ]
6#@param 2 Nombre Imagen
[e24b042]7#@param 3 Tipo imagen [ img |diff ]
[d2b8d24]8#@param 4 Tamaño de la imagen
9#@return  instrucción para ser ejecutada.
10#*/
11
12function ogCreateFileImage () {
[332bbb1]13local SIZEREQUIRED IMGDIR IMGFILE DIRMOUNT LOOPDEVICE  IMGSIZE IMGEXT KERNELVERSION
[d2b8d24]14
15if [ "$*" == "help" ]; then
[6b0b68d]16    ogHelp "$FUNCNAME" : "$MSG_HELP_ogCreateFileImage" \
17           "$FUNCNAME [ REPO|CACHE ] image_name extension  size(K)" \
[d2b8d24]18           "$FUNCNAME REPO Ubuntu12 img 300000" \
19           "$FUNCNAME CACHE Windows7 diff 20000000"
20    return
21fi
22
23
24if [ $# -lt 4 ]; then
25    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME  [ REPO|CACHE ] image_name extension  size(k)"
26    return $?
27fi
28
29SIZEREQUIRED=$4
30[ $SIZEREQUIRED -lt 300000 ] && SIZEREQUIRED=300000
[332bbb1]31KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')
[d2b8d24]32
33if [ "$1" == "CACHE" -o "$1" == "cache" ]; then
[654d744]34        IMGDIR="$(ogGetParentPath "$1" "/$2")"
[e24b042]35        [ "$3" == "img" ] && IMGEXT="img" ||  IMGEXT="img.diff"
[654d744]36        IMGFILE="${IMGDIR}/$(basename "/$2").$IMGEXT"
[d2b8d24]37        ## Si no existe, crear subdirectorio de la imagen.
38        if [ $? != 0 ]; then
[ebc31ef5]39            ogEcho log session  "      $MSG_HELP_ogMakeDir \"$1 $(dirname "$2")."
[654d744]40            ogMakeDir "$1" "$(dirname "/$2")" || return $(ogRaiseError $OG_ERR_NOTWRITE "$3 /$4"; echo $?)
41            IMGDIR="$(ogGetParentPath "$1" "/$2")" || return $(ogRaiseError $OG_ERR_NOTWRITE "$3 /$4"; echo $?)
[d2b8d24]42        fi
[654d744]43        DIRMOUNT="/tmp/$(ogGetMountImageDir "$2" "$3")"
[d2b8d24]44        mkdir -p "$DIRMOUNT"
45        LOOPDEVICE=$(losetup -f)
46        # Si existe el fichero de la imagen se hace copia de seguridad, si  no existe se crea.
47        if [ -f "$IMGFILE" ]; then
[cd1f048]48                # Si la imagen esta montada la desmonto
49                if [ -r "$DIRMOUNT/ogimg.info" ]; then
50                    umount "$DIRMOUNT"
[e24b042]51                    [ $? -ne 0 ] && return $(ogRaiseError $OG_ERR_DONTUNMOUNT_IMAGE "$1 $2.$IMGEXT"; echo $?)
[cd1f048]52                fi
53
[87a78ad6]54                if [ "$BACKUP" == "true" -o "$BACKUP" == "TRUE" ]; then
[d2b8d24]55                    # Copia seguridad
[ebc31ef5]56                    ogEcho log session  "     $MSG_SCRIPTS_FILE_RENAME \"$IMGFILE\" ->  \"$IMGFILE.ant\"."
[791d013]57                    cp -f  "$IMGFILE" "$IMGFILE.ant" 
[d2b8d24]58                    mv -f "$IMGFILE.torrent" "$IMGFILE.torrent.ant" 2>/dev/null
59                    rm -f "$IMGFILE.sum"
60                fi
61
[654d744]62                IMGSIZE=$(ls -l --block-size=1024 "$IMGFILE" | awk '{print $5}')
[d2b8d24]63                if [ $IMGSIZE -lt $SIZEREQUIRED ];then
[ebc31ef5]64                   ogEcho log session  "      $MSG_SYNC_RESIZE"
65                   echo "      truncate --size=>$SIZEREQUIRED k $IMGFILE"
[f456755]66                   truncate --size=">$SIZEREQUIRED"k "$IMGFILE" &> $OGLOGCOMMAND
67                   # FS de la imagen segun la version del kernel: < 3.7 ext4, si >=  btrfs
[332bbb1]68                   if [ $KERNELVERSION \< 3.7 ]; then
[f456755]69                        losetup $LOOPDEVICE "$IMGFILE"
[ebc31ef5]70                        echo "      resize2fs -f $LOOPDEVICE"
[f456755]71                        resize2fs -f $LOOPDEVICE &> $OGLOGCOMMAND
72                       
73                   else
[ebc31ef5]74                        echo "      ogMountImage $1 "$2" $3"
[f456755]75                        ogMountImage $1 "$2" $3
[ebc31ef5]76                        echo "      btrfs filesystem resize max $DIRMOUNT"
[f456755]77                        btrfs filesystem resize max "$DIRMOUNT" &> $OGLOGCOMMAND
78                   fi
[d2b8d24]79                fi
80        else
[ebc31ef5]81                echo "      dd if=/dev/zero of=$IMGFILE bs=1024 count=$SIZEREQUIRED"
[791d013]82                dd if=/dev/zero of="$IMGFILE" bs=1024 count=$SIZEREQUIRED 2>&1 | tee -a $OGLOGCOMMAND
[d2b8d24]83                #Formateamos imagen
84                losetup $LOOPDEVICE $IMGFILE
[f456755]85                # FS de la imagen segun la version del kernel: < 3.7 ext4, si >=  btrfs
[332bbb1]86                if [ $KERNELVERSION \< 3.7 ]; then
[ebc31ef5]87                   echo "      mkfs.ext4 -i 4096  -b 4096 -L "${2##*\/}" $LOOPDEVICE"
[791d013]88                   mkfs.ext4 -i 4096  -b 4096 -L "${2##*\/}" $LOOPDEVICE 2>&1 |tee -a $OGLOGCOMMAND
[f456755]89                else
[ebc31ef5]90                   echo "      mkfs.btrfs  -L ${2##*\/} $LOOPDEVICE "
[791d013]91                   mkfs.btrfs  -L "${2##*\/}" $LOOPDEVICE 2>&1 | tee -a $OGLOGCOMMAND
[f456755]92                fi
[d2b8d24]93        fi
[f456755]94        # Monto la imagen
95        ogMountImage $1 "$2" $3 &>/dev/null
[30ad471]96        [ $? -eq 0 ] || return $( ogRaiseError $OG_ERR_IMAGE "$3 $4"; echo $?)
[c8bbcdc]97        #touch "$DIRMOUNT/ogimg.info"
98        echo "mounted"> $IMGFILE.lock
[d2b8d24]99
[8361974]100        # Si existe dispositivo de loop lo borro.
101        [ $LOOPDEVICE ] && losetup -d $LOOPDEVICE 2>&1 &>/dev/null
[d2b8d24]102
103else
104        [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
[ebc31ef5]105        echo "      hose $REPOIP 2009 --out sh -c \"echo -ne CREATE_IMAGE $2 $3 $SIZEREQUIRED \""
[d2b8d24]106        hose $REPOIP 2009 --out sh -c "echo -ne CREATE_IMAGE \"$2\" $3 $SIZEREQUIRED"
107fi
108
109}
110
111function ogCreateInfoImage () {
112#/**
[1ee5d4d3]113#  ogCreateInfoImage
[d2b8d24]114#@brief   Crear listados con la informacion de la imagen, los situa en /tmp.
115#@param 1 num_disk
116#@param 2 num_part
117#@param 3 Repositorio  [ REPO | CACHE ] (opcional en las completas)
118#@param 4 Nombre Imagen Basica (opcional en las completas)
[e24b042]119#@param 5 Tipo imagen [ img | diff ]
[d2b8d24]120#*/
[332bbb1]121local  IMGTYPE IMGDIRAUX DIRMOUNT DESTRSYNC PASSWORD OPTRSYNC USERRSYNC ORIG FSTYPE PART DIREMPTY IMGLIST IMGINFO IMGACL KERNELVERSION
[d2b8d24]122# Ayuda o menos de 5 parametros y la imagen no es basica
123if [ "$*" == "help" -o   $# -lt 5 -a "$3" != "img"  ]; then
[6b0b68d]124        ogHelp "$FUNCNAME" : "$MSG_HELP_ogCreateInfoImage" \
125                "$FUNCNAME num_disk num_part [ REPO|CACHE ] [ base_image_name ] extension  " \
126                "base image -> $FUNCNAME 1 2 img" \
127                "diff image -> $FUNCNAME 1 1 CACHE Windows7 diff "
[d2b8d24]128        return
129fi
130
131if [ $# -lt 3 ]; then
132    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME  num_disk num_part [ REPO|CACHE ] [ base_image_name]  extension  "
133    return $?
134fi
135
[5962edd]136# Comprobar errores.
137PART=$(ogDiskToDev "$1" "$2") || return $?
138ORIG=$(ogMount $1 $2) || return $?
139
[d2b8d24]140if [ $3 == "img" ]; then
[e24b042]141   IMGTYPE="img"
[d2b8d24]142else
[1ee5d4d3]143   # Comprobamos que las extension sea valida
[30ad471]144   ogCheckStringInGroup $5 "img diff" || return $( ogRaiseError  $OG_ERR_FORMAT "$MSG_SYNC_EXTENSION"; echo $?)
[e24b042]145   IMGTYPE=$5
146   if [ "$IMGTYPE" == "diff" ]; then
[d2b8d24]147        # Imagen completa con la que comparo la particion.
[654d744]148        IMGDIRAUX="$(ogGetMountImageDir "$4" "img")"
[d2b8d24]149        if [ "$3" == "CACHE" -o "$3" == "cache" ]; then
150           DIRMOUNT="/tmp/$IMGDIRAUX"
[654d744]151           DESTRSYNC="$DIRMOUNT"
[d2b8d24]152        else
153           [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
154           DIRMOUNT="$OGIMG/$IMGDIRAUX"
155           USERRSYNC="opengnsys"
[097bc95]156           PASSWORD="--password-file=/scripts/passrsync"
[d2b8d24]157           DESTRSYNC="$USERRSYNC@$REPOIP::ogimages/$IMGDIRAUX"
158        fi
159   fi
160fi
161
162
163FSTYPE=$(ogGetFsType $1 $2)
164
165# Creamos la lista del contenido y lo situamos en la particion a copiar.
166DIREMPTY="/tmp/empty$$"
167IMGLIST="/tmp/ogimg.list"
168IMGINFO="/tmp/ogimg.info"
169IMGACL="/tmp/ogimg.acl"
170
171# Borramos archivos antiguos.
[ebc31ef5]172rm -f /tmp/ogimg.* 2>/dev/null
173rm -f $ORIG/ogimg.* 2>/dev/null
[d2b8d24]174
[1ee5d4d3]175# En las diferenciales no sabemos el tamaño -> ponemos una constante.
176SIZEDATA=${SIZEDATA:-"SIZEDATA"}
[d2b8d24]177
[f456755]178# Incluimos información de la imagen. Segun el kernel sera ext4 o btrfs.
[332bbb1]179KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')
180if [ $KERNELVERSION \< 3.7 ]; then
[251c9e4]181        echo "#EXT4:NO:$FSTYPE:$SIZEDATA" > $IMGINFO
[f456755]182else
183        echo "#BTRFS:LZO:$FSTYPE:$SIZEDATA" > $IMGINFO
184fi
185
[e24b042]186if [ "$IMGTYPE" == "img" ]; then
[d2b8d24]187        # Imagen Basica
[ebc31ef5]188        echo "      rsync -aHAXvn --delete $ORIG/ $DIREMPTY >> $IMGINFO"
[d2b8d24]189        rsync -aHAXvn --delete $ORIG/ $DIREMPTY>> $IMGINFO
190        sed -i -e s/"^sent.*.bytes\/sec"//g -e s/^total.*.speedup.*.$//g -e s/"sending.*.list"//g $IMGINFO
191        sed -i  '/^\.\//d' $IMGINFO
192
193else
194        # Imagen Diferencial
[ebc31ef5]195        echo "      rsync -aHAXvn$OPTRSYNC  --delete  $ORIG/ $DESTRSYNC a $IMGLIST"
[791d013]196        rsync -aHAXvn$OPTRSYNC $PASSWORD  --delete  "$ORIG/" "$DESTRSYNC" >> $IMGLIST
[d2b8d24]197        sed -i -e s/"^sent.*.bytes\/sec"//g -e s/^total.*.speedup.*.$//g -e s/"sending.*.list"//g $IMGLIST
198        sed -i  '/^\.\//d' $IMGLIST
199
200        # Creamos informacion de la imagen
201        grep -e '\->' -e  '\=>' $IMGLIST > /tmp/ogimg.ln
202        grep -e  ^deleting  $IMGLIST | sed s/^deleting\ //g | grep -v ^ogimg  > /tmp/ogimg.rm
203        #grep -v -e '\->' -e  '\=>'  -e ^deleting  $IMGLIST >> $IMGINFO
204        grep -v -e '\->' -e  '\=>'  -e ^deleting -e ^created  $IMGLIST >> $IMGINFO
205
[ebc31ef5]206        rm -f $IMGLIST
[d2b8d24]207
[791d013]208        # Comprobamos que los ficheros de diferencias no esten vacios o salimos con error.
209        if [ $(grep -v -e "^$"  -e "^#" $IMGINFO /tmp/ogimg.ln /tmp/ogimg.rm |wc -l) -eq 0 ]; then
[30ad471]210                ogRaiseError $OG_ERR_NOTDIFFERENT "$1 $2 $3 $4 $5"
[e2a7442]211                return $?       
[791d013]212        fi
213
[d2b8d24]214fi
215
216# Guardamos el contenido de las acl (Solo win) Necesario particion desmontada (esta asi)
217ogUnmount $1 $2
[e27c4f4]218if [ $FSTYPE == "NTFS" ]; then
[ebc31ef5]219        echo "      ntfs-3g.secaudit -b $PART /"
[1e3a1e2]220        ntfs-3g.secaudit -b $PART / > $IMGACL
[e27c4f4]221fi
[d2b8d24]222
[791d013]223
[d2b8d24]224}
225
[6c2dee2]226
227#/**
228#  ogAclFilter
229#@brief Del fichero de acl de la partición extraemos las acl de los ficheros de la diferencial
230#@param No.
231#@return  (nada)
232#*/
233function ogAclFilter () {
234local  IMGACL IMGINFO FILES ACLTMP
235
[30ad471]236# Ayuda o menos de 5 parametros y la imagen no es basica
237if [ "$*" == "help" ]; then
238        ogHelp "$MSG_HELP_ogAclFilter" \
239                "$FUNCNAME [ no parameters ]  "
240        return
241fi
242
[6c2dee2]243IMGACL="/tmp/ogimg.acl"
244IMGINFO="/tmp/ogimg.info"
245FILES="/tmp/files$$"
246ACLTMP="/tmp/acl$$.tmp"
[30ad471]247ACLFILES="/tmp/aclfiles$$"
[6c2dee2]248
249# comprobamos que existan los archivos de origen. Si no salimos sin error.
[d344ed8]250[ -f $IMGACL -a -f $IMGINFO ] || return 0
[6c2dee2]251
252echo "" > $ACLTMP
[30ad471]253grep -n  -e "File" -e "Directory" $IMGACL > $ACLFILES
[6c2dee2]254
255# Al fichero le quitamos las líneas sobrantes: comentarios y lineas vacias.
256sed -e s/"^#.*$"//g $IMGINFO > $FILES
257sed -i '/^$/d'  $FILES
258
[d344ed8]259
[6c2dee2]260# Recorremos el listado y extraemos la acl correspondiente al fichero o directorio.
261while read LINE; do
[30ad471]262    #read END INI <<< "$(grep -n  -e "File" -e "Directory" $IMGACL| grep -A 1 "$LINE"| awk -F :  '!(NR%2){print $1" "p}{p=$1}' )"
263    read END INI <<< "$(grep -A 1 "$LINE" $ACLFILES | awk -F :  '!(NR%2){print $1" "p}{p=$1}' )"
[6c2dee2]264    let NUM=$END-$INI-1
[d344ed8]265    # Si algún archivo no se encuentra, el error lo mandamos a /dev/null
[30ad471]266    sed -n -e $INI,+"$NUM"p  $IMGACL 2>/dev/null >> $ACLTMP
267    echo "aclfilter: $LINE" >> $OGLOGCOMMAND
[6c2dee2]268done < $FILES
269
270cp $ACLTMP $IMGACL
[ebc31ef5]271rm -f $FILES $ACLTMP $ACLFILES
[6c2dee2]272
273}
274
[d2b8d24]275#/**
276#  ogRestoreInfoImage
[e24b042]277#@brief Crear o modificar enlaces y restaurar las ACL. La informacion esta ya copiada a la particion.
[d2b8d24]278#@param 1 num_disk
279#@param 2 num_part
280#*/
281function ogRestoreInfoImage () {
[5ccac26]282local  DEST PART IMGACL IMGLN OPTLN LINEA DESTLN ORIGLN TYPELN
[d2b8d24]283
284# Ayuda o menos de 5 parametros y la imagen no es basica
285if [ "$*" == "help" ]; then
[6b0b68d]286        ogHelp  "$FUNCNAME": "$MSG_HELP_ogRestoreInfoImage" \
287                "$FUNCNAME num_disk num_part" \
288                "base image -> $FUNCNAME 1 2 " \
289                "diff image -> $FUNCNAME 1 1 "
[d2b8d24]290        return
291fi
292
293if [ $# -lt 2 ]; then
294    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME num_disk num_part  "
295    return $?
296fi
297
[5962edd]298# Control de errores.
299PART=$(ogDiskToDev "$1" "$2") || return $?
300DEST=$(ogMount $1 $2) || return $?
301
[d2b8d24]302IMGACL="ogimg.acl"
[5ccac26]303IMGLN="ogimg.ln"
304
305#Creamos o modificamos los enlaces.
306# La imagen diferencial tiene ogimg.ln
307# para la completa lo generamos con los enlaces que contengan  /mnt/
[654d744]308[ -r "$DEST/$IMGLN" ] || grep -e "->" -e "=>" "$DEST/ogimg.info"|grep "/mnt/" > "$DEST/$IMGLN"
309if [ $(wc -l "$DEST/$IMGLN"|cut -f1 -d" ") -ne 0 ]; then
[5ccac26]310   while read LINEA
311   do
312        ORIGLN="${LINEA#*> }"
313        # Si origen hace referencia a la particion lo modificamos
314        echo $ORIGLN|grep "/mnt/"> /dev/null && ORIGLN="$DEST/${ORIGLN#/mnt/*/}"
315        # rsync marca - los enlaces simbolicos y = enlaces "duros"
316        LINEA="${LINEA%>*}"
317        TYPELN="${LINEA##* }"
318        DESTLN="${LINEA% *}"
319
320        if [ "$TYPELN" == "-" ]
321        then
322           OPTLN='-s'
323        else
324           OPTLN=''
325        fi
[654d744]326        cd "$DEST/$(dirname "$DESTLN")"
[ebc31ef5]327        rm -f "$(basename "$DESTLN")"
[654d744]328        ln $OPTLN "$ORIGLN" "$(basename "$DESTLN")"
[5ccac26]329        echo -n "."
[654d744]330   done < "$DEST/$IMGLN"  2>/dev/null
[5ccac26]331   echo ""
[d2b8d24]332
333fi
334
[5ccac26]335# Restauramos acl
[654d744]336if [ "$(ogGetFsType $1 $2)" == "NTFS"  -a -f "$DEST/$IMGACL" ] ; then
[d2b8d24]337        cd /
[654d744]338        cp "$DEST/$IMGACL" /tmp
[d2b8d24]339        ogUnmount "$1" "$2"
[ebc31ef5]340        echo "ntfs-3g.secaudit -se $PART /tmp/$IMGACL"
[791d013]341        ntfs-3g.secaudit -se $PART /tmp/$IMGACL
[f456755]342        # Para evitar que de falso error
343        echo ""
[5ccac26]344fi
[d2b8d24]345
346}
347
348function ogSyncCreate () {
349#/**
350# ogSyncCreate
[e24b042]351#@brief   sincroniza los datos de la partición a la imagen para crearla. La imagen esta montada en un directorio.
[d2b8d24]352#@param 1 num_disk
353#@param 2 num_part
354#@param 3 Repositorio  [ REPO | CACHE ]
355#@param 4 Nombre Imagen
[e24b042]356#@param 5 Tipo imagen [ img | diff ]
[d2b8d24]357#*/
[c4db9c1]358local ORIG DIRAUX DIRMOUNT DESTRSYNC USERRSYNC PASSWORD OPTRSYNC RETVAL
[d2b8d24]359
[791d013]360# Limpiamos los archivo de log
361echo  "" >$OGLOGCOMMAND;
362
[d2b8d24]363if [ "$*" == "help" ]; then
[6b0b68d]364        ogHelp  "$FUNCNAME": "$MSG_HELP_ogSyncCreate" \
365                "$FUNCNAME num_disk num_part [ REPO|CACHE ] image_name extension  " \
366                "$FUNCNAME 1 2 REPO Ubuntu12 img" \
367                "$FUNCNAME 1 1 CACHE Windows7 diff "
[d2b8d24]368        return
369fi
370
371
372if [ $# -lt 4 ]; then
373    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME  num_disk num_part [ REPO|CACHE ] image_name extension  "
374    return $?
375fi
376
[5962edd]377ORIG=$(ogMount $1 $2) || return $?
378
[654d744]379DIRMOUNT="$(ogGetMountImageDir "$4" $5)"
[e24b042]380# Si la imagen es diferencial la lista de ficheros a transferir esta dentro de la imagen.
[654d744]381if [ "$5" == "diff" ]; then
382        FILESFROM=" --files-from=/tmp/ogimg.info"
383        # Borramos los directorios
384        sed -i '/\/$/d' /tmp/ogimg.info
385else
386        FILESFROM=""
387fi
[d2b8d24]388
389if [ "$3" == "CACHE" -o "$3" == "cache" ]; then
390        DESTRSYNC="/tmp/$DIRMOUNT"
391else
392        [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
[097bc95]393        PASSWORD="--password-file=/scripts/passrsync"
394        [ "$ogrsyncz" ==  "true" ] && OPTRSYNC="z "
395        [ "$ogrsyncw" == "true" ] && OPTRSYNC="W$OPTRSYNC"
[d2b8d24]396        USERRSYNC="opengnsys"
397        DESTRSYNC="$USERRSYNC@$REPOIP::ogimages/$DIRMOUNT"
398fi
[1ee5d4d3]399# Sincronizamos los datos de la partición a la imagen
[ebc31ef5]400echo "      rsync -aHAX$OPTRSYNC --progress --inplace --delete $FILESFROM  $ORIG/ $DESTRSYNC"
[0b91489]401rsync -aHAX$OPTRSYNC $PASSWORD --progress --inplace --delete $FILESFROM  "$ORIG/" "$DESTRSYNC" 2>$OGLOGCOMMAND | egrep "^deleting|^sent|^sending|^total|%" |tee -a $OGLOGCOMMAND
402RETVAL=${PIPESTATUS[0]}
[ebc31ef5]403echo "      rsync -aHAX$OPTRSYNC --inplace /tmp/ogimg* $DESTRSYNC"
[791d013]404rsync -aHAX$OPTRSYNC  $PASSWORD  --inplace /tmp/ogimg* "$DESTRSYNC"
[d2b8d24]405
[0b91489]406return $RETVAL
[d2b8d24]407}
408
409
410#/**
411# ogSyncRestore
412#@brief   sincroniza los datos de la imagen a la partición para restaurarla.
413#@param 1 Repositorio  [ REPO | CACHE ]
414#@param 2 Nombre Imagen
[e24b042]415#@param 3 Tipo imagen [ img | diff ]
[d2b8d24]416#@param 4 num_disk
417#@param 5 num_part
418#*/
419function ogSyncRestore () {
[097bc95]420local DIRMOUNT ORIG DESTRSYNC PASSWORD OPTRSYNC USERRSYNC IMGINFO FILESFROM
[d2b8d24]421
[791d013]422# Limpiamos los archivo de log
423echo  "" >$OGLOGCOMMAND;
424
[d2b8d24]425if [ "$*" == "help" ]; then
[6b0b68d]426        ogHelp  "$FUNCNAME": "$MSG_HELP_ogSyncRestore" \
427                "$FUNCNAME [ REPO|CACHE ] image_name extension  num_disk num_part  " \
428                "$FUNCNAME REPO Ubuntu12 img 1 2" \
429                "$FUNCNAME CACHE Windows7 diff 1 1"
[d2b8d24]430        return
431fi
432
433
434if [ $# -lt 5 ]; then
435    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME  [ REPO|CACHE ] image_name extension   num_disk num_part "
436    return $?
437fi
438
439
[654d744]440DIRMOUNT="$(ogGetMountImageDir "$2" "$3")"
[d2b8d24]441DESTRSYNC=$(ogGetMountPoint $4 $5)
442
443# Borramos ficheros de informacion de restauraciones antiguas
444rm -rf $DESTRSYNC/ogimg.*
445
446# Origen y destino de la sincronizacion y en REPO opciones rsync
447if [ "$1" == "CACHE" -o "$1" == "cache" ]; then
448        ORIG="/tmp/$DIRMOUNT"
449else
450        [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
[097bc95]451        PASSWORD="--password-file=/scripts/passrsync"
452        [ "$ogrsyncz" ==  "true" ] && OPTRSYNC="z "
453        [ "$ogrsyncw" == "true" ] && OPTRSYNC="W$OPTRSYNC"
[d2b8d24]454        USERRSYNC="opengnsys"
455        ORIG="$USERRSYNC@$REPOIP::ogimages/$DIRMOUNT"
456fi
457
458# Opciones rsync en cache y repo
[e24b042]459# Para la imagen basica, opcion de borrar archivos de la particion que no existen en la imagen
[d2b8d24]460[ "$3" == "img" ] && [ "$ogrsyncdel" != "false" ] && OPTRSYNC="$OPTRSYNC --delete"
461
[1ee5d4d3]462# Nos traemos listado ficheros y bajamos la imagen
463
[ebc31ef5]464ogEcho log session "      $MSG_SYNC_RESTORE"
[d2b8d24]465
466# Si la imagen es diferencial nos traemos los archivos de informacion de la imagen.
467if [ "$3" == "diff" ]; then
468        # Lista de archivos a copiar:
469        IMGINFO="ogimg.info"
470        FILESFROM=" --files-from=$DESTRSYNC/$IMGINFO"
471
[ebc31ef5]472        echo "      rsync -aHAX$OPTRSYNC --progress  $ORIG/ogimg* $DESTRSYNC"
[791d013]473        rsync -aHAX$OPTRSYNC $PASSWORD --progress  "$ORIG"/ogimg* $DESTRSYNC
[d2b8d24]474        # Borramos linea de información de la imagen, sino busca un fichero con ese nombre
475        sed -i   '/^\#/d' $DESTRSYNC/$IMGINFO
476
477        cd $DESTRSYNC
[1ee5d4d3]478        # Diferencial: Borramos archivos sobrantes.
[ebc31ef5]479        ogEcho log session "      $MSG_SYNC_DELETE" 
[654d744]480        cat "$DESTRSYNC/ogimg.rm" 2>/dev/null | xargs rm -rf
[d2b8d24]481
482fi
483
[ebc31ef5]484echo "      rsync -aHAX$OPTRSYNC --progress  $FILESFROM  $ORIG/ $DESTRSYNC"
[0b91489]485rsync -aHAX$OPTRSYNC $PASSWORD --progress  $FILESFROM  "$ORIG/" "$DESTRSYNC"  2>$OGLOGCOMMAND | egrep "^deleting|^sent|^sending|^total|%"  |tee -a $OGLOGCOMMAND
486return ${PIPESTATUS[0]}
[d2b8d24]487
488}
489
490function ogMountImage () {
491#/**
492# ogMountImage
493#@brief   Monta la imagen para sincronizar.
494#@param 1 Repositorio  [ REPO | CACHE ]
495#@param 2 Nombre Imagen
[e24b042]496#@param 3 Tipo imagen [ img |diff ]
[1ee5d4d3]497#@return punto de montaje
[d2b8d24]498#*/
[332bbb1]499local IMGEXT IMGFILE DIRMOUNT KERNELVERSION
[d2b8d24]500
501if [ "$*" == "help" ]; then
[6b0b68d]502        ogHelp "$FUNCNAME": "$MSG_HELP_ogMountImage" \
503                "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \
504                "$FUNCNAME REPO Ubuntu12" \
505                "$FUNCNAME CACHE Windows7 diff"
506        return
[d2b8d24]507fi
508
509
510if [ $# -lt 2 ]; then
[5ccac26]511    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ]  image_name [ extension ]"
[d2b8d24]512    return $?
513fi
514
[e24b042]515[ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"
[d2b8d24]516
[654d744]517DIRMOUNT="$(ogGetMountImageDir "$2" ${IMGEXT#*\.})"
[1ee5d4d3]518
[1e3a1e2]519if [ "$1" == "REPO" -o "$1" == "repo" ]; then
520        [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
521        hose $REPOIP 2009 --out sh -c "echo -ne MOUNT_IMAGE \"$2\" ${IMGEXT#*\.}"
522        echo "$OGIMG/$DIRMOUNT"
523else
[f456755]524        # Si está montado nada que hacer.
525        df | grep "$DIRMOUNT$" 2>&1 >/dev/null && echo "/tmp/$DIRMOUNT" && return 0
526
[1e3a1e2]527        IMGFILE="$(ogGetPath "$1" /"$2.$IMGEXT")" \
528                || return $(ogRaiseError $OG_ERR_NOTFOUND "$1 $2.$IMGEXT"; echo $?)
[cd1f048]529        mkdir -p "/tmp/$DIRMOUNT"
[f456755]530       
531        # FS de la imagen segun la version del kernel: < 3.7 ext4, si >=  btrfs
[332bbb1]532        KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')
533        if [ $KERNELVERSION \< 3.7 ]; then
[f456755]534            mount -t ext4 -o loop "$IMGFILE" "/tmp/$DIRMOUNT" 1>/dev/null
535        else
536            mount -o compress=lzo  "$IMGFILE" "/tmp/$DIRMOUNT" 1>/dev/null
537        fi
538
539        # Comprobamos que se ha montado bien
[30ad471]540        [ $? -eq 0 ] || return $(ogRaiseError $OG_ERR_DONTMOUNT_IMAGE "$1 $2 $3"; echo $?)
[1ee5d4d3]541        echo "/tmp/$DIRMOUNT"
[d2b8d24]542fi
543
544}
545
546
[cd1f048]547
548
549
[d2b8d24]550function ogUnmountImage () {
551#/**
552# ogUnmountImage  [ REPO | CACHE ] Image_name [ extension ]
553#@brief   Desmonta la imagen para sincronizar.
554#@param 1 Repositorio  [ REPO | CACHE ]
555#@param 2 Nombre Imagen
[e24b042]556#@param 3 Tipo imagen [ img |diff ]
[d2b8d24]557#*/
[e24b042]558local IMGTYPE DIRMOUNT
[d2b8d24]559
560if [ "$*" == "help" ]; then
[6b0b68d]561    ogHelp "$FUNCNAME": "$MSG_HELP_ogUnmountImage" \
562                "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \
563                "$FUNCNAME REPO Ubuntu12" \
564                "$FUNCNAME CACHE Windows7 diff"
[d2b8d24]565    return
566fi
567
568if [ $# -lt 2 ]; then
[8361974]569    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME  [ REPO|CACHE ]  image_name [ extension ]"
[d2b8d24]570    return $?
571fi
572
[e24b042]573[ "$3" == "" ] && IMGTYPE="img" || IMGTYPE="$3"
[d2b8d24]574
575if [ "$1" == "CACHE" -o "$1" == "cache" ]; then
[654d744]576        DIRMOUNT="/tmp/$(ogGetMountImageDir "$2" $IMGTYPE)"
[d2b8d24]577        umount "$DIRMOUNT"
[8361974]578        rmdir "$DIRMOUNT"
[c8bbcdc]579        [ -f $IMGFILE.lock ] && sed -i s/"mounted"//g $IMGFILE.lock
[d2b8d24]580else
581        [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
[ebc31ef5]582        echo "      hose $REPOIP 2009 --out sh -c echo -ne UMOUNT_IMAGE \"$2\" $IMGTYPE"
[e24b042]583        hose $REPOIP 2009 --out sh -c "echo -ne UMOUNT_IMAGE \"$2\" $IMGTYPE"
[d2b8d24]584fi
585
586}
587
[baa5919]588function ogGetMountImageDir () {
[d2b8d24]589#/**
[baa5919]590# ogGetMountImageDir
[d2b8d24]591#@brief   Devuelve el directorio de montaje de la imagen.
592#@param 1 Nombre Imagen
[e24b042]593#@param 2 Tipo imagen [ img |diff ]
[d2b8d24]594#*/
595local DIRMOUNT
596if [ "$*" == "help" ]; then
[6b0b68d]597    ogHelp "$FUNCNAME": "$MSG_HELP_ogGetMountImageDir" \
598                "$FUNCNAME image_name [ extension ]" \
599                "$FUNCNAME Ubuntu12" \
600                "$FUNCNAME Windows7 diff"
[d2b8d24]601    return
602fi
603
604
605if [ $# -lt 1 ]; then
606    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME image_name [ extension ]"
607    return $?
608fi
609
610
611DIRMOUNT="mount/$1"
612[ "$2" == "diff" ] && DIRMOUNT="$DIRMOUNT.diff"
[654d744]613echo "$DIRMOUNT"
[d2b8d24]614
615
616}
617
618
619#/**
[c8bbcdc]620#  ogWaitSyncImage image_name extension stado imagen_size
[d2b8d24]621#@brief Se espera un tiempo a que se monte la imagen en el servidor.
622#@brief Cuando se esta creando la imagen hay que dar el tamaño, para que espere el tiempo de creación. 
623#@param 1 Respositorio [ REPO | CACHE ]
624#@param 2 Nombre Imagen
[e24b042]625#@param 3 Tipo imagen [ img | diff ]
[c8bbcdc]626#@param 4 Estado [ mounted | reduced ]
627#@param 5 Tamaño imagen (opcional)
[d2b8d24]628#*/
[c8bbcdc]629function ogWaitSyncImage () {
630local SIZE TIME DIRMOUNT TIMEOUT TIMEAUX LOCKFILE IMGDIR IMGEXT STATE
[d2b8d24]631
632TIME=$SECONDS
633
634# Ayuda o menos de 5 parametros y la imagen no es basica
635if [ "$*" == "help" ]; then
[6b0b68d]636        ogHelp  "$FUNCNAME": "$MSG_HELP_ogWaitMountImage" \
[c8bbcdc]637                "$FUNCNAME [ REPO | CACHE ] image_name extension state [ image_size ] " \
[6b0b68d]638                "$FUNCNAME REPO Ubuntu12 img 30000000" \
639                "$FUNCNAME CACHE Windows7 diff "
[d2b8d24]640        return
641fi
642
[c8bbcdc]643if [ $# -lt 4 ]; then
644    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO | CACHE ]  image_name extension state [ image_size ] "
[1e3a1e2]645    return $?
[d2b8d24]646fi
647
[c8bbcdc]648SIZE=${5:-"300000"}
649STATE="$4"
650ogCheckStringInGroup "$STATE" "mounted reduced" || \
651        return $(ogRaiseError  command $OG_ERR_FORMAT "STATE = [ mounted | reduced  ]" )
652
653IMGDIR="$(ogGetParentPath "$1" "/$2")"
654[ "$3" == "img" ] && IMGEXT="img" ||  IMGEXT="img.diff"
655LOCKFILE="${IMGDIR}/$(basename "/$2").$IMGEXT.lock"
[d2b8d24]656
657if [ "$1" == "CACHE" -o "$1" == "cache" ]; then
[baa5919]658        DIRMOUNT="/tmp/$(ogGetMountImageDir "$2" $3)"
[d2b8d24]659else
[baa5919]660        DIRMOUNT="$OGIMG/$(ogGetMountImageDir "$2" $3)"
[d2b8d24]661fi
662
[791d013]663echo -n -e "      $MSG_SYNC_SLEEP: $DIRMOUNT\n      #"  | tee -a $OGLOGSESSION $OGLOGFILE
[d2b8d24]664
[c8bbcdc]665# Comprobamos: mounted -> que exista $DIRMOUNT/ogimg.info o que el fichero de lock contenga mounted
666#              reduced -> que el fichero de lock contenga reduced.
667
[d2b8d24]668# time-out segun el tamaño de la imagen. por defecto: 100000k -> 3s
669let TIMEOUT=$SIZE/$CREATESPEED
670[ $TIMEOUT -lt 60 ] && TIMEOUT=60
[c8bbcdc]671until $(grep -i $STATE $LOCKFILE &>/dev/null) ; do
672        [ $STATE = "mounted" -a -f "$DIRMOUNT/ogimg.info" ] && ogEcho session "" && return 0
[d2b8d24]673        TIMEAUX=$[SECONDS-TIME]
[332bbb1]674        [  "$TIMEAUX" -lt "$TIMEOUT" ] || return $(ogRaiseError $OG_ERR_DONTMOUNT_IMAGE "$3 $4 $IMGEXT: time_out."; echo $?)
[791d013]675        echo -n "#"  | tee -a $OGLOGSESSION $OGLOGFILE
[d2b8d24]676        sleep 5
677done
[791d013]678echo  "" | tee -a $OGLOGSESSION $OGLOGFILE
[d2b8d24]679
680}
[cd1f048]681
[e24b042]682
[cd1f048]683function ogReduceImage () {
684#/**
685# ogReduceImage
686#@brief   Reduce el archivo de la imagen a tamaño datos + 500M
687#@param 1 Repositorio  [ REPO | CACHE ]
688#@param 2 Nombre Imagen
[e24b042]689#@param 3 Tipo Imagen [ img |diff ]
[cd1f048]690#@return
691#@exception OG_ERR_FORMAT     # 1 formato incorrecto.
692#@exception OG_ERR_NOTFOUND        # 2 Fichero o dispositivo no encontrado.
693#*/
[f456755]694local IMGEXT DIRMOUNT AVAILABLE USED IMGDIR IMGFILE ENDSIZE LOOPDEVICE
[cd1f048]695if [ "$*" == "help" ]; then
[6b0b68d]696    ogHelp "$FUNCNAME": "$MSG_HELP_ogReduceImage" \
697                "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \
698                "$FUNCNAME REPO Ubuntu12" \
699                "$FUNCNAME CACHE Windows7 diff"
[cd1f048]700    return
701fi
702
703if [ $# -lt 2 ]; then
704    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"
705    return $?
706fi
707
[f456755]708
[e24b042]709[ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"
[654d744]710IMGDIR="$(ogGetParentPath "$1" "/$2")"
711IMGFILE="${IMGDIR}/$(basename "/$2").$IMGEXT"
[f456755]712
713# Solo es posible para imagenes EXT4. Si no es EXT4 salimos sin error
[654d744]714file "$IMGFILE" | grep -i " ext4 filesystem " 2>&1 > /dev/null || return 0
[cd1f048]715
716if [ "$1" == "CACHE" -o "$1" == "cache" ]; then
717        # Al montar se comprueba la existencia de la imagen
[c8bbcdc]718        DIRMOUNT="$(ogMountImage $1 "$2" ${IMGEXT#*\.})"
[56b3a42]719        AVAILABLE=$(df -k|grep "$DIRMOUNT$"|awk '{print $4}')
[cd1f048]720        # Si el espacio libre menor que 500Mb nos salimos
[f456755]721        if [ $AVAILABLE -lt 200000 ]; then
[654d744]722                ogUnmountImage $1 "$2" ${IMGEXT#*\.}
[c8bbcdc]723                echo "reduced" > "$IMGFILE.lock"
[e24b042]724                return 0
725        fi
[cd1f048]726
[f456755]727        # Calculamos la diferencia entre el tamaño interno y externo
[654d744]728        EXTSIZE=$(ls -l --block-size=1024 "$IMGFILE" | cut -f5 -d" ")
[f456755]729        INTSIZE=$(df -k|grep "$DIRMOUNT"|awk '{print $2}')
730        let EDGESIZE=$EXTSIZE-$INTSIZE
[654d744]731        ogUnmountImage $1 "$2" ${IMGEXT#*\.}
[f456755]732        LOOPDEVICE=$(losetup -f)
733        losetup $LOOPDEVICE "$IMGFILE"
734
735        # Redimensiono sistema de ficheros
[ebc31ef5]736        echo "      resize2fs -fpM $LOOPDEVICE"
[f456755]737        resize2fs -fpM $LOOPDEVICE |tee -a $OGLOGCOMMAND
[c8bbcdc]738        ogMountImage $1 "$2" ${IMGEXT#*\.} >/dev/null
[f456755]739
740        # Calculamos el tamaño final del archivo
741        INTSIZE=$(df -k|grep "$DIRMOUNT"|awk '{print $2}')
742        let EXTSIZE=$INTSIZE+$EDGESIZE
[654d744]743        umount "$DIRMOUNT"
[f456755]744
745        # Si existe dispositivo de loop lo borro.
746        [ $LOOPDEVICE ] && losetup -d $LOOPDEVICE
747
748        # Corto el archivo al tamaño del sistema de ficheros.
[ebc31ef5]749        echo "      truncate --size=\"$EXTSIZE\"k $IMGFILE  "
[654d744]750        truncate --size="$EXTSIZE"k "$IMGFILE"
[f456755]751
[c8bbcdc]752        # Desmonto  la imagen
753        echo "reduced" > "$IMGFILE.lock"
[654d744]754        rmdir "$DIRMOUNT"
[f456755]755
[cd1f048]756else
[6d24524]757        [ -z $REPOIP ] && REPOIP=$(ogGetRepoIp)
[ebc31ef5]758        echo "      hose $REPOIP 2009 --out sh -c echo -ne REDUCE_IMAGE \"$2\" ${IMGEXT#*\.}"
[e24b042]759        hose $REPOIP 2009 --out sh -c "echo -ne REDUCE_IMAGE \"$2\" ${IMGEXT#*\.}"
[cd1f048]760fi
761
762
763}
764
765
766
[f456755]767function ogIsSyncImage () {
768#/**
769# ogIsSyncImage
770#@brief   Comprueba si la imagen es sincronizable
771#@param 1 Repositorio  [ REPO | CACHE ]
772#@param 2 Nombre Imagen
773#@param 3 Tipo Imagen [ img |diff ]
774#@return
775#@exception OG_ERR_FORMAT     # 1 formato incorrecto.
776#@exception OG_ERR_NOTFOUND        # 2 Fichero o dispositivo no encontrado.
777#*/
778local IMGEXT IMGDIR IMGFILE
779
780if [ "$*" == "help" ]; then
[6b0b68d]781    ogHelp "$FUNCNAME": "$MSG_HELP_ogIsSyncImage" \
782                "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \
783                "$FUNCNAME REPO Ubuntu12" \
784                "$FUNCNAME CACHE Windows7 diff"
[f456755]785    return
786fi
[cd1f048]787
[f456755]788if [ $# -lt 2 ]; then
789    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"
790    return $?
791fi
[cd1f048]792
[f456755]793[ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"
[654d744]794IMGDIR="$(ogGetParentPath "$1" "/$2")"
[f456755]795IMGFILE="${IMGDIR}"/$(basename "/$2").$IMGEXT
[cd1f048]796
[f456755]797file "$IMGFILE" | grep -i -e " BTRFS Filesystem " -e " ext4 filesystem " >/dev/null
798[ $? -eq 0 ] && return 0 || return $OG_ERR_DONTSYNC_IMAGE
[cd1f048]799
800
[f456755]801}
[6b0b68d]802
803#/**
804# ogCheckSyncImage
805#@brief   Muestra el contenido de la imagen para comprobarla.
806#@param 1 Repositorio  [ REPO | CACHE ]
807#@param 2 Nombre Imagen
808#@param 3 Tipo Imagen [ img |diff ]
809#@return
810#@exception OG_ERR_FORMAT     # 1 formato incorrecto.
811#@exception OG_ERR_NOTFOUND        # 2 Fichero o dispositivo no encontrado.
812#*/
[c8bbcdc]813function ogCheckSyncImage () {
[332bbb1]814local IMGEXT  IMGDIR  IMGFILE DIRMOUNT ISMOUNT RETVAL KERNELVERSION
[6b0b68d]815
816if [ "$*" == "help" ]; then
817    ogHelp "$FUNCNAME":  "$MSG_HELP_ogCheckSyncImage" \
818                "$FUNCNAME [ REPO|CACHE ] image_name [ extension ]" \
819                "$FUNCNAME REPO Ubuntu12" \
820                "$FUNCNAME CACHE Windows7 diff"
821    return
822fi
823
824if [ $# -lt 2 ]; then
825    ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $FUNCNAME [ REPO|CACHE ] image_name [ extension ]"
826    return $?
827fi
828
829[ "$3" == "" -o "$3" == "img" ] && IMGEXT="img" || IMGEXT="img.diff"
830IMGDIR="$(ogGetParentPath "$1" "/$2")"
831IMGFILE="${IMGDIR}/$(basename "/$2").$IMGEXT"
832
[1e3a1e2]833ogIsSyncImage $1 "$2" "${IMGEXT#*\.}" || return $(ogRaiseError $OG_ERR_DONTSYNC_IMAGE "$3 $4"; echo $?)
[6b0b68d]834
[332bbb1]835# Comprobamos que no esté montada (daria falso error)
836if [ "$1" == "CACHE" -o "$1" == "cache" ]; then
837        $(df | grep "/tmp/mount/$2${IMGEXT#img}$" &>/dev/null) && ISMOUNT=TRUE
838else
839        [ -f "$OGIMG/mount/$2${IMGEXT#img}/ogimg.info" ] && ISMOUNT=TRUE
840fi
841[ "$ISMOUNT" == TRUE ] && ogEcho session warning "$MSG_SYNC_NOCHECK" && return 0
842
[6b0b68d]843DIRMOUNT="/tmp/ogCheckImage$$"
844mkdir "$DIRMOUNT"
845# FS de la imagen segun la version del kernel: < 3.7 ext4, si >=  btrfs
[332bbb1]846KERNELVERSION=$(uname -r| awk '{printf("%d",$1);sub(/[0-9]*\./,"",$1);printf(".%02d",$1)}')
847if [ $KERNELVERSION \< 3.7 ]; then
[251c9e4]848        mount -t ext4 -o loop "$IMGFILE" "$DIRMOUNT" 2>&1 | tee -a $OGLOGCOMMAND
849        RETVAL=${PIPESTATUS[0]}
[6b0b68d]850else
[0b91489]851        mount -o compress=lzo  "$IMGFILE" "$DIRMOUNT" 2>&1 | tee -a $OGLOGCOMMAND
[251c9e4]852        RETVAL=${PIPESTATUS[0]}
[6b0b68d]853fi
[791d013]854ls -C "$DIRMOUNT" | tee -a $OGLOGCOMMAND
[251c9e4]855umount "$DIRMOUNT"
[6b0b68d]856
857rmdir "$DIRMOUNT"
[251c9e4]858return $RETVAL
[6b0b68d]859}
Note: See TracBrowser for help on using the repository browser.