sidekiq-unique-jobs 5.0.11 → 6.0.0.rc1

data/examples/notify_worker.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class NotifyWorker
+  include Sidekiq::Worker
+
+  sidekiq_options queue: :notify_worker,
+                  unique: :until_executed
+
+  def perform(pid, blob)
+    [pid, blob]
+  end
+end

data/examples/plain_class.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class PlainClass
+  def self.run(one)
+    [one]
+  end
+
+  def run(one)
+    [one]
+  end
+end

data/examples/simple_worker.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class SimpleWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: :default,
+                  unique: :until_executed,
+                  unique_args: ->(args) { [args.first] }
+
+  def perform(args)
+    sleep 5
+    [args]
+  end
+end

data/examples/spawn_simple_worker.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class SpawnSimpleWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: :not_default
+
+  def perform(arg)
+    SimpleWorker.perform_async arg
+  end
+end

data/examples/test_class.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class TestClass
+  def self.run(one)
+    one
+  end
+end

data/examples/unique_across_workers_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+# This class showcase a job that is considered unique disregarding any worker classes.
+# Currently it will only be compared to other jobs that are disregarding worker classes.
+# If one were to compare the unique keys generated against a job that doesn't have the
+# worker class removed it won't work.
+#
+# The following specs cover this functionality:
+#   - https://github.com/mhenrixon/sidekiq-unique-jobs/blob/master/spec/lib/sidekiq_unique_jobs/client/middleware_spec.rb
+#   - https://github.com/mhenrixon/sidekiq-unique-jobs/blob/master/spec/lib/sidekiq_unique_jobs/unique_args_spec.rb
+class UniqueAcrossWorkersJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_executed, unique_across_workers: true
+
+  def perform(one, two)
+    [one, two]
+  end
+end

data/examples/unique_job_with_conditional_parameter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UniqueJobWithoutUniqueArgsParameter
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue,
+                  retry: true,
+                  backtrace: true,
+                  unique: :until_executed,
+                  unique_args: :unique_args
+
+  def perform(conditional = nil)
+    [conditional]
+  end
+
+  def self.unique_args; end
+end

data/examples/unique_job_with_filter_method.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UniqueJobWithFilterMethod
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue, retry: 1, backtrace: 10,
+                  unique: :while_executing, unique_args: :filtered_args
+
+  def perform(*)
+    # NO-OP
+  end
+
+  def self.filtered_args(args)
+    options = args.extract_options!
+    [args.first, options['type']]
+  end
+end

data/examples/unique_job_with_nil_unique_args.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UniqueJobWithNilUniqueArgs
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue,
+                  retry: true,
+                  backtrace: true,
+                  unique: :until_executed,
+                  unique_args: :unique_args
+
+  def perform(args)
+    [args]
+  end
+
+  def self.unique_args(_args)
+    nil
+  end
+end

data/examples/unique_job_with_no_unique_args_method.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UniqueJobWithNoUniqueArgsMethod
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue,
+                  retry: true,
+                  backtrace: true,
+                  unique: :until_executed,
+                  unique_args: :filtered_args
+
+  def perform(one, two)
+    [one, two]
+  end
+end

data/examples/unique_job_withthout_unique_args_parameter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UniqueJobWithoutUniqueArgsParameter
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue,
+                  retry: true,
+                  backtrace: true,
+                  unique: :until_executed,
+                  unique_args: :unique_args
+
+  def perform(optional = true)
+    # NO-OP
+  end
+
+  def self.unique_args; end
+end

data/examples/unique_on_all_queues_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+# This class showcase a job that is considered unique disregarding any queue.
+# Currently it will only be compared to other jobs that are disregarding queue.
+# If one were to compare the unique keys generated against a job that doesn't have the
+# queue removed it won't work.
+class UniqueOnAllQueuesJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_executed, unique_on_all_queues: true
+
+  def perform(one, two, three = nil)
+    [one, two, three]
+  end
+end

data/examples/until_and_while_executing_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UntilAndWhileExecutingJob
+  include Sidekiq::Worker
+
+  sidekiq_options queue: :working, unique: :until_and_while_executing, lock_timeout: 0
+
+  def perform(one)
+    [one]
+  end
+end

data/examples/until_executed_2_job.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+# This class will lock until the job is successfully executed
+#
+# It will wait for 0 seconds to acquire a lock and it will expire the unique key after 2 seconds
+#
+class UntilExecuted2Job
+  include Sidekiq::Worker
+  sidekiq_options queue: :working,
+                  retry: 1,
+                  backtrace: 10,
+                  unique: :until_executed,
+                  lock_timeout: 0
+
+  def perform(one, two)
+    [one, two]
+  end
+
+  def after_unlock
+    # NO OP
+  end
+end

