Um script de shell executa comandos sequencialmente?

Question

Eu tenho um script python que é um pouco instável e dá um erro de SSL de vez em quando. A exceção é levantada por alguma função enterrada em algumas bibliotecas, de modo que não há praticamente nenhum reparo nela.

Eu implementei uma solução hacky criando um shell script com um loop while que é executado várias vezes e executando o script python dentro desse loop.

Agora, o que eu espero é que, como uma iteração do loop é iniciada e o script seja executado, o loop dentro do shell script permanece onde está até que o script python falhe e a próxima iteração do loop execute novamente o script. roteiro e assim por diante.

Está fazendo isso assim eficiente? Tem algum jeito melhor de fazer isso? e o mais importante é correto?

    

Answer 1

Em:

cmd1
cmd2

ou

cmd1; cmd2

Eles são executados sequencialmente.

Em

cmd1 && cmd2

Ou

cmd1 || cmd2

Eles são executados sequencialmente, mas a execução de cmd2 depende se cmd1 é bem-sucedido (para && ) ou se falha (para || ).

Em

cmd1 | cmd2

ou

cmd1 & cmd2
cmd1 |& cmd2 # ksh
coproc cmd1; cmd2 # bash/zsh

ou

cmd1 <(cmd2) # ksh/zsh/bash (also yash though with a different meaning)

Eles são executados simultaneamente. No primeiro caso, alguns shells só esperam por cmd2 antes de continuar com o resto do script, enquanto outros esperam por ambos. No segundo caso, os shells aguardam apenas que cmd2 ( cmd1 seja executado de forma assíncrona (ou em segundo plano quando executado em um shell interativo)) e no terceiro por cmd1 ( cmd2 assíncrono). / p>

Em:

< "$(cmd1)" x=$(cmd2) y=$(cmd3) cmd4 "$(cmd5)" > "$(cmd6)"

Os comandos são executados sequencialmente, mas a ordem depende do shell. Em qualquer caso, cmd4 será executado por último.

Em:

cmd1 =(cmd2) # zsh

Eles são executados sequencialmente ( cmd2 first).

Observe que, em todos esses casos, qualquer um desses comandos poderia iniciar outros processos. A concha não teria conhecimento deles, portanto não pode esperar por eles.

    

Answer 2

Sim. Isso está correto. Considere isto:

#!/bin/bash

while true; do
    sleep 1
    echo "Slept 1"
    echo "Exit status $?, ok."
    sleep 1
    echo "Slept 1, now executing faulty command 'ps q'"
    ps q
    echo "Exit status $?, not ok. Loop continues forever..."
done

... ficará assim quando executado:

./loop.sh 
Slept 1
Exit status 0, ok.
Slept 1, now executing faulty command 'ps q'
ps: illegal option -- q
usage: ps [-AaCcEefhjlMmrSTvwXx] [-O fmt | -o fmt] [-G gid[,gid...]]
          [-u]
          [-p pid[,pid...]] [-t tty[,tty...]] [-U user[,user...]]
       ps [-L]
Exit status 1, not ok. Loop continues forever...
Slept 1
Exit status 0, ok.
Slept 1, now executing faulty command 'ps q'
ps: illegal option -- q
usage: ps [-AaCcEefhjlMmrSTvwXx] [-O fmt | -o fmt] [-G gid[,gid...]]
          [-u]
          [-p pid[,pid...]] [-t tty[,tty...]] [-U user[,user...]]
       ps [-L]
Exit status 1, not ok. Loop continues forever...
^C

Contanto que o loop seja sempre true , não importa quais códigos de saída os programas dentro do loop possuem. Eles continuarão a executar na sequência em que estão escritos.

Is doing it like this efficient? Is there a better way to do it?

A melhor maneira de fazer isso seria esmagar o bug no seu programa em Python!

    

Answer 3

Para responder à sua pergunta do título: Sim, os comandos em um shell script são executados de forma síncrona em seqüência, portanto, o shell é bloqueado enquanto o script Python está em execução.

Certamente seria melhor corrigir a origem do erro, mas se essa não for uma opção, um script de shell que tentará executar o script python até retornar um código de status zero ( while true;do ./script.py; if [[ "$?" = 0]];break;done ) é uma abordagem sensata.