Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/kvz/cronlock
cronlock lets you deploy cronjobs cluster-wide without worrying about overlaps. It uses Redis to keep track of locks.
https://github.com/kvz/cronlock
cron-jobs locking redis shell
Last synced: 6 days ago
JSON representation
cronlock lets you deploy cronjobs cluster-wide without worrying about overlaps. It uses Redis to keep track of locks.
- Host: GitHub
- URL: https://github.com/kvz/cronlock
- Owner: kvz
- License: mit
- Created: 2012-06-04T13:14:14.000Z (over 12 years ago)
- Default Branch: master
- Last Pushed: 2019-07-10T09:44:21.000Z (over 5 years ago)
- Last Synced: 2024-12-12T02:43:53.289Z (12 days ago)
- Topics: cron-jobs, locking, redis, shell
- Language: Shell
- Homepage: http://kvz.io/blog/2012/12/31/lock-your-cronjobs/
- Size: 104 KB
- Stars: 270
- Watchers: 11
- Forks: 46
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
# cronlock
[](http://travis-ci.org/kvz/cronlock "Check this project's build status on TravisCI")
[](https://www.gittip.com/kvz/ "Sponsor the development of cronlock via Gittip")
[](https://flattr.com/submit/auto?user_id=kvz&url=https://github.com/kvz/cronlock&title=cronlock&language=&tags=github&category=software "Sponsor the development of cronlock via Flattr")
[](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=kevin%40vanzonneveld%2enet&lc=NL&item_name=Open%20source%20donation%20to%20Kevin%20van%20Zonneveld¤cy_code=USD&bn=PP-DonationsBF%3abtn_donate_SM%2egif%3aNonHosted "Sponsor the development of cronlock via Paypal")
[](https://coinbase.com/checkouts/19BtCjLCboRgTAXiaEvnvkdoRyjd843Dg2 "Sponsor the development of cronlock via BitCoin")
## Install
On most Linux & BSD machines, cronlock will install just by downloading it & making it executable.
Here's the one-liner:
```bash
sudo curl -q -L https://raw.github.com/kvz/cronlock/master/cronlock -o /usr/bin/cronlock && sudo chmod +x $_
```
With [Redis](http://redis.io/) present on `localhost`, cronlock should now already work in basic form.
Let's test by letting it execute a simple `pwd`:
```bash
CRONLOCK_HOST=localhost cronlock pwd
```
If this returns the current directory we're good to go. More examples below.
## Introduction
Uses a central [Redis](http://redis.io/) server to globally lock cronjobs across a distributed system.
This can be usefull if you have 30 webservers that you deploy crontabs to (such as
mailing your customers), but you don't want 30 cronjobs spawned.
Of course you could also deploy your cronjobs to 1 box, but in volatile environments
such as EC2 it can be helpful not to rely on 1 'throw away machine' for your scheduled tasks,
and have 1 deploy-script for all your workers.
Another common problem that cronlock will solve is overlap by a single server/cronjob.
It happens a lot that developers underestimate how long a job will run.
This can happen because the job waits on something, acts different under high load/volume, or enters an endless loop.
In these cases you don't want the job to be fired again at the next cron-interval, making your problem twice as bad,
some intervals later, there's a huge `ps auxf` with overlapping cronjobs, high server load, and eventually a crash.
By settings locks, cronlock can also prevent the overlap in longer-than-expected-running cronjobs.
## Design goals
- Lightweight
- As little dependencies as possible / No setup
- Follows locking logic from [this Redis documentation](http://redis.io/commands/setnx)
- Well tested & documented
## Requirements
- Bash (version 3.0 and above) with `/dev/tcp` enabled. Older Debian/Ubuntu systems disable `/dev/tcp`
- `md5` or `md5sum`
- A [Redis](http://redis.io/) server, or cluster of servers that is accessible by all cronlock machines
## Options
- `CRONLOCK_CONFIG` location of config file. this is optional since all config can also be
passed as environment variables. default: `/cronlock.conf`, `/etc/cronlock.conf`
Using the `CRONLOCK_CONFIG` file or by exporting in your environment, you can set these variables
to change the behavior of cronlock:
- `CRONLOCK_HOST` the Redis hostname. default: `localhost`
- `CRONLOCK_PORT` the Redis port. default: `6379`
- `CRONLOCK_AUTH` the Redis auth password. default: Not present
- `CRONLOCK_DB` the Redis database. default: `0`
- `CRONLOCK_REDIS_TIMEOUT` the length of time we wait for a response from redis before we consider it in an errored state.
This ensures that if the redis connection goes away that we don't wait forever waiting for a response. default: `30`
- `CRONLOCK_GRACE` determines how many seconds a lock should at least persist.
This is to make sure that if you have a very small job, and clocks aren't in sync, the same job
on server2/3/4/5/6/etc (maybe even slightly behind in time) will just fire right after server1 releases the lock. default: `40` (I recommend using a grace of at least 30s)
- `CRONLOCK_RELEASE` determines how long a lock can persist at most.
Acts as a failsafe so there can be no locks that persist forever in case of failure. default is a day: `86400`
- `CRONLOCK_RECONNECT_ATTEMPTS` the number of times we try to reconnect before erroring.
If the redis connection is closed, we will attempt to reconnect to redis upto this amount of times. default: `5`
- `CRONLOCK_RECONNECT_BACKOFF` the lenght of time to increase the wait between reconnects.
Acts as a failsafe to allow redis to be started before we try to reconnect. Set to 0 to retry the connection immediately. default: `5`
- `CRONLOCK_KEY` a unique key for this command in the global Redis server. default: a hash of cronlock's arguments
- `CRONLOCK_PREFIX` Redis key prefix used by all keys. default: `cronlock`
- `CRONLOCK_VERBOSE` set to `yes` to print debug messages. default: `no`
- `CRONLOCK_NTPDATE` set to `yes` update the server's clock againt `pool.ntp.org` before execution. default: `no`
- `CRONLOCK_TIMEOUT` how long the command can run before it gets issues a `kill -9`. default: `0`; no timeout
## Redis Cluster Support
Cronlock has support for Redis Cluster (http://redis.io/topics/cluster-spec) introduced in Redis 3.0.
Cronlock acts as a relatively "dumb" cluster client - it will react to MOVED and ASK commands and retry the request to the node given back in the response but it does not attempt to record the slot to node relationship for future use.
Cronlock supports the configuration of only one `CRONLOCK_HOST` and `CRONLOCK_PORT`. Cronlock will always connect to the configured host and port and issue the initial REDIS command with the calculated MD5 key. If the Redis node returns ASK or MOVED, Cronlock will disconnect and connect to the given host and port in the ASK or MOVED respoonse. The new Redis host is used for the remaining duration of the execution of Cronlock (or until another ASK or MOVED command is returned) - Cronlock will connect to the originally configured `CRONLOCK_HOST` and `CRONLOCK_PORT` for the next execution.
Given the support of only one `CRONLOCK_HOST` and `CRONLOCK_PORT` it is recommended that each server running cronlock is configured to initially connect a different master in the Redis Cluster. Thus if one Redis server goes down the instances of Cronlock configured to connect to the other master nodes will continue to operate.
This is easily done if the Redis Cluster is on the same servers as Cronlock - as `CRONLOCK_HOST` can be set to 127.0.0.1 - each copy of Cronlock will therefore initially connect to its local master node - before reconnecting to other alive Redis nodes.
Aside from configuring appropriate values for `CRONLOCK_HOST` and `CRONLOCK_PORT` for the systems running Cronlock - no additional configuration is required for Redis Cluster support.
## Examples
### Single box
```bash
crontab -e
* * * * * cronlock ls -al
```
In this configuration, `ls -al` will be launched every minute. If the previous
`ls -al` has not finished yet, another one is not started.
This works on 1 server, as the default `CRONLOCK_HOST` of `localhost` is used.
In this setup, cronlock works much like [Tim Kay](http://timkay.com/)'s [solo](https://github.com/timkay/solo),
except cronlock requires [Redis](http://redis.io/), so I recommend using Tim Kay's solution here.
### Distributed
```bash
echo '0 8 * * * CRONLOCK_HOST=redis.mydomain.com cronlock /var/www/mail_customers.sh' | crontab
```
In this configuration, a central Redis server is used to track the locking for
`/var/www/mail_customers.sh`. So you see that throughout a cluster of 100 servers,
just one instance of `/var/www/mail_customers.sh` is ran every morning. No less, no more.
As long as your Redis server and at least 1 volatile worker is alive, this happens.
### Distributed using a config file
To avoid messy crontabs, you can use a config file for shared config instead.
Unless `CRONLOCK_CONFIG` is set, cronlock will look in `./cronlock.conf`, then
in `/etc/cronlock.conf`.
Example:
```bash
cat << EOF > /etc/cronlock.conf
CRONLOCK_HOST="redis.mydomain.com"
CRONLOCK_GRACE=50
CRONLOCK_PREFIX="mycompany.cronlocks."
CRONLOCK_NTPDATE="yes"
EOF
crontab -e
* * * * * cronlock /var/www/mail_customers.sh # will use config from /etc/cronlock.conf
```
### Lock commands even though they have different arguments
By default cronlock uses your command and its arguments to make a unique identifier
by which the global lock is acquired. However if you want to run: `ls -al` or `ls -a`,
but just 1 instance of either, you'll want to provide your own key:
```bash
crontab -e
# One of two will be executed because they share the same KEY
* * * * * CRONLOCK_KEY="ls" cronlock ls -al
* * * * * CRONLOCK_KEY="ls" cronlock ls -a
```
### Per application
If you use the same script and Redis server for multiple applications, an unwanted lock could deny app2 its script.
You could make up your own unique `CRONLOCK_KEY` to circumvent, but it's probably
better to use the `CRONLOCK_PREFIX` for that:
```bash
crontab -e
* * * * * CRONLOCK_PREFIX="mylocks.app1." cronlock /var/www/mail_customers.sh
```
```bash
crontab -e
* * * * * CRONLOCK_PREFIX="mylocks.app2." cronlock /var/www/mail_customers.sh
```
Now both /var/www/mail_customers.sh will run, because they have a different application in their prefixes.
## Exit codes
- = `200` Success (delete succeeded or lock not acquired, but normal execution)
- = `201` Failure (cronlock error)
- = `202` Failure (cronlock timeout)
- < `200` Success (acquired lock, executed your command), passes the exit code of your command
## Versioning
This project implements the Semantic Versioning guidelines.
Releases will be numbered with the following format:
`..`
And constructed with the following guidelines:
* Breaking backward compatibility bumps the major (and resets the minor and patch)
* New additions without breaking backward compatibility bumps the minor (and resets the patch)
* Bug fixes and misc changes bumps the patch
For more information on SemVer, please visit [http://semver.org](http://semver.org).
## License
Copyright (c) 2013 Kevin van Zonneveld, [http://kvz.io](http://kvz.io)
Licensed under MIT: [http://kvz.io/licenses/LICENSE-MIT](http://kvz.io/licenses/LICENSE-MIT)