Capitolo 29. Debugging

#!/bin/bash
# ex74.sh

# Questo è uno script errato.
# Ma dove sarà mai l'errore?

a=37

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

exit 0

#!/bin/bash
# missing-keyword.sh: Che messaggio d'errore verrà generato?

for a in 1 2 3
do
  echo "$a"
# done     #  La necessaria parola chiave 'done', alla riga 7, 
           #+ è stata commentata.

exit 0  

#!/bin/bash

#  Si suppone che questo script possa cancellare tutti i file della
#+ directory corrente i cui nomi contengono degli spazi.
#  Non funziona.  
#  Perché?


bruttonome=`ls | grep ' '`

# Provate questo:
# echo "$bruttonome"

rm "$bruttonome"

exit 0

#!/bin/bash
# Andare a caccia di variabili con trap.

trap 'echo Elenco Variabili --- a = $a  b = $b' EXIT
#  EXIT è il nome del segnale generato all'uscita dallo script.

#  Il comando specificato in "trap" non viene eseguito finché
#+ non è stato inviato il segnale appropriato.

echo "Questa visualizzazione viene eseguita prima di \"trap\" --"
echo "nonostante lo script veda prima \"trap\"."
echo

a=39

b=36

exit 0
#  Notate che anche se si commenta il comando 'exit' questo non fa
#+ alcuna differenza, poiché lo script esce in ogni caso dopo
#+ l'esecuzione dei comandi.

#!/bin/bash
#  logon.sh: Un rapido e rudimentale script per verificare se si
#+ è ancora collegati.

umask 177  #  Per essere certi che i file temporanei non siano leggibili dal
           #+ mondo intero.


TRUE=1
FILELOG=/var/log/messages
#  Fate attenzione che $FILELOG deve avere i permessi di lettura
#+ (da root, chmod 644 /var/log/messages).
FILETEMP=temp.$$
#  Crea un file temporaneo con un nome "univoco", usando l'id di
#+ processo dello script.
#     Un'alternativa è usare 'mktemp'.
#     Per esempio:
#     FILETEMP=`mktemp temp.XXXXXX`
PAROLACHIAVE=address
#  A collegamento avvenuto, la riga "remote IP address xxx.xxx.xxx.xxx"
#                                    viene accodata in /var/log/messages.
COLLEGATO=22
INTERRUPT_UTENTE=13
CONTROLLA_RIGHE=100
#  Numero di righe del file di log da controllare.

trap 'rm -f $FILETEMP; exit $INTERRUPT_UTENTE'; TERM INT
#  Cancella il file temporaneo se lo script viene interrotto con un control-c.

echo

while [ $TRUE ]  # Ciclo infinito.
do
  tail -n $CONTROLLA_RIGHE $FILELOG> $FILETEMP
  #  Salva le ultime 100 righe del file di log di sistema nel file
  #+ temporaneo. Necessario, dal momento che i kernel più
  #+ recenti generano molti messaggi di log durante la fase di avvio.
  ricerca=`grep $PAROLACHIAVE $FILETEMP`
  #  Verifica la presenza della frase "IP address",
  #+ che indica che il collegamento è riuscito.

  if [ ! -z "$ricerca" ] #  Sono necessari gli apici per la possibile
                         #+ presenza di spazi.
  then
     echo "Collegato"
     rm -f $FILETEMP     #  Cancella il file temporaneo.
     exit $COLLEGATO
  else
      echo -n "."        #  L'opzione -n di echo sopprime il ritorno a capo,
                         #+ così si ottengono righe continue di punti.
  fi

  sleep 1  
done  


#  Nota: se sostituite la variabile PAROLACHIAVE con "Exit",
#+ potete usare questo script per segnalare, mentre si è collegati,
#+ uno scollegamento inaspettato.

#  Esercizio: Modificate lo script per ottenere quanto suggerito nella
#             nota precedente, rendendolo anche più elegante.

exit 0


# Nick Drage ha suggerito un metodo alternativo:

while true
  do ifconfig ppp0 | grep UP 1> /dev/null && echo "connesso" && exit 0
  echo -n "."   # Visualizza dei punti (.....) finché si è connessi.
  sleep 2
done

# Problema: Può non bastare premere Control-C per terminare il processo.
#+          (La visualizzazione dei punti potrebbe continuare.)
# Esercizio: Risolvetelo.