data/examples/until_executed_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+# This class will lock until the job is successfully executed
+#
+# It will wait for 0 seconds to acquire a lock and it will expire the unique key after 2 seconds
+#
+class UntilExecutedJob
+  include Sidekiq::Worker
+  sidekiq_options queue: :working,
+                  retry: 1,
+                  backtrace: 10,
+                  unique: :until_executed,
+                  lock_timeout: 0,
+                  lock_expiration: 5000
+
+  def perform(one, two = nil)
+    [one, two]
+  end
+
+  def after_unlock
+    # NO OP
+  end
+end

data/examples/until_executing_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UntilExecutingJob
+  include Sidekiq::Worker
+
+  sidekiq_options queue: :working, unique: :until_executing
+
+  def perform; end
+end

data/examples/until_expired_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UntilExpiredJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_expired, lock_expiration: 1, lock_timeout: 0
+
+  def perform(one)
+    TestClass.run(one)
+  end
+end

data/examples/until_global_expired_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class UntilGlobalExpiredJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_expired
+
+  def perform(arg)
+    TestClass.run(arg)
+  end
+end

data/examples/while_executing_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class WhileExecutingJob
+  include Sidekiq::Worker
+  sidekiq_options backtrace: 10,
+                  queue: :working,
+                  retry: 1,
+                  unique: :while_executing
+
+  def perform(args)
+    [args]
+  end
+end

data/examples/while_executing_reject_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class WhileExecutingRejectJob
+  include Sidekiq::Worker
+  sidekiq_options queue: :rejecting,
+                  unique: :while_executing_reject
+
+  def perform(args)
+    sleep 5
+    p args
+  end
+end

data/examples/without_argument_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# :nocov:
+
+class WithoutArgumentJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_executed,
+                  log_duplicate_payload: true
+
+  def perform
+    sleep 20
+  end
+end

data/lib/sidekiq-unique-jobs.rb

@@ -1,93 +1,3 @@
 # frozen_string_literal: true
 
-require 'yaml' if RUBY_VERSION.include?('2.0.0')
-require 'forwardable'
-require 'sidekiq_unique_jobs/version'
-require 'sidekiq_unique_jobs/constants'
-require 'sidekiq_unique_jobs/util'
-require 'sidekiq_unique_jobs/cli'
-require 'sidekiq_unique_jobs/core_ext'
-require 'sidekiq_unique_jobs/timeout_calculator'
-require 'sidekiq_unique_jobs/options_with_fallback'
-require 'sidekiq_unique_jobs/scripts'
-require 'sidekiq_unique_jobs/unique_args'
-require 'sidekiq_unique_jobs/unlockable'
-require 'sidekiq_unique_jobs/lock'
-require 'sidekiq_unique_jobs/middleware'
-require 'sidekiq_unique_jobs/config'
-require 'sidekiq_unique_jobs/sidekiq_unique_ext'
-
-require 'ostruct'
-
-module SidekiqUniqueJobs
-  module_function
-
-  def config
-    @config ||= Config.new(
-      unique_prefix: 'uniquejobs',
-      default_queue_lock_expiration: 30 * 60,
-      default_run_lock_expiration: 60,
-      default_lock: :while_executing,
-      redis_test_mode: :redis, # :mock
-      raise_unique_args_errors: false,
-    )
-  end
-
-  def logger
-    Sidekiq.logger
-  end
-
-  def default_lock
-    config.default_lock
-  end
-
-  def configure(options = {})
-    if block_given?
-      yield config
-    else
-      options.each do |key, val|
-        config.send("#{key}=", val)
-      end
-    end
-  end
-
-  def namespace
-    @namespace ||= connection { |conn| conn.respond_to?(:namespace) ? conn.namespace : nil }
-  end
-
-  # Attempt to constantize a string worker_class argument, always
-  # failing back to the original argument when the constant can't be found
-  #
-  # raises an error for other errors
-  def worker_class_constantize(worker_class)
-    return worker_class unless worker_class.is_a?(String)
-    Object.const_get(worker_class)
-  rescue NameError => ex
-    case ex.message
-    when /uninitialized constant/
-      worker_class
-    else
-      raise
-    end
-  end
-
-  def mocked?
-    config.redis_test_mode == :mock
-  end
-
-  def redis_version
-    @redis_version ||= connection { |conn| conn.info('server')['redis_version'] }
-  end
-
-  def connection(redis_pool = nil)
-    if redis_pool
-      redis_pool.with { |conn| yield conn }
-    else
-      Sidekiq.redis { |conn| yield conn }
-    end
-  end
-
-  def synchronize(item, redis_pool)
-    Lock::WhileExecuting.synchronize(item, redis_pool) { yield }
-  end
-end
+require 'sidekiq_unique_jobs'