¿Ocultar el resultado de un comando de shell solo en caso de éxito?

Ocultar el resultado de un comando de shell generalmente implica redirigir stderr y stdout. ¿Hay alguna instalación o comando incorporado que, de forma predeterminada, oculta la salida pero, por error, voltea toda la salida acumulada? Me gustaría ejecutar esto como un contenedor para sshcomandos remotos . Ahora los tengo usando la redirección, pero no tengo ni idea de qué los hizo fallar, y son demasiado detallados.

EDITAR: Al final, creé la siguiente plantilla basada en la respuesta de @Belmin que modifiqué un poco para acumular todos los comandos anteriores del script, usar el identificador de proceso actual, eliminar automáticamente el registro y agregar un error rojo de falla mensaje cuando algo sale mal. En esta plantilla, los silentcontenedores iniciales tendrán éxito, luego fallarán el tercer comando porque el directorio ya existe:

#!/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

Configuraría una función bash como esta:

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; }

Entonces, puedes ejecutar el comando:

suppress foo -a bar

Debería ser bastante fácil escribir un script para este propósito.

Algo así como este script completamente no probado.

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

Por otro lado, para los comandos que ejecuto como parte de un script, generalmente quiero algo mejor que simplemente imprimir toda la salida. A menudo limito lo que veo a lo desconocido. Aquí hay un guión que adapté de algo que leí hace más de una década.

#!/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 $?

No creo que haya una manera limpia de hacer esto, lo único que puedo pensar es

• Capture la salida del comando.
• Verifique el valor de retorno del comando y si falla
  • Muestra la salida capturada.

Sin embargo, implementar esto podría ser un proyecto interesante pero quizás más allá de las preguntas y respuestas.

quedando corto con algo como tehcommand &>/tmp/$$ || cat /tmp/$$

depende de la facilidad de uso / escritura que desee / necesite. (por ejemplo, usarlo como una tubería o pasar el comando por argumento)

El script corto @zoredache es básicamente un prototipo para esto, lo que daría más solidez, manejaría la concurrencia, etc.

Inténtalo así:

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