Come verificare se una pipe è vuota ed eseguire un comando sui dati se non lo è?

Ho reindirizzato una riga nello script bash e voglio verificare se la pipe ha dati, prima di inviarli a un programma.

Cercando ho scoperto test -t 0ma non funziona qui. Restituisce sempre falso. Quindi, come essere sicuri che la pipe abbia dati?

Esempio:

echo "string" | [ -t 0 ] && echo "empty" || echo "fill"

Produzione: fill

echo "string" | tail -n+2 | [ -t 0 ] && echo "empty" || echo "fill"

Produzione: fill

A differenza del modo standard / canonico per verificare se la pipeline precedente ha prodotto output? l'input deve essere preservato per passarlo al programma. Questo in generale Come convogliare l'output da un processo a un altro ma eseguirlo solo se il primo ha output? che si concentra sull'invio di e-mail.

Non c'è modo di sbirciare il contenuto di una pipe usando le utilità di shell comunemente disponibili, né c'è un modo per leggere un personaggio nella pipe e poi rimetterlo. L'unico modo per sapere che una pipe ha dati è leggere un byte, quindi devi portarlo a destinazione.

Quindi fai proprio questo: leggi un byte; se rilevi una fine del file, fai quello che vuoi fare quando l'input è vuoto; se si legge un byte, quindi fork ciò che si desidera fare quando l'input non è vuoto, reindirizzare quel byte e reindirizzare il resto dei dati.

first_byte=$(dd bs=1 count=1 2>/dev/null | od -t o1 -A n | tr -dc 0-9)
if [ -z "$first_byte" ]; then
  # stuff to do if the input is empty
else
  {
    printf "\\$first_byte"
    cat
  } | {
    # stuff to do if the input is not empty
  }      
fi

L' ifneutility dai moreutils di Joey Hess esegue un comando se il suo input non è vuoto. Di solito non è installato di default, ma dovrebbe essere disponibile o facile da costruire sulla maggior parte delle varianti unix. Se l'input è vuoto, ifnenon fa nulla e restituisce lo stato 0, che non può essere distinto dal comando eseguito correttamente. Se si desidera fare qualcosa se l'input è vuoto, è necessario disporre che il comando non restituisca 0, operazione che può essere eseguita facendo in modo che il caso di successo restituisca uno stato di errore distinguibile:

ifne sh -c 'do_stuff_with_input && exit 255'
case $? in
  0) echo empty;;
  255) echo success;;
  *) echo failure;;
esac

test -t 0non ha nulla a che fare con questo; verifica se l'input standard è un terminale. In un modo o nell'altro non dice nulla sulla disponibilità di input.

Una soluzione semplice è usare il ifnecomando (se l'input non è vuoto). In alcune distribuzioni, non è installato per impostazione predefinita. Fa parte del pacchetto moreutilsnella maggior parte delle distribuzioni.

ifne esegue un determinato comando se e solo se l'input standard non è vuoto

Se l'input standard non è vuoto, viene passato ifneal comando dato

Vecchia domanda, ma nel caso qualcuno lo incontri come ho fatto io: la mia soluzione è leggere con un timeout.

while read -t 5 line; do
    echo "$line"
done

Se stdinè vuoto, questo ritornerà dopo 5 secondi. Altrimenti leggerà tutti gli input e potrai elaborarli secondo necessità.

controlla se il descrittore di file di stdin (0) è aperto o chiuso:

[ ! -t 0 ] && echo "stdin has data" || echo "stdin is empty"

È inoltre possibile utilizzare test -s /dev/stdin(in una subshell esplicita).

# test if a pipe is empty or not
echo "string" | 
    (test -s /dev/stdin && echo 'pipe has data' && cat || echo 'pipe is empty')

echo "string" | tail -n+2 | 
    (test -s /dev/stdin && echo 'pipe has data' && cat || echo 'pipe is empty')

: | (test -s /dev/stdin && echo 'pipe has data' && cat || echo 'pipe is empty')

In bash:

read -t 0 

Rileva se un input ha dati (senza leggere nulla). Quindi è possibile leggere l'input (se l'input è disponibile al momento dell'esecuzione della lettura):

if     read -t 0
then   read -r input
       echo "got input: $input"
else   echo "No data to read"
fi

Nota: capire che questo dipende dai tempi. Questo rileva se l'input ha già dati solo al momento read -tdell'esecuzione.

Ad esempio, con

{ sleep 0.1; echo "abc"; } | read -t 0; echo "$?"

l'uscita è 1(errore di lettura, ovvero: input vuoto). L'eco scrive alcuni dati ma non è molto veloce da avviare e scrive il suo primo byte, quindi read -t 0segnalerà che il suo input è vuoto, poiché il programma non ha ancora scritto nulla.

Un modo semplice per verificare se ci sono dati disponibili per la lettura in Unix è con FIONREADioctl.

Non riesco a pensare a nessuna utility standard che fa proprio questo, quindi ecco un programma banale che lo fa (meglio di ifnefromoututils IMHO ;-)).

fionread [ prog args ... ]

Se non ci sono dati disponibili su stdin, uscirà con lo stato 1. Se ci sono dati, verrà eseguito prog. Se non progviene fornito, verrà chiuso con lo stato 0.

Puoi rimuovere la pollchiamata se sei interessato solo ai dati immediatamente disponibili. Questo dovrebbe funzionare con la maggior parte dei tipi di fds, non solo con pipe.

fionread.c

#include <unistd.h>
#include <poll.h>
#include <sys/ioctl.h>
#ifdef __sun
#include <sys/filio.h>
#endif
#include <err.h>

int main(int ac, char **av){
        int r; struct pollfd pd = { 0, POLLIN };
        if(poll(&pd, 1, -1) < 0) err(1, "poll");
        if(ioctl(0, FIONREAD, &r)) err(1, "ioctl(FIONREAD)");
        if(!r) return 1;
        if(++av, --ac < 1) return 0;
        execvp(*av, av);
        err(1, "execvp %s", *av);
}

Se ti piacciono i one-liner corti e criptici:

$ echo "string" | grep . && echo "fill" || echo "empty"
string
fill
$ echo "string" | tail -n+2 | grep . && echo "fill" || echo "empty"
empty

Ho usato gli esempi della domanda originale. Se non si desidera che i dati convogliati utilizzare l' -qopzione con grep

Questa sembra essere un'implementazione ifne ragionevole in bash se stai bene leggendo l'intera prima riga

ifne () {
        read line || return 1
        (echo "$line"; cat) | eval "$@"
}


echo hi | ifne xargs echo hi =
cat /dev/null | ifne xargs echo should not echo

Questo funziona per me usando read -rt 0

esempio dalla domanda originale, senza dati:

echo "string" | tail -n+2 | if read -rt 0 ; then echo has data ; else echo no data ; fi