ruby_redis_lock 0.1.0 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e55f4562edfe070bce4409e5ac5f80599b44d1b02fad75ca5beeab86afcfb43a
+  data.tar.gz: 37730f073baa006452b6c47141cecc1171f241e150957408fa9fad769f180a0d
+SHA512:
+  metadata.gz: 8324228d9255e2720a994930ca6670706f58f2bf74b827651e49a4d121df757df9b0b782df8b997b8cebcb5a4bd52e04c45097c11ef154e36161658a1fa4adce
+  data.tar.gz: '0792e704125408ffbc7b11a21b71865e27b620b5653ea78d5e67d10dd0a737259125191fbbd4d398481a292c597a2f44cf1832da48a513aa11ef35a7e2d51109'

data/.gitignore

@@ -0,0 +1,2 @@
+.commit-msg*
+coverage

data/.loadpath

@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<loadpath>
-	<pathentry path="" type="src"/>
-	<pathentry path="org.rubypeople.rdt.launching.RUBY_CONTAINER" type="con"/>
-</loadpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<loadpath>
+	<pathentry path="" type="src"/>
+	<pathentry path="org.rubypeople.rdt.launching.RUBY_CONTAINER" type="con"/>
+</loadpath>

data/.project

@@ -1,17 +1,17 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>ruby_redis_lock</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.rubypeople.rdt.core.rubybuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.rubypeople.rdt.core.rubynature</nature>
-	</natures>
-</projectDescription>
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ruby_redis_lock</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.rubypeople.rdt.core.rubybuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.rubypeople.rdt.core.rubynature</nature>
+	</natures>
+</projectDescription>

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -1,5 +1,5 @@
-source 'http://rubygems.org'
-
-gem 'rspec'
-gem 'redis', :git=> 'git://github.com/ezmobius/redis-rb.git'
+source 'http://rubygems.org'
+
+gem 'rspec'
+gem 'redis', :git=> 'git://github.com/ezmobius/redis-rb.git'
 gem 'simplecov'

data/Gemfile.lock

@@ -23,9 +23,13 @@ GEM
     simplecov-html (0.5.3)
 
 PLATFORMS
+  ruby
   x86-mingw32
 
 DEPENDENCIES
   redis!
   rspec
   simplecov
+
+BUNDLED WITH
+   1.16.1

data/Readme.md

@@ -1,85 +1,83 @@
-Ruby-Redis-Lock - Distributed lock for Ruby (using Redis)
-=======================================================
-
-A distributed lock that utilizes Redis.
-It also handles failures.
-If a process acquires a lock for more than some period of time (default is 60 seconds), 
-the lock is automatically released.
-
-Basically, it follows the algorithm explained here: http://redis.io/commands/setnx
-
-Nevertheless, the algorithm on releasing a lock is improved. Please the comments in http://redis.io/commands/setnx
-
-The example of using it:
-
-```ruby
-
-$redis = Redis.new
-
-$redis.lock('some_name', 60, 10) do
- 
- #
- # Do some tasks here
- #
- 
-end
-
-```
-
-The API is below:
-
-```ruby
-lock(lock_name, processing_timeout=60, acquiring_timout=10)
-```
-
-You can change processing_timeout and acquiring_timeout.
-
-The lock will be expired after it has been acquired for a period of time longer than processing_timeout (in seconds).
-
-An error will be raised if the lock cannot be acquired within acquiring_timeout (in seconds).
-
-Installation
-------------------
-
-You can install it directly by:
-
-```sh
-gem install ruby_redis_lock
-```
-
-or put it in your Gemfile:
-
-```sh
-gen 'ruby_redis_lock'
-```
-
-Help me
---------------
-
-1. Clone the project
-2. Install all dependencies with
-
-```
-bundle install
-```
-
-3. Start Redis and running all test cases
-
-```
-bundle exec rspec spec/*
-```
-
-4. Add a feature, if everything is ok
-5. Write tests for the feature
-6. Send me a pull request
-
-
-Author
-------------
-Tanin Na Nakorn
-
-
-Boring legal stuff
--------------------
-
-You can do whatever you want with it
+Ruby-Redis-Lock - Distributed lock for Ruby (using Redis)
+=======================================================
+
+A distributed lock that utilizes Redis.
+It also handles failures.
+If a process acquires a lock for more than some period of time (default is 60 seconds), 
+the lock is automatically released.
+
+Basically, it follows the algorithm explained here: http://redis.io/commands/setnx
+
+I believe it is an optimistic locking algorithm.
+
+Nevertheless, the algorithm on releasing a lock is improved. Please the comments in http://redis.io/commands/setnx
+
+The example of using it:
+
+```ruby
+
+$redis = Redis.new
+
+$redis.lock('some_name', 60, 10) do
+ 
+ #
+ # Do some tasks here
+ #
+ 
+end
+
+```
+
+The API is below:
+
+```ruby
+lock(lock_name, processing_timeout=60, acquiring_timout=10)
+```
+
+You can change processing_timeout and acquiring_timeout.
+
+The lock will be expired after it has been acquired for a period of time longer than processing_timeout (in seconds).
+
+An error will be raised if the lock cannot be acquired within acquiring_timeout (in seconds).
+
+Installation
+------------------
+
+You can install it directly by:
+
+```sh
+gem install ruby_redis_lock
+```
+
+or put it in your Gemfile:
+
+```sh
+gem 'ruby_redis_lock'
+```
+
+Help me
+--------------
+
+1. Fork the project
+2. Install all dependencies with
+```
+bundle install
+```
+3. Start Redis and running all test cases
+```
+bundle exec rspec spec/*
+```
+4. Add a feature, if everything is ok
+5. Write tests for the feature
+6. Send me a pull request
+
+
+Author
+------------
+Tanin Na Nakorn
+
+
+Boring legal stuff
+-------------------
+
+You can do whatever you want with it

