source: client/engine/Rsync.lib @ fe6843b

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 fe6843b was dfcc55a, checked in by ramon <ramongomez@…>, 10 years ago

Versión 1.1: Integrar últimos cambios.

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