redis_getlock 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c0826498386afb3440ad4c10e7ce2b984a6eac2
-  data.tar.gz: f52a7bc3a8d04316bb3985025ca859b4f703885b
+  metadata.gz: e211a307e1814231fd3bff20fe5a435c4086bd4b
+  data.tar.gz: 8eff81ba4ddc1bdbd434cc730c676684b3b6a24f
 SHA512:
-  metadata.gz: d5a15c9c815fb0c2a7b8fe586bbe5985b17aab40b8f0193a9098e5345e396ec1b440e7776c3e6eec9230296304130b748b5f2f8a4560c44a42f4b8f5c037faec
-  data.tar.gz: 950bcb6a8643fdb4470c9963389d11bbe2c9d275bb53567f997ad25787619396474025ca4c9a4a95a20dae51db718b35833d636162c5056ada289ac110d02f1e
+  metadata.gz: c5066ccec8e8b53c5b8f8a58c0d80740921a7627431918ed2a92d3533620c6fa1787c72d3aeaa7b6f0ce6899b434ddd236b14ee1c3c87435e357b1890040bf34
+  data.tar.gz: 77b1d0ba859c9e7b0dd04ee59473c9aefc2e785ca03a131902c342da4c6418eee9646f7b0626b38e2bc821ad8ca6560a8c7f087cae1f10be4655d9f20a327e6f

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.3.1 (2016-08-29)
+
+Enhancements:
+
+* Add timeout option
+
 # 0.3.0 (2016-08-28)
 
 Enhancements:

data/README.md

@@ -28,7 +28,7 @@ However, how long should we set if we are uncertain how long a job takes?
 This gem takes a following approach to resolve this problem.
 
 1. Expiration time is set to `2` (default) seconds
-2. Extend the lock in each `1` (default) sencond interval invoking another thread
+2. Extend the lock in each `1` (default) second interval invoking another thread
 
 This way ensures to release orphaned lock in 2 seconds. We are released from caring of the value of `expire`!!
 
