remote_lock 1.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 HouseTrip
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+[![Build Status](https://travis-ci.org/HouseTrip/remote_lock.png)](https://travis-ci.org/HouseTrip/remote_lock)
+
+remote_lock
+===========
+
+This is a rewrite of a initial extraction from Nick Kallen's [cache-money](http://github.com/nkallen/cache-money) and
+also a fork from James Golick [memcache-lock](https://github.com/jamesgolick/memcache-lock)
+
+This adds supports for memcache or redis as lock storage.
+
+Installation
+------------
+
+```shell
+gem install remote-lock
+```
+
+Initialization
+-------------
+
+* Lock using memcached:
+
+  ```ruby
+  # memcache = MemCache.new(YAML.load(File.read("/path/to/memcache/config")))
+  # Or whatever way you have your memcache connection
+  $lock = RemoteLock.new(RemoteLock::Adapters::Memcached.new(memcache))
+  ```
+
+* Lock using redis:
+
+  ```ruby
+  # redis = Redis.new
+  # Or whatever way you have your redis connection
+  $lock = RemoteLock.new(RemoteLock::Adapters::Redis.new(redis))
+  ```
+
+Usage
+-----
+
+Then, wherever you'd like to lock a key, use it like this:
+
+```ruby
+$lock.synchronize("some-key") do
+  # stuff that needs synchronization in here
+end
+```
+
+Options:
+
+* TTL
+
+  By default keys will expire after 60 seconds, you can define this per key:
+
+  ```ruby
+  $lock.synchronize("my-key", expiry: 30.seconds) do ... end
+  ```
+
+* Attempts
+
+  By default it will try 11 times to lock the resource, this can be set per key:
+
+  ```ruby
+  $lock.synchronize("my-key", retries: 5) do ... end
+  ```
+
+* Tries interval
+
+  You can customize the interval between tries, initially it's 10ms:
+
+  ```ruby
+  $lock.synchronize("my-key", initial_wait: 10e-3) do ... end
+  ```
+
+For more info, see lib/remote_lock.rb. It's very straightforward to read.
+
+Note on Patches/Pull Requests
+=============================
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+License
+============
+MIT licence. Copyright (c) 2013 HouseTrip Ltd.
+
+
+
+Based on the memcache-lock gem: https://github.com/jamesgolick/memcache-lock

data/Rakefile

@@ -0,0 +1,26 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+
+desc 'Run spec tests'
+task :spec do
+  RSpec::Core::RakeTask.new do |spec|
+    spec.pattern = "./spec/**/*_spec.rb"
+  end
+end
+
+task :default => :spec
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "memcache-lock #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/remote_lock.rb

@@ -0,0 +1,57 @@
+class RemoteLock
+  class Error < RuntimeError; end
+
+  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(adapter, prefix = nil)
+    raise "Invalid Adapter" unless Adapters::Base.valid?(adapter)
+    @adapter = adapter
+    @prefix = prefix
+  end
+
+  def synchronize(key, options={})
+    if acquired?(key)
+      yield
+    else
+      acquire_lock(key, options)
+      begin
+        yield
+      ensure
+        release_lock(key)
+      end
+    end
+  end
+
+  def acquire_lock(key, options = {})
+    options = DEFAULT_OPTIONS.merge(options)
+    1.upto(options[:retries]) do |attempt|
+      success = @adapter.store(key_for(key), options[:expiry])
+      return if success
+      break if attempt == options[:retries]
+      Kernel.sleep(2 ** (attempt + rand - 1) * options[:initial_wait])
+    end
+    raise RemoteLock::Error, "Couldn't acquire lock for: #{key}"
+  end
+
+  def release_lock(key)
+    @adapter.delete(key_for(key))
+  end
+
+  def acquired?(key)
+    @adapter.has_key?(key_for(key))
+  end
+
+  private
+
+  def key_for(string)
+    [@prefix, "lock", string].compact.join('|')
+  end
+
+end
+
+require 'remote_lock/adapters/memcached'
+require 'remote_lock/adapters/redis'

data/lib/remote_lock/adapters/base.rb

@@ -0,0 +1,40 @@
+require 'securerandom'
+
+module RemoteLock::Adapters
+  class Base
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def store(key, options = {})
+      raise NotImplementedError
+    end
+
+    def has_key?(key, options = {})
+      raise NotImplementedError
+    end
+
+    def delete(key)
+      raise NotImplementedError
+    end
+
+    def self.valid?(adapter)
+      adapter.respond_to?(:store) &&
+        adapter.respond_to?(:has_key?) &&
+        adapter.respond_to?(:delete)
+    end
+
+    private
+
+    # Globally unique ID for the current thread (or close enough)
+    def uid
+      "#{Socket.gethostname}-#{Process.pid}-#{thread_id}"
+    end
+
+    def thread_id
+      Thread.current[:thread_uid] ||= SecureRandom.hex(4)
+    end
+
+  end
+end

data/lib/remote_lock/adapters/memcached.rb

@@ -0,0 +1,20 @@
+require 'remote_lock/adapters/base'
+
+module RemoteLock::Adapters
+  class Memcached < Base
+
+    def store(key, expires_in_seconds)
+      status = @connection.add(key, uid, expires_in_seconds)
+      status =~ /^STORED/
+    end
+
+    def delete(key)
+      @connection.delete(key)
+    end
+
+    def has_key?(key)
+      @connection.get(key) == uid
+    end
+
+  end
+end

data/lib/remote_lock/adapters/redis.rb

@@ -0,0 +1,21 @@
+require 'remote_lock/adapters/base'
+
+module RemoteLock::Adapters
+  class Redis < Base
+
+    def store(key, expires_in_seconds)
+      @connection.setnx(key, uid).tap do |status|
+        @connection.expire(key, expires_in_seconds) if status
+      end
+    end
+
+    def delete(key)
+      @connection.del(key)
+    end
+
+    def has_key?(key)
+      @connection.get(key) == uid
+    end
+
+  end
+end

data/lib/remote_lock/version.rb

@@ -0,0 +1,3 @@
+class RemoteLock
+  VERSION = "1.0.0"
+end

data/spec/adapters/hash_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Hash do
+  it_behaves_like 'a remote lock adapter', {}
+end

data/spec/adapters/memcached_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module RemoteLock::Adapters
+  describe Memcached do
+    it_behaves_like 'a remote lock adapter', memcache
+
+    context "Memcache scope" do
+      let(:adapter)  { Memcached.new(memcache) }
+      let(:uid)      { '1234' }
+      let(:test_key) { "test_key" }
+
+      before do
+        adapter.stub(:uid).and_return(uid)
+      end
+
+      describe "#store" do
+        it "should store the lock in memcached" do
+          memcache.get(test_key).should be_nil
+          adapter.store(test_key, 100)
+          memcache.get(test_key).should eq uid
+        end
+      end
+
+      describe "#has_key?" do
+        it "should return true if the key exists in memcache with uid value" do
+          memcache.add(test_key, uid)
+          adapter.has_key?(test_key).should be_true
+        end
+
+        it "should return false if the key doesn't exist in memcache or is a different uid" do
+          memcache.add(test_key, "notvalid")
+          adapter.has_key?(test_key).should be_false
+          memcache.delete(test_key)
+          adapter.has_key?(test_key).should be_false
+        end
+      end
+
+      describe "#delete" do
+        it "should remove the key from memcached" do
+          memcache.add(test_key, uid)
+          adapter.delete(test_key)
+          memcache.get(test_key).should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/adapters/redis_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module RemoteLock::Adapters
+  describe Redis do
+    it_behaves_like 'a remote lock adapter', redis
+
+    context "Redis scope" do
+      let(:adapter) { Redis.new(redis) }
+      let(:uid)      { '1234' }
+      let(:test_key) { "test_key" }
+
+      before do
+        adapter.stub(:uid).and_return(uid)
+      end
+
+      describe "#store" do
+        it "should store the lock in memcached" do
+          redis.get(test_key).should be_nil
+          adapter.store(test_key, 100)
+          redis.get(test_key).should eq uid
+        end
+
+        context "expiry" do
+          it "should expire the key after the time is over" do
+            adapter.store(test_key, 1)
+            sleep 1.1
+            redis.exists(test_key).should be_false
+          end
+
+          it "should expire the key after the time is over" do
+            adapter.store(test_key, 10)
+            sleep 0.5
+            redis.exists(test_key).should be_true
+          end
+        end
+      end
+
+      describe "#has_key?" do
+        it "should return true if the key exists in memcache with uid value" do
+          redis.setnx(test_key, uid)
+          adapter.has_key?(test_key).should be_true
+        end
+
+        it "should return false if the key doesn't exist in memcache or is a different uid" do
+          redis.setnx(test_key, "notvalid")
+          adapter.has_key?(test_key).should be_false
+          redis.del(test_key)
+          adapter.has_key?(test_key).should be_false
+        end
+      end
+
+      describe "#delete" do
+        it "should remove the key from memcached" do
+          redis.setnx(test_key, uid)
+          adapter.delete(test_key)
+          redis.get(test_key).should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/memcache.yml

@@ -0,0 +1,2 @@
+test:
+  servers: localhost:11211

data/spec/remote_lock_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe RemoteLock do
+
+  adapters = {
+    :memcached => RemoteLock::Adapters::Memcached.new(memcache),
+    :redis => RemoteLock::Adapters::Redis.new(redis)
+  }
+
+  adapters.each_pair do |name, adapter|
+    context "Using adapter: #{name}" do
+      before do
+        Kernel.stub(:sleep)
+      end
+
+      let(:lock) { RemoteLock.new(adapter) }
+
+      describe "#synchronize" do
+
+        it "yields the block" do
+          expect { |call|
+            lock.synchronize('lock_key', &call)
+          }.to yield_control
+        end
+
+        it "acquires the specified lock before the block is run" do
+          adapter.has_key?("lock_key").should be_false
+          lock.synchronize('lock_key') do
+            adapter.has_key?("lock|lock_key").should be_true
+          end
+        end
+
+        it "releases the lock after the block is run" do
+          adapter.has_key?("lock_key").should be_false
+          expect { |call| lock.synchronize('lock_key', &call) }.to yield_control
+          adapter.has_key?("lock|lock_key").should be_false
+        end
+
+        it "releases the lock even if the block raises" do
+          adapter.has_key?("lock|lock_key").should be_false
+          lock.synchronize('lock_key') { raise } rescue nil
+          adapter.has_key?("lock|lock_key").should be_false
+        end
+
+        specify "does not block on recursive lock acquisition" do
+          lock.synchronize('lock_key') do
+            lambda {
+              expect{ |call| lock.synchronize('lock_key', &call) }.to yield_control
+            }.should_not raise_error
+          end
+        end
+
+        it "permits recursive calls from the same thread" do
+          lock.acquire_lock('lock_key')
+          lambda {
+            expect { |call| lock.synchronize('lock_key', &call) }.to yield_control
+          }.should_not raise_error
+        end
+
+        it "prevents calls from different threads" do
+          lock.acquire_lock('lock_key')
+          another_thread do
+            lambda {
+              expect { |call| lock.synchronize('lock_key', &call) }.to_not yield_control
+            }.should raise_error(RemoteLock::Error)
+          end
+        end
+      end
+
+      describe '#acquire_lock' do
+        specify "creates a lock at a given cache key" do
+          adapter.has_key?("lock|lock_key").should be_false
+          lock.acquire_lock("lock_key")
+          adapter.has_key?("lock|lock_key").should be_true
+        end
+
+        specify "retries specified number of times" do
+          lock.acquire_lock('lock_key')
+          another_process do
+            adapter.should_receive(:store).exactly(3).times.and_return(false)
+            lambda {
+              lock.acquire_lock('lock_key', :expiry => 10, :retries => 3)
+            }.should raise_error(RemoteLock::Error)
+          end
+        end
+
+        specify "correctly sets timeout on entries" do
+          adapter.should_receive(:store).with('lock|lock_key', 42).and_return true
+          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')
+          another_process do
+            lambda { lock.acquire_lock('lock_key') }.should raise_error(RemoteLock::Error)
+          end
+        end
+
+        specify "prevents two threads from acquiring the same lock at the same time" do
+          lock.acquire_lock('lock_key')
+          another_thread do
+            lambda { lock.acquire_lock('lock_key') }.should raise_error(RemoteLock::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(RemoteLock::Error)
+        end
+      end
+
+      describe '#release_lock' do
+        specify "deletes the lock for a given cache key" do
+          adapter.has_key?("lock|lock_key").should be_false
+          lock.acquire_lock("lock_key")
+          adapter.has_key?("lock|lock_key").should be_true
+          lock.release_lock("lock_key")
+          adapter.has_key?("lock|lock_key").should be_false
+        end
+      end
+
+      context "lock prefixing" do
+        it "should prefix the key name when a prefix is set" do
+          lock = RemoteLock.new(adapter, "staging_server")
+          lock.acquire_lock("lock_key")
+          adapter.has_key?("staging_server|lock|lock_key").should be_true
+        end
+      end
+    end
+  end
+
+  #  helpers
+
+  def another_process
+    current_pid = Process.pid
+    Process.stub :pid => (current_pid + 1)
+    redis.client.reconnect
+    yield
+    Process.unstub :pid
+    redis.client.reconnect
+  end
+
+  def 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

@@ -0,0 +1,21 @@
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'remote_lock'
+require 'memcache'
+require 'redis'
+
+require "rspec"
+require "rspec/core"
+require 'rspec/core/rake_task'
+require 'yaml'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'support/**/*.rb')).each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.before :each do
+    memcache.flush_all
+    redis.flushdb
+  end
+end

data/spec/support/behave_as_a_remote_lock_adapter.rb

@@ -0,0 +1,27 @@
+shared_examples_for "a remote lock adapter" do |storage|
+  let(:adapter) { described_class.new(storage) }
+  let(:key)      { 'my_test_key' }
+
+  it "should behave like RemoteLock::Strategies::Base" do
+    RemoteLock::Adapters::Base.valid?(adapter).should be_true
+  end
+
+
+  describe "#store" do
+    it "should set the key as acquired" do
+      adapter.has_key?(key).should be_false
+      adapter.store(key, 100)
+      adapter.has_key?(key).should be_true
+    end
+  end
+
+  describe "#delete" do
+    it "should remove the key as locked" do
+      adapter.store(key, 100)
+      adapter.has_key?(key).should be_true
+      adapter.delete(key)
+      adapter.has_key?(key).should be_false
+    end
+  end
+
+end

data/spec/support/memcached_storage.rb

@@ -0,0 +1,7 @@
+def memcache
+  return $memcache if $memcache
+  config = YAML.load(IO.read((File.expand_path(File.join(File.dirname(__FILE__) , "../memcache.yml")))))['test']
+  $memcache = MemCache.new(config)
+  $memcache.servers = config['servers']
+  $memcache
+end

data/spec/support/redis_storage.rb

@@ -0,0 +1,3 @@
+def redis
+  $redis ||= Redis.new()
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: remote_lock
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Julien Letessier
+- Tiago Scolari
+- Arne Hartherz
+- Pedro Cunha
+- Khiet Le
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: memcache-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: remote-based mutexes
+email:
+- julien.letessier@gmail.com
+- tscolari@gmail.com
+- arne.hartherz@makandra.de
+- pkunha@gmail.com
+- kle@housetrip.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/remote_lock/adapters/base.rb
+- lib/remote_lock/adapters/memcached.rb
+- lib/remote_lock/adapters/redis.rb
+- lib/remote_lock/version.rb
+- lib/remote_lock.rb
+- LICENSE
+- Rakefile
+- README.md
+- spec/adapters/hash_spec.rb
+- spec/adapters/memcached_spec.rb
+- spec/adapters/redis_spec.rb
+- spec/memcache.yml
+- spec/remote_lock_spec.rb
+- spec/spec_helper.rb
+- spec/support/behave_as_a_remote_lock_adapter.rb
+- spec/support/memcached_storage.rb
+- spec/support/redis_storage.rb
+homepage: http://github.com/HouseTrip/remote_lock
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 589636169546274691
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 589636169546274691
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Leverages (memcached|redis)'s atomic operation to provide a distributed locking
+  / synchromisation mechanism.
+test_files:
+- spec/adapters/hash_spec.rb
+- spec/adapters/memcached_spec.rb
+- spec/adapters/redis_spec.rb
+- spec/memcache.yml
+- spec/remote_lock_spec.rb
+- spec/spec_helper.rb
+- spec/support/behave_as_a_remote_lock_adapter.rb
+- spec/support/memcached_storage.rb
+- spec/support/redis_storage.rb