Migration de serveur linux - samba

mardi 1er mars 2016

Format PDF |

Installation du serveur et récupération des données

Installation du nouveau serveur, l’ancien serveur reste utilisé.

récupération des utilisateurs et groupes de l’ancien serveur

récupérer /etc/group et /etc/passwd du "vieux" serveur dans le répertoire root du nouveau, répertoire personnel de l’utilisateur root où l’on se trouve par défaut après s’être connecté en root.
- scp root@IP_OLD:/etc/group group_old
- scp root@IP_OLD:/etc/passwd passwd_old

Toute cette procédure est justifiée par le fait que smbpasswd contient l’uid et doit être rapatrié entièrement, donc il faudra protéger les UID et privilégier les anciens (utilisateurs déclarés dans Samba).

les groupes et utilisateurs "nouveaux" dont les gid/uid sont en conflit avec des groupes et utilisateurs de samba sur l’ancien serveur devront être modifiés.
Par exemple, pour modifier l’utilisateur et le groupe ftptrans/transfert et leur mettre un nouvel uid/gid à 502.
- usermod -u 502 ftptrans
- groupmod -g 502 transfert

il est préférable de sauvegarder les anciens fichiers group et passwd du nouveau serveur
- cp /etc/group /root/group_new
- cp /etc/passwd /root/passwd_new

1) Groupes

Supprimer les CTRL-M de group_old s’il y en a
extraction des groupes samba (par exemple >= 1000) de l’ancien serveur
- cat group_old | awk -F: '{ if ($3 > 999) print $0 }' | sort -t':' -k3n -k1> fic_g_old1000
extraction des groupes système et utilisateurs non samba (< 1000) du nouveau serveur
- cat group_new | awk -F: '{ if ($3 < 1000 ) print $0 }' | sort -t':' -k3n -k1 > fic_g_new1000
sauvegarde du fichier des groupes du nouveau serveur
- mv /etc/group /etc/group_orig
recréation du fichier des groupes
- cat fic_g_new1000 fic_g_old1000 > /etc/group

2) Utilisateurs

extraction des utilisateurs samba (par exemple >= 1002) de l’ancien serveur
- cat passwd_old | awk -F: '{ if ($3 > 1001 ) print $0 }' | sort -t':' -n -k3 > fic_u_old1000
extraction des utilisateurs (< 1002) du nouveau serveur
- cat passwd_new | awk -F: '{ if ($3 < 1002 ) print $0 }' | sort -t':' -n -k3 > fic_u_new1000
sauvegarde du fichier des utilisateurs du nouveau serveur
- mv /etc/passwd /etc/passwd_orig
recréation du fichier des utilisateurs
- cat fic_u_new1000 fic_u_old1000 > /etc/passwd

il peut être utile de mettre ces commandes dans un fichier de script afin de régénérer les fichiers passwd et group en cas de changements avec nouveaux utilisateurs ou nouvelles machines reliées à Samba

Désactiver sur le nouveau serveur le démarrage automatique des services smb et nmb, pour éviter les conflits avec l’ancien serveur lors du transfert des données.

new_serv:~ # chkconfig -d smb
smb                       0:off  1:off  2:off  3:off  4:off  5:off  6:off
new_serv:~ # chkconfig -d nmb
nmb                       0:off  1:off  2:off  3:off  4:off  5:off  6:off

Récupérer de l’ancien serveur les fichiers suivant avec la commande scp : scp root@IP_OLD:/fichier /fichier

/etc/hosts
/etc/ssh/sshd-banner qu’il faudra éditer pour signaler que l’on est sur un nouveau serveur et éviter la confusion avec l’ancien

Récupération des données de l’ancien serveur

