combina saída de dois comandos no bash

Question

É possível combinar a saída desses dois comandos?

node ~/projects/trunk/index.js 
python ~/projects/trunk/run.py run

Nenhum comando sai, por isso não sei como fazer isso.

    

Answer 1

Acabei fazendo isso, as outras sugestões não funcionaram, já que o segundo comando foi morto ou nunca executado.

alias app () {
    nohup python ~/projects/trunk/run.py run 1>/tmp/log 2>&1 &
    echo $! > /tmp/api.pid
    nohup node ~/projects/trunk/index.js 1>/tmp/log 2>&1 &
    echo $! > /tmp/client.pid
    tail -f /tmp/log
}

    

Answer 2

Você pode combinar dois comandos agrupando-os com { } :

{ command1 & command2; }

até agora, você pode redirecionar o grupo para um arquivo (último ; antes de } ser obrigatório):

{ command1 & command2; } > new_file

se você quiser separar STDOUT e STDERR em dois arquivos:

{ command1 & command2; } > STDOUT_file 2> STDERR_file

    

Answer 3

Em geral, é possível usar um subshell ou um agrupamento de comandos e redirecionar a saída de todo o grupo de uma só vez.

Código:

( command1 ; command2 ; command3 ) | cat

{ command1 ; command2 ; command3 ; } > outfile.txt

A principal diferença entre os dois é que o primeiro divide um processo filho, enquanto o segundo opera no contexto do shell principal. Isso pode ter consequências em relação à configuração e uso de variáveis e outras configurações de ambiente, bem como desempenho.

Não se esqueça de que o colchete de fechamento no agrupamento de comandos (e funções) deve ser separado do conteúdo por um ponto-e-vírgula ou por uma nova linha. Isso ocorre porque "}" é, na verdade, um comando (palavra-chave) próprio e deve ser tratado como um.

    

Answer 4

Tente isto:

paste $(node ~/projects/trunk/index.js) $(python ~/projects/trunk/run.py run) > outputfile

    

Answer 5

A maioria das soluções até agora lida mal com o problema da linha parcial. Suponha por um segundo que os programas são:

cmd1() {
    perl -e 'while(1) { print "a"x3000_000,"\n"}'
}
export -f cmd1
cmd2() {
    perl -e 'while(1) { print "b"x3000_000,"\n"}'
}
export -f cmd2

Ao executá-los em paralelo, você deseja que a saída tenha linhas completas de a s seguidas por linhas completas de b s. O que você não quer é a s e b s misturando na mesma linha ( tr -s ab substitui a repetição a s por um único a , então é mais fácil ver o que acontece):

# This is bad - half lines are mixed
$ (cmd1 & cmd2 ) | tr -s ab
bababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
ababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab

Se você usar o GNU Parallel, você terá linhas cheias de linhas com a s ou b s, mas nunca misturadas:

$ parallel --line-buffer ::: cmd1 cmd2 | tr -s ab
a
a
b
b
b
b
a

Novas versões do GNU Parallel até evitam o preenchimento de seu disco: O acima pode ser executado para sempre.