blob: c2905ab3c0a7134d599e08d0d97b2eb999f04458 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
#!/bin/bash
#/**
# createDiffImage
#@brief Script de ejemplo para crear una imagen diferencial de un sistema de archivos.
#@brief (puede usarse como base para el programa de creación de imágenes usado por OpenGnSys Admin).
#@param 1 disco
#@param 2 particion
#@param 3 REPO|CACHE
#@param 4 imagen_completa
#@param 5 imagen_diferencial
#@return
#@exception OG_ERR_FORMAT # 1 formato incorrecto.
#@exception OG_ERR_PARTITION # 3 Error en partición de disco o en su sistema de archivos
#@exception OG_ERR_NOTFOUND # Fichero de registro no encontrado.
#@exception OG_ERR_IMAGE # 5 Error en funcion ogCreateImage o ogRestoreImage.
#@exception OG_ERR_NOTWRITE # 14 error de escritura
#@exception OG_ERR_NOTCACHE # 15 si cache no existe 15
#@exception OG_ERR_CACHESIZE # 16 si espacio de la cache local o remota no tiene espacio 16
#@exception OG_ERR_LOCKED # 4 Partición o fichero bloqueado.
#@exception OG_ERR_DONTMOUNT_IMAGE # 70 Error al montar una imagen sincronizada.
#@exception OG_ERR_DONTSYNC_IMAGE # 71 Imagen no sincronizable (es monolitica)
#@note Se toma como punto de partida el script createImage.
#@todo: que hacer, si el tamaño de la cache es sufciente, pero no tiene espacio libre
#@version 1.0 - creacion de la diferencial con rsync y btrfs
#@author
#@date 2012-12-04
#*/ ##
trap "onexit $1 $2 $3 \"$4\" \"$5\"" 1 2 3 6 9 14 15 ERR
# Establecemos factor de compresion
# !!! Se configura en las lineas 122 y 128.
function onexit() {
local exit_status=$?
echo "$MSG_ERR_GENERIC $exit_status" |tee -a $OGLOGFILE $OGLOGSESSION
ogUnmountImage $3 "$5" $DIFFTYPE &>/dev/null
ogUnmountImage $3 "$4" $IMGEXT &>/dev/null
if [ $exit_status -ne 4 ]; then
ogUnlockImage "$3" "/$4.$IMGEXT" &>/dev/null
ogUnlockImage "$3" "/$5.$DIFFEXT" &>/dev/null
ogUnlock $1 $2 &>/dev/null
fi
exit $exit_status
}
#Carga el configurador del engine desde el fichero engine.cfg
[ -z $OGENGINECONFIGURATE ] && source /opt/opengnsys/etc/engine.cfg
# Factor de calculo de Time out al crear imagen: valor por defecto en engine.cfg
CREATESPEED=${CREATESPEED:-"100000*4"}
# Sistema de fichero de la imagen según kernel, menor que 3.7 EXT4. comparamos revision
[ $(uname -r|cut -d. -f2) -lt 7 ] && IMGFS="EXT4" || IMGFS="BTRFS"
TIME1=$SECONDS
PROG="$(basename $0)"
# Si se solicita, mostrar ayuda.
if [ "$*" == "help" ]; then
ogHelp "$PROG: $MSG_HELP_createDiffImage" \
"$PROG ndisco nparticion REPO|CACHE base_image diff_image" \
"$PROG 1 1 REPO Windows7 Win7aula23"
exit 0
fi
[ $# -lt 5 ] && ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $PROG ndisco nparticion REPO|CACHE base_image diff_image"
# Valores por defecto en etc/engine.cfg
IMGEXT="img"
DIFFEXT="img.diff"
DIFFTYPE="diff"
echo "[1] $MSG_SCRIPTS_START $0 $*" | tee -a $OGLOGSESSION $OGLOGFILE
# Comprobamos si la imagen diferencial o la particion estan bloqueada:
ogIsImageLocked "$3" "$5.$DIFFEXT" && ogRaiseError $OG_ERR_LOCKED "$3 $5.$DIFFEXT"
ogIsLocked "$1" "$2" && ogRaiseError $OG_ERR_LOCKED "$1 $2"
# Comprobar si la imagen completa existe.
IMGFILE=$(ogGetPath "$3" "$4.$IMGEXT") || ogRaiseError $OG_ERR_NOTFOUND "$3 $4.$IMGEXT"
# Comprobar que la imagen completa es sincronizable
ogIsSyncImage "$3" "$4" "img" || ogRaiseError $OG_ERR_DONTSYNC_IMAGE "$3 $4"
# Comprobar que no está bloqueada
ogIsImageLocked "$3" "$4.$IMGEXT" && ogRaiseError $OG_ERR_LOCKED "$3 $4.$IMGEXT"
echo " " > $OGLOGCOMMAND
# Si el repositorio es CACHE comprobamos que exista
if [ "$3" == "CACHE" -o "$3" == "cache" ]; then
! ogFindCache >/dev/null && ogRaiseError $OG_ERR_NOTCACHE "CACHE "
fi
echo " " > $OGLOGCOMMAND
# Obtener información de los parámetros de entrada.
PART=$(ogDiskToDev "$1" "$2" 2>/dev/null) || ogRaiseError $OG_ERR_PARTITION "$1 $2"
#Comprobamos que la partición se puede montar.
ORIG=$(ogMount $1 $2) || ogRaiseError $OG_ERR_PARTITION "$1 $2"
#Comprobamos acceso de escritura.
DIRTEMP=$(date +%Y%m%d-%H%M%S)
ogMakeDir $3 /$4$DIRTEMP 2>/dev/null || ogRaiseError $OG_ERR_NOTWRITE "$3" && ogDeleteTree $3 /$4$DIRTEMP
DIFFDIR="$(ogGetParentPath "$3" "/$5")"
DIFFFILE="$DIFFDIR/$5.$DIFFEXT"
ogLockImage "$3" "/$4.$IMGEXT"
ogLockImage "$3" "/$5.$DIFFEXT"
LOOPDEVICE=$(losetup -f)
# Comprobar consistencia del sistema de archivos.
echo " " > $OGLOGCOMMAND
SIZEFS=$(ogGetFsSize $1 $2)
echo "[20] $MSG_HELP_ogCheckFs $1 $2 $SIZEFS (KB) " | tee -a $OGLOGSESSION $OGLOGFILE
ogUnmount $1 $2
ogCheckFs $1 $2 >$OGLOGCOMMAND || ogRaiseError $OG_ERR_PARTITION "ogCheckFs $1 $2"
TIMEAUX1=$[SECONDS-TIME1]
echo " $MSG_SCRIPTS_TASK_END, $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX1/60]m $[TIMEAUX1%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
# Borramos ficheros de paginacion y configuracion
# Establecemos factor de compresion, varia segun el sistema operativo y el kernel.
case "$(ogGetFsType $1 $2)" in
EXT[234])
ogCleanLinuxDevices $1 $2
rm -rf $ORIG/tmp/*
# Compresion linux && ext4 || btrfs
[ $IMGFS == "EXT4" ] && COMPRESS=110/100 || COMPRESS=80/100
;;
NTFS)
[ $(ogGetPath $1 $2 pagefile.sys) ] && ogDeleteFile $1 $2 pagefile.sys
[ $(ogGetPath $1 $2 hiberfil.sys) ] && ogDeleteFile $1 $2 hiberfil.sys
# Compresion windows && ext4 || btrfs
[ $IMGFS == "EXT4" ] && COMPRESS=130/100 || COMPRESS=90/100
;;
esac
# Crear la imagen.
echo " " > $OGLOGCOMMAND
TIME2=$SECONDS
echo "[40] $MSG_HELP_createDiffImage: $1 $2 $3 $4" | tee -a $OGLOGSESSION $OGLOGFILE
# Creamos la lista del contenido y lo situamos en la particion a copiar.
FSTYPE=$(ogGetFsType $1 $2)
IMGDIRAUX=$(ogGetMountDir "$4" $IMGEXT)
# Montamos imagen completa (con la que vamos a comparar)
ogMountImage $3 "$4" $IMGEXT >/dev/null
# Comprobar que la imagen completa se ha montado
ogWaitMountImage $3 "$4" $IMGEXT || ogRaiseError $OG_ERR_DONTMOUNT_IMAGE "$3 $4 $IMGEXT: time_out."
# Creamos la informacion de la imagen.
echo "[50] $MSG_HELP_ogCreateInfoImage " | tee -a $OGLOGSESSION $OGLOGFILE
ogCreateInfoImage $1 $2 $3 "$4" "${DIFFTYPE}"
TIMEAUX3=$[SECONDS-TIME2]
echo " $MSG_SCRIPTS_TASK_END $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX3/60]m $[TIMEAUX3%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
# Del fichero de acl de la partición extraemos las acl de los ficheros de la diferencial
echo "[60] $MSG_HELP_ogAclFilter " | tee -a $OGLOGSESSION $OGLOGFILE
ogAclFilter
TIMEAUX5=$[SECONDS-TIMEAUX3]
echo " $MSG_SCRIPTS_TASK_END $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX5/60]m $[TIMEAUX5%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
#Calculamos el tamaño de la imagen:
ogMount $1 $2 >/dev/null
ogLock $1 $2
echo -n " $MSG_SCRIPTS_CREATE_SIZE" | tee -a $OGLOGSESSION $OGLOGFILE
cd $ORIG
SIZEDATA=$(cat /tmp/ogimg.info | tr '\n' '\0'| du -c --files0-from=- 2>/dev/null|tail -n1 |cut -f1)
let SIZEREQUIRED=$SIZEDATA*$COMPRESS
# Tamaño minimo fichero imagen 300000
[ $SIZEREQUIRED -lt 300000 ] && SIZEREQUIRED=300000
# Comprueba que quepa en el repositorio
[ "$3" == "CACHE" -o "$3" == "cache" ] && SIZEFREE=$(ogGetFreeSize `ogFindCache`) && ogMountCache >/dev/null
[ "$3" == "REPO" -o "$3" == "repo" ] && SIZEFREE=$(df -k | grep $OGIMG | awk '{print $4}')
echo " $SIZEREQUIRED $SIZEFREE" | tee -a $OGLOGSESSION $OGLOGFILE
[ $SIZEREQUIRED -gt $SIZEFREE ] && ogRaiseError $OG_ERR_CACHESIZE "$3"
# Configuro la informacion del tamaño de los datos en /tmp/ogimg.info
sed -i s/SIZEDATA/"$SIZEDATA"/g /tmp/ogimg.info
# Creamos o redimensionamos la imagen
echo "[70] $MSG_HELP_ogCreateFileImage." | tee -a $OGLOGSESSION $OGLOGFILE
ogCreateFileImage $3 "$5" $DIFFTYPE $SIZEREQUIRED
# Esperamos que se monte la imagen despues de crarla en el servidor
ogWaitMountImage "$3" "$5" "$DIFFTYPE" $SIZEREQUIRED || ogRaiseError $OG_ERR_DONTMOUNT_IMAGE "$3 $5 $DIFFTYPE: time_out."
TIMEAUX6=$[SECONDS-TIMEAUX5]
echo -e " $MSG_SCRIPTS_TASK_END, $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX6/60]m $[TIMEAUX6%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
echo "[80] $MSG_HELP_ogSyncCreate" | tee -a $OGLOGSESSION $OGLOGFILE
# Copio los datos a la imagen diferecial :
ogSyncCreate $1 $2 $3 "$5" $DIFFTYPE
# Reducimos la imagen diferencial -> solo para kernel <= 3.7, imagenes con FS ext4
echo "[90] $MSG_HELP_ogReduceImage: $3 /$4.$IMGEXT" | tee -a $OGLOGSESSION $OGLOGFILE
ogReduceImage $3 "$5" $DIFFTYPE
# Desmontamos las imagenes
ogUnmountImage $3 "$5" $DIFFTYPE
ogUnmountImage $3 "$4" $IMGEXT
TIMEAUX7=$[SECONDS-TIMEAUX6]
echo " $MSG_SCRIPTS_TASK_END, $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX7/60]m $[TIMEAUX7%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
TIMEAUX8=$[SECONDS-TIME2]
echo " $MSG_SCRIPTS_TIME_PARTIAL : $[TIMEAUX8/60]m $[TIMEAUX8%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
ogUnlockImage "$3" "/$4.$IMGEXT"
ogUnlockImage "$3" "/$5.$DIFFEXT"
ogUnlock $1 $2
# Comprobamos que la imagen esta bien
ogIsSyncImage $3 "$5" diff || ogRaiseError $OG_ERR_IMAGE "$3 $5"
#resumen de la operacion
IMGSIZE=$(ls -l --block-size=1024 ${DIFFFILE}| cut -f5 -d" ")
TIME=$[SECONDS-TIME1]
echo "[100] $MSG_SCRIPTS_TIME_TOTAL $[TIME/60]m $[TIME%60]s" | tee -a $OGLOGSESSION $OGLOGFILE
echo " FileSystem $PART with $SIZEDATA KB data created onto file-image as $5 and used $IMGSIZE KB acros DFS rsync " | tee -a $OGLOGSESSION $OGLOGFILE
|
