sidekiq-unique-jobs 5.0.11 → 6.0.0.rc1

data/lib/sidekiq_unique_jobs/config.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module SidekiqUniqueJobs
-  class Config < OpenStruct
-    def inline_testing_enabled?
-      testing_enabled? && Sidekiq::Testing.inline?
-    end
-
-    def mocking?
-      redis_test_mode.to_sym == :mock
-    end
-
-    def testing_enabled?
-      Sidekiq.const_defined?(TESTING_CONSTANT, false) && Sidekiq::Testing.enabled?
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/lock.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'sidekiq_unique_jobs/lock/until_executed'
-require 'sidekiq_unique_jobs/lock/until_executing'
-require 'sidekiq_unique_jobs/lock/while_executing'
-require 'sidekiq_unique_jobs/lock/until_timeout'
-require 'sidekiq_unique_jobs/lock/until_and_while_executing'
-
-module SidekiqUniqueJobs
-  module Lock
-  end
-end

data/lib/sidekiq_unique_jobs/lock/until_timeout.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module SidekiqUniqueJobs
-  module Lock
-    class UntilTimeout < UntilExecuted
-      def unlock(scope)
-        return true if scope.to_sym == :server
-
-        raise ArgumentError, "#{scope} middleware can't #{__method__} #{unique_key}"
-      end
-
-      def execute(_callback)
-        yield if block_given?
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/run_lock_failed.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-SidekiqUniqueJobs::RunLockFailed = Class.new(StandardError)

data/lib/sidekiq_unique_jobs/script_mock.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'digest/sha1'
-
-module SidekiqUniqueJobs
-  module ScriptMock
-    module_function
-
-    extend SingleForwardable
-    def_delegator :SidekiqUniqueJobs, :connection
-
-    def call(file_name, redis_pool, options = {})
-      send(file_name, redis_pool, options)
-    end
-
-    def acquire_lock(redis_pool, options = {})
-      connection(redis_pool) do |conn|
-        unique_key = options[:keys][0]
-        job_id     = options[:argv][0]
-        expires    = options[:argv][1].to_i
-        stored_jid = conn.get(unique_key)
-
-        return (stored_jid == job_id) ? 1 : 0 if stored_jid
-        return 0 unless conn.set(unique_key, job_id, nx: true, ex: expires)
-
-        conn.hsetnx(SidekiqUniqueJobs::HASH_KEY, job_id, unique_key)
-
-        return 1
-      end
-    end
-
-    def release_lock(redis_pool, options = {})
-      connection(redis_pool) do |conn|
-        unique_key = options[:keys][0]
-        job_id     = options[:argv][0]
-        stored_jid = conn.get(unique_key)
-
-        return -1 unless stored_jid
-        return 0 unless stored_jid == job_id || stored_jid == '2'
-
-        conn.del(unique_key)
-        conn.hdel(SidekiqUniqueJobs::HASH_KEY, job_id)
-
-        return 1
-      end
-    end
-
-    def synchronize(redis_pool, options = {})
-      connection(redis_pool) do |conn|
-        unique_key = options[:keys][0]
-        time       = options[:argv][0].to_i
-        expires    = options[:argv][1].to_f
-
-        return 1 if conn.set(unique_key, time + expires, nx: true, ex: expires)
-
-        stored_time = conn.get(unique_key)
-        if stored_time && stored_time < time
-          return 1 if conn.set(unique_key, time + expires, xx: true, ex: expires)
-        end
-
-        return 0
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/scripts/acquire_lock.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module SidekiqUniqueJobs
-  module Scripts
-    class AcquireLock
-      extend Forwardable
-      def_delegator SidekiqUniqueJobs, :logger
-
-      def self.execute(redis_pool, unique_key, jid, max_lock_time)
-        new(redis_pool, unique_key, jid, max_lock_time).execute
-      end
-
-      attr_reader :redis_pool, :unique_key, :jid, :max_lock_time
-
-      def initialize(_redis_pool, unique_key, jid, max_lock_time)
-        raise UniqueKeyMissing, 'unique_key is required' if unique_key.nil?
-        raise JidMissing, 'jid is required' if jid.nil?
-        raise MaxLockTimeMissing, 'max_lock_time is required' if max_lock_time.nil?
-
-        @unique_key    = unique_key
-        @jid           = jid
-        @max_lock_time = max_lock_time
-      end
-
-      def execute
-        result = Scripts.call(:acquire_lock, redis_pool,
-                              keys: [unique_key],
-                              argv: [jid, max_lock_time])
-
-        handle_result(result)
-      end
-
-      def handle_result(result)
-        case result
-        when 1
-          logger.debug { "successfully acquired lock #{unique_key} for #{max_lock_time} seconds" }
-          true
-        when 0
-          logger.debug { "failed to acquire lock for #{unique_key}" }
-          false
-        else
-          raise UnexpectedValue, "failed to acquire lock : unexpected return value (#{result})"
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/scripts/release_lock.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module SidekiqUniqueJobs
-  module Scripts
-    class ReleaseLock
-      extend Forwardable
-      def_delegator SidekiqUniqueJobs, :logger
-
-      def self.execute(redis_pool, unique_key, jid)
-        new(redis_pool, unique_key, jid).execute
-      end
-
-      attr_reader :redis_pool, :unique_key, :jid
-
-      def initialize(redis_pool, unique_key, jid)
-        raise UniqueKeyMissing, 'unique_key is required' if unique_key.nil?
-        raise JidMissing, 'jid is required' if jid.nil?
-
-        @redis_pool    = redis_pool
-        @unique_key    = unique_key
-        @jid           = jid
-      end
-
-      def execute
-        result = Scripts.call(:release_lock, redis_pool,
-                              keys: [unique_key],
-                              argv: [jid])
-
-        handle_result(result)
-      end
-
-      def handle_result(result)
-        case result
-        when 1
-          logger.debug { "successfully unlocked #{unique_key}" }
-          true
-        when 0
-          logger.debug { "expiring lock #{unique_key} is not owned by #{jid}" }
-          false
-        when -1
-          logger.debug { "#{unique_key} is not a known key" }
-          false
-        else
-          raise UnexpectedValue, "failed to release lock : unexpected return value (#{result})"
-        end
-      end
-    end
-  end
-end

