ahmet alp balkan's questions

Estou tentando escrever um script bash que bifurca dois processos de servidor em segundo plano (cujo encerramento significa um problema), e esse script sairia assim que um deles terminasse (sem esperar pelo outro).

Aqui está o que eu tentei até agora:

Tentativa 1

waitUsando a diretiva bash . Isso não funcionou porque ainda aguarda a conclusão de ambos os processos. No meu caso, estou executando dois processos de servidor, portanto, se eles forem concluídos, significa que algo está errado, portanto, devo sair desse script completamente.

#!/usr/bin/env bash
set -e

./server1 &
pid1="$!"
./server2 & 
pid1="$!"

wait "$1"
wait "$2"

Tentativa 2

O mesmo que acima, mas apenas diga waitsem especificar pid. Faz o mesmo comportamento.

...
pid2="$!"
wait

Tentativa 3

Eu tentei usar sub-shells e sair de lá. Mas o exitse aplica apenas ao sub-shell, então ainda esperamos que ambos os processos em segundo plano terminem:

#!/usr/bin/env bash
set -e

( ./server1 || echo crash1; exit 1 ) &
( ./server2 || echo crash2; exit 2 ) &
wait

Existe uma maneira de conseguir isso (bifurcar dois processos do servidor em segundo plano e sair assim que um deles terminar) no bash?

Eu vi isso em um script bash e tentei entender:

exec {STDIN}>&0
exec {STDOUT}>&1
exec {STDERR}>&2

As "strings mágicas" {STDIN}, etc são reconhecidas por diretiva em scripts bash?{STDOUT}exec

STDOUT já não está definido como &1(e STDERR definido como &2, ...) de qualquer maneira?

O que essas linhas fazem?

Estou usando o macOS com rmferramenta do GNU coreutils (não do próprio macOS rm).

Então eu tenho um script onde eu limpo algum diretório assim:

if [ -d "${cleanup_repo_clone_root}" ]; then
    echo "Cleaning up tmp directory: ${cleanup_repo_clone_root}"
    set -x; rm -rf -- "${cleanup_repo_clone_root}"
fi

Eu joguei um set -xlá para ver o que está acontecendo.

Está me mostrando a saída:

+ set -x
+ rm -rf -- /var/folders/h7/n46zg3md4l57vzsgxcs355/T/tmp.eizQw1iNBQ
rm: cannot remove '/var/folders/h7/n46zg3md4l57vzsgxcs355/T/tmp.eizQw1iNBQ': Directory not empty

mas se eu copiar e colar esse comando rm e executá-lo, funciona bem!

$ rm -rf -- /var/folders/h7/n46zg3md4l57vzsgxcs355/T/tmp.eizQw1iNBQ

O que esta acontecendo aqui?

Estou executando o seguinte comando:

some_command --flag "foo\
    bar\
    quux" arg2

Isso faz com que a string seja passada como foo\tbar\tquux.

Estou procurando uma maneira de passar esse argumento sem ser caracteres de tabulação (ou outros caracteres de espaço em branco adicionados) mantendo o recuo (para tornar meu script legível).

Eu tenho zsh 5.3 (através de oh-my-zsh), se eu executar echo --message="foo!", recebo um prompt de cotação não terminado na próxima linha:

$ echo --message="foo!"
dquote>

Isso não acontece no bash.

Quando eu retiro o !caractere do argumento, funciona bem:

$ echo --message="foo"
--message=foo

O que está acontecendo aqui?

Também devo observar que, se eu responder ao prompt de cotação não terminado com "e pressionar return, recebo essa saída, que descarta totalmente o !:

$ echo --message="foo!"
dquote> "
--message=foo

Estou tentando encontrar a página de manual para [[(colchetes duplos).

Aparentemente man test, apenas documentos teste arquivos [.

As condicionais para [[e [são exatamente as mesmas?

Estou usando o zsh com o iTerm como meu emulador de terminal no macOS e meu ambiente tem TERM=xterm-256colorpor padrão.

Se eu executar tput setaf 3ele sai com o código 0.

Se eu definir TERM=vt100e executar tput setaf 3ele sai com o código 1 (indicando falha).

Por que este é o caso?

Eu tenho um soquete unix local encapsulado em outro soquete unix em uma instância remota por SSH:

ssh -N -L $HOME/my.sock:/var/run/another.sock

no entanto, quando eu encerro o ssh normalmente (ou seja, ctrl+C ou SIGTERM), o arquivo $HOME/my.sockpermanece. Parece que isso não foi limpo corretamente. Existe uma opção/sinalizador para isso?

Isso é problemático porque, se eu executar o comando pela segunda vez, ele falhará devido ao arquivo de soquete existente. (Não consigo ver um sinalizador/opção de "reutilização" que substituirá o arquivo de soquete existente.) E prefiro não adicionar um arquivo rm -f $HOME/my.sock.

Estou tentando ter um soquete de domínio Unix local, digamos, ~/docker.sock. Eu quero que ele faça proxy de tudo para um soquete de domínio Unix remoto em execução em outro lugar por SSH. (Você pode encontrar um diagrama do que estou tentando fazer abaixo).

O OpenSSH suporta isso ( um exemplo aqui). Por exemplo, este comando fará proxy das conexões do cliente MySQL em um servidor remoto para minha instância local:

ssh -R/var/run/mysql.sock:/var/run/mysql.sock -R127.0.0.1:3306:/var/run/mysql.sock somehost

Mas não é assim que eu quero que seja. Ele encaminha o tráfego que chega ao soquete remoto para o meu soquete local (quero o contrário).