Existem padrões estabelecidos para a instalação de um interruptor kill ou on / off para trabalhos cron do usuário?

Question

Temos criações longas que normalmente programamos nossas tarefas cron, mas ocasionalmente precisamos executar novamente uma compilação durante um período de tempo não padrão e pode gerar conflitos com tarefas agendadas que normalmente são seguras para serem executadas nesses horários. .

Temos várias contas que executam as tarefas de criação e agendadas, por isso não podemos suspender o serviço do crontab para a máquina inteira e, em seguida, reiniciá-lo mais tarde.

Eu queria saber se alguém tinha um padrão ou implementação. Eu imagino isso funcionando como

O usuário cria um arquivo: ~ / block-crontab
usuário executa build A tarefa cron procura esse arquivo no diretório home do usuário e, se estiver lá, apenas ignora todas as tarefas cron. Caso contrário, executará os trabalhos Então, quando a compilação é feita, o usuário remove ~ / block-crontab

Isso funcionaria? Eu estou supondo que eu preciso modificar o script cron de alguma forma. Eu estou principalmente me perguntando se existe uma abordagem melhor / padrão para este problema?

obrigado.

    

Answer 1

Em vez de mexer com crond , sugiro que implemente algumas formas (até simples) de bloqueio dentro dos seus scripts de construção. Por exemplo, toque e verifique se há um arquivo em /var/run/ : se seu script encontrar algo, que outro processo está construindo o projeto. Você obviamente precisa remover o arquivo de trava quando terminar.

Como o @GnP observou nos comentários, você também pode usar o utilitário flock para gerenciar semi-automaticamente seus arquivos de bloqueio.

Se você não puder confiar em nenhum mecanismo de bloqueio, emita um service crond stop para desligar o sistema crond .

    

Answer 2

Eu costumo apenas quebrar todos os comandos de longa duração em uma tela e obter cron para iniciar a tela apenas se não houver um já em execução.

Portanto, a linha a seguir em crontab

*/2 * * * *  /bin/bash /path/to/LongRunningScript.bash

... se transforma em algo assim:

*/2 * * * *  /usr/bin/screen -S MyUniqueName -Q select . || /usr/bin/screen -dmS MyUniqueName /bin/bash /path/to/LongRunningScript.bash

Eu gosto disso porque também dá a você a chance de se conectar a um script em execução e verificar sua saída / status.

Em seu cenário, você pode obter cron para verificar outra tela antes de executar uma compilação, por exemplo

0 3 * * *  /usr/bin/screen -S ManualBuild -Q select . || /usr/bin/screen -dmS AutomatedBuild /bin/bash /path/to/BuildScripts.bash
10 3 * * *  /usr/bin/screen -S ManualBuild -Q select . || /usr/bin/screen -dmS OtherAutomatedBuild /bin/bash /path/to/OtherBuildScripts.bash

Quando você executa uma compilação manual, apenas entre em screen antes de executar o script (por favor, comente se você precisa de dicas sobre como conectar / desconectar de screen . É um utilitário útil - dê uma olhada se você ainda não começou a usá-lo)

Digite screen -S ManualBuild , clique em [enter] e execute os comandos que você deseja executar.

Nota: Se você usar o exemplo como fornecido, poderá confundir cron se tiver mais de uma sessão de tela com o nome "ManualBuild" em execução.