pmckee11-redis-lock 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83a23888f2a8facee8e44efa6bfed1787ccbaaff
-  data.tar.gz: c90fec2dd78ab7d4deb6539cb3c526771371e5b4
+  metadata.gz: 290df5759f6a3511b52c04a4399e72c6f8fa63b3
+  data.tar.gz: 7d51790da0d3841fb80054146adae29e8c4a601c
 SHA512:
-  metadata.gz: 9ad344a0f17edd109ac36d756ac6fdb0bb928442223828c88666757d8ecfe4a1c142cd59f5d006f9c2fb3c7ea87ca5adf89f68f28f7e181c8df3539d968fc274
-  data.tar.gz: d147966d672dba6e0723759b89a40d87e16200d583a13bdb88efc7b62a2ccac049046745c805f34ce77f4011e747ee072c3bff4c5fa04dd5a7a399151541b7a2
+  metadata.gz: 16ea49364c09328c26190ec9b99dd7a0fe56342df44eec8d3e6c5dda99663577510f04ed12fbbe2199026d8b5d897a90562217bb16c46d90944a5a36ea8b57bb
+  data.tar.gz: 41f0d9710dcdb9acb844e8220bfae98a0751c46e6247f581e93e68bce5ea69e4c815658d45c6a05395af70103c9a28915fb75f3562439310e33e20619424187e

data/Gemfile.lock

@@ -27,4 +27,4 @@ PLATFORMS
 
 DEPENDENCIES
   pmckee11-redis-lock!
-  rspec
+  rspec (~> 3.0, >= 3.0)

data/README.md

@@ -13,11 +13,37 @@ 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 
+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 or newer server, allowing it to leverage those newer features to make fewer round trips and provide better performance 
+
+## Usage
+
+Create an instance of `Redis::Lock` with the desired redis connection and parameters. `auto_release_time` is the lock TTL in seconds (defaults to 10) and `base_sleep` is the amount of time in milliseconds to sleep after the first failure to acquire a lock (defaults to 100ms). Successive failures to acquire a lock result in exponential back off to prevent wasted cycles:
+
+    redis = Redis.new
+    my_lock = Redis::Lock.new(redis, 
+                              "my-lock-key", 
+                              :auto_release_time => LOCK_TTL_IN_SECS, 
+                              :base_sleep => SLEEP_IN_MS)
+                           
+Once you have a lock, you can manually lock and unlock or pass a block to lock only around your code:
+
+    my_lock.lock
+    # Do stuff
+    my_lock.unlock
+
+    my_lock.do |lock|
+        # Do stuff
+    end
+
+You can also configure the maximum amount of time in seconds to block on acquiring a lock (defaults to 10):
+
+    my_lock(5).do |lock|
+        # Do stuff
+    end
 
 ## Contributing
 
@@ -25,4 +51,4 @@ There are a few other redis lock implementations in ruby, but none of them seeme
 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
+5. Create new Pull Request

data/lib/redis-lock.rb

@@ -55,12 +55,17 @@ class Redis
       end
     end
 
+    # @return Boolean that is true if the lock is currently held by any process
+    def locked?
+      return !@redis.get(@key).nil?
+    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)
+    def locked_by_me?(force_remote = false)
       if @time_locked
         if force_remote
           return @redis.get(@key) == @instance_name

data/lib/redis-lock/version.rb

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

data/redis-lock.gemspec

@@ -19,5 +19,5 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   
   gem.add_dependency "redis", '~> 3.0', '>= 3.0.5'
-  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec", '~> 3.0', '>= 3.0'
 end

data/spec/redis-lock_spec.rb

@@ -23,16 +23,18 @@ describe Redis::Lock do
   context "#lock" do
     it "should set an appropriate key in redis" do
       lock.lock
-      @redis.get("lock:#{key}").should_not be_nil
+      expect(@redis.get("lock:#{key}")).not_to be_nil
     end
 
     context "when a block is provided" do
       it "locks before yielding and releases after" do
+        expect(lock).to receive(:test_message)
         lock.lock do |l|
-          l.should == lock
-          @redis.get("lock:#{key}").should_not be_nil
+          expect(l).to eq(lock)
+          l.test_message
+          expect(@redis.get("lock:#{key}")).not_to be_nil
         end
-        @redis.get("lock:#{key}").should be_nil
+        expect(@redis.get("lock:#{key}")).to be_nil
       end
     end
 
