source: client/engine/Rsync.lib

qndtest
Last change on this file was a5ed410, checked in by Ramón M. Gómez <ramongomez@…>, 4 years ago

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