29. Débogage

#!/bin/bash
# ex74.sh

# C'est un script bogué.
# Où est donc l'erreur ?

a=37

if [$a -gt 27 ]
then
  echo $a
fi  

exit 0

#!/bin/bash
# missing-keyword.sh : Quel message d'erreur sera généré ?

for a in 1 2 3
do
  echo "$a"
# done     # Requiert le mot clé 'done' mis en commentaire ligne 7.

exit 0  

#!/bin/bash

#  Ce script est supposé supprimer tous les fichiers du répertoire courant
#+ contenant des espaces dans le nom.
#  Cela ne fonctionne pas.
#  Pourquoi ?


mauvaisnom=`ls | grep ' '`

# Essayez ceci :
# echo "$mauvaisnom"

rm "$mauvaisnom"

exit 0

#!/bin/bash
# Chasse aux variables avec un piège.

trap 'echo Liste de Variables --- a = $a  b = $b' EXIT
# EXIT est le nom du signal généré en sortie d'un script.
#
#  La commande spécifiée par le "trap" ne s'exécute pas
#+ tant que le signal approprié n'est pas envoyé.

echo "Ceci s'affiche avant le \"trap\" -- "
echo "même si le script voit le \"trap\" avant"
echo

a=39

b=36

exit 0
# Notez que mettre en commentaire la commande 'exit' ne fait aucune différence
# car le script sort dans tous les cas après avoir exécuté les commandes.

#!/bin/bash
# logon.sh: Un script rapide mais sale pour vérifier si vous êtes déjà connecté.

umask 177  #  S'assurer que les fichiers temporaires ne sont pas lisibles
           #+ par tout le monde.

VRAI=1
JOURNAL=/var/log/messages
# Notez que $JOURNAL doit être lisible (en tant que root, chmod 644 /var/log/messages).
FICHIER_TEMPORAIRE=temp.$$
# Crée un fichier temporaire "unique" en utilisant l'identifiant du processus.
#     Utiliser 'mktemp' est une alternative.
#     Par exemple :
#     FICTMP=`mktemp temp.XXXXXX`
MOTCLE=adresse
# À la connexion, la ligne "remote IP address xxx.xxx.xxx.xxx"
#                     ajoutée à /var/log/messages.
ENLIGNE=22
INTERRUPTION_UTILISATEUR=13
VERIFIE_LIGNES=100
# Nombre de lignes à vérifier dans le journal.

trap 'rm -f $FICHIER_TEMPORAIRE; exit $INTERRUPTION_UTILISATEUR' TERM INT
# Nettoie le fichier temporaire si le script est interrompu avec Control-C.

echo

while [ $VRAI ]  # Boucle sans fin.
do
  tail -n $VERIFIE_LIGNES $JOURNAL> $FICHIER_TEMPORAIRE
  # Sauve les 100 dernières lignes du journal dans un fichier temporaire.
  # Nécessaire car les nouveaux noyaux génèrent beaucoup de messages lors de la
  # connexion.
  search=`grep $MOTCLE $FICHIER_TEMPORAIRE`
  # Vérifie la présence de la phrase "IP address"
  # indiquant une connexion réussie.

  if [ ! -z "$search" ] # Guillemets nécessaires à cause des espaces possibles.
  then
     echo "En ligne"
     rm -f $FICHIER_TEMPORAIRE    # Suppression du fichier temporaire.
     exit $ENLIGNE
  else
     echo -n "."        # l'option -n supprime les retours à la ligne de echo,
                        # de façon à obtenir des lignes de points continus.
  fi

  sleep 1  
done  


# Note : Si vous modifiez la variable MOTCLE par "Exit",
# ce script peut être utilisé lors de la connexion pour vérifier une déconnexion
# inattendue.

# Exercice : Modifiez le script, suivant la note ci-dessus, et embellissez-le.

exit 0


# Nick Drage suggère une autre méthode.

while true
  do ifconfig ppp0 | grep UP 1> /dev/null && echo "connecté" && exit 0
  echo -n "."   # Affiche des points (.....) jusqu'au moment de la connexion.
  sleep 2
done

# Problème : Appuyer sur Control-C pour terminer ce processus peut être
# insuffisant (des points pourraient toujours être affichés).
# Exercice : Corrigez ceci.



# Stéphane Chazelas a lui-aussi suggéré une autre méthode.

CHECK_INTERVAL=1

while ! tail -n 1 "$JOURNAL" | grep -q "$MOTCLE"
do echo -n .
   sleep $CHECK_INTERVAL
done
echo "On-line"

