[quote=“ricardo”]
Or là, l’incrémentation se fait avant l’appel à la fonction, ce qui me semble illogique.
EDIT :
Je ne remets pas en cause cette “logique” et je la comprends aussi 
[/quote]
je vois …
Alors ceci te semblera plus adapté :
index=1
while ((index < ${#controle[@]}))
do
appel_fonction
((index++))
doneAh oui, là c’est plus “causant” et c’est où mes souvenirs étaient restés. Je n’aurais même pas demandé d’explications.
Donc ça existe bien encore ?
Cela dit, je ferai comme vous l’indiquez pour être dans le vent 
EDIT :
Je viens de me rendre compte que je confondais ‘for’ et ‘while’ 
[quote=“ricardo”]Ah oui, là c’est plus “causant” et c’est où mes souvenirs étaient restés. Je n’aurais même pas demandé d’explications.
Donc ça existe bien encore ?
Cela dit, je ferai comme vous l’indiquez pour être dans le vent [/quote]
La boucle for n’a rien de nouveau (elle existait en c, fortran, COBOL et en pascal 
) à toi de faire ton choix entre :
index=1
while ((index < ${#controle[@]}))
do
appel_fonction
((index++))
done
et
for (( index=1 ; index < ${#controle[@]} ; index++ ))
do
appel_fonction
done
Pour la lecture de la seconde boucle, tu peut dire « pour i allant de 1 à taille de controle - 1 (attention faut pas l’oublier), faire l’appel de fonction ». Ou pour suivre le code plus précisément « pour i allant de 1 à taille de controle - 1 (attention faut pas l’oublier) et incrémenté de 1 en 1, faire l’appel de fonction ».
Oui Michel, comme tu l’expliques ( « pour i allant de 1 à taille de controle…), je n’aurais ptet pas fait de confusion.
Ce qui m’a induit en erreur, c’est le “on boucle tant que index…” de Totor car pour moi, ‘tant que’ = ‘while’ dans ma mémoire.
Je suis content quand même d’approfondir ces broutilles, ça me permets de réfléchir à ce que je fais et non de faire sans comprendre.
Impec tout ça, je vais faire dans l’AM ou ce soir et je vous le présenterai.
Je reviens à la charge :
Quand tu précises qu’il ne faut pas oublier le ‘-1’, tu peux expliquer et me dire où il est mentionné dans la ligne ?
EDIT :
Je pense avoir la réponse avec ce qu’à écrit Totor :
[quote]- au premier tour de boucle : index vaut 1 et il y a 3 éléments dans le tableau controle (1 est bien inférieur à 3) --> sauvegarde avec les éléments ayant pour indice 1
Alors, je viens de faire un premier jet, testé_qui_va_bien.
c’est bon ?
J’ai intégré dans le script (ligne “read…”), le test “teste si la sauvegarde a abouti”
Ça fait ptet un peu fouillis mais ça fonctionne. Autre solution ?
function test_sauvegarde()
{
sudo rsync -av --del --backup --backup-dir="${controle[$index]}" --exclude-from="${exclure[$index]}" "${dossier_a_sauver[$index]}" "${sauve[$index]}"
}
[code]#-----------------Variables-------------------
mount_rep="/mnt/autre"
ddext=(’’ ‘/dev/sdb9’ ‘/dev/sdb10’)
systeme_fich=(’’ ‘ext3’ ‘ext2’)
controle=(’’ ‘/home/controle’ ‘/home/controle-ricardo’)
exclure=(’’ ‘/root/exclure’ ‘/home/ricardo/.exclure’)
sauve=(’’ ‘/mnt/autre/sauve’ ‘/mnt/autre/sauve-ricardo’)
dossier_a_sauver=(’’ ‘/’ ‘/home/ricardo’)
[/code]
read -p "prêt pour la sauvegarde ? o/* : " onyva
if [ "$onyva" = o ]
then
for((index=1; index < ${#controle[@]}; index++))
do
test_sauvegarde "$controle" "$exclure" "$dossier_a_sauver" "$sauve"
# Teste si la sauvegarde a abouti ( = 0), sinon, on sort.
if (("$?" > 0))
then
printf "\nErreur lors de la sauvegarde de %s\n" "${dossier_a_sauver[$index]}" >&2
exit 1
else
printf "\nSauvegarde de %s : OK\n" "${dossier_a_sauver[$index]}"
fi
done
else
exit 1
fiEDIT :
Il faut ajouter quelque chose à la fin de la fonction “test_sauvegarde” pour que ça sorte en cas d’erreur ou ce qui est traité dans le script suffit ?
Le copié/collé pour le code n’est pas terrible au niveau de l’alignement 
Plus clair :
3 remarques (avant mon départ 
) :
1/ ligne test_sauvegarde “$controle” “$exclure” “$dossier_a_sauver” “$sauve”
A ton avis, quelles sont les valeurs des variables “$controle” “$exclure” “$dossier_a_sauver” “$sauve” ?
2/ ligne sudo rsync -av --del --backup --backup-dir="${controle[$index]}" --exclude-from="${exclure[$index]}" “${dossier_a_sauver[$index]}” “${sauve[$index]}”
pourquoi utiliser directement les tableaux puisque tu passes ces données en paramètre de la fonction 
3/ les lignes if (("$?" > 0))
then
printf “\nErreur lors de la sauvegarde de %s\n” “${dossier_a_sauver[$index]}” >&2
exit 1
else
printf “\nSauvegarde de %s : OK\n” “${dossier_a_sauver[$index]}”
fi
sont à intégrer dans le corps de la fonction puis traiter le point 2 !
sur ce, je passe la main 
mais félicitations 
tu as compris beaucoup de choses !
[quote=“Totor”]
1/ ligne test_sauvegarde “$controle” “$exclure” “$dossier_a_sauver” "$sauve"
A ton avis, quelles sont les valeurs des variables “$controle” “$exclure” “$dossier_a_sauver” “$sauve” ? [/quote]
Une chose à la fois, pour le 1/, je suppose qu’il faut donc écrire :
?
EDIT :
Pour le 2/, j’ai compris ma connerie
à remplacer par :
@ricardo > Ceci
C’est équivalent à :
controle[0]=''
controle[1]='/home/controle'
controle[2]='/home/controle-ricardo'
et ${#controle[@]} # vaut 3
Donc i vaut 1 (tu l’initialise à 1), puis 2. Donc i va de 1 à taille de controle - 1.
C’est le test inférieur strict qui permet de s’en assurer.
Merci Michel, ça je l’avais compris.
Je redonne avec mes dernières modifs mais j’ai un doute sur le 3/ de Totor
Ce script fonctionne mais est-ce correct :
[code]#---------------------------------------------
function test_sauvegarde()
{
sudo rsync -av --del --backup --backup-dir="$1" --exclude-from="$2" “$3” “$4”
# Teste si la sauvegarde a abouti ( = 0), sinon, on sort.
if (("$?" > 0))
then
printf "\nErreur lors de la sauvegarde de %s\n" "$3" >&2
exit 1
else
printf "\nSauvegarde de %s : OK\n" "$3"
fi
}
#-----------------Variables-------------------
mount_rep="/mnt/autre"
ddext=(’’ ‘/dev/sdb9’ ‘/dev/sdb10’)
systeme_fich=(’’ ‘ext3’ ‘ext2’)
controle=(’’ ‘/home/controle’ ‘/home/controle-ricardo’)
exclure=(’’ ‘/root/exclure’ ‘/home/ricardo/.exclure’)
sauve=(’’ ‘/mnt/autre/sauve’ ‘/mnt/autre/sauve-ricardo’)
dossier_a_sauver=(’’ ‘/’ ‘/home/ricardo’)
#---------------------------------------------
read -p "prêt pour la sauvegarde ? o/* : " onyva
if [ “$onyva” = o ]
then
for((index=1; index < ${#controle[@]}; index++))
do
test_sauvegarde “${controle[$index]}” “${exclure[$index]}” “${dossier_a_sauver[$index]}” “${sauve[$index]}”
done
else
exit 1
fi
[/code]
A ta place je retirerais le exit 1 de la fonction. Comme ça même si la première sauvegarde se rate il essaieras tout de même le second.
OK, je supprime.
Pour le reste, c’est bon ?
Ça y est Totor n’est plus là, tu essaie de te défiler ? 
Pour bien faire les choses, je vois encore un dernier problème. Totor disais à juste titre un tôt dans le sujet que par principe ce serais bien que le programme laisse le système dans l’état où il était avant l’exécution.
Le problème c’est qu’en l’état tu as de multiples points de sortie (chaque exit) et qu’il faudrait démonter les partitions montées lorsque le programme sort inopinément. Pour faire ça bien il faudrait limiter le nombre de point de sorti (que les sorti d’erreur où il faut nettoyer soient encapsulée). Pour ça, il suffit de le mettre dans une fonction (oui encore une…), je propose de l’appeler cleanNexit ou nettoyage_sorti (ou autre) si tu préfère le français. Cette fonction devrait :
[ul][li]démonter les partitions si elles ont étaient montées par ton script[/li]
[li]sortir en erreur[/li][/ul]
Je te laisse avec ces indications, je repasse ce soir de toute manière.
En fait, je crois que ce problème avait déjà été réglé.
Je reprends tout le script et je te donne mon avis entre les lignes avec ##### en début :
[code]#----------------- Fonctions ----------------------------
function test_sauvegarde()
{
sudo rsync -av --del --backup --backup-dir="$1" --exclude-from="$2" “$3” “$4”
# Teste si la sauvegarde a abouti ( = 0), sinon, on sort.
if (("$?" > 0))
then
printf "\nErreur lors de la sauvegarde de %s\n" "$3"
else
printf "\nSauvegarde de %s : OK\n" "$3"
fi
}
#----------------- Variables -------------------
mount_rep="/mnt/autre"
ddext=(’’ ‘/dev/sdb9’ ‘/dev/sdb10’)
systeme_fich=(’’ ‘ext3’ ‘ext2’)
controle=(’’ ‘/home/controle’ ‘/home/controle-ricardo’)
exclure=(’’ ‘/root/exclure’ ‘/home/ricardo/.exclure’)
sauve=(’’ ‘/mnt/autre/sauve’ ‘/mnt/autre/sauve-ricardo’)
dossier_a_sauver=(’’ ‘/’ ‘/home/ricardo’)
#----------------- Départ du script ----------------------------
[ -e "${ddext[1]}" ] && [ -e "${ddext[2]}" ] || { echo "Le DDext ne répond pas !" >&2; exit 1; }
mkdir -p "$mount_rep" || { echo "Le dossier de montage n'existe pas !" >&2; exit 1; }
deja_montee=0
PS3="Entrez le N° de la sauvegarde choisie : "
select sauvegarde in “sauve” “sauve2” quitter
do
case ${REPLY} in
[1-2])
index=${REPLY}
if ! grep -q “^${ddext[$index]} “$mount_rep” ${systeme_fich[$index]}” /etc/mtab
then
sudo mount -t “${systeme_fich[$index]}” “${ddext[$index]}” “$mount_rep” || exit 1;
break
else
printf "Info : La partition ${ddext[$index]} est déjà montée\n"
deja_montee=1
break
fi
;;
3) echo “On sort du script”; exit;
;;
*) echo “Saisie non valide !”
;;
esac
done
echo -e "\033[4mCONTENU de la CORBEILLE\033[0m\n"
if [ -e ~/.local/share/Trash/files/ ]
then
ls ~/.local/share/Trash/files
read -p "on peut la vider ? o/* : " corbeille
if [ “$corbeille” = o ]
then
rm -rf ~/.local/share/Trash/*
echo -e "\033[4mCORBEILLE VIDÉE\033[0m"
fi
else
echo "La corbeille est vide"
fi
read -p "prêt pour la sauvegarde ? o/* : " onyva
if [ “$onyva” = o ]
then
for((index=1; index < ${#controle[@]}; index++))
do
test_sauvegarde “${controle[$index]}” “${exclure[$index]}” “${dossier_a_sauver[$index]}” “${sauve[$index]}”
done
else
exit 1
fi
if [ "$deja_montee" = 0 ]
then
sudo umount "$mount_rep"
else
sync
fi
[/code]
[code]# Teste l’existence des partitions de sauvegarde et celle du dossier de montage, sinon, on sort avec erreur 1.
[ -e “${ddext[1]}” ] && [ -e “${ddext[2]}” ] || { echo “Le DDext ne répond pas !” >&2; exit 1; }
mkdir -p “$mount_rep” || { echo “Le dossier de montage n’existe pas !” >&2; exit 1; }
Nous sommes d’accord.
[code]sudo mount -t “${systeme_fich[$index]}” “${ddext[$index]}” “$mount_rep” || exit 1;
Ce serait vrai si le seul cas qui peut faire planter le montage était le fais qu’il soit déjà monté. Il est possible de tenter de le monter avec le mauvais système de fichier par exemple.
Il faudrait faire un exit là, non ?
[code]exit 1
C’est celui au quel je pensais. La méthode dont tu parle est celle employée par les hackers du noyau. Pour le faire ils utilisent un mécanismes du C appelé goto qui n’existe pas en shell. Pour information ils font plus ou moins comme ça :
void fonction(void* arg) {
// premier bout de code
if (errno != 0) goto clean;
// second bout de code
if (errno != 0) goto clean;
// etc
clean:
// Code qui libère les ressources
}Le goto permet de « sauter » vers le clean.
Donc nous on a pas ça, le plus simple est donc de mettre le code de libération dans une fonction et de s’en servir (comme tu le disais donc (^_^)).
Oui, j’avais pensé au goto du C et du basic mais je me doutais que ça n’existe plus dans les langages modernes.
Je vais réfléchir au seul truc qui te chiffonne encore
[quote]Ce serait vrai si le seul cas qui peut faire planter le montage était le fais qu’il soit déjà monté. Il est possible de tenter de le monter avec le mauvais système de fichier par exemple.
[/quote]
Pour le
[quote]*) echo “Saisie non valide !”[/quote],
Tant que tu t’évertues à taper autre chose que 1, 2 ou 3, il boucle et il revient à la question. Donc, si tu veux sortir, tu es obligé de taper ‘3’ et dans ce cas, il ‘exit’
J’avais déjà posé ta question à Totor 
On n’est donc pas loin, je crois.
Je fais cette fonction tout à l’heure et je te soumets le tout.
[quote=“ricardo”]Pour le
[quote]*) echo “Saisie non valide !”[/quote],
Tant que tu t’évertues à taper autre chose que 1, 2 ou 3, il boucle et il revient à la question. Donc, si tu veux sortir, tu es obligé de taper ‘3’ et dans ce cas, il ‘exit’
J’avais déjà posé ta question à Totor [/quote]
Au temps pour moi, tu as raison (à ma décharge je ne suis pas habitué aux « bashismes »).
[quote=“ricardo”]On n’est donc pas loin, je crois.
[/quote]
Clairement, le script est déjà très propre et a une bonne qualité. Rare sont les scripts « perso » aussi bien fais (ou alors peut être ajouter la gestion de l’option -h/–help qui avait déjà était abordée).
Oui, quand tout sera terminé, j’y penserai.
Ce soir, je viens d’avoir une coupure de Net ???
C’est revenu mais avec les orages, on ne sait jamais.
J’étudie ce qui reste ce soi… nuit 
Remplacé la dernière condition par la fonction ‘sortie_propre()’ à la fin de laquelle j’ai été obligé d’ajouter un ‘exit’, sinon le script continuait.
Vérifie bien ce point Michel.
Remplacé les ‘exit’ par l’appel à cette fonction, y-compris sur le point que tu as soulevé. Tu avais raison, en cas de faute sur le système de fichier, on avait l’alerte mais ça continuait et ça aurait planté, bien sûr.
Je crois avoir testé toutes les autres possibilités sans avoir rencontré d’erreur.
[code]#!/bin/bash
#+ Il est souhaitable que ces partitions soient sur un DD différent de celui qui abrite le système
#----------------- Fonctions ----------------------------
function test_sauvegarde()
{
sudo rsync -av --del --backup --backup-dir="$1" --exclude-from="$2" “$3” “$4”
# Teste si la sauvegarde a abouti ( = 0), sinon, on sort.
if (("$?" > 0))
then
printf "\nErreur lors de la sauvegarde de %s\n" "$3"
else
printf "\nSauvegarde de %s : OK\n" "$3"
fi
}
function sortie_propre()
{
if [ "$deja_montee" = 0 ]
then
sudo umount "$mount_rep"
else
# Si la partition de sauvegarde était déjà montée lors de l'appel, on sort sans la démonter.
sync
fi
exit
}
#----------------- Variables -------------------
mount_rep="/mnt/autre"
ddext=(’’ ‘/dev/sdb9’ ‘/dev/sdb10’)
systeme_fich=(’’ ‘ext3’ ‘ext2’)
controle=(’’ ‘/home/controle’ ‘/home/controle-ricardo’)
exclure=(’’ ‘/root/exclure’ ‘/home/ricardo/.exclure’)
sauve=(’’ ‘/mnt/autre/sauve’ ‘/mnt/autre/sauve-ricardo’)
dossier_a_sauver=(’’ ‘/’ ‘/home/ricardo’)
#----------------- Départ du script ----------------------------
[ -e "${ddext[1]}" ] && [ -e "${ddext[2]}" ] || { echo "Le DDext ne répond pas !" >&2; exit 1; }
mkdir -p "$mount_rep" || { echo "Le dossier de montage n'existe pas !" >&2; exit 1; }
deja_montee=0
PS3="Entrez le N° de la sauvegarde choisie : "
select sauvegarde in “sauve” “sauve2” quitter
do
case ${REPLY} in
[1-2])
index=${REPLY}
if ! grep -q “^${ddext[$index]} “$mount_rep” ${systeme_fich[$index]}” /etc/mtab
then
sudo mount -t “${systeme_fich[$index]}” “${ddext[$index]}” “$mount_rep” || sortie_propre
break
else
printf "Info : La partition ${ddext[$index]} est déjà montée\n"
deja_montee=1
break
fi
;;
3) echo “On sort du script”; sortie_propre
;;
*) echo “Saisie non valide !”
;;
esac
done
echo -e "\033[4mCONTENU de la CORBEILLE\033[0m\n"
if [ -e ~/.local/share/Trash/files/ ]
then
ls ~/.local/share/Trash/files
read -p "on peut la vider ? o/* : " corbeille
if [ “$corbeille” = o ]
then
rm -rf ~/.local/share/Trash/*
echo -e "\033[4mCORBEILLE VIDÉE\033[0m"
fi
else
echo "La corbeille est vide"
fi
read -p "prêt pour la sauvegarde ? o/* : " onyva
if [ “$onyva” = o ]
then
for((index=1; index < ${#controle[@]}; index++))
do
test_sauvegarde “${controle[$index]}” “${exclure[$index]}” “${dossier_a_sauver[$index]}” “${sauve[$index]}”
done
else
sortie_propre
fi
[/code]
Un petit détail.
Que ce passe t’il quand la sauvegarde se passe bien ?
Petit trucs cosmétique : la fonction test_sauvegarde() se content-elle de tester si la sauvegarde s’est bien passée ?