data/lib/sidekiq_unique_jobs/testing/sidekiq_overrides.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'sidekiq/testing'
-
-module Sidekiq
-  module Worker
-    module ClassMethods
-      # Clear all jobs for this worker
-      def clear
-        jobs.each do |job|
-          unlock(job) if Sidekiq::Testing.fake?
-        end
-
-        Sidekiq::Queues[queue].clear
-        jobs.clear
-      end
-
-      unless respond_to?(:execute_job)
-        def execute_job(worker, args)
-          worker.perform(*args)
-        end
-      end
-
-      def unlock(job)
-        SidekiqUniqueJobs::Unlockable.unlock(job)
-      end
-    end
-
-    module Overrides
-      def self.included(base)
-        base.extend Testing
-        base.class_eval do
-          class << self
-            alias_method :clear_all_orig, :clear_all
-            alias_method :clear_all, :clear_all_ext
-          end
-        end
-      end
-
-      module Testing
-        def clear_all_ext
-          SidekiqUniqueJobs::Util.del('*', 1000, false) unless SidekiqUniqueJobs.mocked?
-          clear_all_orig
-        end
-      end
-    end
-
-    include Overrides
-  end
-end

data/lib/sidekiq_unique_jobs/timeout_calculator.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module SidekiqUniqueJobs
-  class TimeoutCalculator
-    def self.for_item(item)
-      new(item)
-    end
-
-    def initialize(item)
-      @item = item
-    end
-
-    def time_until_scheduled
-      scheduled = item[AT_KEY]
-      return 0 unless scheduled
-      (Time.at(scheduled) - Time.now.utc).to_i
-    end
-
-    def seconds
-      raise NotImplementedError
-    end
-
-    def worker_class_queue_lock_expiration
-      worker_class_expiration_for QUEUE_LOCK_TIMEOUT_KEY
-    end
-
-    def worker_class_run_lock_expiration
-      worker_class_expiration_for RUN_LOCK_TIMEOUT_KEY
-    end
-
-    def worker_class
-      @worker_class ||= SidekiqUniqueJobs.worker_class_constantize(item[CLASS_KEY])
-    end
-
-    private
-
-    def worker_class_expiration_for(key)
-      return unless worker_class.respond_to?(:get_sidekiq_options)
-      worker_class.get_sidekiq_options[key]
-    end
-
-    attr_reader :item
-  end
-
-  class RunLockTimeoutCalculator < TimeoutCalculator
-    def seconds
-      @seconds ||= (
-        worker_class_run_lock_expiration ||
-        SidekiqUniqueJobs.config.default_run_lock_expiration
-      ).to_i
-    end
-  end
-
-  class QueueLockTimeoutCalculator < TimeoutCalculator
-    def seconds
-      queue_lock_expiration + time_until_scheduled
-    end
-
-    def queue_lock_expiration
-      @queue_lock_expiration ||=
-        (
-          worker_class_queue_lock_expiration ||
-          SidekiqUniqueJobs.config.default_queue_lock_expiration
-        ).to_i
-    end
-  end
-end

data/redis/synchronize.lua

@@ -1,16 +0,0 @@
-local unique_key     = KEYS[1]
-local time           = ARGV[1]
-local expires        = ARGV[2]
-
-if redis.pcall('set', unique_key, time + expires, 'nx', 'ex', expires) then
-  return 1
-end
-
-local stored_time = redis.pcall('get', unique_key)
-if stored_time and stored_time < time then
-  if redis.pcall('set', unique_key, time + expires, 'xx', 'ex', expires) then
-    return 1
-  end
-end
-
-return 0