# Stephane Chazelas ha un'altra alternativa ancora:

INTERVALLO=1

while ! tail -n 1 "$FILELOG" | grep -q "$PAROLACHIAVE"
do echo -n .
   sleep $INTERVALLO
done
echo "Connesso"

# Esercizio: Discutete i punti di forza e i punti deboli
#            di ognuno di questi differenti approcci.

#!/bin/bash
# parent.sh
# Eseguire processi multipli su una postazione SMP.*
# * SMP=Symmetric multiprocessing: multiprocessore simmetrico [N.d.T.]
# Autore: Tedman Eng

#  Questo è il primo di due script,
#+ entrambi i quali devono essere presenti nella directory di lavoro corrente.




LIMITE=$1        # Numero totale dei processi da mettere in esecuzione
NUMPROC=4        # Numero di thread concorrenti (fork?)
PROCID=1         # ID del processo che sta per partire
echo "Il mio PID è $$"

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

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


while true
do

trap "inizia_thread" SIGRTMIN

done

exit 0



# ======== Secondo script ========


#!/bin/bash
# child.sh
# Eseguire processi multipli su una postazione SMP.
# Questo script viene richiamato da parent.sh.
# Autore: Tedman Eng

temp=$RANDOM
indice=$1
shift
let "temp %= 5"
let "temp += 4"
echo "Inizio $indice  Tempo:$temp" "$@"
sleep ${temp}
echo "Termino $indice"
kill -s SIGRTMIN $PPID

exit 0


# =================== NOTA DELL'AUTORE DELLO SCRIPT ==================== #
#  Non è completamente esente da errori.
#  L'ho eseguito con limite = 500 e dopo poche centinaia di iterazioni,
#+ uno dei thread concorrenti è scomparso!
#  Non sono sicuro che si tratti di collisioni dal trap dei segnali
#+ o qualcos'altro.
#  Una volta ricevuto il trap, intercorre un breve lasso di tempo tra 
#+ l'esecuzione del gestore del trap e l'impostazione del trap successivo.
#+ In questo intervallo il segnale di trap potrebbe andar perso e,
#+ conseguentemente, anche la generazione del processo figlio.

#  Non ho alcun dubbio che qualcuno riuscirà a individuare il "bug"
#+ e a lavorerci sopra . . . in futuro.



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


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



##################################################################
# Quello che segue è lo script originale scritto da Vernia Damiano.
# Sfortunatamente non funziona correttamente.
##################################################################

#!/bin/bash

#  Lo script deve essere richiamato con almeno un parametro numerico
#+ (numero dei processi simultanei).
#  Tutti gli altri parametri sono passati ai processi in esecuzione.


INDICE=8        # Numero totale di processi da mettere in esecuzione
TEMPO=5         # Tempo massimo d'attesa per processo
E_NOARG=65      # Nessun argomento(i) passato allo script.

if [ $# -eq 0 ] # Controlla la presenza di almeno un argomento.
then
  echo "Utilizzo: `basename $0` numero_dei_processi [parametri passati]"
  exit $E_NOARG
fi

NUMPROC=$1              # Numero dei processi simultanei
shift
PARAMETRI=( "$@" )      # Parametri di ogni processo

function avvia() {
	local temp
	local index
	temp=$RANDOM
	index=$1
	shift
	let "temp %= $TEMPO"
	let "temp += 1"
	echo "Inizia $index Tempo:$temp" "$@"
	sleep ${temp}
	echo "Termina $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 $?

: <<COMMENTO_DELL'AUTORE_DELLO_SCRIPT
Avevo la necessità di eseguire un programma, con determinate opzioni, su un
numero diverso di file, utilizzando una macchina SMP. Ho pensato, quindi, di
mantenere in esecuzione un numero specifico di processi e farne iniziare uno
nuovo ogni volta . . . che uno di quest'ultimi terminava.

L'istruzione "wait" non è d'aiuto, poichè attende sia per un dato processo
sia per *tutti* i processi in esecuzione sullo sfondo (background). Ho scritto,
di conseguenza, questo script che è in grado di svolgere questo compito,
usando l'istruzione "trap".
  --Vernia Damiano
COMMENTO_DELL'AUTORE_DELLO_SCRIPT