Les données des partages Samba ainsi que les fichiers netlogon pour les postes rattachés à un domaine géré par Samba.
/var/lib/samba/, s’assurer que les services smb/nmb sont arrêtés sur le nouveau serveur
/etc/samba/,
/etc/shadow
/etc/HOSTNAME (si le nouveau a été mal nommé pendant masterisation)
/var/spool/cron/tabs/root il faudra redémarrer le serveur cron par service crond restart
/etc/ssh/sshd_config il faudra redémarrer le serveur ssh par service sshd restart

avec la commande rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@IP_OLD_SERVER:/repertoire_source/ /repertoire/destination/

En raison du volume de certains répertoires, lancer les synchronisations le soir ou le week-end.

Pour automatiser les synchronisations

:attention à titre expérimental :attention

générer la clé ssh du nouveau serveur par ssh-keygen
- ne pas mettre de passphrase
- Au lieu de générer la clé de manière interactive, il est possible de passer par une seule commande :
  - ssh-keygen -t rsa -P "" -f .ssh/id_rsa
  - l’option -q permettra un silence total, le "random art" de la clé ne sera pas affiché.
envoyer la clé, par défaut dans .ssh/id_rsa.pub dans le fichier .ssh/authorized_keys de l’ancien serveur en écrasant ou à la place de l’ancien fichier
- en étant dans le répertoire de root : scp .ssh/id_rsa.pub root@IP_OLD:/root/.ssh/authorized_keys
~~se connecter au nouveau serveur depuis l’ancien en SSH de manière à avoir la clé du nouveau dans le fichier .ssh/known_hosts de l’ancien serveur~~
~~redémarrer le service ssh de l’ancien serveur par service sshd restart :~~
tester la connexion directe sans mot de passe depuis le nouveau serveur vers l’ancien serveur.
tester un rsync de la même manière sur /home/netlogon par la commande rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@IP_OLD:/home/netlogon/ /home/netlogon/
copier-coller la liste des synchronisations à faire dans un fichier de liste, un partage par ligne, du type /home/netlogon/ sans oublier le dernier "/".
la boucle pour la commande des synchronisations est : for ligne in ; do rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@IP_OLD:$ligne $ligne; done;

Exemple de fichier de liste
cat liste_synchros

 
/var/lib/samba/
/etc/samba/
/etc/shadow
/var/spool/cron/tabs/root
/etc/ssh/sshd_config
/home/data/
/home/user/
/home/echanges/
/home/netlogon/

Exemple de fichier de script
cat synchros.sh

 

#!/bin/bash
IP_OLD=""; # adresse IP de l'ancien serveur, sur lequel on se connecte pour récupérer les données. Permet de réutiliser le script en ne changeant que cette variable.
reponse="z";
until [ $reponse == "y" -o $reponse == "n" ] ; do echo "Afficher à l'écran (en plus du fichier journal) le détail des fichiers téléchargés ? y/n"; read reponse ; done;
nblignes=$(cat liste_synchros | grep -vE "^$" | wc -l);
echo "Il y a $nblignes dossiers à copier" | tee -a synchros.log;
tabtaille[0]=$nblignes;
tabtailleh[0]=$nblignes;
totalk=0;
compteur=1;
echo "On détermine la taille des fichiers et dossiers à télécharger, cela peut prendre un peu de temps." | tee -a synchros.log
for ligne in <span class="base64" title="PGNvZGUgY2xhc3M9InNwaXBfY29kZSBzcGlwX2NvZGVfaW5saW5lIiBkaXI9Imx0ciI+Y2F0IGxpc3RlX3N5bmNocm9zPC9jb2RlPg=="></span> ;
 do
        echo -n "$ligne" | tee -a synchros.log;
        taillek=$(ssh root@$IP_OLD du -s $ligne 2>/dev/null | grep "$ligne" | awk '{ print $1 }');
	totalk=$(expr $totalk + $taillek);
	tabtaille[$compteur]=$taillek;
	if [ $taillek -gt 1024 ]
	then
		taillem=$(expr $taillek / 1024);
		if [ $taillem -gt 1024 ]
		then
			tailleg=$(expr $taillem / 1024);
			restm=$(expr $tailleg \* 1024);
			taillem=$(expr $taillem - $restm);
			tabtailleh[$compteur]="$tailleg Go et $taillem Mo";
		else
			tabtailleh[$compteur]="$taillem Mo";
		fi
	else
		tabtailleh[$compteur]="$taillek Ko";
	fi
	echo " : ${tabtailleh[$compteur]}" | tee -a synchros.log;
	compteur=$(expr $compteur + 1);