data/lib/ruby_redis_lock/ruby_redis_lock.rb

@@ -1,66 +1,56 @@
-module RubyRedisLock
-  
-
-  def lock(lock_name, processing_timeout=60, acquiring_timout=10)
-    acquire_lock(lock_name, processing_timeout, acquiring_timout)
-    yield
-  ensure
-    release_lock(lock_name, processing_timeout)
-  end
-  
-  
-  private
-    def acquire_lock(lock_name, processing_timeout=60, acquiring_timeout=10)
-      
-      start_time = Time.now.to_i
-      
-      while !try_acquire_lock(lock_name, processing_timeout)
-      
-        sleep(rand(100).to_f/100.0)
-      
-        if (Time.now.to_i - start_time) > acquiring_timeout
-          raise Exception, "Acquiring lock timeout > #{acquiring_timeout} seconds"
-        end
-        
-      end
-      
-      return true
-    
-    end
-  
-    def try_acquire_lock(lock_name, processing_timeout=60)
-      
-      ret = self.setnx(ruby_redis_lock_key(lock_name), "#{Time.now.to_i + processing_timeout}")
-      return true if ret == true
-      
-      expiration = self.get(ruby_redis_lock_key(lock_name)).to_i
-      return false if Time.now.to_i < expiration
-
-      previous_expiration = self.getset(ruby_redis_lock_key(lock_name), "#{Time.now.to_i + processing_timeout}").to_i
-      return true if expiration == previous_expiration
-      
-      return false
-      
-    end
-    
-    def release_lock(lock_name, processing_timeout=60)
-      
-      expiration = self.get(ruby_redis_lock_key(lock_name)).to_i
-      return false if Time.now.to_i > expiration
-      
-      previous_expiration = self.getset(ruby_redis_lock_key(lock_name), "#{Time.now.to_i + processing_timeout}").to_i
-      
-      if expiration == previous_expiration # it still owns the lock
-        self.del(ruby_redis_lock_key(lock_name))
-        return true
-      end
-      
-      return false
-    end
-  
-    def ruby_redis_lock_key(lock_name)
-      "RubyRedisLock:#{lock_name}"
-    end
-  
-
+module RubyRedisLock
+
+  LockAcquisitionTimeoutException = Class.new(StandardError)
+
+  def lock(lock_name, processing_timeout=60, acquiring_timout=10)
+    lock_acquired = acquire_lock(lock_name, processing_timeout, acquiring_timout)
+    yield
+  ensure
+    release_lock(lock_name, processing_timeout) if lock_acquired
+  end
+
+  private
+
+  def acquire_lock(lock_name, processing_timeout=60, acquiring_timeout=10)
+    start_time = Time.now.to_i
+    while !try_acquire_lock(lock_name, processing_timeout)
+      sleep 0.5
+      if (Time.now.to_i - start_time) > acquiring_timeout
+        raise LockAcquisitionTimeoutException, "Acquiring lock timeout > #{acquiring_timeout} seconds"
+      end
+    end
+    true
+  end
+
+  def try_acquire_lock(lock_name, processing_timeout=60)
+    ret = self.setnx(ruby_redis_lock_key(lock_name), "#{Time.now.to_i + processing_timeout}")
+    return true if ret == true
+
+    expiration = self.get(ruby_redis_lock_key(lock_name)).to_i
+    return false if Time.now.to_i < expiration
+
+    previous_expiration = self.getset(ruby_redis_lock_key(lock_name), "#{Time.now.to_i + processing_timeout}").to_i
+    return true if expiration == previous_expiration
+
+    false
+  end
+
+  def release_lock(lock_name, processing_timeout=60)
+    expiration = self.get(ruby_redis_lock_key(lock_name)).to_i
+    return false if Time.now.to_i > expiration
+
+    previous_expiration = self.getset(ruby_redis_lock_key(lock_name), "#{Time.now.to_i + processing_timeout}").to_i
+
+    if expiration == previous_expiration # it still owns the lock
+      self.del(ruby_redis_lock_key(lock_name))
+      return true
+    end
+
+    false
+  end
+
+  def ruby_redis_lock_key(lock_name)
+    "RubyRedisLock:#{lock_name}"
+  end
+
 end

