Script di shell di uscita basato sul codice di uscita del processo

Ho uno script di shell che esegue una serie di comandi. Come faccio a chiudere lo script della shell se uno dei comandi esce con un codice di uscita diverso da zero?

Dopo ogni comando, il codice di uscita può essere trovato nella $?variabile in modo da avere qualcosa del tipo:

ls -al file.ext
rc=$?; if [[ $rc != 0 ]]; then exit $rc; fi

Devi stare attento ai comandi piped poiché l' $?unico ti dà il codice di ritorno dell'ultimo elemento nella pipe così, nel codice:

ls -al file.ext | sed 's/^/xx: /"

non restituirà un codice di errore se il file non esiste (poiché il file sed parte della pipeline funziona effettivamente, restituendo 0).

La bashshell in realtà fornisce un array che può aiutare in quel caso, quell'essere PIPESTATUS. Questo array ha un elemento per ciascuno dei componenti della pipeline, a cui puoi accedere individualmente come ${PIPESTATUS[0]}:

pax> false | true ; echo ${PIPESTATUS[0]}
1

Si noti che questo ti sta ottenendo il risultato del falsecomando, non l'intera pipeline. Puoi anche far elaborare l'intero elenco come ritieni opportuno:

pax> false | true | false; echo ${PIPESTATUS[*]}
1 0 1

Se si desidera ottenere il codice di errore più grande da una pipeline, è possibile utilizzare qualcosa del tipo:

true | true | false | true | false
rcs=${PIPESTATUS[*]}; rc=0; for i in ${rcs}; do rc=$(($i > $rc ? $i : $rc)); done
echo $rc

Questo passa attraverso ciascuno degli PIPESTATUSelementi a sua volta, memorizzandolo rcse fosse maggiore del rcvalore precedente .

Se vuoi lavorare con $?, Dovrai controllarlo dopo ogni comando, dato che $? viene aggiornato dopo la chiusura di ciascun comando. Ciò significa che se si esegue una pipeline, si otterrà solo il codice di uscita dell'ultimo processo nella pipeline.

Un altro approccio è quello di fare questo:

set -e
set -o pipefail

Se lo metti in cima allo script della shell, sembra che Bash se ne occuperà per te. Come notato da un precedente poster, "set -e" farà uscire bash con un errore su qualsiasi semplice comando. "set -o pipefail" causerà la chiusura di bash con un errore su qualsiasi comando in una pipeline.

Vedi qui o qui per ulteriori discussioni su questo problema. Ecco la sezione manuale di bash sul set incorporato.

" set -e" è probabilmente il modo più semplice per farlo. Metti questo prima di qualsiasi comando nel tuo programma.

Se si chiama exit in bash senza parametri, verrà restituito il codice di uscita dell'ultimo comando. In combinazione con OR, bash dovrebbe invocare exit solo se il comando precedente fallisce. Ma non l'ho provato.

comando1 || Uscita;
comando2 || Uscita;

Bash memorizzerà anche il codice di uscita dell'ultimo comando nella variabile $ ?.

[ $? -eq 0 ] || exit $?; # exit for none-zero return code

http://cfaj.freeshell.org/shell/cus-faq-2.html#11

11. Come ottengo il codice di uscita di cmd1incmd1|cmd2

    Innanzitutto, nota che il cmd1codice di uscita potrebbe essere diverso da zero e comunque non significa un errore. Questo accade ad esempio in

    cmd | head -1

    potresti osservare uno stato di uscita 141 (o 269 con ksh93) di cmd1, ma è perché è cmdstato interrotto da un segnale SIGPIPE quando head -1terminato dopo aver letto una riga.

    Conoscere lo stato di uscita degli elementi di una pipeline cmd1 | cmd2 | cmd3

    un. con zsh:

    I codici di uscita sono forniti nell'array speciale pipestatus. cmd1il codice di uscita è inserito $pipestatus[1], il cmd3codice di uscita è attivo $pipestatus[3], quindi $?è sempre lo stesso di $pipestatus[-1].

    b. con bash:

    I codici di uscita sono forniti PIPESTATUSnell'array speciale. cmd1il codice di uscita è inserito ${PIPESTATUS[0]}, il cmd3codice di uscita è attivo ${PIPESTATUS[2]}, quindi $?è sempre lo stesso di ${PIPESTATUS: -1}.

    ...

    Per maggiori dettagli consultare il seguente link .

per bash:

# this will trap any errors or commands with non-zero exit status
# by calling function catch_errors()
trap catch_errors ERR;

#
# ... the rest of the script goes here
#  

function catch_errors() {
   # do whatever on errors
   # 
   #
   echo "script aborted, because of errors";
   exit 0;
}

In bash questo è facile, basta collegarli con &&:

command1 && command2 && command3

Puoi anche usare il nidificato se costrutto:

if command1
   then
       if command2
           then
               do_something
           else
               exit
       fi
   else
       exit
fi

#
#------------------------------------------------------------------------------
# run a command on failure exit with message
# doPrintHelp: doRunCmdOrExit "$cmd"
# call by:
# set -e ; doRunCmdOrExit "$cmd" ; set +e
#------------------------------------------------------------------------------
doRunCmdOrExit(){
    cmd="$@" ;

    doLog "DEBUG running cmd or exit: \"$cmd\""
    msg=$($cmd 2>&1)
    export exit_code=$?

    # if occured during the execution exit with error
    error_msg="Failed to run the command:
        \"$cmd\" with the output:
        \"$msg\" !!!"

    if [ $exit_code -ne 0 ] ; then
        doLog "ERROR $msg"
        doLog "FATAL $msg"
        doExit "$exit_code" "$error_msg"
    else
        #if no errors occured just log the message
        doLog "DEBUG : cmdoutput : \"$msg\""
        doLog "INFO  $msg"
    fi

}
#eof func doRunCmdOrExit