32. 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
# progress-bar2.sh
# Auteur : Graham Ewart (script remis en forme par l'auteur
#          du Guide ABS).
# Utilisé avec l'accord de l'auteur (merci !).
# Traduction : Jean-Philippe Guérard

# Lancez ce script avec bash, il ne marche pas avec sh.

intervalle=1
intervalle_long=10

{
     trap "exit" SIGUSR1
     sleep $intervalle; sleep $intervalle
     while true
     do
       echo -n '.'     # Affiche des points.
       sleep $intervalle
     done; } &         # Lance la barre de progression en tâche de fond.

pid=$!
trap "echo !; kill -USR1 $pid; wait $pid"  EXIT        # Pour gérer ^C.

echo -n 'Processus long '
sleep $intervalle_long
echo ' Fini !'

kill -USR1 $pid
wait $pid              # Arrête la barre de progression.
trap EXIT

exit $?

#!/bin/bash
# parent.sh
# Running multiple processes on an SMP box.
# Author: Tedman Eng

#  This is the first of two scripts,
#+ both of which must be present in the current working directory.




LIMIT=$1         # Total number of process to start
NUMPROC=4        # Number of concurrent threads (forks?)
PROCID=1         # Starting Process ID
echo "My PID is $$"

function start_thread() {
        if [ $PROCID -le $LIMIT ] ; then
                ./child.sh $PROCID&
                let "PROCID++"
        else
           echo "Limit reached."
           wait
           exit
        fi
}

while [ "$NUMPROC" -gt 0 ]; do
        start_thread;
        let "NUMPROC--"
done


while true
do

trap "start_thread" SIGRTMIN

done

exit 0



# ======== Second script follows ========


#!/bin/bash
# child.sh
# Running multiple processes on an SMP box.
# This script is called by parent.sh.
# Author: Tedman Eng

temp=$RANDOM
index=$1
shift
let "temp %= 5"
let "temp += 4"
echo "Starting $index  Time:$temp" "$@"
sleep ${temp}
echo "Ending $index"
kill -s SIGRTMIN $PPID

exit 0


# ======================= SCRIPT AUTHOR'S NOTES ======================= #
#  It's not completely bug free.
#  I ran it with limit = 500 and after the first few hundred iterations,
#+ one of the concurrent threads disappeared!
#  Not sure if this is collisions from trap signals or something else.
#  Once the trap is received, there's a brief moment while executing the
#+ trap handler but before the next trap is set.  During this time, it may
#+ be possible to miss a trap signal, thus miss spawning a child process.

#  No doubt someone may spot the bug and will be writing 
#+ . . . in the future.



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



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



#################################################################
# The following is the original script written by Vernia Damiano.
# Unfortunately, it doesn't work properly.
#################################################################

#!/bin/bash

#  Must call script with at least one integer parameter
#+ (number of concurrent processes).
#  All other parameters are passed through to the processes started.


INDICE=8        # Total number of process to start
TEMPO=5         # Maximum sleep time per process
E_BADARGS=65    # No arg(s) passed to script.

if [ $# -eq 0 ] # Check for at least one argument passed to script.
then
  echo "Usage: `basename $0` number_of_processes [passed params]"
  exit $E_BADARGS
fi

NUMPROC=$1              # Number of concurrent process
shift
PARAMETRI=( "$@" )      # Parameters of each process

function avvia() {
         local temp
         local index
         temp=$RANDOM
         index=$1
         shift
         let "temp %= $TEMPO"
         let "temp += 1"
         echo "Starting $index Time:$temp" "$@"
         sleep ${temp}
         echo "Ending $index"
         kill -s SIGRTMIN $$
}

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

trap parti SIGRTMIN

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

wait
trap - SIGRTMIN

exit $?

: <<SCRIPT_AUTHOR_COMMENTS
I had the need to run a program, with specified options, on a number of
different files, using a SMP machine. So I thought [I'd] keep running
a specified number of processes and start a new one each time . . . one
of these terminates.

The "wait" instruction does not help, since it waits for a given process
or *all* process started in background. So I wrote [this] bash script
that can do the job, using the "trap" instruction.
  --Vernia Damiano
SCRIPT_AUTHOR_COMMENTS