ht-memcache-lock 0.2.0 → 0.3.0

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format nested
+--backtrace

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ht-memcache-lock (0.2.0)
+    ht-memcache-lock (0.3.0)
 
 GEM
   remote: http://rubygems.org/
@@ -15,10 +15,11 @@ GEM
       coderay (~> 1.0.5)
       method_source (~> 0.8)
       slop (~> 3.3.1)
+    pry-nav (0.2.2)
+      pry (~> 0.9.10)
     rake (10.0.0)
     rdoc (3.12)
       json (~> 1.4)
-    rr (1.0.4)
     rspec (2.12.0)
       rspec-core (~> 2.12.0)
       rspec-expectations (~> 2.12.0)
@@ -36,7 +37,7 @@ DEPENDENCIES
   ht-memcache-lock!
   memcache-client
   pry
+  pry-nav
   rake
   rdoc
-  rr
   rspec

data/Rakefile

@@ -1,6 +1,6 @@
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 
 desc 'Run spec tests'

data/lib/memcache-lock/version.rb

@@ -1,5 +1,5 @@
 module Memcache
   module Lock
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/memcache-lock.rb

@@ -1,20 +1,24 @@
-require "memcache-lock/version"
+require 'memcache-lock/version'
+require 'securerandom'
 
 class MemcacheLock
   class Error < RuntimeError; end
 
-  DEFAULT_RETRY = 5
-  DEFAULT_EXPIRY = 30
+  DEFAULT_OPTIONS = {
+    :initial_wait => 10e-3, # seconds -- first soft fail will wait for 10ms
+    :expiry       => 60,    # seconds
+    :retries      => 11,    # these defaults will retry for a total 41sec max
+  }
 
   def initialize(cache)
     @cache = cache
   end
 
-  def synchronize(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY)
-    if recursive_lock?(key)
+  def synchronize(key, options={})
+    if acquired?(key)
       yield
     else
-      acquire_lock(key, lock_expiry, retries)
+      acquire_lock(key, options)
       begin
         yield
       ensure
@@ -23,14 +27,13 @@ class MemcacheLock
     end
   end
 
-  def acquire_lock(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY)
-    retries.times do |count|
-      begin
-        response = @cache.add("lock/#{key}", Process.pid, lock_expiry)
-        return if response == "STORED\r\n"
-        raise Error if count == retries - 1
-      end
-      exponential_sleep(count) unless count == retries - 1
+  def acquire_lock(key, options={})
+    options = DEFAULT_OPTIONS.merge(options)
+    1.upto(options[:retries]) do |attempt|
+      response = @cache.add("lock/#{key}", uid, options[:expiry])
+      return if response == "STORED\r\n"
+      break if attempt == options[:retries]
+      Kernel.sleep(2 ** (attempt + rand - 1) * options[:initial_wait])
     end
     raise Error, "Couldn't acquire memcache lock for: #{key}"
   end
@@ -39,13 +42,20 @@ class MemcacheLock
     @cache.delete("lock/#{key}")
   end
 
-  def exponential_sleep(count)
-    @runtime += Benchmark::measure { sleep((2**count) / 2.0) }
+  private
+  
+  def acquired?(key)
+    @cache.get("lock/#{key}") == uid
   end
 
   private
-  def recursive_lock?(key)
-    @cache.get("lock/#{key}") == Process.pid
+  
+  # Globally unique ID for the current thread (or close enough)
+  def uid
+    "#{Socket.gethostname}-#{Process.pid}-#{thread_id}"
   end
-end
 
+  def thread_id
+    Thread.current[:thread_uid] ||= SecureRandom.hex(4)
+  end
+end

data/memcache-lock.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |gem|
   # gem.add_runtime_dependancy 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'pry-nav'
   gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'rr'
   gem.add_development_dependency 'rdoc'
   gem.add_development_dependency 'memcache-client'
 

data/spec/memcache-lock_spec.rb

@@ -1,10 +1,15 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'spec_helper'
 
 describe MemcacheLock do
+  before do
+    Kernel.stub(:sleep)
+    @lock = MemcacheLock.new($memcache)
+  end    
+
   describe '#synchronize' do
     it "yields the block" do
       block_was_called = false
-      $lock.synchronize('lock_key') do
+      @lock.synchronize('lock_key') do
         block_was_called = true
       end
       block_was_called.should == true
@@ -12,27 +17,43 @@ describe MemcacheLock do
 
     it "acquires the specified lock before the block is run" do
       $memcache.get("lock/lock_key").should == nil
-      $lock.synchronize('lock_key') do
+      @lock.synchronize('lock_key') do
         $memcache.get("lock/lock_key").should_not == nil
       end
     end
 
     it "releases the lock after the block is run" do
       $memcache.get("lock/lock_key").should == nil
-      $lock.synchronize('lock_key') {}
+      @lock.synchronize('lock_key') {}
       $memcache.get("lock/lock_key").should == nil
 
     end
 
     it "releases the lock even if the block raises" do
       $memcache.get("lock/lock_key").should == nil