done;
if [ $totalk -gt 1024 ]
then
	totalm=$(expr $totalk / 1024);
	if [ $totalm -gt 1024 ]
	then
		totalg=$(expr $totalm / 1024);
		if [ $totalg -gt 1024 ]
		then
			totalt=$(expr $totalg /1024);
			totalh="$totalt To";
		else
			totalh="$totalg Go";
		fi
	else
		totalh="$totalm Mo";
	fi
else
	totalh="$totalk Ko";
fi	
echo "Total : $totalh" | tee -a synchros.log;
compteur=1;
tailledlk=0;
for ligne in <span class="base64" title="PGNvZGUgY2xhc3M9InNwaXBfY29kZSBzcGlwX2NvZGVfaW5saW5lIiBkaXI9Imx0ciI+Y2F0IGxpc3RlX3N5bmNocm9zPC9jb2RlPg=="></span> ; 
 do 
	if [ $tailledlk -gt 1024 ]
        then
                tailledlm=$(expr $tailledlk / 1024);
                if [ $tailledlm -gt 1024 ]
                then
                        tailledlg=$(expr $tailledlm / 1024);
                        tailledlh="$tailledlg Go";
                else
                        tailledlh="$tailledlm Mo";
                fi
        else
                tailledlh="$tailledlk Ko";
        fi
	taillelocale=$(du -sh $ligne | awk '{ print $1 }');
        echo "====== synchronisation de $ligne - $compteur/$nblignes - ${tabtailleh[$compteur]} à télécharger, $taillelocale sur disque ======" | tee -a synchros.log;
	echo "Téléchargé jusqu'à maintenant : $tailledlh sur $totalh" | tee -a synchros.log;
	dispo=$(df $ligne | tail -n 1 | awk '{ print $3 }');
	echo "Il reste $dispo Ko, il faut ${tabtaille[$compteur]} Ko"  | tee -a synchros.log;
	if [ $dispo -gt ${tabtaille[$compteur]} ]
	then
		echo "Il y a assez de place sur la destination"  | tee -a synchros.log;
		 if [ $reponse == "y" ]
        	then
                	rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@$IP_OLD:$ligne $ligne 2>&1 | tee -a synchros.log;
        	else
        	        rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@$IP_OLD:$ligne $ligne 2>&1 1>>synchros.log;
       		fi
	else
		echo "Il n'y a pas assez de place sur la destination" | tee -a synchros.log;
	fi
	tailledlk=$(expr ${tabtaille[$compteur]} + $tailledlk);
	compteur=$(expr $compteur + 1);
 done;
 echo "====== fin du script le $(date) ======" | tee -a synchros.log;

Ne pas oublier de changer la valeur de l’adresse IP_OLD (ancien serveur) indiquée à la première ligne

Il ne restera plus qu’à rendre le script exécutable : chmod u+x synchros.sh
Et enfin à le lancer ./synchros.sh

Il peut être utile de lancer deux fois à la suite le script, au cas où un transfert ne se ferait pas correctement.

Afin de voir si tous les transferts se sont bien passés, il est possible de regarder le fichier journal less synchros.log

Migration sur site

L’ancien serveur reste accessible aux utilisateurs

Synchroniser les données, même si cela a été fait à l’étape précédente, afin de mettre à jour.
en utilisant une commande du type rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@IP_OLD_SERVER:/repertoire_source/ /repertoire/destination/