@@ -45,8 +47,8 @@ describe Redis::Lock do
           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)
+          expect(Time.now - time).to be_within(0.1).of(2.0)
+          expect(e).to be_a(Redis::Lock::AcquireLockTimeOut)
         end
       end
     end
@@ -54,7 +56,7 @@ describe Redis::Lock do
     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)
+        expect(@redis).to receive(:set).with("lock:#{key}", an_instance_of(String), :nx => true, :ex => 7).and_return(true)
         other_lock.lock
       end
     end
@@ -62,12 +64,12 @@ describe Redis::Lock do
     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
+        expect(other_lock).to receive(:sleep).with(0.025).ordered
+        expect(other_lock).to receive(:sleep).with(0.05).ordered
+        expect(other_lock).to receive(:sleep).with(0.1).ordered
+        expect(other_lock).to receive(:sleep).with(0.2).ordered
+        expect(other_lock).to receive(:sleep) do |sleep_time|
+          expect(sleep_time).to eq(0.4)
           lock.unlock
         end.ordered
         lock.lock
@@ -80,7 +82,7 @@ describe Redis::Lock do
     it "should delete an appropriate key from redis" do
       lock.lock
       lock.unlock
-      @redis.get("lock:#{key}").should be_nil
+      expect(@redis.get("lock:#{key}")).to be_nil
     end
 
     it "should not delete a lock held by another instance" do
@@ -88,13 +90,13 @@ describe Redis::Lock do
       other_lock.lock
       sleep(1.1)
       lock.lock
-      other_lock.unlock
-      @redis.get("lock:#{key}").should_not be_nil
+      other_lock.unlock(true)
+      expect(@redis.get("lock:#{key}")).not_to be_nil
     end
 
     context "when the instance has not been locked" do
       it "is a no op" do
-        @redis.should_not_receive(:eval)
+        expect(@redis).not_to receive(:eval)
         lock.unlock
       end
     end
@@ -104,7 +106,7 @@ describe Redis::Lock do
         other_lock = Redis::Lock.new(@redis, key, :auto_release_time => 1)
         other_lock.lock
         sleep(1)
-        @redis.should_not_receive(:eval)
+        expect(@redis).not_to receive(:eval)
         other_lock.unlock
       end
 
@@ -113,7 +115,7 @@ describe Redis::Lock 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
+          expect(@redis).to receive(:eval).with(Redis::Lock::UNLOCK_LUA_SCRIPT, ["lock:#{key}"], instance_of(Array)).once
           other_lock.unlock(true)
         end
       end
@@ -121,18 +123,40 @@ describe Redis::Lock do
   end
 
   context "#locked?" do
+    context "when the lock is held" do
+      before :each do
+        lock.lock
+      end
+
+      after :each do
+        lock.unlock
+      end
+
+      it "returns true" do
+        expect(lock.locked?).to be_truthy
+      end
+    end
+
+    context "when the lock is not held" do
+      it "returns false" do
+        expect(lock.locked?).to be_falsey
+      end
+    end
+  end
+
+  context "#locked_by_me?" do
     it "correctly determines if the instance holds the lock" do
-      lock.locked?.should be_false
+      expect(lock.locked_by_me?).to be_falsey
       lock.lock
-      lock.locked?.should be_true
+      expect(lock.locked_by_me?).to be_truthy
       lock.unlock
-      lock.locked?.should be_false
+      expect(lock.locked_by_me?).to be_falsey
     end
 
     context "when the instance has not been locked" do
       it "is a no op" do
-        @redis.should_not_receive(:eval)
-        lock.unlock
+        expect(@redis).not_to receive(:get)
+        lock.locked_by_me?
       end
     end
 
@@ -141,8 +165,8 @@ describe Redis::Lock 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
+        expect(@redis).not_to receive(:get)
+        expect(other_lock.locked_by_me?).to be_falsey
       end
 
       context "but force_remote is true" do
@@ -150,11 +174,11 @@ describe Redis::Lock 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
+          expect(@redis).to receive(:get).once.and_return(nil)
+          expect(other_lock.locked_by_me?(true)).to be_falsey
         end
       end
     end
   end
   
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pmckee11-redis-lock
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Peter McKee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-26 00:00:00.000000000 Z
+date: 2015-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -34,16 +34,22 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 description: Distributed lock using ruby redis
 email:
 - pmckee11@gmail.com
@@ -82,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Distributed lock using ruby redis