Solução genérica para evitar que uma tarefa cron longa seja executada em paralelo?

Question

Estou procurando uma solução simples e genérica que permita executar qualquer script ou aplicativo no crontab e impedir que ele seja executado duas vezes.

A solução deve ser independente do comando executado.

Suponho que ele deve parecer com lock && (command ; unlock) , em que o bloqueio retornará false se houver outro bloqueio.

A segunda parte seria como se adquirisse o bloqueio, execute o comando e desbloqueie após o comando ser executado, mesmo que ele retorne um erro.

    

Answer 1

Dê uma olhada no run-one . A partir da página de manual do comando run-one :

run-oneisawrapperscriptthatrunsnomorethanoneuniqueinstanceofsomecommandwithauniquesetofarguments.

Thisisoftenusefulwithcronjobs,whenyouwantnomorethanonecopyrunningatatime.

Comotimeousudo,bastaprefixarocomando.Então,umcronjobpoderiaseparecercom:

*/60****run-onersync-azP$HOMEexample.com:/srv/backup

Paramaisinformaçõeseinformações,confiraa postagem no blog introduzindo-o por Dustin Kirkland.

    

Answer 2

Uma maneira muito simples de configurar um bloqueio:

if mkdir /var/lock/mylock; then
  echo "Locking succeeded" >&2
else
  echo "Lock failed - exit" >&2
  exit 1
fi

Um script que deseja executar precisa criar o bloqueio. Se o bloqueio existir, outro script estará ocupado, portanto, o primeiro script não poderá ser executado. Se o arquivo não existir, nenhum script adquiriu o bloqueio. Então, o script atual adquire o bloqueio. Quando o script terminar, o bloqueio precisa ser liberado removendo o bloqueio.

Para mais informações sobre os bloqueios do bash, consulte esta página

    

Answer 3

Não é necessário instalar algum pacote sofisticado:

#!/bin/bash
pgrep -xf "$*" > /dev/null || "$@"

É mais rápido escrever esse script você mesmo do que rodar o "apt-get install", não é? Você pode querer adicionar "-u $ (id -u)" ao pgrep para verificar instâncias executadas apenas pelo usuário atual.

    

Answer 4

Veja também solo de Tim Kay, que realiza o bloqueio vinculando uma porta em um endereço de loopback exclusivo do usuário:

link

No caso de o site dele ficar inativo:

Uso:

solo -port=PORT COMMAND

where
    PORT        some arbitrary port number to be used for locking
    COMMAND     shell command to run

options
    -verbose    be verbose
    -silent     be silent

Use assim:

* * * * * solo -port=3801 ./job.pl blah blah

Script:

#!/usr/bin/perl -s
#
# solo v1.7
# Prevents multiple cron instances from running simultaneously.
#
# Copyright 2007-2016 Timothy Kay
# http://timkay.com/solo/
#
# It is free software; you can redistribute it and/or modify it under the terms of either:
#
# a) the GNU General Public License as published by the Free Software Foundation;
#    either version 1 (http://dev.perl.org/licenses/gpl1.html), or (at your option)
#    any later version (http://www.fsf.org/licenses/licenses.html#GNUGPL), or
#
# b) the "Artistic License" (http://dev.perl.org/licenses/artistic.html), or
#
# c) the MIT License (http://opensource.org/licenses/MIT)
#

use Socket;

alarm $timeout                              if $timeout;

$port =~ /^\d+$/ or $noport                     or die "Usage: $0 -port=PORT COMMAND\n";

if ($port)
{
    # To work with OpenBSD: change to
    # $addr = pack(CnC, 127, 0, 1);
    # but make sure to use different ports across different users.
    # (Thanks to  www.gotati.com .)
    $addr = pack(CnC, 127, $<, 1);
    print "solo: bind ", join(".", unpack(C4, $addr)), ":$port\n"   if $verbose;

    $^F = 10;           # unset close-on-exec

    socket(SOLO, PF_INET, SOCK_STREAM, getprotobyname('tcp'))       or die "socket: $!";
    bind(SOLO, sockaddr_in($port, $addr))               or $silent? exit: die "solo($port): $!\n";
}

sleep $sleep if $sleep;

exec @ARGV;

    

Answer 5

Você precisa de um bloqueio. run-one faz o trabalho, mas você também pode querer olhar para flock do pacote util-linux .

É um pacote padrão fornecido pelos desenvolvedores do kernel, permite mais personalização do que run-one e ainda é muito simples.

    

Answer 6

Uma solução simples do bash-hackers.org que funcionou para mim estava usando mkdir . Essa é uma maneira fácil de garantir que apenas uma instância do seu programa esteja em execução. Crie um diretório com mkdir .lock que retorna

• true se a criação foi bem sucedida e
• false se o arquivo de bloqueio existir, indicando que há atualmente uma instância em execução.

Portanto, esta simples função fez toda a lógica de bloqueio de arquivos:

if mkdir .lock; then
    echo "Locking succeeded"
    eval startYourProgram.sh ;
else
    echo "Lock file exists. Program already running? Exit. "
    exit 1
fi


echo "Program finished, Removing lock."
rm -r .lock

    

Answer 7

Esta solução é para um script bash que precisa ser verificado

v=$(pgrep -xf "/bin/bash $0 $@")
[ "${v/$BASHPID/}" != "" ] && exit 0