[[TOC(heading=Índice)]]
= Página en construcción: 13 enero 2013 =
= Sincronización de imágenes con Btrfs o ext4 =
== Introducción ==
Hasta ahora Opengnsys permite crear un archivo imagen de una partición completa que luego puede clonarse en otra. Estas imágenes hay que tratarlas como un todo y no permiten ver su contenido.


Con la sincronización de imágenes pretendemos:
 * comparar la imagen con el contenido de la partición y sólo copiar o borrar los archivos que difieran. 
 * comparar la imagen con el contenido de la partición y crear una imagen diferencial con los archivos que difieran y la información de los archivos que sobran, de forma que al restaurar primero la imagen completa y luego la diferencial la partición destino quede como la del equipo modelo.

La sincronización de imágenes se introducirá en la versión 1.0.5 en modo de prueba. Tenemos dos aproximaciones diferentes que denominamos SYNC1 y SYNC2 la diferencia principal es que la versión 1 guarda los datos de las imágenes en un directorio del servidor y la versión 2 lo empaqueta en un archivo que contiene un sistema de ficheros, según el kernel del cliente de opengnsys será ext4 o btrfs.

Estos sistemas de ficheros son de lectura y escritura, por lo que nos permite modificar la imagen una vez creada. Además el btrfs permite montarlo en modo comprimido, de forma que la compresión y descompresión se realiza de modo transparente para el usuario.

En esta página vamos a documentar los procedimientos que se utilizan en la versión sync2, aunque si se van a hacer pruebas es mejor instalar la versión 1.0.5 o utilizar los script bajados del proyecto.

'''Procedimiento'''

Creamos imágenes (en cache o repo). Creamos un archivo vacío, lo montamos en modo loop y creamos dentro de él un sistema de ficheros. Montamos el sistema de fichero y clonamos dentro con los datos de la partición sincronizandolos con rsync.

Para restaurar montaremos la imagen (en cache o repo) y utilizaremos rsync para sincronizar la partición. La partición puede estar vacía o haber sido restaurada y luego modificada por el uso.

Para windows restauraremos las ACL con ntfs-3g.secaudit

En el servidor puedo montar la imagen y modificar, borra o añadir los archivos que queramos.


'''Problemas conocidos.''' 

Al crear la imagen en el servidor hay veces que no se monta bien, la sincronización se realiza sobre el directorio de montaje y la imagen queda vacía. Al restaurar se monta la imagen sobre el directorio y no tiene datos. Es muy importante comprobar el contenido de la imagen.

Al restaurar la cache no se pueden mostrar log, si ponemos esta opción a rsync se cuelga el equipo. Esto pasaba con las imágenes en squash, no se ha vuelto a probar con las que son en ext4 o btrfs.

Al crear la imagen se hace una estimación del tamaño delos datos para crear el archivo vacío inicial, al terminar se reduce hasta el tamaño real que ocupan los datos. Esto funciona bien en ext4, pero en btrfs no se puede hacer porque el comando que trae la distribución da error muy a menudo.

La transferencia de la imagen con formato ext4 y btrfs a través de la red ha ido bien con multicast, unicast y rsync. No se ha probado con torrent.

== Crear una imagen tipo ext4 o btrfs ==
La imagen será un archivo con un sistema de fichero que contenga los datos de la partición. 

Creamos el archivo vacío:
{{{
dd if=/dev/zero of=$IMGFILE bs=1024 count=$SIZEREQUIRED
}}}

IMGFILE: nombre archivo imagen.\\
SIZEREQUIRED: tamaño de la imagen en kilobytes.



Detectamos cual es el kernel para elegir el sistema de ficheros a utilizar. Si es menor que 3.7 usamos ext4, si es mayor o igual btrfs:
{{{
KERNEL=$(file $BASEDIR/tftpboot/ogclient/ogvmlinuz |awk -F . '{print $2}')
[ $KERNEL -lt 7 ] && IMGFS="EXT4" || IMGFS="BTRFS"
}}}


Creamos el sistema de ficheros:
{{{
LOOPDEVICE=$(losetup -f)
if [ $IMGFS == "EXT4" ]; then
      losetup $LOOPDEVICE "$IMGNAME.img"
      resize2fs -f $LOOPDEVICE &> $REPOLOG
else
      mount -o compress=lzo  "$IMGNAME.img" "$DIRMOUNT"
      btrfs filesystem resize max "$DIRMOUNT"  2>&1 > $REPOLOG
fi
}}}

Para guardar la información de la imagen (como tenemos en partclone: tipo de sistema operativo, tamaño, archivos de que contiene, ...) necesitaremos incluir uno o varios archivos en el sistema de fichero original antes de realizar la creación.


=== Sincronización imagen ===

Montamos la imagen y la partición que queremos clonar y sincronizamos tomando como origen la partición. 