il faudra aussi copier les répertoires et fichiers système/de configuration

/var/lib/samba, s’assurer que les services smb/nmb sont arrêtés sur le nouveau serveur
/etc/samba,
/etc/shadow
~~/etc/hosts~~ car fait précédemment
/etc/HOSTNAME (si le nouveau a été mal nommé pendant masterisation)
/var/spool/cron/tabs/root il faudra redémarrer le serveur ssh par service sshd restart
/etc/ssh/sshd_config
~~/etc/ssh/sshd-banner~~ car fait précédemment

en utilisant la commande scp de la manière suivante : scp -r root@IP_OLD:/chemin/repertoire /chemin/, sans le "/" final pour le chemin source cette fois.

par exemple : scp -r root@10.233.185.93:/etc/samba /etc/ (répertoire )ou scp -r root@10.233.185.93:/var/spool/cron/tabs/root /var/spool/cron/tabs/ (fichier)

:attention à titre expérimental :attention Pour automatiser les synchronisations, voir onglet précédent, et relancer le même script.

Si l’authentification par clé fonctionne pour les synchronisations par rsync, alors il en sera de même pour les scp.

Interruption de service

les utilisateurs n’auront plus accès au serveur à cet instant
:attention Prévenir ou faire prévenir les utilisateurs :attention

Arrêter smb et nmb sur l’ancien serveur
- service smb stop
- service nmb stop
réactiver le démarrage automatique des services smb, nmb, sur le nouveau serveur
- chkconfig -a nom_service (smb/nmb)
Permuter les adresses IP entre l’ancien et le nouveau serveur,
- en console ou en SSH
  - en cas de connexion à l’ancien serveur depuis le nouveau en SSH, en commençant par mettre l’adresse provisoire sur l’ancienne machine avant de mettre l’adresse définitive sur le nouveau
Arrêter les 2 machines
Effectuer la manutention nécessaire (déplacement machines, câbles …)
Redémarrer les 2 machines (théoriquement automatique à la mise sous tension)

Réouverture du service

les utilisateurs accèdent désormais au nouveau serveur

Vérifier les services smb/nmb sur le nouveau serveur
- service nom_service status
Tester avec les utilisateurs.
Dernières synchronisations
- /root

Ne pas oublier de mettre à jour la documentation de site.

Bonus : détail du script synchro

Rappel : le code du script de synchronisation

#!/bin/bash
IP_OLD=""; # adresse IP de l'ancien serveur, sur lequel on se connecte pour récupérer les données. Permet de réutiliser le script en ne changeant que cette variable.
reponse="z";
until [ $reponse == "y" -o $reponse == "n" ] ; do echo "Afficher à l'écran (en plus du fichier journal) le détail des fichiers téléchargés ? y/n"; read reponse ; done;
nblignes=$(cat liste_synchros | grep -vE "^$" | wc -l);
echo "Il y a $nblignes dossiers à copier" | tee -a synchros.log;
tabtaille[0]=$nblignes;
tabtailleh[0]=$nblignes;
totalk=0;
compteur=1;
echo "On détermine la taille des fichiers et dossiers à télécharger, cela peut prendre un peu de temps." | tee -a synchros.log
for ligne in <span class="base64" title="PGNvZGUgY2xhc3M9InNwaXBfY29kZSBzcGlwX2NvZGVfaW5saW5lIiBkaXI9Imx0ciI+Y2F0IGxpc3RlX3N5bmNocm9zPC9jb2RlPg=="></span> ;
 do
        echo -n "$ligne" | tee -a synchros.log;
        taillek=$(ssh root@$IP_OLD du -s $ligne 2>/dev/null | grep "$ligne" | awk '{ print $1 }');
	totalk=$(expr $totalk + $taillek);
	tabtaille[$compteur]=$taillek;
	if [ $taillek -gt 1024 ]
	then
		taillem=$(expr $taillek / 1024);
		if [ $taillem -gt 1024 ]
		then
			tailleg=$(expr $taillem / 1024);
			restm=$(expr $tailleg \* 1024);
			taillem=$(expr $taillem - $restm);
			tabtailleh[$compteur]="$tailleg Go et $taillem Mo";
		else
			tabtailleh[$compteur]="$taillem Mo";
		fi
	else
		tabtailleh[$compteur]="$taillek Ko";
	fi
	echo " : ${tabtailleh[$compteur]}" | tee -a synchros.log;
	compteur=$(expr $compteur + 1);
