sidekiq-lock 0.3.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70c2ca23e60ff013252e111d7507b3665deaaadd31d23a6dc10e972315be335f
-  data.tar.gz: 67cdd99cb1e60accad3304bc13f295051b54d09553ab278503d98240bf149d21
+  metadata.gz: 94c0d6993d3e6f8c2acd6a63e2e78464ac974369138f6c20eeb91525d0b5ea13
+  data.tar.gz: 75437ca38c53bc825d0e6e77b8dc2ef64c5c42bb8802746f5fbacf1f91c9e4f5
 SHA512:
-  metadata.gz: 3595ae9803227cbb2051908bd7ecbbbbec409a57e5f41dbae552b838f5d71decf35dab1ade805ff851c806f7aa69896b0485018401fa41f5454e2638067133ca
-  data.tar.gz: ea73c729c4da75a0a6c47c652376e96f5574ba2f2f93b09ecc6f12564d2d605d00e625247643cbb17462a3a0dca3049a5ed696882f53fe26ff59dda84be3f0a1
+  metadata.gz: 463adf7d4dbf5d468a1c795105a716d94fd6f77141e7c7f3d77a84076e4e222cc2b6fb57f64d5286bca6fc8b9491c4de891190fb3d255f1766acd879253220d0
+  data.tar.gz: c215cce1d79e99aaa28a04a5238aac165a8e5d36271a372b39067a80040109e5f64117114fdbfae227c5cb406f86cd46e554cfa6820978573abd1f08b04ada6d

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.6.0 (May 27, 2023)
+
+- support for Sidekiq 7 (thanks to [@stympy](https://github.com/stympy))
+- move CI pipelines to Github Actions - drop tests for everything below Sidekiq 5, run tests on redis 6.2 & 7.0 and ruby 2.6 - 3.1
+
+## 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)
@@ -6,7 +20,7 @@
 
 ## 0.3.0 (July 28, 2016)
 
-- ability to set custom lock value. Works just like setting timeout and name (handles procs as well).
+- 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: {

data/README.md

@@ -1,16 +1,18 @@
+<p align="center">
+  <img width="300" height="210" src="https://github.com/rwojsznis/sidekiq-lock/raw/main/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)
+[![Code Climate](https://codeclimate.com/github/rwojsznis/sidekiq-lock.png)](https://codeclimate.com/github/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
 
@@ -34,7 +36,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
@@ -52,13 +55,17 @@ 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 (only if it's: acquired by current thread and not already expired)
 
@@ -115,9 +122,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/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,7 +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,7 +11,7 @@ module Sidekiq
       private
 
       def setup_lock(options, payload)
-        Thread.current[Sidekiq::Lock::THREAD_KEY] = RedisLock.new(options, payload)
+        Sidekiq.lock_container.store(RedisLock.new(options, payload))
       end
 
       def lock_options(worker)

data/lib/sidekiq/lock/redis_lock.rb

@@ -23,18 +23,17 @@ 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
 
       def release!
-        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]
-          end
-        end
+        # even if lock expired / was take over by another process
+        # it still means from our perspective that we released it
+        @acquired = false
+
+        # https://redis.io/commands/del/#return
+        release_lock == 1
       end
 
       def name
@@ -53,6 +52,27 @@ module Sidekiq
 
       attr_reader :options, :payload
 
+      def release_lock
+        # Sidekiq 7 uses redis-client gem, designed for redis 6+
+        if Sidekiq::VERSION >= '7'
+          Sidekiq.redis do |r|
+            begin
+              r.evalsha redis_lock_script_sha, [name], [value]
+            rescue RedisClient::CommandError
+              r.eval redis_lock_script, 1, [name], [value]
+            end
+          end
+        else
+          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]
+            end
+          end
+        end
+      end
+
       def redis_lock_script_sha
         @lock_script_sha ||= Digest::SHA1.hexdigest redis_lock_script
       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.3.1'
+    VERSION = '0.6.0'
   end
 end

data/lib/sidekiq/lock/worker.rb

@@ -3,7 +3,7 @@ module Sidekiq
     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

data/lib/sidekiq/lock.rb

@@ -1,11 +1,20 @@
+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)
@@ -14,6 +23,7 @@ module Sidekiq
 
   module Lock
     THREAD_KEY = :sidekiq_lock
+    METHOD_NAME = :lock
   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

@@ -4,7 +4,7 @@ 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'
+      skip 'Sidekiq 7+ does not print out middleware information' if Sidekiq::VERSION >= '7'
 
       cmd = 'sidekiq -r ./test/test_workers.rb -v'
       buffer = ''

data/test/lib/middleware_test.rb

@@ -4,38 +4,43 @@ module Sidekiq
   module Lock
     describe Middleware do
       before do
-        Sidekiq.redis = REDIS
+        if Sidekiq::VERSION >= '7'
+          Sidekiq.configure_server do |config|
+            config.redis = { url: REDIS_URL }
+          end
+        else
+          Sidekiq.redis = REDIS
+        end
         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

@@ -4,12 +4,16 @@ module Sidekiq
   module Lock
     describe RedisLock do
       before do
-        Sidekiq.redis = REDIS
+        if Sidekiq::VERSION >= '7'
+          Sidekiq.configure_client do |config|
+            config.redis = { url: REDIS_URL }
+          end
+        else
+          Sidekiq.redis = REDIS
+        end
         Sidekiq.redis { |c| c.flushdb }
       end
 
-      let(:args) { [{'timeout' => 100, 'name' => 'test-lock'}, []] }
-
       it "raises an error on missing timeout&name values" do
         assert_raises ArgumentError do
           RedisLock.new({},[])
@@ -52,46 +56,59 @@ module Sidekiq
       end
 
       it "can acquire a lock" do
-        lock = RedisLock.new(*args)
+        lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
+        assert lock.acquire!
+      end
+
+      it "sets proper lock value on first and second acquire" do
+        lock = RedisLock.new({'timeout' => 1000, 'name' => 'test-lock', 'value' => 'lock value'}, [])
         assert lock.acquire!
+        assert_equal 'lock value', redis("get", lock.name)
+        assert lock.release!
+        # at this point script should be used from evalsha
+        assert lock.acquire!
+        assert_equal 'lock value', redis("get", lock.name)
+
+        redis("script", "flush")
+        assert lock.acquire!
+        assert_equal 'lock value', redis("get", lock.name)
       end
 
-      it "cannot aquire lock if it's already taken by other process/thread" do
-        faster_lock = RedisLock.new(*args)
+      it "cannot acquire lock if it's already taken by other process/thread" do
+        faster_lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
         assert faster_lock.acquire!
 
-        slower_lock = RedisLock.new(*args)
+        slower_lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
         refute slower_lock.acquire!
       end
 
       it "releases taken lock" do
-        lock = RedisLock.new(*args)
+        lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
         lock.acquire!
         assert redis("get", "test-lock")
 
-        lock.release!
+        assert lock.release!
         assert_nil redis("get", "test-lock")
       end
 
       it "releases lock taken by another process without deleting lock key" do
-        lock = RedisLock.new(*args)
+        lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
         lock.acquire!
         lock_value = redis("get", "test-lock")
         assert lock_value
         sleep 0.11 # timeout lock
 
-        new_lock = RedisLock.new(*args)
+        new_lock = RedisLock.new({'timeout' => 100, 'name' => 'test-lock'}, [])
         new_lock.acquire!
         new_lock_value = redis("get", "test-lock")
 
-        lock.release!
+        refute lock.release!
 
         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 = RedisLock.new({'timeout' => 100, 'name' => 'test-lock', 'value' => 'custom_value'}, [])
         lock.acquire!
         assert redis("get", "test-lock")
 

data/test/lib/testing/inline_test.rb

@@ -2,20 +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

@@ -3,26 +3,64 @@ require 'test_helper'
 module Sidekiq
   module Lock
     describe Worker do
-      after { set_lock_variable! }
+      # after {  }
 
-      it 'sets lock method that points to thread variable' do
-        set_lock_variable! "test"
-        assert_equal "test", LockWorker.new.lock
+      class CustomContainer
+        def initialize
+          @lock = nil
+        end
+
+        def fetch
+          @lock
+        end
+
+        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,8 +1,3 @@
-require 'coveralls'
-Coveralls.wear! do
-  add_filter '/test/'
-end
-
 require 'minitest/autorun'
 require 'minitest/pride'
 require 'mocha/setup'
@@ -12,7 +7,8 @@ require 'test_workers'
 
 Sidekiq.logger.level = Logger::ERROR
 
-REDIS = Sidekiq::RedisConnection.create(url: 'redis://localhost/15')
+REDIS_URL = ENV['REDIS_URL'] || 'redis://localhost/15'
+REDIS = Sidekiq::RedisConnection.create(url: REDIS_URL)
 
 def redis(command, *args)
   Sidekiq.redis do |c|
@@ -20,10 +16,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-lock
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Rafal Wojsznis
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-03-03 00:00:00.000000000 Z
+date: 2023-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -66,34 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rack-test
-  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'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -143,26 +115,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
-- Appraisals
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- gemfiles/sidekiq_2.gemfile
-- gemfiles/sidekiq_3.gemfile
-- gemfiles/sidekiq_4.gemfile
-- gemfiles/sidekiq_5.gemfile
 - 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
@@ -174,7 +139,7 @@ homepage: https://github.com/emq/sidekiq-lock
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -189,12 +154,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Simple redis-based lock mechanism for your sidekiq workers
 test_files:
+- test/lib/container_test.rb
 - test/lib/lock_test.rb
 - test/lib/middleware_test.rb
 - test/lib/redis_lock_test.rb

data/.gitignore

@@ -1,21 +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
-*.gemfile.lock

data/.travis.yml

@@ -1,20 +0,0 @@
-language: ruby
-cache: bundler
-
-services:
-  - redis-server
-
-gemfile:
-  - gemfiles/sidekiq_2.gemfile
-  - gemfiles/sidekiq_3.gemfile
-  - gemfiles/sidekiq_4.gemfile
-  - gemfiles/sidekiq_5.gemfile
-
-rvm:
-  - 2.2.9
-  - 2.3.6
-  - 2.4.3
-  - 2.5.0
-
-notifications:
-  email: false

data/Appraisals

@@ -1,15 +0,0 @@
-appraise 'sidekiq-2' do
-  gem 'sidekiq', '~> 2.17', '>= 2.17.8'
-end
-
-appraise 'sidekiq-3' do
-  gem 'sidekiq', '~> 3.5', '>= 3.5.4'
-end
-
-appraise 'sidekiq-4' do
-  gem 'sidekiq', '~> 4.2', '>= 4.2.10'
-end
-
-appraise 'sidekiq-5' do
-  gem 'sidekiq', '~> 5.1', '>= 5.1'
-end

data/Gemfile

@@ -1,2 +0,0 @@
-source "https://rubygems.org"
-gemspec

data/gemfiles/sidekiq_2.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "sidekiq", "~> 2.17", ">= 2.17.8"
-
-gemspec path: "../"

data/gemfiles/sidekiq_3.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "sidekiq", "~> 3.5", ">= 3.5.4"
-
-gemspec path: "../"

data/gemfiles/sidekiq_4.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "sidekiq", "~> 4.2", ">= 4.2.10"
-
-gemspec path: "../"

data/gemfiles/sidekiq_5.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "sidekiq", "~> 5.1", ">= 5.1"
-
-gemspec path: "../"

data/sidekiq-lock.gemspec

@@ -1,30 +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"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rack-test"
-  spec.add_development_dependency "coveralls", "~> 0.8"
-  spec.add_development_dependency "mocha", "~> 0.14.0"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "appraisal"
-end