Como esperar que o programa termine e canalizar stdin para stdout quando terminar?

Aqui é onde está o caso de uso real - eu tenho um script bash que gostaria que apenas passasse stdin para stdout, depois que terminasse de dizer algo.

$ cat /etc/password | say_and_pass "stage 1" | grep -v test | say "stage 2"

O problema com o que você está tentando fazer aqui é que você parece ter dois fluxos de dados - um para saye outro para processamento de texto (ou seja, cate grep).

Você não pode usar um único pipeline para isso, pois isso apenas misturará os dados. cat /etc/passwd | sayfará com que seu computador tente falar todo o conteúdo do arquivo. Além disso, saynão grava nada na saída padrão, portanto, nada iria mais longe no pipeline.

Se você deseja "interromper" seu fluxo de processamento de dados para lidar com a saída separada para outros utilitários como say, você precisa configurar um FIFO (ou seja, um "pipe nomeado") para um ou outro de seus fluxos de dados ou usar arquivos temporários gravados em disco.

Seu caso de uso demonstrativo não é muito útil para um exemplo, pois, apesar dos says, você está apenas grepexecutando ping em um arquivo, o que pode ser feito em uma etapa com grep -v test /etc/passwd( cat file | grep patterné um uso inútil decat ).

Dito isso, um exemplo usando um arquivo de rascunho:

scratch=$(mktemp)
trap "rm -f $scratch" EXIT
cat /etc/passwd > $scratch
say "Stage one"
grep -v test $scratch
say "Stage two"

E um usou um pipe nomeado para say:

mkfifo youtalktoomuch
say youtalktoomuch &
exec 3> youtalktoomuch
do_thing_one
echo "Stage one" > youtalktoomuch
do_thing_two
echo "Stage two" > youtalktoomuch
exec 3>&-
rm youtalktoomuch

Once again, though, if you need to connect the output of `do_thing_one` to the input of `do_thing_two` without piping one into the other, you will need to use either another named pipe or a scratch file on disk to hold the data.

Acontece que tudo o que tive que fazer foi consumir todo o stdin no início do meu script ... Não quero que ele processe o stdin quando for recebido, mas quando todo o comando anterior na cadeia de pipes for concluído.

Portanto, meu say_and_passscript é simplesmente este, que funciona para o meu caso de uso!

#!/usr/bin/env bash

OUT=$(cat -)

MSG="$*"
say "$MSG"

echo "$OUT"

Tentar:

say "stage 1" && cat /etc/passwd  |  { say "stage 2" && grep -v test ; }

Na verdade, não tenho sayno meu sistema, mas isso funciona:

espeak "stage 1" && cat /etc/passwd  |  { espeak "stage 2" && grep -v test ; }

H!

Sugiro, com base em sua própria resposta, apenas despejar stdin em stdout, removendo a parte que o armazena em uma variável. Isso deve reduzir o consumo de memória e fazer com que a cadeia de pipes funcione como os pipes deveriam (uma linha é processada e o resultado enviado para o próximo processo).

#!/usr/bin/env bash

MSG="$*"
say "$MSG"

cat -

Esta versão say_and_passfaz o que o OP pede:

#!/usr/bin/env bash

# Create a temporary file to store stdin
TEMP_STDIN="$(mktemp)"

# Capture stdin and save it to temporary file
cat - > "${TEMP_STDIN}"

# say message, but prevent any output to stdout
say "$@" > /dev/null

# Dump saved stdin to stdout
cat "${TEMP_STDIN}"

# Clean up, but prevent any output to stdout
rm -f "${TEMP_STDIN}" > /dev/null

Ele usa um arquivo temporário, como @DopeGhoti sugere, mas mantém qualquer outra lógica (o grep, por exemplo) fora do script. Isso o torna say_and_passmais geral e reutilizável.

Minha interpretação do objetivo/propósito é que queremos uma forma audível de monitorar o progresso de um pipeline potencialmente longo.

Então, ao executar:

cmd1 | say_and_pass "stage 1" | cmd2 | say_and_pass "stage 2"

Como usuário, você pode saber de forma audível que cmd1concluiu totalmente sua execução; a desvantagem é que cmd2não pode começar a processar seu stdin até que cmd1esteja completo. Mas parece que o OP está ciente dessa troca e disposto a fazê-la.

Isso é semelhante à resposta de @BradParks, mas não é limitado pela memória disponível para bash (como @agc aponta) e é um pouco mais cuidadoso para evitar a poluição acidental de stdout.

Observe também que não há necessidade de capturar a mensagem em uma variável própria, então simplesmente encaminhamos "$@"para say.

#!/usr/bin/env bash
OUT="$*"
say "$OUT" | cat -

Se você usar &&, seu significado, faça o primeiro comando após o segundo comando, mas o resultado do primeiro comando não é importante para o segundo comando. Quer dizer, você tem 2 comandos diferentes, porque usa &&. Se você usar |, isso significa que o primeiro comando faz algo e dá algo para o segundo comando. No final, você deve fornecer um atributo para o comando cat. desculpe meu ingles a propósito