jashmenn-redis-lock 0.1.1

data/README.md

@@ -0,0 +1,47 @@
+redis-lock
+==========
+
+Requires the redis gem.  Including this in your project will give you additional locking abilities on any instance of a redis connection you create.
+
+Installation
+------------
+	
+	gem install redis-lock
+
+Usage
+-----
+
+	require 'redis'
+	require 'redis-lock # This will automatically include Lock into the Redis class.
+
+Here's a little example of what you can do with it:
+
+	timeout = 10 # measured in seconds
+	max_attempts = 100 # number of times the action will attempt to lock the key before raising an exception
+	
+	$redis = Redis.new
+	
+	$redis.lock('beers_on_the_wall', timeout, max_attempts)
+	# Now no one can acquire a lock on 'beers_on_the_wall'
+	
+	$redis.unlock('beers_on_the_wall')
+	# Other processes can now acquire a lock on 'beers_on_the_wall'
+	
+For convenience, there is also a `lock_with_update` function that accepts a block.  It handles the locking and unlocking for you.
+
+	$redis.lock_for_update('beers_on_the_wall') do
+		$redis.multi do
+			$redis.set('sing', 'take one down, pass it around.')
+			$redis.decr('beers_on_the_wall')
+		end
+	end
+	
+Additional Notes
+----------------
+
+This gem basically implements the algorithm described here: http://redis.io/commands/setnx
+
+Author
+------
+
+Patrick Tulskie; http://patricktulskie.com

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "redis-lock"
+    gem.summary = %Q{TODO: one-line summary of your gem}
+    gem.description = %Q{TODO: longer description of your gem}
+    gem.email = "patricktulskie@gmail.com"
+    gem.homepage = "http://github.com/PatrickTulskie/redis-lock"
+    gem.authors = ["Patrick Tulskie"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "redis-lock #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/redis-lock.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/../lib/redis/lock'
+
+class Redis
+  include Redis::Lock
+end

data/lib/redis/lock.rb

@@ -0,0 +1,93 @@
+require 'redis'
+
+class Redis
+  module Lock
+    
+    # Lock a given key for updating
+    #
+    # Example:
+    #
+    # $redis = Redis.new
+    # lock_for_update('beers_on_the_wall', 20, 1000) do
+    #   $redis.decr('beers_on_the_wall')
+    # end
+    
+    def lock_for_update(key, timeout = 60, max_attempts = 100)
+      if self.lock(key, timeout, max_attempts)
+        begin
+          response = yield if block_given?
+        ensure
+          self.unlock(key)
+        end
+        return response
+      end
+    end
+    
+    # Lock a given key.  Optionally takes a timeout and max number of attempts to lock the key before giving up.
+    # 
+    # Example:
+    # 
+    # $redis.lock('beers_on_the_wall', 10, 100)
+    
+    def lock(key, timeout = 60, max_attempts = 100)
+      current_lock_key = lock_key(key)
+      expiration_value = lock_expiration(timeout)
+      attempt_counter = 0
+      begin
+        if self.setnx(current_lock_key, expiration_value)
+          return true
+        else
+          current_lock = self.get(current_lock_key)
+          if (current_lock.to_s.split('-').first.to_i) < Time.now.to_i
+            compare_value = self.getset(current_lock_key, expiration_value)
+            return true if compare_value == current_lock
+          end
+        end
+      
+        raise "Unable to acquire lock for #{key}."
+      rescue => e
+        if e.message == "Unable to acquire lock for #{key}."
+          if attempt_counter == max_attempts
+            raise
+          else
+            attempt_counter += 1
+            sleep 1
+            retry
+          end
+        else
+          raise
+        end
+      end
+    end
+    
+    # Unlock a previously locked key if it has not expired and the current process was the one that locked it.
+    # 
+    # Example:
+    # 
+    # $redis.unlock('beers_on_the_wall')
+    
+    def unlock(key)
+      current_lock_key = lock_key(key)
+      lock_value = self.get(current_lock_key)
+      return true unless lock_value
+      lock_timeout, lock_holder = lock_value.split('-')
+      if (lock_timeout.to_i > Time.now.to_i) && (lock_holder.to_i == Process.pid)
+        self.del(current_lock_key)
+        return true
+      else
+        return false
+      end
+    end
+  
+    private
+  
+    def lock_expiration(timeout)
+      "#{Time.now.to_i + timeout + 1}-#{Process.pid}"
+    end
+  
+    def lock_key(key)
+      "lock:#{key}"
+    end
+  
+  end
+end

data/spec/redis_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'redis-lock'
+require 'logger'
+
+describe 'redis' do
+  
+  before(:all) do
+    @redis = Redis.new
+  end
+
+  before(:each) do
+    @redis.flushdb
+  end
+
+  after(:each) do
+    @redis.flushdb
+  end
+
+  after(:all) do
+    @redis.quit
+  end
+  
+  it "should respond to lock" do
+    @redis.should respond_to(:lock)
+  end
+  
+  it "should respond to unlock" do
+    @redis.should respond_to(:unlock)
+  end
+  
+  it "should respond to lock_for_update" do
+    @redis.should respond_to(:lock_for_update)
+  end
+  
+  it "should lock a key" do
+    @redis.lock('test_key').should be_true
+    @redis.get('lock:test_key').should_not be_empty
+  end
+  
+  it "should unlock a key" do
+    @redis.lock('test_key').should be_true
+    @redis.unlock('test_key').should be_true
+  end
+  
+  it "should raise an exception if unable to acquire lock" do
+    @redis.lock('test_key', 9000)
+    lambda { @redis.lock('test_key', 9000, 1) }.should raise_exception("Unable to acquire lock for test_key.")
+  end
+  
+  it "should execute a block during a lock_for_update transaction" do
+    @redis.lock_for_update('test_key', 9000) { @redis.set('test_key', 'awesome') }
+    @redis.get('test_key').should == 'awesome'
+  end
+  
+  it "should unlock at the end of a lock_for_update" do
+    @redis.lock_for_update('test_key', 9000) { @redis.set('test_key', 'awesome') }
+    @redis.get('lock:test_key').should be_nil
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'redis'
+$TESTING = true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: jashmenn-redis-lock
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Patrick Tulskie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70214692078260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70214692078260
+description: ! "  Adds pessimistic locking capabilities to the redis gem.\n  \n  Since
+  these capabilities are utilized client-side, all clients must use this gem and follow
+  the order of lock => make changes => unlock in order to obtain maximum safety when
+  modifying sensitive keys.\n  \n  Tested with redis-server 2.0.4 and should work
+  with all versions > 0.091.\n"
+email: patricktulskie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- Rakefile
+- VERSION
+- lib/redis-lock.rb
+- lib/redis/lock.rb
+- spec/redis_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/PatrickTulskie/redis-lock
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+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.17
+signing_key: 
+specification_version: 3
+summary: Adds the ability to utilize client-side pessimistic locking in Redis.
+test_files:
+- spec/redis_spec.rb
+- spec/spec_helper.rb