Accueil > Linux & Logiciels Libres > Migration de serveur linux - samba
324 visites

Migration de serveur linux - samba

mardi 1er mars 2016

Version imprimable de cet article Version imprimable

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 `cat liste_synchros` ; 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 `cat liste_synchros` ;
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 `cat liste_synchros` ;
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 `cat liste_synchros` ;
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 `cat liste_synchros` ;
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 `cat liste_synchros` ;
    • 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 `cat liste_synchros` ;
    • 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

Répondre à cet article

Total 121372 visites depuis 2149 jours | Site réalisé par Vader[FR] | SPIP | | Plan du site | Suivre la vie du site RSS 2.0 | contact mail