-      $lock.synchronize('lock_key') { raise } rescue nil
+      @lock.synchronize('lock_key') { raise } rescue nil
       $memcache.get("lock/lock_key").should == nil
     end
 
     specify "does not block on recursive lock acquisition" do
-      $lock.synchronize('lock_key') do
-        lambda { $lock.synchronize('lock_key') {} }.should_not raise_error
+      @lock.synchronize('lock_key') do
+        lambda { @lock.synchronize('lock_key') {} }.should_not raise_error
+      end
+    end
+
+    it "permits recursive calls from the same thread" do
+      @lock.acquire_lock('lock_key')
+      lambda {
+        @lock.synchronize('lock_key') { nil }
+      }.should_not raise_error
+    end
+
+    it "prevents calls from different threads" do
+      @lock.acquire_lock('lock_key')
+      as_another_thread do
+        lambda {
+          @lock.synchronize('lock_key') { nil }
+        }.should raise_error(MemcacheLock::Error)
       end
     end
   end
@@ -40,46 +61,68 @@ describe MemcacheLock do
   describe '#acquire_lock' do
     specify "creates a lock at a given cache key" do
       $memcache.get("lock/lock_key").should == nil
-      $lock.acquire_lock("lock_key")
+      @lock.acquire_lock("lock_key")
       $memcache.get("lock/lock_key").should_not == nil
     end
 
     specify "retries specified number of times" do
-      $lock.acquire_lock('lock_key')
+      @lock.acquire_lock('lock_key')
       as_another_process do
-        mock($memcache).add("lock/lock_key", Process.pid, timeout = 10) { "NOT_STORED\r\n" }.times(3)
-        stub($lock).exponential_sleep
-        lambda { $lock.acquire_lock('lock_key', timeout, 3) }.should raise_error
+        $memcache.should_receive(:add).exactly(3).times.and_return("NOT_STORED\r\n")
+        lambda { @lock.acquire_lock('lock_key', :expiry => 10, :retries => 3) }.should raise_error(MemcacheLock::Error)
       end
     end
 
     specify "correctly sets timeout on memcache entries" do
-      mock($memcache).add('lock/lock_key', Process.pid, timeout = 10) { "STORED\r\n" }
-      $lock.acquire_lock('lock_key', timeout)
+      $memcache.should_receive(:add).with('lock/lock_key', anything, 42).and_return("STORED\r\n")
+      @lock.acquire_lock('lock_key', :expiry => 42)
     end
 
     specify "prevents two processes from acquiring the same lock at the same time" do
-      $lock.acquire_lock('lock_key')
+      @lock.acquire_lock('lock_key')
       as_another_process do
-        lambda { $lock.acquire_lock('lock_key') }.should raise_error
+        lambda { @lock.acquire_lock('lock_key') }.should raise_error(MemcacheLock::Error)
       end
     end
 
-    def as_another_process
-      current_pid = Process.pid
-      stub(Process).pid { current_pid + 1 }
-      yield
+    specify "prevents two threads from acquiring the same lock at the same time" do
+      @lock.acquire_lock('lock_key')
+      as_another_thread do
+        lambda { @lock.acquire_lock('lock_key') }.should raise_error(MemcacheLock::Error)
+      end
     end
 
+    specify "prevents a given thread from acquiring the same lock twice" do
+      @lock.acquire_lock('lock_key')
+      lambda { @lock.acquire_lock('lock_key') }.should raise_error(MemcacheLock::Error)
+    end
   end
 
   describe '#release_lock' do
     specify "deletes the lock for a given cache key" do
       $memcache.get("lock/lock_key").should == nil
-      $lock.acquire_lock("lock_key")
+      @lock.acquire_lock("lock_key")
       $memcache.get("lock/lock_key").should_not == nil
-      $lock.release_lock("lock_key")
+      @lock.release_lock("lock_key")
       $memcache.get("lock/lock_key").should == nil
     end
   end
+
+
+  #  helpers
+
+  def as_another_process
+    current_pid = Process.pid
+    Process.stub :pid => (current_pid + 1)
+    yield
+    Process.unstub :pid
+  end
+
+  def as_another_thread
+    old_tid = Thread.current[:thread_uid]
+    Thread.current[:thread_uid] = nil
+    yield
+    Thread.current[:thread_uid] = old_tid
+  end
+
 end

data/spec/spec_helper.rb

@@ -8,12 +8,10 @@ require "rspec/core"
 require 'rspec/core/rake_task'
 
 RSpec.configure do |config|
-  config.mock_with :rr
   config.before :suite do
     config = YAML.load(IO.read((File.expand_path(File.dirname(__FILE__) + "/memcache.yml"))))['test']
     $memcache = MemCache.new(config)
     $memcache.servers = config['servers']
-    $lock = MemcacheLock.new($memcache)
   end
 
   config.before :each do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ht-memcache-lock
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-13 00:00:00.000000000 Z
+date: 2012-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -45,7 +45,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry-nav
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -61,7 +61,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rr
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -117,6 +117,7 @@ extra_rdoc_files: []
 files:
 - .document
 - .gitignore
+- .rspec
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -143,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2722382117642160453
+      hash: 3262276607432502556
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -152,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2722382117642160453
+      hash: 3262276607432502556
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23