Buffer de saída do comando completamente antes de canalizar para outro comando?

Existe uma maneira de executar apenas um comando depois que outro é feito sem um arquivo temporário? Eu tenho um comando mais em execução e outro comando que formata a saída e a envia para um servidor HTTP usando curl. Se eu apenas executar commandA | commandB, commandBiniciará curl, conectará ao servidor e começará a enviar dados. Como commandAleva tanto tempo, o servidor HTTP expirará. Eu posso fazer o que eu quero comcommandA > /tmp/file && commandB </tmp/file && rm -f /tmp/file

Por curiosidade, quero saber se existe uma maneira de fazer isso sem o arquivo temporário. Eu tentei, mbuffer -m 20M -q -P 100mas o processo de enrolamento ainda é iniciado logo no início. O Mbuffer aguarda apenas o término do commandAenvio dos dados. (Os dados em si são apenas algumas centenas de kb no máximo)

Isso é semelhante a algumas das outras respostas. Se você possui o pacote "moreutils", deve ter o spongecomando Tentar

commandA | sponge | { IFS= read -r x; { printf "%s\n" "$x"; cat; } | commandB; }

O spongecomando é basicamente um filtro de passagem (como cat), exceto que ele não começa a gravar a saída até ter lido toda a entrada. Ou seja, ele "absorve" os dados e os libera quando você os aperta (como uma esponja). Então, até certo ponto, isso é "trapaça" - se houver uma quantidade não trivial de dados, spongequase certamente usaremos um arquivo temporário. Mas é invisível para você; você não precisa se preocupar com tarefas domésticas, como escolher um nome de arquivo exclusivo e limpar depois.

A { IFS= read -r x; { printf "%s\n" "$x"; cat; } | commandB; } lê a primeira linha de saída do sponge. Lembre-se, isso não aparece até commandAterminar.  Em seguida, ele dispara commandB, grava a primeira linha no canal e chama catpara ler o restante da saída e gravá-lo no canal.

Os comandos na linha de tubulação são iniciados simultaneamente, você precisa armazenar a commandAsaída em algum lugar para usar posteriormente. Você pode evitar o arquivo temporário usando a variável:

output=$(command A; echo A)
printf '%s' "${output%%A}" | commandB

Não conheço nenhum utilitário UNIX padrão que possa resolver esse problema. Uma opção seria usar awkpara acumular commandAsaída e liberá-la de commandBuma só vez, como

commandA  | awk '{x = x ORS $0}; END{printf "%s", x | "commandB"}'

Lembre-se de que isso pode exigir muita memória, pois awkestá construindo uma sequência a partir de sua entrada.

Você pode resolver o requisito com um pequeno script. Essa variante específica evita o arquivo temporário e o possível consumo de memória à custa de processos adicionais.

#!/bin/bash
#
IFS= read LINE

if test -n "$LINE"
then
    test -t 2 && echo "Starting $*" >&2
    (
        echo "$LINE"
        cat

    ) | "$@"
else
    exit 0
fi

Se você chamasse o script waituntil(e o tornasse executável, coloque-o no PATH, etc), usaria assim

commandA... | waituntil commandB...

Exemplo

( sleep 3 ; date ; id ) | waituntil nl