faz um cronjob esperar que o trabalho rsync anterior termine

11

Estou usando o rsync para fazer backup de alguns dados de um servidor para outro. Tudo funciona bem, mas pode demorar mais para terminar, dependendo da quantidade de dados que há para transferir.

Existe alguma maneira garantida de garantir que um comando rsync não seja iniciado antes que o anterior termine usando um cronjob?

Por exemplo, a cada hora eu executo o comando rsync, mas é possível que a transferência leve mais de uma hora para ser concluída, para que a próxima comece antes que a anterior termine.

    
por chovy 28.12.2012 / 01:18

8 respostas

10

Você pode implementar algum tipo de bloqueio para verificar se o rsync ainda está em execução:

pgrep -c rsync

Editado e adicionado a partir dos comentários:

pgrep -c rsync || rsync ...

Isso executará o comando rsync somente se não houver nenhum processo rsync em execução.

    
por 28.12.2012 / 01:39
10

Você pode usar o comando flock para ajudá-lo a fazer isso. Neste caso, flock -n é provavelmente o que você quer, pois causará uma falha imediata do comando se ele não puder obter o bloqueio, por exemplo,

30 * * * *  /usr/bin/flock -n /tmp/myRsyncJob.lck /path/to/your/rsyncScript 
    
por 29.12.2012 / 13:52
3

Se você está disposto a considerar outras ferramentas, você também pode dar uma olhada no rdiff-backup . Ele usa o librsync para fazer backups e salva um número configurável de deltas / incrementos. Ele também é bloqueado para que apenas um processo de backup do rdiff possa ser executado a qualquer momento.

    
por 28.12.2012 / 01:42
3

Aqui está o que eu faria. Crie um script wrapper em torno do rsync para criar um arquivo de bloqueio.

script 1
- create lock file
- rsync
- remove lock file

script 2 (running later then script 1)
- check if lock file is there
    - if not run
    - if it is there wait 10 minutes in a loop. break out of lopp when the lock file is gone
- continue to run script
    
por 28.12.2012 / 01:39
2

Minha resposta é um pouco igual à que Mike contou.

No script, você deve colocar algo assim:

  • crie um arquivo de bloqueio
  • Verifique a existência do arquivo de bloqueio quando for executado na próxima vez.

Mas há uma coisa muito importante que você deve fazer. e que para implementar um sistema de armadilha.

Então, com isso, o que você pode fazer é que, mesmo que de alguma forma o seu script seja morto ou alguém o mate, você pode capturar esse sinal e remover o arquivo de bloqueio, para que você não tenha um arquivo de bloqueio obsoleto .

Você pode ler como implementar isso em aqui .

Apenas uma coisa pequena, você não pode interceptar o sinal 9, quer dizer, se alguém faz kill -9 , você não pode capturar isso, pois esse sinal interage diretamente com o kernel e não há como interceptar isso.

Além disso, como sugerido por John, você precisa remover o arquivo de bloqueio toda vez que o sistema for reinicializado, apenas para garantir que não haja nenhum arquivo obsoleto.

Isso pode ser feito facilmente colocando um pequeno comando rm -f <FILE> em /etc/rc.local

    
por 28.12.2012 / 10:40
1

Dê uma olhada no anacron (cron anacrônico) com a opção -s (serialize). Serialize garante que o comando não será chamado novamente se o anterior ainda estiver em execução.

    
por 28.12.2012 / 04:07
0

Use hatools ( link ) para bloquear o rsync cron no modo de espera.

    
por 28.12.2012 / 13:07
0

Eu não consegui a solução do mgabriel funcionar no OSX pois a versão OSX do pgrep não parece ter a opção -c (suponho que isso seja para contagem). Em vez disso, usei o seguinte:

[ $(pgrep ping | wc -l) -eq 0 ] && ping multiplay.co.uk || echo "Sorry, ping already in progress"

Eu usei ping como um comando de exemplo.

Espero que isso ajude.

    
por 02.01.2013 / 15:18