robust-redis-lock 0.1.0

data/lib/redis-lock.rb

@@ -0,0 +1,104 @@
+require 'redis'
+
+class Redis::Lock
+  require 'robust-redis-lock/script'
+
+  attr_reader :key
+
+  class << self
+    attr_accessor :redis
+    attr_accessor :timeout
+    attr_accessor :sleep
+    attr_accessor :expire
+    attr_accessor :namespace
+  end
+
+  self.timeout   = 60
+  self.expire    = 60
+  self.sleep     = 0.1
+  self.namespace = 'redis:lock'
+
+  def initialize(key, options={})
+    raise "key cannot be nil" if key.nil?
+    @key      = (options[:namespace] || self.class.namespace) + ":" + key
+
+    @redis    = options[:redis] || self.class.redis
+    raise "redis cannot be nil" if @redis.nil?
+
+    @timeout  = options[:timeout] || self.class.timeout
+    @expire   = options[:expire]  || self.class.expire
+    @sleep    = options[:sleep]   || self.class.sleep
+  end
+
+  def lock
+    result = false
+    start_at = Time.now
+    while Time.now - start_at < @timeout
+      break if result = try_lock
+      sleep @sleep.to_f
+    end
+
+    yield if block_given?
+
+    result
+  ensure
+    unlock if block_given?
+  end
+
+  def try_lock
+    now = Time.now.to_i
+
+    # This script loading is not thread safe (touching a class variable), but
+    # that's okay, because the race is harmless.
+    @@lock_script ||= Script.new <<-LUA
+        local key = KEYS[1]
+        local now = tonumber(ARGV[1])
+        local expires_at = tonumber(ARGV[2])
+        local token_key = 'redis:lock:token'
+
+        local prev_expires_at = tonumber(redis.call('hget', key, 'expires_at'))
+        if prev_expires_at and prev_expires_at > now then
+          return {'locked', nil}
+        end
+
+        local next_token = redis.call('incr', token_key)
+
+        redis.call('hset', key, 'expires_at', expires_at)
+        redis.call('hset', key, 'token', next_token)
+
+        if prev_expires_at then
+          return {'recovered', next_token}
+        else
+          return {'acquired', next_token}
+        end
+    LUA
+    result, token = @@lock_script.eval(@redis, :keys => [@key], :argv => [now, now + @expire])
+
+    @token = token if token
+
+    case result
+    when 'locked'    then return false
+    when 'recovered' then return :recovered
+    when 'acquired'  then return true
+    end
+  end
+
+  def unlock
+    # Since it's possible that the operations in the critical section took a long time,
+    # we can't just simply release the lock. The unlock method checks if @expire_at
+    # remains the same, and do not release when the lock timestamp was overwritten.
+    @@unlock_script ||= Script.new <<-LUA
+        local key = KEYS[1]
+        local token = ARGV[1]
+
+        if redis.call('hget', key, 'token') == token then
+          redis.call('del', key)
+          return true
+        else
+          return false
+        end
+    LUA
+    result = @@unlock_script.eval(@redis, :keys => [@key], :argv => [@token])
+    !!result
+  end
+end

data/lib/robust-redis-lock.rb

@@ -0,0 +1 @@
+require 'redis-lock'

data/lib/robust-redis-lock/script.rb

@@ -0,0 +1,24 @@
+class Redis::Lock::Script
+  def initialize(script)
+    @script = script
+    @sha = Digest::SHA1.hexdigest(@script)
+  end
+
+  def eval(redis, options={})
+    redis.evalsha(@sha, options)
+  rescue ::Redis::CommandError => e
+    if e.message =~ /^NOSCRIPT/
+      redis.script(:load, @script)
+      retry
+    end
+    if e.message =~ /^ERR unknown command/
+      raise "You are using a version of Redis that does not support LUA scripting. Please use Redis 2.6.0 or greater"
+    end
+    raise e
+  end
+
+  def to_s
+    @script
+  end
+end
+

data/lib/robust-redis-lock/version.rb

@@ -0,0 +1,5 @@
+class Redis
+  class Lock
+    VERSION = '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: robust-redis-lock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Kareem Kouddous
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Robust redis lock
+email:
+- kareeknyc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/redis-lock.rb
+- lib/robust-redis-lock/script.rb
+- lib/robust-redis-lock/version.rb
+- lib/robust-redis-lock.rb
+homepage: http://github.com/crowdtap/robust-redis-lock
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Robust redis lock
+test_files: []