On most Linux & BSD machines, cronlock will install just by downloading it & making it executable. Here's the one-liner:
sudo curl -q -L https://raw.github.com/kvz/cronlock/master/cronlock -o /usr/bin/cronlock && sudo chmod +x $_
With Redis present on
localhost, cronlock should now already work in basic form.
Let's test by letting it execute a simple
CRONLOCK_HOST=localhost cronlock pwd
If this returns the current directory we're good to go. More examples below.
Uses a central Redis 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.
- As little dependencies as possible / No setup
- Follows locking logic from this Redis documentation
- Well tested & documented
- Bash (version 3.0 and above) with
/dev/tcpenabled. Older Debian/Ubuntu systems disable
- A Redis server, or cluster of servers that is accessible by all cronlock machines
CRONLOCK_CONFIGlocation of config file. this is optional since all config can also be passed as environment variables. default:
CRONLOCK_CONFIG file or by exporting in your environment, you can set these variables
to change the behavior of cronlock:
CRONLOCK_HOSTthe Redis hostname. default:
CRONLOCK_PORTthe Redis port. default:
CRONLOCK_AUTHthe Redis auth password. default: Not present
CRONLOCK_DBthe Redis database. default:
CRONLOCK_REDIS_TIMEOUTthe 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:
CRONLOCK_GRACEdetermines 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_RELEASEdetermines 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:
CRONLOCK_RECONNECT_ATTEMPTSthe 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:
CRONLOCK_RECONNECT_BACKOFFthe 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:
CRONLOCK_KEYa unique key for this command in the global Redis server. default: a hash of cronlock's arguments
CRONLOCK_PREFIXRedis key prefix used by all keys. default:
yesto print debug messages. default:
yesupdate the server's clock againt
pool.ntp.orgbefore execution. default:
CRONLOCK_TIMEOUThow 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_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_PORT for the next execution.
Given the support of only one
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_PORT for the systems running Cronlock - no additional configuration is required for Redis Cluster support.
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
localhost is used.
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.
CRONLOCK_CONFIG is set, cronlock will look in
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
but just 1 instance of either, you'll want to provide your own key:
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
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:
crontab -e * * * * * CRONLOCK_PREFIX="mylocks.app1." cronlock /var/www/mail_customers.sh
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.
200Success (delete succeeded or lock not acquired, but normal execution)
201Failure (cronlock error)
202Failure (cronlock timeout)
200Success (acquired lock, executed your command), passes the exit code of your command
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.