# Exercice : Discutez les avantages et inconvénients de chacune des méthodes.

#!/bin/bash
# parent.sh
# Exécuter plusieurs processus sur une machine SMP.
# Auteur : Tedman Eng

#  Ceci est le premier de deux scripts,
#+ les deux étant présent dans le même répertoire courant.




LIMITE=$1         # Nombre total de processus à lancer
NBPROC=4          # Nombre de threads simultanés (processus fils ?)
IDPROC=1          # ID du premier processus
echo "Mon PID est $$"

function lance_thread() {
        if [ $IDPROC -le $LIMITE ] ; then
                ./child.sh $IDPROC&
                let "IDPROC++"
        else
           echo "Limite atteinte."
           wait
           exit
        fi
}

while [ "$NBPROC" -gt 0 ]; do
        lance_thread;
        let "NBPROC--"
done


while true
do

trap "lance_thread" SIGRTMIN

done

exit 0



# ======== Le deuxième script suit ========


#!/bin/bash
# child.sh
# Lancer plusieurs processus sur une machine SMP.
# Ce script est appelé par parent.sh.
# Auteur : Tedman Eng

temp=$RANDOM
index=$1
shift
let "temp %= 5"
let "temp += 4"
echo "Début $index  Temps :$temp" "$@"
sleep ${temp}
echo "Fin   $index"
kill -s SIGRTMIN $PPID

exit 0


# ==================== NOTES DE L'AUTEUR DU SCRIPT ==================== #
#  Ce n'est pas complètement sans bogue.
#  Je l'exécute avec limit = 500 et, après les premières centaines d'itérations,
#+ un des threads simultanés a disparu !
#  Pas sûr que ce soit dû aux collisions des signaux trap.
#  Une fois que le signal est reçu, le gestionnaire de signal est exécuté
#+ un bref moment mais le prochain signal est configuré.
#+ Pendant ce laps de temps, un signal peut être perdu,
#+ donc un processus fils peut manquer.

#  Aucun doute que quelqu'un va découvrir le bogue et nous l'indiquer
#+ ... dans le futur.



# ===================================================================== #



# ----------------------------------------------------------------------#



#################################################################
# Ce qui suit est le script original écrit par Vernia Damiano.
# Malheureusement, il ne fonctionne pas correctement.
#################################################################

# multiple-processes.sh : Lance plusieurs processus sur une machine
# multi-processeurs.

# Script écrit par Vernia Damiano.
# Utilisé avec sa permission.

#  Doit appeler le script avec au moins un paramètre de type entier
#+ (nombre de processus concurrents).
#  Tous les autres paramètres sont passés aux processus lancés.


INDICE=8                 # Nombre total de processus à lancer
TEMPO=5                  # Temps de sommeil maximum par processus
E_MAUVAISARGUMENTS=65    # Pas d'arguments passés au script.

if [ $# -eq 0 ] # Vérifie qu'au moins un argument a été passé au script.
then
  echo "Usage: `basename $0` nombre_de_processus [paramètres passés aux processus]"
  exit $E_MAUVAISARGUMENTS
fi

NBPROCESSUS=$1          # Nombre de processus concurrents
shift
PARAMETRI=( "$@" )      # Paramètres de chaque processus

function avvia() {
        local temp
        local index
        temp=$RANDOM
        index=$1
        shift
        let "temp %= $TEMPO"
        let "temp += 1"
        echo "Lancement de $index Temps:$temp" "$@"
        sleep ${temp}
        echo "Fin $index"
        kill -s SIGRTMIN $$
}

function parti() {
        if [ $INDICE -gt 0 ] ; then
                avvia $INDICE "${PARAMETRI[@]}" &
                let "INDICE--"
        else
                trap : SIGRTMIN
        fi
}

trap parti SIGRTMIN

while [ "$NBPROCESSUS" -gt 0 ]; do
        parti;
        let "NBPROCESSUS--"
done

wait
trap - SIGRTMIN

exit $?

: <<COMMENTAIRES_AUTEUR_SCRIPT
J'avais besoin de lancer un programme avec des options spécifiées sur un certain
nombre de fichiers différents en utilisant une machine SMP. Donc, j'ai pensé
conserver un certain nombre de processus en cours et en lancer un à chaque fois
qu'un autre avait terminé.

L'instruction "wait" n'aide pas car il attend un processus donné ou "tous" les
processus exécutés en arrière-plan. Donc, j'ai écrit ce script bash, réalisant ce
travail en utilisant l'instruction "trap".
  --Vernia Damiano
COMMENTAIRES_AUTEUR_SCRIPT