Existem padrões estabelecidos para instalar um interruptor de interrupção ou desativação para tarefas do cron do usuário?

Temos compilações demoradas que normalmente agendam nossos trabalhos cron, mas às vezes temos que executar novamente uma compilação durante um período não padrão e podemos entrar em conflito com trabalhos cron que normalmente são seguros para execução nesses momentos.

Como temos várias contas que executam tarefas de compilação e cron, não podemos suspender o serviço crontab de toda a máquina e depois reiniciá-lo mais tarde.

Fiquei me perguntando se alguém tinha um padrão ou implementação. Eu imagino isso funcionando como

O usuário cria um arquivo: ~ / block-crontab
user executa build O job cron procura esse arquivo no diretório home do usuário e, se houver, ignora todos os jobs cron. Caso contrário, ele executa os trabalhos. Quando a compilação é concluída, o usuário remove ~ / block-crontab

Isso funcionaria? Suponho que precisaria modificar o script cron de alguma forma. Estou pensando principalmente se existe uma abordagem melhor / padrão para esse problema?

obrigado.

Em vez de mexer com crond, sugiro fortemente implementar alguma forma (até simples) de bloqueio dentro de seus scripts de construção. Por exemplo, toque e verifique se há um arquivo em /var/run/: se o seu script encontrar algo, outro processo está criando o projeto. Obviamente, você precisa remover o arquivo de bloqueio quando terminar.

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

Se você não pode / não pode confiar em nenhum mecanismo de bloqueio, basta emitir a service crond stoppara desligar o crondsistema.

Costumo apenas envolver todos os comandos de execução longa em uma tela e croncomeçar a tela apenas se ainda não houver um em execução.

Portanto, a seguinte linha 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 lhe dá a chance de anexar a um script em execução e verificar sua saída / status.

No seu cenário, você pode cronprocurar 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, basta entrar screenprimeiro antes de executar o script (comente se precisar de dicas sobre como conectar / desconectar screen. É um utilitário útil - experimente se você ainda não começou a usá-lo)

Digite screen -S ManualBuild, pressione [enter]e execute os comandos que deseja executar.

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