Edite o script de shell durante a execução

Você pode editar um script de shell enquanto ele está sendo executado e as alterações afetam o script em execução?

Estou curioso sobre o caso específico de um script csh. Eu tenho aquele lote que executa vários tipos de compilação diferentes e executa a noite toda. Se algo me ocorrer no meio da operação, gostaria de entrar e adicionar comandos adicionais ou comentar os não executados.

Se não for possível, existe algum shell ou mecanismo de lote que me permita fazer isso?

Claro que tentei, mas demorarei horas antes de ver se funcionou ou não, e estou curioso para saber o que está acontecendo ou não nos bastidores.

Os scripts não funcionam dessa maneira; a cópia em execução é independente do arquivo de origem que você está editando. Da próxima vez que o script for executado, ele será baseado na versão salva mais recentemente do arquivo de origem.

Pode ser sábio dividir esse script em vários arquivos e executá-los individualmente. Isso reduzirá o tempo de execução até a falha. (ou seja, divida o lote em um script de tipo de compilação, executando cada um individualmente para ver qual está causando o problema).

Ele não afeta, pelo menos, o bash no meu ambiente, mas na maneira muito desagradável . Veja esses códigos. Primeiro a.sh:

#!/bin/sh

echo "First echo"
read y

echo "$y"

echo "That's all."

b.sh:

#!/bin/sh

echo "First echo"
read y

echo "Inserted"

echo "$y"

# echo "That's all."

Faz

$ cp a.sh run.sh
$ ./run.sh
$ # open another terminal
$ cp b.sh run.sh  # while 'read' is in effect
$ # Then type "hello."

No meu caso, a saída é sempre:

Olá
Olá
Isso é tudo.
Isso é tudo.

(Claro que é muito melhor automatizá-lo, mas o exemplo acima é legível.)

[editar] Isso é imprevisível, portanto perigoso. A melhor solução alternativa é , conforme descrito aqui, colocar tudo em uma chave e, antes da chave de fechamento, colocar "sair" . Leia bem a resposta do link a para evitar armadilhas.

[adicionado] O comportamento exato depende de uma nova linha extra, e talvez também de seu tipo de Unix, sistema de arquivos, etc. Se você simplesmente deseja ver algumas influências, simplesmente adicione "echo foo / bar" a b.sh antes e / ou depois a linha "ler".

Tente isto ... crie um arquivo chamado bash-is-odd.sh:

#!/bin/bash
echo "echo yes i do odd things" >> bash-is-odd.sh

Isso demonstra que o bash está, de fato, interpretando o script "conforme você avança". De fato, editar um script de longa execução tem resultados imprevisíveis, inserindo caracteres aleatórios etc. Por quê? Como o bash lê a partir da posição do último byte, a edição muda a localização do caractere atual que está sendo lido.

O Bash é, em uma palavra, muito, muito inseguro por causa desse "recurso". O svn e rsyncquando usado com scripts bash são particularmente problemáticos, porque por padrão eles "mesclam" os resultados ... editando no local. rsynctem um modo que corrige isso. svn e git não.

Eu apresento uma solução. Crie um arquivo chamado /bin/bashx:

#!/bin/bash
source "$1"

Agora use #!/bin/bashxem seus scripts e sempre execute-os com em bashxvez de bash. Isso corrige o problema - você pode garantir rsyncseus scripts.

Solução alternativa (em linha) proposta / testada por @ AF7:

{
   # your script
} 
exit $?

Os suspensórios encaracolados protegem contra edições e a saída protege contra anexos. Claro, estaríamos todos muito melhor se o bash viesse com uma opção, como -w(arquivo inteiro), ou algo que fizesse isso.

Divida seu script em funções e, cada vez que uma função for chamada, sourceela será feita em um arquivo separado. Em seguida, você pode editar os arquivos a qualquer momento e o script em execução pegará as alterações na próxima vez que for originado.

foo() {
  source foo.sh
}
foo

Boa pergunta! Espero que este script simples ajude

#!/bin/sh
echo "Waiting..."
echo "echo \"Success! Edits to a .sh while it executes do affect the executing script! I added this line to myself during execution\"  " >> ${0}
sleep 5
echo "When I was run, this was the last line"

Parece no Linux que as alterações feitas em um .sh em execução são realizadas pelo script em execução, se você puder digitar rápido o suficiente!

Uma observação interessante - se você está executando um script Python, ele não muda. (Isso provavelmente é flagrantemente óbvio para qualquer pessoa que entende como o shell executa scripts Python, mas pensou que poderia ser um lembrete útil para quem procura por essa funcionalidade.)

Eu criei:

#!/usr/bin/env python3
import time
print('Starts')
time.sleep(10)
print('Finishes unchanged')

Então, em outro shell, enquanto ele está dormindo, edite a última linha. Quando isso é concluído, ele exibe a linha inalterada, provavelmente porque está executando um .pyc? O mesmo acontece no Ubuntu e no macOS.

Não tenho csh instalado, mas

#!/bin/sh
echo Waiting...
sleep 60
echo Change didn't happen

Execute isso, edite rapidamente a última linha para ler

echo Change happened

A saída é

Waiting...
/home/dave/tmp/change.sh: 4: Syntax error: Unterminated quoted string

Hrmph.

Eu acho que as edições nos scripts de shell não têm efeito até que sejam executados novamente.

Se tudo isso estiver em um único script, não, não funcionará. No entanto, se você configurá-lo como um script de driver chamando subscripts, poderá alterar um subscript antes de ser chamado ou antes de ser chamado novamente se você estiver em loop e, nesse caso, acredito que essas alterações seria refletido na execução.

Estou ouvindo não ... mas e com alguma indireção:

BatchRunner.sh

Command1.sh
Command2.sh

Command1.sh

runSomething

Command2.sh

runSomethingElse

Então você deve ser capaz de editar o conteúdo de cada arquivo de comando antes que o BatchRunner o faça certo?

OU

Uma versão mais limpa faria com que o BatchRunner olhasse para um único arquivo onde seria executado consecutivamente uma linha por vez. Então você deve ser capaz de editar este segundo arquivo enquanto o primeiro está rodando, certo?

Use Zsh ao invés para seu script.

AFAICT, Zsh não exibe esse comportamento frustrante.

geralmente, é incomum editar seu script durante sua execução. Tudo que você precisa fazer é colocar na verificação de controle para suas operações. Use instruções if / else para verificar as condições. Se algo falhar, faça isso, senão aquilo. Esse é o caminho a percorrer.