source: client/engine/Rsync.lib @ d1795da

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 d1795da was c4db9c1, checked in by irina <irinagomez@…>, 11 years ago

#565 Se crea codigo y mensaje de error para los problemas de transferencia de rsync.

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