data/lib/ruby_redis_lock/version.rb

@@ -0,0 +1,3 @@
+module RubyRedisLock
+  VERSION = "0.1.1"
+end

data/lib/ruby_redis_lock.rb

@@ -1,9 +1,9 @@
-require 'redis'
-
-require File.expand_path('../ruby_redis_lock/ruby_redis_lock', __FILE__)
-
-
-class Redis
-  include RubyRedisLock
-  
+require 'redis'
+
+require File.expand_path('../ruby_redis_lock/ruby_redis_lock', __FILE__)
+
+
+class Redis
+  include RubyRedisLock
+  
 end

data/redis_test.bat

@@ -1,2 +1,2 @@
-"C:\redis\redis-server" test.conf
+"C:\redis\redis-server" test.conf
 pause

data/ruby_redis_lock.gemspec

@@ -1,21 +1,24 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = "ruby_redis_lock"
-  s.version     = "0.1.0"
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Tanin Na Nakorn"]
-  s.email       = ["tanin47@yahoo.com"]
-  s.homepage    = "http://github.com/tanin47/ruby_redis_lock"
-  s.summary     = %q{RubyRedisLock is a distributed lock for Ruby (using Redis)}
-  s.description = %q{distributed lock for Ruby (using Redis)}
-
-  s.rubyforge_project = "ruby_redis_lock"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {coverage,spec}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-end
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby_redis_lock/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "ruby_redis_lock"
+  spec.version     = RubyRedisLock::VERSION
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ["Tanin Na Nakorn", "Mike Gregory"]
+  spec.email       = ["tanin47@yahoo.com", "mgregory@carecloud.com"]
+  spec.homepage    = "http://github.com/mgregory-carecloud/ruby_redis_lock"
+  spec.license       = "MIT"
+  
+  spec.summary     = %q{RubyRedisLock is a distributed lock for Ruby (using Redis)}
+  spec.description = %q{distributed lock for Ruby (using Redis)}
+
+  spec.rubyforge_project = "ruby_redis_lock"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {coverage,spec}/**/*_spec.rb`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+end

data/spec/{acquire_lock_spec.rb → lib/acquire_lock_spec.rb}

@@ -1,44 +1,44 @@
-require 'spec_helper'
-
-describe 'acquire_lock' do
-  
-  it "acquires the lock if it does not exist" do
-    @redis.send(:acquire_lock, "test").should == true
-  end
-  
-  it "acquires the lock if it is expired" do
-    
-    @redis.send(:acquire_lock, "test", 0.1).should == true
-    
-    sleep(1)
-    @redis.send(:acquire_lock, "test").should == true
-    
-  end
-  
-  it "raise errors when acquiring the lock takes too long" do
-    
-    @redis.send(:acquire_lock, "test", 60, 60).should == true
-    
-    lambda { @redis.send(:acquire_lock, "test", 60, 1) }.should raise_error
-    
-  end
-  
-  it "waits until the other thread finishes and acquire lock" do
-    
-    start_time = Time.now.to_i
-    @redis.send(:acquire_lock, "test", 60, 60).should == true
-    
-    Thread.new { 
-      Thread.current.join(1)
-      sleep(5)
-      @redis.send(:release_lock, "test", 60).should == true
-    }
-    
-    Thread.current.join(1)
-    @redis.send(:acquire_lock, "test", 60, 20).should == true
-    
-    (Time.now.to_i - start_time).should be > 4
-    
-  end
-  
+require 'spec_helper'
+
+describe 'acquire_lock' do
+  
+  it "acquires the lock if it does not exist" do
+    @redis.send(:acquire_lock, "test").should == true
+  end
+  
+  it "acquires the lock if it is expired" do
+    
+    @redis.send(:acquire_lock, "test", 0.1).should == true
+    
+    sleep(1)
+    @redis.send(:acquire_lock, "test").should == true
+    
+  end
+  
+  it "raise errors when acquiring the lock takes too long" do
+    
+    @redis.send(:acquire_lock, "test", 60, 60).should == true
+    
+    lambda { @redis.send(:acquire_lock, "test", 60, 1) }.should raise_error
+    
+  end
+  
+  it "waits until the other thread finishes and acquire lock" do
+    
+    start_time = Time.now.to_i
+    @redis.send(:acquire_lock, "test", 60, 60).should == true
+    
+    Thread.new { 
+      Thread.current.join(1)
+      sleep(5)
+      @redis.send(:release_lock, "test", 60).should == true
+    }
+    
+    Thread.current.join(1)
+    @redis.send(:acquire_lock, "test", 60, 20).should == true
+    
+    (Time.now.to_i - start_time).should be > 4
+    
+  end
+  
 end