@@ -75,13 +75,13 @@ Or install it yourself as:
 Similarly with ruby standard library [mutex](https://ruby-doc.org/core-2.2.0/Mutex.html), following methods are available:
 
 * lock
-  * Attempts to grab the lock and waits if it isn’t available.
+  * Attempts to grab the lock and waits if it isn’t available. Returns true if successfully acquired a lock
 * locked?
   * Returns true if this lock is currently held by some (including myself).
 * synchronize {}
-  * Obtains a lock, runs the block, and releases the lock when the block completes.
+  * Obtains a lock, runs the block, and releases the lock when the block completes. Raises `RedisGetlock::LockError` error when failed to acquire a lock.
 * unlock
-  * Releases the lock.
+  * Releases the lock. Returns true if successfully released a lock
 * self_locked?
   * Returns true if this lock is currently held by myself.
 
@@ -91,6 +91,8 @@ Options of `RedisGetlock.new` are:
   * Provide a redis instance
 * key
   * Key name for a distributed lock
+* timeout
+  * The timeout of trying to get the lock. A negative value means infinite timeout (default: -1)
 * logger
   * Provide a logger for RedisGetlock (for debug)
 * expire

data/bin/try

@@ -3,14 +3,32 @@
 require "bundler/setup"
 require "redis_getlock"
 require 'logger'
+require 'optparse'
 
-if ARGV[0] == 'exit!'
+opts = {
+  timeout: -1,
+  kill: false
+}
+OptionParser.new.tap {|op|
+  op.on('--timeout VALUE') {|v|
+    opts[:timeout] = Float(v)
+  }
+  op.on('--kill') {|v|
+    opts[:kill] = true
+  }
+  op.parse(ARGV)
+}
+
+if opts[:kill]
   trap('INT') do
     exit!
   end
 end
 
-mutex = RedisGetlock.new(redis: Redis.new, key: 'redis_getlock', logger: Logger.new(STDOUT))
+mutex = RedisGetlock.new(
+  redis: Redis.new, key: 'redis_getlock', logger: Logger.new(STDOUT),
+  timeout: opts[:timeout],
+)
 puts 'redis-cli> del redis_getlock'
 mutex.synchronize do
   loop do

data/lib/redis_getlock.rb

@@ -4,35 +4,55 @@ require 'securerandom'
 require 'json'
 
 class RedisGetlock
-  attr_reader :redis, :key, :logger, :expire, :interval, :uuid
+  attr_reader :redis, :key, :logger, :timeout, :expire, :interval, :uuid
 
+  TIMEOUT = -1
   EXPIRE = 2
   INTERVAL = 1
 
-  def initialize(redis:, key:, logger: nil, expire: EXPIRE, interval: INTERVAL)
+  class LockError < ::StandardError; end
+
+  def initialize(redis:, key:, logger: nil, timeout: TIMEOUT, expire: EXPIRE, interval: INTERVAL)
     @redis = redis
     @key = key
     @logger = logger
+    @timeout = timeout
     @expire = expire
     @interval = interval
     @uuid = SecureRandom.uuid
   end
 
   def lock
-    logger.info { "#{log_head}Wait acquiring a redis lock '#{key}'" } if logger
+    logger.info { "#{log_head}Wait #{timeout < 0 ? '' : "#{timeout} sec "}to acquire a mysql lock '#{key}'" } if logger
     if set_options_available?
-      lock_with_set_options
+      locked = lock_with_set_options
+    else
+      locked = lock_without_set_options
+    end
+    @thr.terminate if @thr and @thr.alive?
+    if locked
+      @thr = Thread.new(&method(:keeplock))
+      logger.info { "#{log_head}Acquired a redis lock '#{key}'" } if logger
+      true
     else
-      lock_without_set_options
+      logger.info { "#{log_head}Timeout to acquire a redis lock '#{key}'" } if logger
+      false
     end
-    @thr = Thread.new(&method(:keeplock))
-    logger.info { "#{log_head}Acquired a redis lock '#{key}'" } if logger
   end
 
   def unlock
-    @thr.terminate
-    redis.del(key)
-    logger.info { "#{log_head}Released a redis lock '#{key}'" } if logger
+    @thr.terminate if @thr and @thr.alive?
+    if self_locked?
+      redis.del(key)
+      logger.info { "#{log_head}Released a redis lock '#{key}'" } if logger
+      true
+    elsif locked?
+      logger.info { "#{log_head}Failed to release a redis lock since somebody else locked '#{key}'" } if logger
+      false
+    else
+      logger.info { "#{log_head}Redis lock did not exist '#{key}'" } if logger
+      true
+    end
   end
 
   def locked?
@@ -40,13 +60,13 @@ class RedisGetlock
   end
 
   def self_locked?
-    redis.exists(key) && uuid == JSON.parse(redis.get(key))['uuid']
+    locked? && uuid == JSON.parse(redis.get(key))['uuid']
   end
 
   def synchronize(&block)
-    lock
+    raise LockError unless lock
     begin
-      yield
+      return yield
     ensure
       unlock
     end
@@ -67,10 +87,12 @@ class RedisGetlock
   # redis >= 2.6.12
   # ref. http://redis.io/commands/set
   def lock_with_set_options
+    started = Time.now.to_f
     loop do
       current = Time.now.to_f
       payload = {uuid: uuid, expire_at: (current + expire).to_s}.to_json
-      break if redis.set(key, payload, {nx: true, ex: expire}) # key does not exist
+      return true if redis.set(key, payload, {nx: true, ex: expire}) # key does not exist
+      return false if timeout >= 0 and (current - started) >= timeout
       sleep interval
     end
   end
@@ -83,13 +105,14 @@ class RedisGetlock
       payload = {uuid: uuid, expire_at: (current + expire).to_s}.to_json
       if redis.setnx(key, payload) # key does not exist
         redis.expire(key, expire)
-        break # acquire lock
+        return true # acquire lock
       end
       previous = JSON.parse(redis.get(key))
       if previous['expire_at'].to_f < current # key exists, but previous
         compared = redis.getset(key, paylod)
-        break if previous['expire_at'] == compared['expire_at'] # acquire lock
+        return true if previous['expire_at'] == compared['expire_at'] # acquire lock
       end
+      return false if timeout >= 0 and (current - started) >= timeout
       sleep interval
     end
   end

data/lib/redis_getlock/version.rb

@@ -1,3 +1,3 @@
 class RedisGetlock
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_getlock
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Naotoshi Seo