done;
if [ $totalk -gt 1024 ]
then
	totalm=$(expr $totalk / 1024);
	if [ $totalm -gt 1024 ]
	then
		totalg=$(expr $totalm / 1024);
		if [ $totalg -gt 1024 ]
		then
			totalt=$(expr $totalg /1024);
			totalh="$totalt To";
		else
			totalh="$totalg Go";
		fi
	else
		totalh="$totalm Mo";
	fi
else
	totalh="$totalk Ko";
fi	
echo "Total : $totalh" | tee -a synchros.log;
compteur=1;
tailledlk=0;
for ligne in <span class="base64" title="PGNvZGUgY2xhc3M9InNwaXBfY29kZSBzcGlwX2NvZGVfaW5saW5lIiBkaXI9Imx0ciI+Y2F0IGxpc3RlX3N5bmNocm9zPC9jb2RlPg=="></span> ; 
 do 
	if [ $tailledlk -gt 1024 ]
        then
                tailledlm=$(expr $tailledlk / 1024);
                if [ $tailledlm -gt 1024 ]
                then
                        tailledlg=$(expr $tailledlm / 1024);
                        tailledlh="$tailledlg Go";
                else
                        tailledlh="$tailledlm Mo";
                fi
        else
                tailledlh="$tailledlk Ko";
        fi
	taillelocale=$(du -sh $ligne | awk '{ print $1 }');
        echo "====== synchronisation de $ligne - $compteur/$nblignes - ${tabtailleh[$compteur]} à télécharger, $taillelocale sur disque ======" | tee -a synchros.log;
	echo "Téléchargé jusqu'à maintenant : $tailledlh sur $totalh" | tee -a synchros.log;
	dispo=$(df $ligne | tail -n 1 | awk '{ print $3 }');
	echo "Il reste $dispo Ko, il faut ${tabtaille[$compteur]} Ko"  | tee -a synchros.log;
	if [ $dispo -gt ${tabtaille[$compteur]} ]
	then
		echo "Il y a assez de place sur la destination"  | tee -a synchros.log;
		 if [ $reponse == "y" ]
        	then
                	rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@$IP_OLD:$ligne $ligne 2>&1 | tee -a synchros.log;
        	else
        	        rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@$IP_OLD:$ligne $ligne 2>&1 1>>synchros.log;
       		fi
	else
		echo "Il n'y a pas assez de place sur la destination" | tee -a synchros.log;
	fi
	tailledlk=$(expr ${tabtaille[$compteur]} + $tailledlk);
	compteur=$(expr $compteur + 1);
 done;
 echo "====== fin du script le $(date) ======" | tee -a synchros.log;

Et l’explication détaillée :

#!/bin/bash
- comme tout script Linux bash (ou même php en ligne de commande, voir onglet "Scripts" de cet article), on commence par indiquer quel interpréteur utiliser.
IP_OLD=""; # adresse IP de l'ancien serveur, sur lequel on se connecte pour récupérer les données. Permet de réutiliser le script en ne changeant que cette variable.
- Initialisation de plusieurs variables, ici il s’agit de l’adresse IP de l’ancien serveur, qui est toujours en production. Sera utilisée à 2 reprises, pour déterminer la taille puis faire le rsync
reponse="z";
until [ $reponse == "y" -o $reponse == "n" ] ; do echo "Afficher à l'écran (en plus du fichier journal) le détail des fichiers téléchargés ? y/n"; read reponse ; done;
nblignes=$(cat liste_synchros | grep -vE "^$" | wc -l);
- Afin de savoir à quelle étape on en est, on affiche le fichier liste par cat
- puis on redirige la sortie standard vers une deuxième commande pour en enlever (-v) les lignes vides avec grep.
  - L’expression régulière (utilisable grâce à l’option -E) signifie : ^ début de ligne $ fin de ligne, donc ligne ne contenant rien entre les deux, donc vide
