source: client/engine/Rsync.lib @ a63fc89

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

#657 sincronizadas tipo archivo: se permite configurar el sistema de fichero por defecto de la imagen

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