source: client/engine/Rsync.lib @ 64f4ada

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 64f4ada was 1a2fa9d8, checked in by ramon <ramongomez@…>, 10 years ago

#673: Actualizar código incluido en OepnGnSys? 1.0.6 sobre la rama version1.1 para desarrollar la nueva versión.

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