echo "Il y a $nblignes dossiers à copier" | tee -a synchros.log;
- On affiche le nombre de lignes, et donc de dossiers à traiter.
- le tee fait un affichage à l’écran + envoi dans un fichier,
  - l’option -a ajoute à la fin du fichier au lieu de l’écraser
tabtaille[0]=$nblignes;
tabtailleh[0]=$nblignes;
totalk=0;
compteur=1;
- initialisation des 2 tableaux contenant la taille des dossiers en Ko pour les calculs et en Ko/Mo/Go/To "lisible par un humain", ainsi que le total et un compteur.
  - en BASH, les tableaux commencent à zéro, or les lignes sont comptées à partir de 1, c’est pourquoi le nombre de lignes est mis en case 0.
echo "On détermine la taille des fichiers et dossiers à télécharger, cela peut prendre un peu de temps." | tee -a synchros.log
- même remarque que précédemment concernant le tee
for ligne in ;
- Pour chaque ligne du fichier liste_synchros
do
- faire
echo -n "$ligne" | tee -a synchros.log;
- même remarque que précédemment concernant le tee
taillek=$(ssh root@$IP_OLD du -s $ligne 2>/dev/null | grep "$ligne" | awk '{ print $1 }');
- On détermine la taille en utilisant la commande du (disk usage, ne pas confondre avec df, disk free) sur l’ancien serveur, actuellement en production, à distance par SSH.
  - l’option -s signifie que l’on veut le summary, autrement dit le résumé pour le dossier, sa taille globale, et non le détail de chaque fichier.
  - l’option -h afficherait le résultat dans une forme lisible par un humain : en Ko, Mo, Go...
  - 2>/dev/null renvoie les messages de la sortie standard n°2, réservée aux messages d’erreurs, et en l’occurrence à la bannière SSH, vers le vide.
  - le grep qui suit ne retiendra que la ligne contenant le nom du dossier dont l’on souhaite déterminer la taille
  - le awk final ne gardera que le premier champ - le séparateur par défaut étant l’espace - qui contient la taille du dossier.
