pmckee11-redis-lock 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83a23888f2a8facee8e44efa6bfed1787ccbaaff
+  data.tar.gz: c90fec2dd78ab7d4deb6539cb3c526771371e5b4
+SHA512:
+  metadata.gz: 9ad344a0f17edd109ac36d756ac6fdb0bb928442223828c88666757d8ecfe4a1c142cd59f5d006f9c2fb3c7ea87ca5adf89f68f28f7e181c8df3539d968fc274
+  data.tar.gz: d147966d672dba6e0723759b89a40d87e16200d583a13bdb88efc7b62a2ccac049046745c805f34ce77f4011e747ee072c3bff4c5fa04dd5a7a399151541b7a2

data/.gitignore

@@ -0,0 +1,3 @@
+redis-lock*.gem
+*~
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis-lock.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    pmckee11-redis-lock (0.1.0)
+      redis (~> 3.0, >= 3.0.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    redis (3.2.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pmckee11-redis-lock!
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Peter McKee
+
+MIT License
+
+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,28 @@
+# Redis::Lock
+
+This gem implements robust pessimistic locking as described at http://redis.io/commands/set using the ruby redis client.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pmckee11-redis-lock', require: 'redis-lock'
+
+and then run bundler.
+
+Or run
+
+    $ gem install pmckee11-redis-lock
+
+## Background
+
+This implements a distributed lock with a timeout almost exactly as described in the redis documentation.
+There are a few other redis lock implementations in ruby, but none of them seemed to be using the newer features in redis that can yield a performance improvement (e.g. the expanded SET parameters and Lua scripting). Using this gem requires a redis 2.6.12 server, allowing it to leverage those newer features to make fewer round trips and provide better performance 
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:rspec)
+
+task :default => [:rspec]

data/lib/redis-lock.rb

@@ -0,0 +1,97 @@
+require "redis"
+require "securerandom"
+
+class Redis
+  class Lock
+
+    attr_reader :redis
+    attr_reader :key
+
+    class AcquireLockTimeOut < StandardError
+    end
+
+    UNLOCK_LUA_SCRIPT = "if redis.call('get',KEYS[1])==ARGV[1] then redis.call('del',KEYS[1]) end"
+
+    # @param redis is a Redis instance
+    # @param key String for a unique name of the lock to acquire
+    # @param options[:auto_release_time] Int for the max number of seconds a lock can be held before it is auto released
+    # @param options[:base_sleep] Int for the number of millis to sleep after the first time a lock is not acquired
+    #                             (successive reattempts will be made with exponential back off)
+    def initialize(redis, key, options = {})
+      @redis               = redis
+      @key                 = "lock:#{key}"
+      @auto_release_time   = options[:auto_release_time] || 30
+      @base_sleep_in_secs  = (options[:base_sleep] || 100) / 1000.0
+      # Unique token set as the redis value of @key when locked by this instance
+      @instance_name       = SecureRandom.hex
+      # If lock was called and unlock has not yet been called, this is set to the time the lock was acquired
+      @time_locked         = nil
+    end
+
+    # Acquire the lock. If a block is provided, the lock is acquired before yielding to the block and released once the
+    # block is returned.
+    # @param acquire_timeout Int for max number of seconds to spend acquiring the lock before raising an error
+    def lock(acquire_timeout = 10, &block)
+      raise AcquireLockTimeOut.new unless attempt_lock(acquire_timeout)
+      if block
+        begin
+          yield(self)
+        ensure
+          unlock
+        end
+      end
+    end
+
+    # Releases the lock if it is held by this instance. By default, this method relies on the expiration time of the key
+    # as a performance optimization when possible. If this is undesirable for some reason, set force_remote to true.
+    # @param force_remote Boolean for whether to explicitly delete on the redis server instead of relying on expiration
+    def unlock(force_remote = false)
+      # unlock is a no-op if we never called lock
+      if @time_locked
+        if Time.now < @time_locked + @auto_release_time || force_remote
+          @redis.eval(UNLOCK_LUA_SCRIPT, [@key], [@instance_name])
+        end
+        @time_locked = nil
+      end
+    end
+
+    # Determines whether or not the lock is held by this instance. By default, this method relies on the expiration time
+    # of the key  as a performance optimization when possible. If this is undesirable for some reason, set force_remote
+    # to true.
+    # @param force_remote Boolean for whether to verify with a call to the redis server instead of using the lock time
+    # @return Boolean that is true if this lock instance currently holds the lock
+    def locked?(force_remote = false)
+      if @time_locked
+        if force_remote
+          return @redis.get(@key) == @instance_name
+        end
+        if Time.now < @time_locked + @auto_release_time
+          return true
+        end
+      end
+      return false
+    end
+
+    private
+
+    # @param acquire_timeout Int for the number of seconds to spend attempting to acquire the lock
+    # @return true if locked, false otherwise
+    def attempt_lock(acquire_timeout)
+      locked = false
+      sleep_time = @base_sleep_in_secs
+      when_to_timeout = Time.now + acquire_timeout
+      until locked
+        locked = @redis.set(@key, @instance_name, :nx => true, :ex => @auto_release_time)
+        unless locked
+          return false if Time.now > when_to_timeout
+          sleep(sleep_time)
+          # exponentially back off, but ensure that we take all of our wait time without going over
+          sleep_time = [sleep_time * 2, when_to_timeout - Time.now].min
+        end
+      end
+      @time_locked = Time.now
+      return true
+    end
+
+  end
+end

data/lib/redis-lock/version.rb

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

data/redis-lock.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redis-lock/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pmckee11-redis-lock"
+  gem.version       = Redis::Lock::VERSION
+  gem.authors       = ["Peter McKee"]
+  gem.email         = ["pmckee11@gmail.com"]
+  gem.description   = %q{Distributed lock using ruby redis}
+  gem.summary       = %q{Distributed lock using ruby redis}
+  gem.homepage      = "https://github.com/pmckee11/redis-lock"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_dependency "redis", '~> 3.0', '>= 3.0.5'
+  gem.add_development_dependency "rspec"
+end

data/spec/redis-lock_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe Redis::Lock do
+  let(:key) {"key"}
+  let(:lock) {Redis::Lock.new(@redis, key)}
+
+  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
+
+  context "#lock" do
+    it "should set an appropriate key in redis" do
+      lock.lock
+      @redis.get("lock:#{key}").should_not be_nil
+    end
+
+    context "when a block is provided" do
+      it "locks before yielding and releases after" do
+        lock.lock do |l|
+          l.should == lock
+          @redis.get("lock:#{key}").should_not be_nil
+        end
+        @redis.get("lock:#{key}").should be_nil
+      end
+    end
+
+    context "when acquire_timeout is provided" do
+      it "times out after the given timeout with an appropriate error" do
+        other_lock = Redis::Lock.new(@redis, key)
+        time = Time.now
+        lock.lock
+        begin
+          other_lock.lock(2)
+          fail()
+        rescue => e
+          (Time.now - time).should be_within(0.1).of(2.0)
+          e.should be_a(Redis::Lock::AcquireLockTimeOut)
+        end
+      end
+    end
+
+    context "when initialized with auto_release_time" do
+      it "sets the redis key with an appropriate expiration" do
+        other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 7)
+        @redis.should_receive(:set).with("lock:#{key}", an_instance_of(String), :nx => true, :ex => 7).and_return(true)
+        other_lock.lock
+      end
+    end
+
+    context "when initialized with base_sleep" do
+      it "retries with exponential back off starting at base_sleep millis" do
+        other_lock = Redis::Lock.new(@redis, key, :base_sleep => 25)
+        other_lock.should_receive(:sleep).with(0.025).ordered
+        other_lock.should_receive(:sleep).with(0.05).ordered
+        other_lock.should_receive(:sleep).with(0.1).ordered
+        other_lock.should_receive(:sleep).with(0.2).ordered
+        other_lock.should_receive(:sleep) do |sleep_time|
+          sleep_time.should == 0.4
+          lock.unlock
+        end.ordered
+        lock.lock
+        other_lock.lock
+      end
+    end
+  end
+
+  context "#unlock" do
+    it "should delete an appropriate key from redis" do
+      lock.lock
+      lock.unlock
+      @redis.get("lock:#{key}").should be_nil
+    end
+
+    it "should not delete a lock held by another instance" do
+      other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 1)
+      other_lock.lock
+      sleep(1.1)
+      lock.lock
+      other_lock.unlock
+      @redis.get("lock:#{key}").should_not be_nil
+    end
+
+    context "when the instance has not been locked" do
+      it "is a no op" do
+        @redis.should_not_receive(:eval)
+        lock.unlock
+      end
+    end
+
+    context "when the instance lock has expired based on the lock time" do
+      it "is a no op" do
+        other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 1)
+        other_lock.lock
+        sleep(1)
+        @redis.should_not_receive(:eval)
+        other_lock.unlock
+      end
+
+      context "but force_remote is true" do
+        it "makes a redis call" do
+          other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 1)
+          other_lock.lock
+          sleep(1)
+          @redis.should_receive(:eval).with(Redis::Lock::UNLOCK_LUA_SCRIPT, ["lock:#{key}"], instance_of(Array)).once
+          other_lock.unlock(true)
+        end
+      end
+    end
+  end
+
+  context "#locked?" do
+    it "correctly determines if the instance holds the lock" do
+      lock.locked?.should be_false
+      lock.lock
+      lock.locked?.should be_true
+      lock.unlock
+      lock.locked?.should be_false
+    end
+
+    context "when the instance has not been locked" do
+      it "is a no op" do
+        @redis.should_not_receive(:eval)
+        lock.unlock
+      end
+    end
+
+    context "when the instance lock has expired based on the lock time" do
+      it "is a no op" do
+        other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 1)
+        other_lock.lock
+        sleep(1)
+        @redis.should_not_receive(:get)
+        other_lock.locked?.should be_false
+      end
+
+      context "but force_remote is true" do
+        it "makes a redis call" do
+          other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 1)
+          other_lock.lock
+          sleep(1)
+          @redis.should_receive(:get).once.and_return(nil)
+          other_lock.locked?(true).should be_false
+        end
+      end
+    end
+  end
+  
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: pmckee11-redis-lock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter McKee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Distributed lock using ruby redis
+email:
+- pmckee11@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/redis-lock.rb
+- lib/redis-lock/version.rb
+- redis-lock.gemspec
+- spec/redis-lock_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/pmckee11/redis-lock
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Distributed lock using ruby redis
+test_files:
+- spec/redis-lock_spec.rb
+- spec/spec_helper.rb