source: client/engine/Rsync.lib @ 501e543

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 501e543 was 1cacd3f, checked in by irina <irinagomez@…>, 11 years ago

#657 sincronizadas tipo archivo: errata Rsync.lib

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