Nascondere l'output di un comando shell solo in caso di successo?

Nascondere l'output di un comando shell di solito comporta il reindirizzamento di stderr e stdout. C'è qualche funzione o comando integrato che nasconde di default l'output ma in caso di errore scarica tutto l'output accumulato? Vorrei eseguire questo come wrapper per i sshcomandi remoti . Ora li ho usando il reindirizzamento, ma non ho idea di cosa li abbia fatti fallire, e sono troppo prolissi.

EDIT: Alla fine ho creato il seguente modello basato sulla risposta di @Belmin che ho modificato un po 'per accumulare tutti i comandi precedenti dallo script, utilizzare l'identificatore del processo corrente, rimuovere automaticamente il registro e aggiungere un errore rosso di errore messaggio quando qualcosa va storto. In questo modello i silentwrapper iniziali avranno esito positivo, quindi falliranno il terzo comando perché la directory esiste già:

#!/bin/sh

set -e

SILENT_LOG=/tmp/silent_log_$$.txt
trap "/bin/rm -f $SILENT_LOG" EXIT

function report_and_exit {
    cat "${SILENT_LOG}";
    echo "\033[91mError running command.\033[39m"
    exit 1;
}

function silent {
    $* 2>>"${SILENT_LOG}" >> "${SILENT_LOG}" || report_and_exit;
}

silent mkdir -v pepe
silent mkdir -v pepe2
silent mkdir -v pepe
silent mkdir -v pepe2

Configurerei una funzione bash come questa:

function suppress { /bin/rm --force /tmp/suppress.out 2> /dev/null; ${1+"$@"} > /tmp/suppress.out 2>&1 || cat /tmp/suppress.out; /bin/rm /tmp/suppress.out; }

Quindi, potresti semplicemente eseguire il comando:

suppress foo -a bar

Dovrebbe essere abbastanza facile scrivere una sceneggiatura per questo scopo.

Qualcosa di simile a questo script completamente non testato.

OUTPUT=`tempfile`
program_we_want_to_capture &2>1 > $OUTPUT
[ $? -ne 0 ]; then
    cat $OUTPUT
    exit 1
fi
rm $OUTPUT

D'altra parte per i comandi che eseguo come parte di uno script di solito voglio qualcosa di meglio che semplicemente stampare tutto l'output. Spesso limito ciò che vedo all'ignoto. Ecco una sceneggiatura che mi sono adattata da qualcosa che ho letto più di dieci anni fa.

#!/bin/bash

the_command 2>&1 | awk '
BEGIN \
{
  # Initialize our error-detection flag.
  ErrorDetected = 0
}
# Following are regex that will simply skip all lines
# which are good and we never want to see
/ Added UserList source/ || \
/ Added User/ || \
/ init domainlist / || \
/ init iplist / || \
/ init urllist / || \
/ loading dbfile / || \
/^$/ {next} # Uninteresting message.  Skip it.

# Following are lines that we good and we always want to see
/ INFO: ready for requests / \
{
  print "  " $0 # Expected message we want to see.
  next
}

# any remaining lines are unexpected, and probably error messages.  These will be printed out and highlighted.
{
  print "->" $0 # Unexpected message.  Print it
  ErrorDetected=1
}

END \
{
  if (ErrorDetected == 1) {
    print "Unexpected messages (\"->\") detected in execution."
    exit 2
  }
}
'
exit $?

Non penso che ci sia un modo pulito per farlo, l'unica cosa che mi viene in mente è

• Cattura l'output del comando.
• Controllare il valore restituito dal comando e se ha esito negativo
  • visualizza l'output acquisito.

L'implementazione di questo potrebbe essere un progetto interessante ma forse al di là delle domande e risposte.

andare a corto di qualcosa del genere tehcommand &>/tmp/$$ || cat /tmp/$$

dipende da quanto usabilità / digitazione desideri / necessiti. (es. usandolo come pipe o passando il comando per argomento)

Lo script breve di @zoredache è sostanzialmente un proto-wrapper per questo, che darebbe più robustezza, gestirà la concorrenza, ecc.

Prova così:

out=`command args...` || echo $out