totalk=$(expr $totalk + $taillek);
- on incrémente la taille totale avec la taille du dossier à télécharger. les tailles sont indiquées en Ko par défaut.
tabtaille[$compteur]=$taillek;
- la taille du dossier est stockée dans une case du tableau, à l’indice correspondant au numéro de ligne.
if [ $taillek -gt 1024 ]
then
taillem=$(expr $taillek / 1024);
if [ $taillem -gt 1024 ]
then
tailleg=$(expr $taillem / 1024);
restm=$(expr $tailleg \* 1024);
taillem=$(expr $taillem - $restm);
tabtailleh[$compteur]="$tailleg Go et $taillem Mo";
else
tabtailleh[$compteur]="$taillem Mo";
fi
else
tabtailleh[$compteur]="$taillek Ko";
fi
- on calcule ensuite la taille en Mo si la taille en Ko dépasse 1024 Ko, puis la taille en Go si la taille en Mo dépasse 1024 Mo, de sorte à obtenir un format lisible par un humain, qui est enregistré dans le tableau tabtailleh.
echo " : ${tabtailleh[$compteur]}" | tee -a synchros.log;
- La valeur de la case est ensuite affichée.
compteur=$(expr $compteur + 1);
- on incrémente le compteur
done;
- fin de la première boucle pour de calcul des tailles des dossiers
if [ $totalk -gt 1024 ]
then
totalm=$(expr $totalk / 1024);
if [ $totalm -gt 1024 ]
then
totalg=$(expr $totalm / 1024);
if [ $totalg -gt 1024 ]
then
totalt=$(expr $totalg /1024);
totalh="$totalt To";
else
totalh="$totalg Go";
fi
else
totalh="$totalm Mo";
fi
else
totalh="$totalk Ko";
fi
echo "Total : $totalh" | tee -a synchros.log;
- de la même manière que précédemment, on calcule la taille totale à télécharger dans un format lisible par un humain.
compteur=1;
- on réinitialise le compteur avant la deuxième boucle.
tailledlk=0;
- on initialise aussi une variable qui servira au calcul du cumul de taille de téléchargement, afin de mieux visualiser la progression
for ligne in ;
- Pour chaque ligne du fichier liste_synchros
do
- faire
if [ $tailledlk -gt 1024 ]
then
tailledlm=$(expr $tailledlk / 1024);
if [ $tailledlm -gt 1024 ]
then
tailledlg=$(expr $tailledlm / 1024);
tailledlh="$tailledlg Go";
else
tailledlh="$tailledlm Mo";
fi
else
tailledlh="$tailledlk Ko";
fi
- de la même manière que précédemment, on calcule la taille totale déjà téléchargée dans un format lisible par un humain.
taillelocale=$(du -sh $ligne | awk '{ print $1 }');
- on utilise à nouveau la commande du mais cette fois en local et avec les deux options s et h
echo "====== synchronisation de $ligne - $compteur/$nblignes - ${tabtailleh[$compteur]} à télécharger, $taillelocale sur disque ======" | tee -a synchros.log;
echo "Téléchargé jusqu'à maintenant : $tailledlh sur $totalh" | tee -a synchros.log;
- affichage de diverses données : nom du dossier à synchroniser, numéro de ligne (du fichier liste) traitée sur nombre total de lignes, taille du dossier à télécharger et en local, ainsi que progression globale.
dispo=$(df $ligne | tail -n 1 | awk '{ print $3 }');
- calcul de la taille disponible sur la partition contenant le dossier cible avec df (disk free)
  - Par défaut, la taille est en Ko.
  - le tail -n 1 enlève la ligne de titre pour ne garder que la dernière ligne
  - le awk affiche le troisième champ à savoir le nombre de Ko libres.
echo "Il reste $dispo Ko, il faut ${tabtaille[$compteur]} Ko";
if [ $dispo -gt ${tabtaille[$compteur]} ]
- si le nombre de Ko libres est supérieur à la taille en Ko du dossier distant à télécharger, qui a été enregistrée précédemment dans le tableau
then
- alors
echo "Il y a assez de place sur la destination";
if [ $reponse == "y" ]
- si la réponse à la question initiale est "y" (affichage à l’écran du détail de la liste des fichiers au téléchargement)
then
rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@$IP_OLD:$ligne $ligne 2>&1 | tee -a synchros.log;
else
- si la réponse à la question initiale est "n" (ne pas afficher à l’écran le détail de la liste des fichiers au téléchargement)
rsync --numeric-ids -avz --rsh="ssh -c arcfour" root@$IP_OLD:$ligne $ligne 2>&1 1>>synchros.log;
fi
- fin du si pour détail de la liste des fichiers
else
echo "Il n'y a pas assez de place sur la destination";
fi
- fin du si pour espace libre
tailledlk=$(expr ${tabtaille[$compteur]} + $tailledlk);
compteur=$(expr $compteur + 1);
- on incrémente le compteur via un calcul numérique exécuté par la commande expr et on fait de même pour la taille téléchargée.
done;
- fin de la deuxième boucle pour des synchronisations
echo "====== fin du script le $(date) ======" | tee -a synchros.log;
- fin du script, même remarque que précédemment concernant le tee