Montamos la imagen. En el servidor:
{{{
if [ $IMGFS == "EXT4" ]; then
     mount $OPTMOUNT -t ext4 $1 $2
else
     mount $OPTMOUNT -o compress=lzo  "$1" "$2"
fi
}}}

OPTMOUNT: ro cuando restauramos, vacío al crearla, ya que por defecto es de lectura y escritura.

Montamos la partición, en el cliente:
{{{
ogMount 1 X
}}}

# Creamos la lista del contenido.

{{{
mkdir /tmp/vacio
# Creamos la lista del contenido y lo situamos en la particion a copiar.
rsync -aHvn --delete /mnt/sdaX/ /tmp/vacio > /tmp/ogimg.lista
}}}

Sólo para windows: creamos la lista de acl:

{{
# Desmontamos la particion
ogUnmount 1 X 
# Guardamos las ACL:
ntfs-3g.secaudit -b /dev/sdaX / > /tmp/ogimg.acl
# Montamos la partición para seguir el proceso.
ogMount 1 X

# Sincronizamos la imagen desde la partición.

{{{
rsync -aHAX$OPTRSYNC --inplace --delete  /mnt/sdaX/ "opengnsys@$REPOIP::ogimages/mount/$IMGNAME"

# Guardamos la lista del contenido y las acl si existen:
rsync -aHAX$OPTRSYNC --inplace /tmp/ogimg.* opengnsys@$REPOIP::ogimages/mount/$IMGNAME *
}}}

* Utilizamos el servicio de rsync en el servidor, ya que cuando utilizamos rsync sobre samba va peor. La configuración se explica abajo.

Desmontamos la imagen. En el servidor:
{{{
umount /opt/opengnsys/images/mount/$IMGNAME
}}}


== Restaurar - Sincronizar de la imagen tipo ext4 o btrfs ==

La imagen puede estar en la cache o en repo.

Montamos la imagen:
Montamos la imagen. En el servidor:

{{{
# Creamos el punto de montaje:
mkdir /opt/opengnsy/images/mount/$IMGNAME

# Montamos la imagen:
if [ $IMGFS == "EXT4" ]; then
     mount -o ro -t ext4 $IMGNAME.img /opt/opengnsy/images/mount/$IMGNAME
else
     mount -o ro,compress=lzo  "$IMGNAME.img" "/opt/opengnsy/images/mount/$IMGNAME"
fi
}}}

Montamos la partición, en el cliente:
{{{
ogMount 1 X
}}}

Sincronizamos la partición tomando como origen la imagen. La partición puede estar vacía o haber sido restaurada con anterioridad y sólo hay que restaurar las modificaciones que haya hecho por el uso.

{{{
rsync -aHAXq$OPTRSYNC --password-file=/passrsync  opengnsys@$REPOIP::ogimages/mount/$IMGNAME /mnt/sdaX
}}}

Sólo para windows restauramos las ACL:

{{{
# Copiamos las acl a /tmp
cp //mnt/sdaX/ogimg.acl /tmp

# Desmontamos la partición:
ogUnmount 1 X

# Restauramos las acl:
ntfs-3g.secaudit -se /dev/sdaX /tmp/ogimg.acl
}}}


== Nueva versión por aquí ==

== Opciones rsync ==
/ la barra en el directorio de origen hace que transfiera el contenido del directorio al directorio destino (si no la ponemos copia también el directorio)

-a, --archive  modo archivo: igual que -rlptgoD (no -H,-A,-X) conserva los enlaces simbólicos, dispositivos, permisos  y propietario.             

-q –quiet: no muestra mensajes que no sean errores. Si no se pone a veces se cuelga el equipo.

--delete  Borra los ficheros que no existían en el original

-A preserva ACLs

-X preserva atributos extendidos (como los de Selinux)

-H preserva enlaces “duros”

-n realiza la prueba pero no hace cambios, nos sirve para crear el listado.



No utilizamos:

-z, --compress Comprime el fichero en la transferencia → no: tanto en cache como repo va más lento

-v, --verbose  : Muestra todos los archivos que se van copiando) → cuelga el equipo.

--progress: muestra los archivos y el progreso → cuelga el equipo.

-g preserva grupo (incluido en a)

-o preserva propietario (incluido en a)

== Crear una imagen diferencial ==

'''Definición de imagen diferencial: '''

Supongamos que tenemos una imagen completa y la hemos restaurado en un equipo que hará de modelo. Instalamos una serie de programas. 

Llamaremos imagen diferencial de una completa a la que contengan los archivos nuevos y la información de los archivos que sobran, de forma que al restaurar primero la imagen completa y luego la diferencial la partición destino quede como la del equipo modelo.


'''Procedimiento'''
 * Se monta la imagen completa y se compara el contenido de la partición con la imagen: Se crea la lista de las diferencias con rsync
 * Se trata la lista de diferencias: se separan los archivos a copiar, a borrar y los enlaces (simbólicos o no), ya que se tendrán que procesar de forma diferente al restaurar.
 * En un directorio temporal se copian los archivos que están en la partición y no en la imagen completa.
 * Se crea una imagen squash del directorio


{{{
# Montamos imagen completa (con la que vamos a comparar)
mount -t squashfs -o loop /opt/opengnsys/image/ImgCompleta $OGCAC$OGIMG/montar
# Creamos las diferencias 
rsync -aHvn --delete /mnt/sda2/ $OGCAC$OGIMG/montar > lista_img 
sed -i -e s/"^sent.*.bytes\/sec"//g  -e s/^total.*.speedup.*.$//g -e s/"sending.*.list"//g lista_img 

# creasmo directorio temporarl 
mkdir $OGCAC$OGIMG/img.tmp 
grep -e '\->' -e  '\=>' lista_img > $OGCAC$OGIMG/img.tmp/list__ln 
grep -e  ^deleting  lista_img | sed s/^deleting\ //g > $OGCAC$OGIMG/img.tmp/list_rm 
grep -v -e '\->' -e  '\=>'  -e ^deleting  lista_img > $OGCAC$OGIMG/img.tmp/lista_rsync 
# 
echo "rsync -aHq --files-from=$OGCAC$OGIMG/img.tmp/list_rsync /mnt/sda2/  $OGCAC$OGIMG/img.tmp" | tee -a $FILELOG 
rsync -aHq --files-from=$OGCAC$OGIMG/img.tmp/list_rsync  /mnt/sda2/  $OGCAC$OGIMG/img.tmp  >> $FILELOG 2>&1 

echo "mksquashfs $OGCAC$OGIMG/img.tmp ubuntu11DesdePArticionSqfs.diff" | tee -a $FILELOG 
mksquashfs $OGCAC$OGIMG/img.tmp ubuntu11DesdePArticionSqfs.diff | tee -a $FILELOG 
}}}

== Restaurar - Sincronizar una imagen diferencial ==

Tras restaurar la imagen completa, la restauración de la imagen diferencial hará lo siguiente:
 * Montará la partición destino y la imagen diferencial
 * Con rsync copiará los archivos incluidos en la lista de la diferencial (Es más rápido que si se le permite que compare el contenido de la imagen con la partición).
 * Borrara los archivos sobrantes, con la información de la lista para borrar
 * Creará los enlaces simbólicos, con la informacón de  la lista de enlaces



{{{
echo "Restaurar diferencial"  | tee -a $FILELOG 
ogMount 1 X
mount $OGCAC$OGIM/imagen.diff $OGCAC$OGIMG/montar
rsync -aHq –files-from=$OGCAC$OGIMG/montar/list_rsync  $OGCAC$OGIMG/montar/ /mnt/sdaX | tee -a $FILELOG 
echo "Diferencial: creando enlaces y borrando"  | tee -a $FILELOG 
cd $PART
rm -rf $(cat $OGCAC$OGIMG/montar/list_rc) 

# nota: mal la comparación de ->  no distingue el => para los enlaces duros
while read dest enlace orig 
do 
   echo $dest ... $enlace ... $orig 
   if [ "$enlace" == "->" ] 
   then 
        echo enlace: $enlace 
        OPTLN='-s' 
   fi 

   echo "ln $OPTLN   ${dest%\/*}/$orig $dest" 
   #ln $OPTLN   ${dest%\/*}/$orig $dest 
   echo "" 
done < $OGCAC$OGIMG/montar/list_ln 

}}}

== Transformando una imagen de partclone en sqfs ==

Partimos de una imagen de partclone comprimida, la transformamos en una que se pueda montar. 

Se restaura la imagen en un fichero (dos opciones según el compresor):
{{{
cat Imagen.img.gz | gzip -d -c | partclone.restore -C -s - -O imgMontable.img

lzop -dc Ubuntu11.img | partclone.restore -C -s - -O ubuntu11Montar.img
}}}

Montando la imagen 
{{{
mkdir montar 
mount -o loop ubuntuMontar.img montar/ 
mount.ntfs-3g -o loop w7BasicaMontar.img montar/
}}}

Comprimiendo la imagen en formato sqfsImage.sqfs.lib

{{{
cd /opt/opengnsys/images
sudo mkdit montar
sudo mount -o loop ubuntuMontar montar
sudo mksquashfs montar ubuntuMontar.sqfs
}}}

Montando el fichero sqfs
{{{
mount -t squashfs -o loop ubuntuMontar.sqfs montar
}}}

== Pruebas ==
[wiki:SyncronizeComparacion Comparación gestión de imágenes rsync/mksquash con partclone]