lock_key 0.1.1 → 0.2.0

data/README.md

@@ -23,7 +23,7 @@ Or install it yourself as:
 ## Usage
 
 Based on [redis-lock](https://github.com/PatrickTulskie/redis-lock) and the [setnx redis comments](http://redis.io/commands/setnx)
-LockKey provides basic key leve locking.
+LockKey provides basic key level locking.
 
 ## Locking a key
 

data/lib/lock_key/lock_key.rb

@@ -27,25 +27,25 @@ class Redis
       :sleep_for => 0.5
     }
 
-    @@value_delimeter = "-:-:-"
-
-    def self.value_delimeter; @@value_delimeter; end
-    def self.value_delimeter=(del); @@value_delimeter = del; end
+    VALUE_DELIMETER = "-:-:-"
 
     def self.defaults=(defaults); @@defaults = @@defaults.merge(defaults); end
     def self.defaults; @@defaults; end
 
     # The lock key id for this thread. Uses uuid so that concurrency is not an issue
-    # w.r.t. keys
+    # with respect to keys
     def self.lock_key_id; Thread.current[:lock_key_id] ||= UUID_GEN.call; end
 
     # Locks a key in redis options are same as default.
     # If a block is given the lock is automatically released
     # If no block is given, be sure to unlock the key when you're done.
-    # Note... Locks should be as _Small_ as possible with respec to the time you
-    # have the lock for!
-    # @param key String The key to lock
-    # @param opts Hash the options hash for the lock
+    #
+    # Note: Concurrency is hard, and deadlock is always a danger. Don't do any
+    # more than is absolutely needed inside the lock so that the lock exists
+    # for the shortest time possible.
+    #
+    # @param key String The Redis key to lock
+    # @param opts Hash The options hash for the lock
     # @option opts :wait_for Numeric The time to wait for to obtain a lock
     # @option opts :expire Numeric The time before the lock expires
     # @option opts :raise  Causes a raise if a lock cannot be obtained
@@ -62,17 +62,23 @@ class Redis
     end
 
     def locked_key?(key)
-      !lock_expired?(_redis_.get(lock_key_for(key)))
+      !!fetch(key)
     end
 
     def kill_lock!(key)
       _redis_.del(lock_key_for(key))
     end
 
-    # Unlocks the key. Use a block... then you don't need this
-    # @param key String the key to unlock
-    # @param opts Hash an options hash
-    # @option opts :key the value of the key to unlock.
+    # Manually unlocks a key.
+    #
+    # This method is mainly intended for applications where the lock is obtained
+    # in one thread and then passed to another thread to be released. If you
+    # are obtaining and releasing a lock in the same thread, you should prefer
+    # the block form of lock_key over this method.
+    #
+    # @param key String The Redis key to unlock
+    # @param opts Hash An options hash
+    # @option opts :key The value of the key to unlock.
     #
     # @example
     #   # Unlock the key if this thread owns it.
@@ -88,10 +94,10 @@ class Redis
     #     redis.unlock_key "foo", :key => key_value
     #   end
     def unlock_key(key, opts={})
-      lock_key = opts[:key]
-      value = _redis_.get(lock_key_for(key))
+      held_value = opts[:key]
+      value = fetch(key)
       return true unless value
-      if value == lock_key || i_have_the_lock?(value)
+      if value == held_value || i_have_the_lock?(value)
         kill_lock!(key)
         true
       else
@@ -104,54 +110,60 @@ class Redis
       self
     end
 
-    def lock_key_for(key)
-      "lock_key:#{key}"
+    def fetch(key)
+      _redis_.get lock_key_for(key)
     end
 
-    def lock_value_for(key, opts)
-      "#{(Time.now + opts[:expire]).to_i}#{value_delimeter}#{LockKey.lock_key_id}"
+    def lock_key_for(key)
+      "lock_key:#{key}"
     end
 
-    def value_delimeter
-      LockKey.value_delimeter
+    def lock_key_value
+      LockKey.lock_key_id
     end
 
     def obtain_lock(key, opts={})
-      _key_ = lock_key_for(key)
-      _value_ = lock_value_for(key,opts)
-      return _value_ if _redis_.setnx(_key_, _value_)
+      new_lock = renew_lock_if_owned(key,opts)
+      return new_lock if new_lock
 
