summaryrefslogtreecommitdiffstats
path: root/client/shared/scripts/createBaseImage
blob: 50e419527ad18c26bdbd53279dfae4827bbec886 (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
#!/bin/bash

#/**
#         createBaseImage
#@brief   Script de ejemplo para crear una imagen 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
#@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_LOCKED     # 4 Imagen o particion bloqueada
#@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_DONTMOUNT_IMAGE # 70 Error al montar una imagen sincronizada
#@note  se toma como punto de partida el script createImage, cambiando solo lo especifico para la imagen sincronizada
#@todo: que hacer, si el tamaño de la cache es sufciente, pero no tiene espacio libre
#@version 1.0 - creación imagen con btrfs
#@author  
#@date   2012-12-04
#*/ ##

trap "onexit $1 $2 $3 \"$4\"" 1 2 3 6 9 14 15 ERR

# Si salimos con error demontamos la imagen y desbloqueamos la imagen y la particion
function onexit() {
    local exit_status=$?
    echo -e  "\n $PROG error ${MSG_INTERFACE_END#*\]} $exit_status"  |tee -a $OGLOGFILE  $OGLOGSESSION
    ogUnmountImage $3 "$4" $IMGEXT &>/dev/null
    if [ $exit_status -ne 4 ]; then
	ogUnlockImage "$3" "/$4.$IMGEXT" 
	ogUnlock $1 $2
    fi
    exit $exit_status
}

TIME1=$SECONDS
#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"
# % de compresion para estimacion tamaño imagen IMGFS="EXT4"
ZSYNC=${ZSYNC:-"120"}

# Si IMGFS="BTRFS" la compresion es mayor.
[ $IMGFS == "BTRFS" ] && let ZSYNC=$ZSYNC-30

PROG="$(basename $0)"
# Si se solicita, mostrar ayuda.
if [ "$*" == "help" ]; then
    ogHelp  "$PROG: $MSG_HELP_createBaseImage" \
	    "$PROG ndisco nparticion REPO|CACHE base_image" \
            "$PROG 1 1 REPO Windows7"
    exit 0
fi

[ $# -ne 4 ] && ogRaiseError $OG_ERR_FORMAT "$MSG_FORMAT: $PROG ndisco nparticion REPO|CACHE imagen" 


# Limpiamos fichero de log
echo  " " > $OGLOGCOMMAND
[ "$(ogGetCaller)" == "RestaurarImagenBasica" ] || echo  -n ""> $OGLOGSESSION

echo "[1] $MSG_SCRIPTS_START $0 $*" | tee -a $OGLOGSESSION  $OGLOGFILE

# Valores por defecto en etc/engine.cfg
IMGEXT="img"
REPOIP=$(ogGetRepoIp)


# Comprobamos si la imagen o la particion estan bloqueada:
ogIsImageLocked "$3" "$4.$IMGEXT" && ogRaiseError $OG_ERR_LOCKED "$3 $4.$IMGEXT"
ogIsLocked "$1" "$2" && ogRaiseError $OG_ERR_LOCKED  "$1 $2"

# Si el repositorio es CACHE comprobamos que exista
if [ "$3" == "CACHE" -o "$3" == "cache" ]; then 
	! ogFindCache >/dev/null && ogRaiseError $OG_ERR_NOTCACHE "CACHE "
fi

#Comprobamos acceso de escritura.
DIRTEMP="/$4$(date +%Y%m%d-%H%M%S)"
ogMakeDir $3 "$DIRTEMP" 2>/dev/null || ogRaiseError $OG_ERR_NOTWRITE "$3" && ogDeleteTree $3 "$DIRTEMP" 

# Obtener información de los parámetros de entrada.
PART=$(ogDiskToDev "$1" "$2" 2>/dev/null) || ogRaiseError $OG_ERR_PARTITION "$1 $2"
# Comprobar consistencia del sistema de archivos.
echo " " > $OGLOGCOMMAND
SIZEFS=$(ogGetFsSize  $1 $2)
echo "[20] $MSG_HELP_ogCheckFs  $PART $SIZEFS (KB) " | tee -a $OGLOGSESSION $OGLOGFILE
ogUnmount $1 $2
ogCheckFs $1 $2 &> $OGLOGCOMMAND || ogRaiseError $OG_ERR_PARTITION "ogCheckFs $1 $2"

# Comprobamos que la particion se puede montar
ORIG=$(ogMount $1 $2) || ogRaiseError $OG_ERR_PARTITION "$1 $2"


# Borramos ficheros de paginacion y configuracion
case "$(ogGetFsType $1 $2)" in 
    EXT[234])
	ogCleanLinuxDevices $1 $2
	rm -rf $ORIG/tmp/*
	;;
    NTFS)
	[ $(ogGetPath $1 $2 pagefile.sys) ] && ogDeleteFile $1 $2 pagefile.sys
	[ $(ogGetPath $1 $2 hiberfil.sys) ] && ogDeleteFile $1 $2 hiberfil.sys	
	[ $(ogGetPath $1 $2 swapfile.sys) ] && ogDeleteFile $1 $2 swapfile.sys 
	;;
esac


#Comprobar espacio que requerira la imagen para ser almacenada
SIZEDATA=$(df -k | grep $PART | awk '{print $3}')
#Aplicar factor de compresion
let SIZEREQUIRED=$SIZEDATA*$ZSYNC/100
# El tamaño mínimo del sistema de ficheros btrfs es 250M, ponemos 300
[ $SIZEREQUIRED -lt 300000 ] && SIZEREQUIRED=300000
#Comprobar espacio libre en el contenedor.
[ "$3" == "CACHE" -o "$3" == "cache" ] && SIZEFREE=$(ogGetFreeSize `ogFindCache`)
[ "$3" == "REPO"  -o "$3" == "repo"  ] && SIZEFREE=$(df -k | grep $OGIMG | awk '{print $4}')
echo "      $MSG_SCRIPTS_CREATE_SIZE  $SIZEREQUIRED $SIZEFREE" | tee -a $OGLOGSESSION $OGLOGFILE
[ $SIZEREQUIRED -gt $SIZEFREE ] && ogRaiseError $OG_ERR_CACHESIZE "$3"

IMGDIR="$(ogGetParentPath "$3" "/$4")"
IMGFILE=${IMGDIR[$3]}/$(basename "/$4").$IMGEXT


# Crear la imagen.
echo " " > $OGLOGCOMMAND
TIME2=$SECONDS

ogLockImage "$3"  "/$4.$IMGEXT"

echo "[40] $MSG_HELP_ogCreateImage $1 $2 $3 $4 " | tee -a $OGLOGSESSION $OGLOGFILE
# Si existe el fichero de la imagen se hace copia de seguridad y se redimensiona, si  no existe se crea.
echo "[50] $MSG_HELP_ogCreateFileImage." | tee -a $OGLOGSESSION $OGLOGFILE
ogCreateFileImage $3 "$4" $IMGEXT $SIZEREQUIRED

# Creamos la lista del contenido y lo situamos en la particion a copiar.
echo "[60] $MSG_HELP_ogCreateInfoImage"  | tee -a $OGLOGSESSION $OGLOGFILE
ogCreateInfoImage $1 $2 $IMGEXT

TIMEAUX3=$[SECONDS-TIME2]
echo "      $MSG_SCRIPTS_TASK_END, $MSG_SCRIPTS_TIME_PARTIAL : $[TIMEAUX3/60]m $[TIMEAUX3%60]s" | tee -a $OGLOGSESSION $OGLOGFILE

# Esperamos que el servidor termine de crear y montar la imagen
ogWaitMountImage "$3" "$4" $IMGEXT $SIZEREQUIRED 

# Sincronizamos los datos de la particion con la imagen.
echo "[70] $MSG_HELP_ogSyncCreate."  | tee -a $OGLOGSESSION $OGLOGFILE
ogSyncCreate $1 $2 $3 "$4"  $IMGEXT

TIMEAUX5=$[SECONDS-TIMEAUX3]
echo "      $MSG_SCRIPTS_TASK_END, $MSG_SCRIPTS_TIME_PARTIAL: $[TIMEAUX5/60]m $[TIMEAUX5%60]s" | tee -a $OGLOGSESSION $OGLOGFILE

# Reducimos la imagen: solo para kernel <= 3.7, imagenes con FS ext4.
echo "[80] $MSG_HELP_ogReduceImage: $3 /$4.$IMGEXT" | tee -a $OGLOGSESSION $OGLOGFILE
ogReduceImage $3 "$4" $IMGEXT

# Desmontamos la Imagen
ogUnmountImage $3 "$4" $IMGEXT
ogUnlockImage "$3" "/$4.$IMGEXT"
ogUnlock $1 $2

echo  " " > $OGLOGCOMMAND
# Comprobamos que la imagen esta bien detectacdo que es un sistema de ficheros.
echo "[95] $MSG_HELP_ogCheckSyncImage" | tee -a $OGLOGSESSION $OGLOGFILE
ogCheckSyncImage $3 "$4" "img" 
[ $? -eq 0 ] || ogRaiseError $OG_ERR_IMAGE "$3 $4 img" 


#resumen de la operacion
IMGSIZE=$(ls -l --block-size=1024 "$IMGFILE" | 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 $4 and used $IMGSIZE KB acros DFS rsync " | tee -a $OGLOGSESSION $OGLOGFILE