sidekiq-lock 0.2.0 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 592d4bf95b4bbd2cba2444898c5f6843c0a9112c6c45e018999af361b8a5ca73
+  data.tar.gz: 7b0a5614796a292af28fc0880915a76ac85ecfb8c669b07d57d5019d8f246342
+SHA512:
+  metadata.gz: ff115e3d009c6b6803e20326c2d84bf2286d9e4b652fe840b743596b8257919d7c54b3f1b9e1dcf2f9f1cba16af6541490464a77d55b52ff1b9407f28a7981f3
+  data.tar.gz: 0cf165b35136db26001b236837dcd7a831867fc81d8b81a3e14c2efe76edf41ade9cb5ba437b311b9ec1626af5aae176a3a09fde0c393ef5b949f2f5e5f8fa64

data/CHANGELOG.md

@@ -1,4 +1,31 @@
-## 0.2.0
+## 0.5.0 (August 13, 2021)
+
+- maintenance - test on latest ruby versions (remove outdated rubies from build), add sidekiq 6 to build matrix, remove coveralls
+- fix for ruby 3 (thanks to [@ak15](https://github.com/ak15))
+
+## 0.4.0 (July 18, 2018)
+
+- make lock container configurable (non breaking change) - in case you would like to something else than `Thread.current` - now you easily can
+
+## 0.3.1 (March 3, 2018)
+
+- do not assume `ActiveSupport` is loaded / or old `Sidekiq` patches are present (add own symbolize keys logic)
+- make `options` and `payload` attr readers as `private` in `RedisLock` as it should be - **potentially breaking change** if you were accessing those (abusing) somehow for whatever reason (that shouldn't happen in the first place!)
+- run test on travis for sidekiq `2.17`, `3.5`, `4.2` and `>= 5.1` and all newest rubies (`2.2` - `2.5`)
+
+## 0.3.0 (July 28, 2016)
+
+- ability to set custom lock value. Works just like setting timeout and name, handles procs as well (thanks to [@piokaczm](https://github.com/piokaczm))
+
+``` ruby
+sidekiq_options lock: {
+    timeout: timeout,
+    name:    name,
+    value:   custom_value
+  }
+```
+
+## 0.2.0 (December 08, 2013)
 
 - ability to globally configure `lock` method name
 
@@ -18,6 +45,6 @@ end
   That will setup `RedisLock` under proper thread variable.
   This can be handy if you test your workers inline (without full stack middleware)
 
-## 0.0.1
+## 0.0.1 (October 14, 2013)
 
 - Initial release

data/README.md

@@ -1,14 +1,19 @@
+<p align="center">
+  <img width="300" height="210" src="https://github.com/emq/sidekiq-lock/raw/master/logo.png">
+</p>
+
 # Sidekiq::Lock
 
 [![Code Climate](https://codeclimate.com/github/emq/sidekiq-lock.png)](https://codeclimate.com/github/emq/sidekiq-lock)
-[![Build Status](https://travis-ci.org/emq/sidekiq-lock.png?branch=master)](https://travis-ci.org/emq/sidekiq-lock)
-[![Coverage Status](https://coveralls.io/repos/emq/sidekiq-lock/badge.png)](https://coveralls.io/r/emq/sidekiq-lock)
-[![Dependency Status](https://gemnasium.com/emq/sidekiq-lock.png)](https://gemnasium.com/emq/sidekiq-lock)
+[![Build Status](https://travis-ci.com/rwojsznis/sidekiq-lock.svg?branch=master)](https://travis-ci.com/rwojsznis/sidekiq-lock)
 [![Gem Version](https://badge.fury.io/rb/sidekiq-lock.png)](http://badge.fury.io/rb/sidekiq-lock)
 
+**Note:** This is a _complete_ piece of software, it should work across all future sidekiq & ruby versions.
+
 Redis-based simple locking mechanism for [sidekiq][2]. Uses [SET command][1] introduced in Redis 2.6.16.
 
-It can be handy if you push a lot of jobs into the queue(s), but you don't want to execute specific jobs at the same time - it provides a `lock` method that you can use in whatever way you want.
+It can be handy if you push a lot of jobs into the queue(s), but you don't want to execute specific jobs at the same
+time - it provides a `lock` method that you can use in whatever way you want.
 
 ## Installation
 
@@ -32,7 +37,8 @@ $ bundle
 
 Sidekiq-lock is a middleware/module combination, let me go through my thought process here :).
 
-In your worker class include `Sidekiq::Lock::Worker` module and provide `lock` attribute inside `sidekiq_options`, for example:
+In your worker class include `Sidekiq::Lock::Worker` module and provide `lock` attribute inside `sidekiq_options`,
+for example:
 
 ``` ruby
 class Worker
@@ -50,15 +56,19 @@ end
 
 What will happen is:
 
-- middleware will setup a `Sidekiq::Lock::RedisLock` object under `Thread.current[Sidekiq::Lock::THREAD_KEY]` (well, I had no better idea for this) - assuming you provided `lock` options, otherwise it will do nothing, just execute your worker's code
+- middleware will setup a `Sidekiq::Lock::RedisLock` object under `Thread.current[Sidekiq::Lock::THREAD_KEY]`
+(it should work in most use cases without any problems - but it's configurable, more below) - assuming you provided
+`lock` options, otherwise it will do nothing, just execute your worker's code
 
-- `Sidekiq::Lock::Worker` module provides a `lock` method that just simply points to that thread variable, just as a convenience
+- `Sidekiq::Lock::Worker` module provides a `lock` method that just simply points to that thread variable, just as
+a convenience
 
 So now in your worker class you can call (whenever you need):
 
-- `lock.acquire!` - will try to acquire the lock, if returns false on failure (that means some other process / thread took the lock first)
+- `lock.acquire!` - will try to acquire the lock, if returns false on failure (that means some other process / thread
+took the lock first)
 - `lock.acquired?` - set to `true` when lock is successfully acquired
-- `lock.release!` - deletes the lock (if not already expired / taken by another process)
+- `lock.release!` - deletes the lock (only if it's: acquired by current thread and not already expired)
 
 ### Lock options
 
@@ -66,6 +76,7 @@ sidekiq_options lock will accept static values or `Proc` that will be called on
 
 - timeout - specified expire time, in milliseconds
 - name - name of the redis key that will be used as lock name
+- value - (optional) value of the lock, if not provided it's set to random hex
 
 Dynamic lock example:
 
@@ -75,7 +86,8 @@ class Worker
   include Sidekiq::Lock::Worker
   sidekiq_options lock: {
     timeout: proc { |user_id, timeout| timeout * 2 },
-    name:    proc { |user_id, timeout| "lock:peruser:#{user_id}" }
+    name:    proc { |user_id, timeout| "lock:peruser:#{user_id}" },
+    value:   proc { |user_id, timeout| "#{user_id}" }
   }
 
   def perform(user_id, timeout)
@@ -83,7 +95,15 @@ class Worker
     # do some work
     # only at this point I want to acquire the lock
     if lock.acquire!
-      # I can do the work
+      begin
+        # I can do the work
+        # ...
+      ensure
+        # You probably want to manually release lock after work is done
+        # This method can be safely called even if lock wasn't acquired
+        # by current worker (thread). For more references see RedisLock class
+        lock.release!
+      end
     else
       # reschedule, raise an error or do whatever you want
     end
@@ -103,9 +123,32 @@ Sidekiq.configure_server do |config|
 end
 ```
 
+### Customizing lock _container_
+
+If you would like to change default behavior of storing lock instance in `Thread.current` for whatever reason you
+can do that as well via server configuration:
+
+``` ruby
+# Any thread-safe class that implements .fetch and .store methods will do
+class CustomStorage
+  def fetch
+    # returns stored lock instance
+  end
+  
+  def store(lock_instance)
+    # store lock
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.lock_container = CustomStorage.new
+end
+```
+
 ### Inline testing
 
-As you know middleware is not invoked when testing jobs inline, you can require in your test/spec helper file `sidekiq/lock/testing/inline` to include two methods that will help you setting / clearing up lock manually:
+As you know middleware is not invoked when testing jobs inline, you can require in your test/spec helper file
+`sidekiq/lock/testing/inline` to include two methods that will help you setting / clearing up lock manually:
 
 - `set_sidekiq_lock(worker_class, payload)` - note: payload should be an array of worker arguments
 - `clear_sidekiq_lock`

data/lib/sidekiq/lock.rb

@@ -1,12 +1,20 @@
-require "sidekiq/lock/middleware"
-require "sidekiq/lock/redis_lock"
-require "sidekiq/lock/version"
-require "sidekiq/lock/worker"
+require 'sidekiq/lock/container'
+require 'sidekiq/lock/middleware'
+require 'sidekiq/lock/redis_lock'
+require 'sidekiq/lock/version'
+require 'sidekiq/lock/worker'
 
 module Sidekiq
+  def self.lock_container
+    @lock_container ||= Lock::Container.new
+  end
 
   def self.lock_method
-    @lock_method || :lock
+    @lock_method ||= Lock::METHOD_NAME
+  end
+
+  def self.lock_container=(container)
+    @lock_container = container
   end
 
   def self.lock_method=(method)
@@ -15,6 +23,7 @@ module Sidekiq
 
   module Lock
     THREAD_KEY = :sidekiq_lock
+    METHOD_NAME = :lock
   end
 end
 
@@ -23,4 +32,3 @@ Sidekiq.configure_server do |config|
     chain.add Sidekiq::Lock::Middleware
   end
 end
-

data/lib/sidekiq/lock/container.rb

@@ -0,0 +1,15 @@
+module Sidekiq
+  module Lock
+    class Container
+      THREAD_KEY = :sidekiq_lock
+
+      def fetch
+        Thread.current[THREAD_KEY]
+      end
+
+      def store(lock)
+        Thread.current[THREAD_KEY] = lock
+      end
+    end
+  end
+end

data/lib/sidekiq/lock/middleware.rb

@@ -1,8 +1,7 @@
 module Sidekiq
   module Lock
     class Middleware
-
-      def call(worker, msg, queue)
+      def call(worker, msg, _queue)
         options = lock_options(worker)
         setup_lock(options, msg['args']) unless options.nil?
 
@@ -11,14 +10,13 @@ module Sidekiq
 
       private
 
-        def setup_lock(options, payload)
-          Thread.current[Sidekiq::Lock::THREAD_KEY] = RedisLock.new(options, payload)
-        end
-
-        def lock_options(worker)
-          worker.class.get_sidekiq_options['lock']
-        end
+      def setup_lock(options, payload)
+        Sidekiq.lock_container.store(RedisLock.new(options, payload))
+      end
 
+      def lock_options(worker)
+        worker.class.get_sidekiq_options['lock']
+      end
     end
   end
 end

data/lib/sidekiq/lock/redis_lock.rb

@@ -1,16 +1,18 @@
 module Sidekiq
   module Lock
     class RedisLock
-      attr_reader :options, :payload
-
       # checks for configuration
-      def initialize(options, payload)
-        @options  = options.symbolize_keys
+      def initialize(options_hash, payload)
+        @options = {}
+
+        options_hash.each_key do |key|
+          @options[key.to_sym] = options_hash[key]
+        end
+
         @payload  = payload
         @acquired = false
 
-        timeout
-        name
+        timeout && name
       end
 
       def acquired?
@@ -21,7 +23,7 @@ module Sidekiq
       # this also requires redis-rb >= 3.0.5
       def acquire!
         @acquired ||= Sidekiq.redis do |r|
-          r.set(name, value, { nx: true, px: timeout })
+          r.set(name, value, nx: true, px: timeout)
         end
       end
 
@@ -29,44 +31,51 @@ module Sidekiq
         Sidekiq.redis do |r|
           begin
             r.evalsha redis_lock_script_sha, keys: [name], argv: [value]
-            rescue Redis::CommandError
-              r.eval redis_lock_script, keys: [name], argv: [value]
+          rescue Redis::CommandError
+            r.eval redis_lock_script, keys: [name], argv: [value]
           end
         end
       end
 
       def name
-        raise ArgumentError, "Provide a lock name inside sidekiq_options" if options[:name].nil?
+        raise ArgumentError, 'Provide a lock name inside sidekiq_options' if options[:name].nil?
 
         @name ||= (options[:name].respond_to?(:call) ? options[:name].call(*payload) : options[:name])
       end
 
       def timeout
-        raise ArgumentError, "Provide lock timeout inside sidekiq_options" if options[:timeout].nil?
+        raise ArgumentError, 'Provide lock timeout inside sidekiq_options' if options[:timeout].nil?
 
         @timeout ||= (options[:timeout].respond_to?(:call) ? options[:timeout].call(*payload) : options[:timeout]).to_i
       end
 
       private
 
-        def redis_lock_script_sha
-          @lock_script_sha ||= Digest::SHA1.hexdigest redis_lock_script
-        end
+      attr_reader :options, :payload
 
-        def redis_lock_script
-          <<-LUA
-          if redis.call("get", KEYS[1]) == ARGV[1]
-          then
-            return redis.call("del",KEYS[1])
-          else
-            return 0
-          end
-          LUA
-        end
+      def redis_lock_script_sha
+        @lock_script_sha ||= Digest::SHA1.hexdigest redis_lock_script
+      end
 
-        def value
-          @value ||= SecureRandom.hex(25)
+      def redis_lock_script
+        <<-LUA
+        if redis.call("get", KEYS[1]) == ARGV[1]
+        then
+          return redis.call("del",KEYS[1])
+        else
+          return 0
         end
+        LUA
+      end
+
+      def value
+        @value ||= set_lock_value(options[:value])
+      end
+
+      def set_lock_value(custom_value)
+        return SecureRandom.hex(25) unless custom_value
+        custom_value.respond_to?(:call) ? custom_value.call(*payload) : custom_value
+      end
     end
   end
 end

data/lib/sidekiq/lock/testing/inline.rb

@@ -1,8 +1,8 @@
 def set_sidekiq_lock(worker_class, payload)
   options = worker_class.get_sidekiq_options['lock']
-  Thread.current[Sidekiq::Lock::THREAD_KEY] = Sidekiq::Lock::RedisLock.new(options, payload)
+  Sidekiq.lock_container.store(Sidekiq::Lock::RedisLock.new(options, payload))
 end
 
 def clear_sidekiq_lock
-  Thread.current[Sidekiq::Lock::THREAD_KEY] = nil
+  Sidekiq.lock_container.store(nil)
 end

data/lib/sidekiq/lock/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module Lock
-    VERSION = "0.2.0"
+    VERSION = '0.5.0'
   end
 end

data/lib/sidekiq/lock/worker.rb

@@ -1,13 +1,11 @@
 module Sidekiq
   module Lock
     module Worker
-
       def self.included(base)
         base.send(:define_method, Sidekiq.lock_method) do
-          Thread.current[Sidekiq::Lock::THREAD_KEY]
+          Sidekiq.lock_container.fetch
         end
       end
-
     end
   end
 end

data/test/lib/container_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'open3'
+
+module Sidekiq
+  module Lock
+    describe Container do
+      it 'stores and fetches given value under Thread.current' do
+        begin
+          container = Sidekiq::Lock::Container.new
+          thread_key = Sidekiq::Lock::Container::THREAD_KEY
+
+          Thread.current[thread_key] = 'value'
+          assert_equal 'value', container.fetch
+
+          container.store 'new-value'
+          assert_equal Thread.current[thread_key], 'new-value'
+        ensure
+          Thread.current[thread_key] = nil
+        end
+      end
+    end
+  end
+end

data/test/lib/lock_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'open3'
+
+module Sidekiq
+  describe Lock do
+    it 'automatically loads lock middleware for sidekiq server' do
+      skip 'Sidekiq 2 does not print out middleware information' if Sidekiq::VERSION < '3.0.0'
+
+      cmd = 'sidekiq -r ./test/test_workers.rb -v'
+      buffer = ''
+
+      # very not fancy (https://78.media.tumblr.com/tumblr_lzkpw7DAl21qhy6c9o2_400.gif)
+      # solution, but should do the job
+      Open3.popen3(cmd) do |stdin, stdout, stderr, thread|
+        begin
+          Timeout.timeout(5) do
+            until stdout.eof? do
+              buffer << stdout.read_nonblock(16)
+            end
+          end
+        rescue Timeout::Error
+          Process.kill('KILL', thread.pid)
+        end
+      end
+
+      assert_match(/\s?Middleware:.*Sidekiq::Lock::Middleware/i, buffer)
+    end
+  end
+end

data/test/lib/middleware_test.rb

@@ -1,42 +1,40 @@
-require "test_helper"
+require 'test_helper'
 
 module Sidekiq
   module Lock
     describe Middleware do
-
       before do
         Sidekiq.redis = REDIS
         Sidekiq.redis { |c| c.flushdb }
-        set_lock_variable!
+        reset_lock_variable!
       end
 
-      let(:handler){ Sidekiq::Lock::Middleware.new }
+      let(:handler) { Sidekiq::Lock::Middleware.new }
 
       it 'sets lock variable with provided static lock options' do
-        handler.call(LockWorker.new, {'class' => LockWorker, 'args' => []}, 'default') do
+        handler.call(LockWorker.new, { 'class' => LockWorker, 'args' => [] }, 'default') do
           true
         end
 
-        assert_kind_of RedisLock, lock_thread_variable
+        assert_kind_of RedisLock, lock_container_variable
       end
 
       it 'sets lock variable with provided dynamic options' do
-        handler.call(DynamicLockWorker.new, {'class' => DynamicLockWorker, 'args' => [1234, 1000]}, 'default') do
+        handler.call(DynamicLockWorker.new, { 'class' => DynamicLockWorker, 'args' => [1234, 1000] }, 'default') do
           true
         end
 
-        assert_equal "lock:1234", lock_thread_variable.name
-        assert_equal 2000,   lock_thread_variable.timeout
+        assert_equal "lock:1234", lock_container_variable.name
+        assert_equal 2000, lock_container_variable.timeout
       end
 
       it 'sets nothing for workers without lock options' do
-        handler.call(RegularWorker.new, {'class' => RegularWorker, 'args' => []}, 'default') do
+        handler.call(RegularWorker.new, { 'class' => RegularWorker, 'args' => [] }, 'default') do
           true
         end
 
-        assert_nil lock_thread_variable
+        assert_nil lock_container_variable
       end
-
     end
   end
 end

data/test/lib/redis_lock_test.rb

@@ -1,4 +1,4 @@
-require "test_helper"
+require 'test_helper'
 
 module Sidekiq
   module Lock
@@ -40,11 +40,15 @@ module Sidekiq
       it "can accept block as arguments" do
         lock = RedisLock.new({
             'timeout' => proc { |options| options['timeout'] * 2 },
-            'name'    => proc { |options| "#{options['test']}-sidekiq" }
+            'name'    => proc { |options| "#{options['test']}-sidekiq" },
+            'value'    => proc { |options| "#{options['test']}-sidekiq" }
           }, ['timeout' => 500, 'test' => 'hello'])
 
         assert_equal 1000, lock.timeout
         assert_equal 'hello-sidekiq', lock.name
+        lock.acquire!
+        assert_equal 'hello-sidekiq', redis("get", lock.name)
+        lock.release!
       end
 
       it "can acquire a lock" do
@@ -84,6 +88,16 @@ module Sidekiq
 
         assert_equal new_lock_value, redis("get", "test-lock")
       end
+
+      it "releases taken lock" do
+        custom_args = [args.first.merge('value' => 'custom_value'), []]
+        lock = RedisLock.new(*custom_args)
+        lock.acquire!
+        assert redis("get", "test-lock")
+
+        lock.release!
+        assert_nil redis("get", "test-lock")
+      end
     end
   end
 end

data/test/lib/testing/inline_test.rb

@@ -2,21 +2,23 @@ require "test_helper"
 require "sidekiq/lock/testing/inline"
 
 describe "inline test helper" do
-
-  after { set_lock_variable! }
+  after { reset_lock_variable! }
 
   it "has helper fuction for setting lock" do
-    Sidekiq::Lock::RedisLock.expects(:new).with({ timeout: 1, name: 'lock-worker' }, 'worker argument').returns('lock set')
+    Sidekiq::Lock::RedisLock
+      .expects(:new)
+      .with({ timeout: 1, name: 'lock-worker' }, 'worker argument')
+      .returns('lock set')
+
     set_sidekiq_lock(LockWorker, 'worker argument')
-    assert_equal 'lock set', lock_thread_variable
+    assert_equal 'lock set', lock_container_variable
   end
 
   it "has helper fuction for clearing lock" do
     set_lock_variable! "test"
-    assert_equal "test", lock_thread_variable
+    assert_equal "test", lock_container_variable
 
     clear_sidekiq_lock
-    assert_nil lock_thread_variable
+    assert_nil lock_container_variable
   end
-
 end

data/test/lib/worker_test.rb

@@ -1,29 +1,66 @@
-require "test_helper"
+require 'test_helper'
 
 module Sidekiq
   module Lock
     describe Worker do
+      # after {  }
 
-      after { set_lock_variable! }
+      class CustomContainer
+        def initialize
+          @lock = nil
+        end
+
+        def fetch
+          @lock
+        end
 
-      it 'sets lock method that points to thread variable' do
-        set_lock_variable! "test"
-        assert_equal "test", LockWorker.new.lock
+        def store(lock)
+          @lock = lock
+        end
       end
 
+      # it 'sets lock method that points to thread variable' do
+      #   set_lock_variable! "test"
+      #   assert_equal "test", LockWorker.new.lock
+      # end
+
       it 'allows method name configuration' do
-        Sidekiq.lock_method = :custom_lock_name
+        begin
+          Sidekiq.lock_method = :custom_lock_name
 
-        class WorkerWithCustomLockName
-          include Sidekiq::Worker
-          include Sidekiq::Lock::Worker
-        end
+          class WorkerWithCustomLockName
+            include Sidekiq::Worker
+            include Sidekiq::Lock::Worker
+          end
+
+          set_lock_variable! "custom_name"
 
-        set_lock_variable! "custom_name"
+          assert_equal "custom_name", WorkerWithCustomLockName.new.custom_lock_name
 
-        assert_equal "custom_name", WorkerWithCustomLockName.new.custom_lock_name
+          reset_lock_variable!
+        ensure
+
+          Sidekiq.lock_method = Sidekiq::Lock::METHOD_NAME
+        end
       end
 
+      it 'allows container configuration' do
+        begin
+          container = CustomContainer.new
+          Sidekiq.lock_container = container
+
+          class WorkerWithCustomContainer
+            include Sidekiq::Worker
+            include Sidekiq::Lock::Worker
+          end
+
+          container.store "lock-variable"
+
+          assert_equal "lock-variable", WorkerWithCustomContainer.new.lock
+        ensure
+          Sidekiq.lock_container = Sidekiq::Lock::Container.new
+        end
+      end
     end
   end
 end

data/test/test_helper.rb

@@ -1,20 +1,13 @@
-require 'coveralls'
-Coveralls.wear!
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/setup'
 
-Encoding.default_external = Encoding::UTF_8
-Encoding.default_internal = Encoding::UTF_8
-
-require "minitest/autorun"
-require "minitest/pride"
-require "mocha/setup"
-
-require "sidekiq"
-require "sidekiq-lock"
-require "test_workers"
+require 'sidekiq'
+require 'test_workers'
 
 Sidekiq.logger.level = Logger::ERROR
 
-REDIS = Sidekiq::RedisConnection.create(url: "redis://localhost/15", namespace: "sidekiq_lock_test")
+REDIS = Sidekiq::RedisConnection.create(url: 'redis://localhost/15')
 
 def redis(command, *args)
   Sidekiq.redis do |c|
@@ -22,10 +15,14 @@ def redis(command, *args)
   end
 end
 
-def set_lock_variable!(value = nil)
-  Thread.current[Sidekiq::Lock::THREAD_KEY] = value
+def set_lock_variable!(value)
+  Sidekiq.lock_container.store(value)
+end
+
+def reset_lock_variable!
+  set_lock_variable!(nil)
 end
 
-def lock_thread_variable
-  Thread.current[Sidekiq::Lock::THREAD_KEY]
+def lock_container_variable
+  Sidekiq.lock_container.fetch
 end

data/test/test_workers.rb

@@ -1,3 +1,5 @@
+require 'sidekiq-lock'
+
 class LockWorker
   include Sidekiq::Worker
   include Sidekiq::Lock::Worker

metadata

@@ -1,128 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-lock
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - Rafal Wojsznis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-08 00:00:00.000000000 Z
+date: 2021-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.0
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !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: rack-test
   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: coveralls
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.14.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.14.0
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: Simple redis-based lock mechanism for your sidekiq workers
 email:
 - rafal.wojsznis@gmail.com
@@ -130,21 +129,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/sidekiq-lock.rb
 - lib/sidekiq/lock.rb
+- lib/sidekiq/lock/container.rb
 - lib/sidekiq/lock/middleware.rb
 - lib/sidekiq/lock/redis_lock.rb
 - lib/sidekiq/lock/testing/inline.rb
 - lib/sidekiq/lock/version.rb
 - lib/sidekiq/lock/worker.rb
-- sidekiq-lock.gemspec
+- test/lib/container_test.rb
+- test/lib/lock_test.rb
 - test/lib/middleware_test.rb
 - test/lib/redis_lock_test.rb
 - test/lib/testing/inline_test.rb
@@ -154,38 +152,32 @@ files:
 homepage: https://github.com/emq/sidekiq-lock
 licenses:
 - MIT
+metadata: {}
 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: -2239756141932312381
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2239756141932312381
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 3.2.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple redis-based lock mechanism for your sidekiq workers
 test_files:
-- test/lib/middleware_test.rb
+- test/test_workers.rb
+- test/lib/worker_test.rb
 - test/lib/redis_lock_test.rb
 - test/lib/testing/inline_test.rb
-- test/lib/worker_test.rb
+- test/lib/middleware_test.rb
+- test/lib/lock_test.rb
+- test/lib/container_test.rb
 - test/test_helper.rb
-- test/test_workers.rb

data/.gitignore

@@ -1,20 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.rvmrc
-.ruby-version
-.ruby-gemset

data/.travis.yml

@@ -1,13 +0,0 @@
-language: ruby
-
-services:
-  - redis-server
-
-rvm:
-  - 1.9.3
-  - jruby-19mode
-  - rbx
-  - 2.0.0
-
-notifications:
-  email: false

data/Gemfile

@@ -1,8 +0,0 @@
-source "https://rubygems.org"
-gemspec
-
-platforms :rbx do
-  gem "rubysl", "~> 2.0"                     # if using anything in the ruby standard library
-  gem "rubinius-developer_tools", "~> 2.0.0" # if using any of coverage, debugger, profiler
-  gem "minitest"                             # if using minitest
-end

data/sidekiq-lock.gemspec

@@ -1,28 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'sidekiq/lock/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "sidekiq-lock"
-  spec.version       = Sidekiq::Lock::VERSION
-  spec.authors       = ["Rafal Wojsznis"]
-  spec.email         = ["rafal.wojsznis@gmail.com"]
-  spec.description   = spec.summary = "Simple redis-based lock mechanism for your sidekiq workers"
-  spec.homepage      = "https://github.com/emq/sidekiq-lock"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "sidekiq", ">= 2.14.0"
-  spec.add_dependency "redis",   ">= 3.0.5"
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rack-test"
-  spec.add_development_dependency "coveralls", "~> 0.7.0"
-  spec.add_development_dependency "mocha", "~> 0.14.0"
-end