-      got_lock = false
       wait_until = Time.now + opts[:wait_for]
 
-      until got_lock || Time.now > wait_until
-        current_lock = _redis_.get(_key_)
-        if lock_expired?(current_lock)
-          _value_ = lock_value_for(key,opts)
-          new_lock = _redis_.getset(_key_, _value_)
-          got_lock = new_lock if i_have_the_lock?(new_lock)
-        elsif i_have_the_lock?(current_lock)
-          got_lock = current_lock
+      until new_lock || Time.now > wait_until
+        _key_ = lock_key_for(key)
+        if _redis_.setnx(_key_, lock_key_value)
+          new_lock = lock_key_value
+          _redis_.expire(_key_, opts[:expire])
         end
         sleep opts[:sleep_for]
       end
 
-      if !got_lock && opts[:raise]
+      if !new_lock && opts[:raise]
         raise LockAttemptTimeout, "Could not lock #{key}"
       end
 
-      got_lock
-    end
-
-    def lock_expired?(lock_value)
-      return true if lock_value.nil?
-      exp = lock_value.split(value_delimeter).first
-      Time.now.to_i > exp.to_i
+      new_lock
     end
 
     def i_have_the_lock?(lock_value)
       return false unless lock_value
-      lock_value.split(value_delimeter).last == LockKey.lock_key_id
+      # should just be a straight comparison, but need to roll out
+      # new code that changes things first
+      lock_value.split(VALUE_DELIMETER).last == LockKey.lock_key_id
+    end
+
+    def i_dont_have_the_lock?(lock_value)
+      !i_have_the_lock?(lock_value)
+    end
+
+    def renew_lock_if_owned(key,opts)
+      current_value = fetch(key)
+      return false if current_value && i_dont_have_the_lock?(current_value)
+      _key_ = lock_key_for(key)
+      result = _redis_.multi do
+        _redis_.set(_key_, lock_key_value)
+        _redis_.expire(_key_, opts[:expire])
+      end
+      lock_key_value if result.first == "OK"
     end
   end
 end

data/lib/lock_key/version.rb

@@ -1,3 +1,3 @@
 module LockKey
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/lock_key_spec.rb

@@ -5,10 +5,6 @@ describe "LockKey" do
     REDIS.flushdb
   end
 
-  after do
-    REDIS.unlock_key "foo"
-  end
-
   it "takes out a lock" do
     REDIS.lock_key "foo"
     REDIS.locked_key?("foo").should be_true
@@ -28,12 +24,28 @@ describe "LockKey" do
     REDIS.locked_key?("foo").should be_false
   end
 
+  it "lets you request the same lock many times" do
+    REDIS.lock_key "foo"
+    expect { REDIS.lock_key "foo" }.to_not raise_error
+  end
+
+  it "raises an error when it can't get a lock" do
+    REDIS.lock_key("foo", :expire => 10)
+    t = Thread.new do
+      expect do
+        REDIS.lock_key("foo", :wait_for => 1) { sleep 1 }
+      end.to raise_error
+    end
+
+    t.join
+  end
+
   it "handles many threads" do
     captures = []
     one   = lambda{ REDIS.lock_key("foo", :expire => 5) { sleep 2; captures << :one   } }
     two   = lambda{ REDIS.lock_key("foo", :expire => 5) { sleep 1; captures << :two   } }
     three = lambda{ REDIS.lock_key("foo", :expire => 5) { sleep 2; captures << :three } }
-    four  = lambda{ REDIS.lock_key("foo", :expire => 1, wait_for: 1) { sleep 2; captures << :four  } }
+    four  = lambda{ REDIS.lock_key("foo", :expire => 1, wait_for: 1, raise: false) { sleep 2; captures << :four  } }
 
     threads = []
 

data/spec/spec_helper.rb

@@ -1,4 +1,3 @@
 require 'lock_key'
 
 REDIS = Redis.new
-puts REDIS.inspect

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lock_key
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-06 00:00:00.000000000 Z
+date: 2012-11-09 00:00:00.000000000 Z
 dependencies: []
 description: Uses redis to take out multi-threaded/processed safe locks
 email: