sidekiq-unique-jobs 7.1.8 → 7.1.29

data/lib/sidekiq_unique_jobs/timer_task.rb

@@ -1,25 +1,279 @@
 # frozen_string_literal: true
 
+require "concurrent/collection/copy_on_notify_observer_set"
+require "concurrent/concern/dereferenceable"
+require "concurrent/concern/observable"
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/executor/executor_service"
+require "concurrent/executor/ruby_executor_service"
+require "concurrent/executor/safe_task_executor"
+require "concurrent/scheduled_task"
+
 module SidekiqUniqueJobs
-  # @see [Concurrent::TimerTask] https://www.rubydoc.info/gems/concurrent-ruby/Concurrent/TimerTask
+  # A very common concurrency pattern is to run a thread that performs a task at
+  # regular intervals. The thread that performs the task sleeps for the given
+  # interval then wakes up and performs the task. Lather, rinse, repeat... This
+  # pattern causes two problems. First, it is difficult to test the business
+  # logic of the task because the task itself is tightly coupled with the
+  # concurrency logic. Second, an exception raised while performing the task can
+  # cause the entire thread to abend. In a long-running application where the
+  # task thread is intended to run for days/weeks/years a crashed task thread
+  # can pose a significant problem. `TimerTask` alleviates both problems.
+  #
+  # When a `TimerTask` is launched it starts a thread for monitoring the
+  # execution interval. The `TimerTask` thread does not perform the task,
+  # however. Instead, the TimerTask launches the task on a separate thread.
+  # Should the task experience an unrecoverable crash only the task thread will
+  # crash. This makes the `TimerTask` very fault tolerant. Additionally, the
+  # `TimerTask` thread can respond to the success or failure of the task,
+  # performing logging or ancillary operations.
+  #
+  # One other advantage of `TimerTask` is that it forces the business logic to
+  # be completely decoupled from the concurrency logic. The business logic can
+  # be tested separately then passed to the `TimerTask` for scheduling and
+  # running.
+  #
+  # In some cases it may be necessary for a `TimerTask` to affect its own
+  # execution cycle. To facilitate this, a reference to the TimerTask instance
+  # is passed as an argument to the provided block every time the task is
+  # executed.
+  #
+  # The `TimerTask` class includes the `Dereferenceable` mixin module so the
+  # result of the last execution is always available via the `#value` method.
+  # Dereferencing options can be passed to the `TimerTask` during construction or
+  # at any later time using the `#set_deref_options` method.
+  #
+  # `TimerTask` supports notification through the Ruby standard library
+  # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
+  # Observable} module. On execution the `TimerTask` will notify the observers
+  # with three arguments: time of execution, the result of the block (or nil on
+  # failure), and any raised exceptions (or nil on success).
+  #
+  # @!macro copy_options
+  #
+  # @example Basic usage
+  #   task = Concurrent::TimerTask.new{ puts 'Boom!' }
+  #   task.execute
+  #
+  #   task.execution_interval #=> 60 (default)
+  #
+  #   # wait 60 seconds...
+  #   #=> 'Boom!'
+  #
+  #   task.shutdown #=> true
+  #
+  # @example Configuring `:execution_interval`
+  #   task = Concurrent::TimerTask.new(execution_interval: 5) do
+  #          puts 'Boom!'
+  #        end
+  #
+  #   task.execution_interval #=> 5
+  #
+  # @example Immediate execution with `:run_now`
+  #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
+  #   task.execute
+  #
+  #   #=> 'Boom!'
+  #
+  # @example Last `#value` and `Dereferenceable` mixin
+  #   task = Concurrent::TimerTask.new(
+  #     dup_on_deref: true,
+  #     execution_interval: 5
+  #   ){ Time.now }
   #
-  class TimerTask < ::Concurrent::TimerTask
+  #   task.execute
+  #   Time.now   #=> 2013-11-07 18:06:50 -0500
+  #   sleep(10)
+  #   task.value #=> 2013-11-07 18:06:55 -0500
+  #
+  # @example Controlling execution from within the block
+  #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
+  #     task.execution_interval.times{ print 'Boom! ' }
+  #     print "\n"
+  #     task.execution_interval += 1
+  #     if task.execution_interval > 5
+  #       puts 'Stopping...'
+  #       task.shutdown
+  #     end
+  #   end
+  #
+  #   timer_task.execute # blocking call - this task will stop itself
+  #   #=> Boom!
+  #   #=> Boom! Boom!
+  #   #=> Boom! Boom! Boom!
+  #   #=> Boom! Boom! Boom! Boom!
+  #   #=> Boom! Boom! Boom! Boom! Boom!
+  #   #=> Stopping...
+  #
+  # @example Observation
+  #   class TaskObserver
+  #     def update(time, result, ex)
+  #       if result
+  #         print "(#{time}) Execution successfully returned #{result}\n"
+  #       else
+  #         print "(#{time}) Execution failed with error #{ex}\n"
+  #       end
+  #     end
+  #   end
+  #
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ 42 }
+  #   task.add_observer(TaskObserver.new)
+  #   task.execute
+  #   sleep 4
+  #
+  #   #=> (2013-10-13 19:08:58 -0400) Execution successfully returned 42
+  #   #=> (2013-10-13 19:08:59 -0400) Execution successfully returned 42
+  #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
+  #   task.shutdown
+  #
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ sleep }
+  #   task.add_observer(TaskObserver.new)
+  #   task.execute
+  #
+  #   #=> (2013-10-13 19:07:25 -0400) Execution timed out
+  #   #=> (2013-10-13 19:07:27 -0400) Execution timed out
+  #   #=> (2013-10-13 19:07:29 -0400) Execution timed out
+  #   task.shutdown
+  #
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ raise StandardError }
+  #   task.add_observer(TaskObserver.new)
+  #   task.execute
+  #
+  #   #=> (2013-10-13 19:09:37 -0400) Execution failed with error StandardError
+  #   #=> (2013-10-13 19:09:38 -0400) Execution failed with error StandardError
+  #   #=> (2013-10-13 19:09:39 -0400) Execution failed with error StandardError
+  #   task.shutdown
+  #
+  # @see http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
+  # @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
+  class TimerTask < Concurrent::RubyExecutorService
+    include Concurrent::Concern::Dereferenceable
+    include Concurrent::Concern::Observable
+
+    # Default `:execution_interval` in seconds.
+    EXECUTION_INTERVAL = 60
+
+    # Default `:timeout_interval` in seconds.
+    TIMEOUT_INTERVAL = 30
+
+    # Create a new TimerTask with the given task and configuration.
+    #
+    # @!macro timer_task_initialize
+    #   @param [Hash] opts the options defining task execution.
+    #   @option opts [Integer] :execution_interval number of seconds between
+    #     task executions (default: EXECUTION_INTERVAL)
+    #   @option opts [Boolean] :run_now Whether to run the task immediately
+    #     upon instantiation or to wait until the first #  execution_interval
+    #     has passed (default: false)
+    #
+    #   @!macro deref_options
+    #
+    #   @raise ArgumentError when no block is given.
+    #
+    #   @yield to the block after :execution_interval seconds have passed since
+    #     the last yield
+    #   @yieldparam task a reference to the `TimerTask` instance so that the
+    #     block can control its own lifecycle. Necessary since `self` will
+    #     refer to the execution context of the block rather than the running
+    #     `TimerTask`.
+    #
+    #   @return [TimerTask] the new `TimerTask`
+    def initialize(opts = {}, &task)
+      raise ArgumentError, "no block given" unless task
+
+      super
+      set_deref_options opts
+    end
+
+    # Is the executor running?
+    #
+    # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+    def running?
+      @running.true?
+    end
+
+    # Execute a previously created `TimerTask`.
+    #
+    # @return [TimerTask] a reference to `self`
+    #
+    # @example Instance and execute in separate steps
+    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> false
+    #   task.execute
+    #   task.running? #=> true
+    #
+    # @example Instance and execute in one line
+    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }.execute
+    #   task.running? #=> true
+    def execute
+      synchronize do
+        if @running.false?
+          @running.make_true
+          schedule_next_task(@run_now ? 0 : @execution_interval)
+        end
+      end
+      self
+    end
+
+    # Create and execute a new `TimerTask`.
+    #
+    # @!macro timer_task_initialize
+    #
+    # @example
+    #   task = Concurrent::TimerTask.execute(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> true
+    def self.execute(opts = {}, &task)
+      TimerTask.new(opts, &task).execute
+    end
+
+    # @!attribute [rw] execution_interval
+    # @return [Fixnum] Number of seconds after the task completes before the
+    #   task is performed again.
+    def execution_interval
+      synchronize { @execution_interval }
+    end
+
+    # @!attribute [rw] execution_interval
+    # @return [Fixnum] Number of seconds after the task completes before the
+    #   task is performed again.
+    def execution_interval=(value)
+      raise ArgumentError, "must be greater than zero" if (value = value.to_f) <= 0.0
+
+      synchronize { @execution_interval = value }
+    end
+
+    private :post, :<<
+
     private
 
     def ns_initialize(opts, &task)
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
-      @run_now  = opts[:now] || opts[:run_now]
-      @executor = Concurrent::RubySingleThreadExecutor.new
-      @running  = Concurrent::AtomicBoolean.new(false)
-      @task     = task
-      @value    = nil
+      if opts[:timeout] || opts[:timeout_interval]
+        warn "TimeTask timeouts are now ignored as these were not able to be implemented correctly"
+      end
+      @run_now = opts[:now] || opts[:run_now]
+      @executor = Concurrent::SafeTaskExecutor.new(task)
+      @running = Concurrent::AtomicBoolean.new(false)
+      @value = nil
 
       self.observers = Concurrent::Collection::CopyOnNotifyObserverSet.new
     end
 
+    # @!visibility private
+    def ns_shutdown_execution
+      @running.make_false
+      super
+    end
+
+    # @!visibility private
+    def ns_kill_execution
+      @running.make_false
+      super
+    end
+
+    # @!visibility private
     def schedule_next_task(interval = execution_interval)
       exec_task = ->(completion) { execute_task(completion) }
       Concurrent::ScheduledTask.execute(interval, args: [Concurrent::Event.new], &exec_task)
@@ -27,52 +281,19 @@ module SidekiqUniqueJobs
     end
 
     # @!visibility private
-    def execute_task(completion) # rubocop:disable Metrics/MethodLength
+    def execute_task(completion)
       return nil unless @running.true?
 
-      timeout_task = -> { timeout_task(completion) }
-
-      Concurrent::ScheduledTask.execute(
-        timeout_interval,
-        args: [completion],
-        &timeout_task
-      )
-      @thread_completed = Concurrent::Event.new
-
-      @value = @reason  = nil
-      @executor.post do
-        @value = @task.call(self)
-      rescue Exception => ex # rubocop:disable Lint/RescueException
-        @reason = ex
-      ensure
-        @thread_completed.set
-      end
-
-      @thread_completed.wait
-
+      _success, value, reason = @executor.execute(self)
       if completion.try?
+        self.value = value
         schedule_next_task
         time = Time.now
         observers.notify_observers do
-          [time, value, @reason]
+          [time, self.value, reason]
         end
       end
       nil
     end
-
-    # @!visibility private
-    def timeout_task(completion)
-      return unless @running.true?
-      return unless completion.try?
-
-      @executor.kill
-      @executor.wait_for_termination
-      @executor = Concurrent::RubySingleThreadExecutor.new
-
-      @thread_completed.set
-
-      schedule_next_task
-      observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-    end
   end
 end

data/lib/sidekiq_unique_jobs/timing.rb

@@ -48,7 +48,7 @@ module SidekiqUniqueJobs
     # @return [Float]
     #
     def clock_stamp
-      if Process.const_defined?("CLOCK_MONOTONIC")
+      if Process.const_defined?(:CLOCK_MONOTONIC)
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       else
         now_f

data/lib/sidekiq_unique_jobs/upgrade_locks.rb

@@ -87,9 +87,9 @@ module SidekiqUniqueJobs
       digest     = grabbed_key.gsub(":GRABBED", "")
       locks      = conn.hgetall(grabbed_key)
 
-      conn.pipelined do
-        conn.hmset(locked_key, *locks.to_a)
-        conn.zadd(DIGESTS, locks.values.first, digest)
+      conn.pipelined do |pipeline|
+        pipeline.hmset(locked_key, *locks.to_a)
+        pipeline.zadd(DIGESTS, locks.values.first, digest)
       end
     end
 
@@ -114,11 +114,11 @@ module SidekiqUniqueJobs
     def batch_delete(*keys)
       return if keys.empty?
 
-      conn.pipelined do
+      conn.pipelined do |pipeline|
         if VersionCheck.satisfied?(redis_version, ">= 4.0.0")
-          conn.unlink(*keys)
+          pipeline.unlink(*keys)
         else
-          conn.del(*keys)
+          pipeline.del(*keys)
         end
       end
     end

data/lib/sidekiq_unique_jobs/version.rb

@@ -3,5 +3,5 @@
 module SidekiqUniqueJobs
   #
   # @return [String] the current SidekiqUniqueJobs version
-  VERSION = "7.1.8"
+  VERSION = "7.1.29"
 end

data/lib/sidekiq_unique_jobs/web/helpers.rb

@@ -27,7 +27,7 @@ module SidekiqUniqueJobs
       # @return [String] the file contents of the template
       #
       def unique_template(name)
-        File.open(unique_filename(name)).read
+        File.read(unique_filename(name))
       end
 
       #
@@ -51,6 +51,16 @@ module SidekiqUniqueJobs
         @digests ||= SidekiqUniqueJobs::Digests.new
       end
 
+      #
+      # The collection of digests
+      #
+      #
+      # @return [SidekiqUniqueJobs::ExpiringDigests] the sorted set with expiring digests
+      #
+      def expiring_digests
+        @expiring_digests ||= SidekiqUniqueJobs::ExpiringDigests.new
+      end
+
       #
       # The collection of changelog entries
       #

data/lib/sidekiq_unique_jobs/web.rb

@@ -8,7 +8,7 @@ module SidekiqUniqueJobs
   #
   # @author Mikael Henriksson <mikael@mhenrixon.com>
   module Web
-    def self.registered(app) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.registered(app) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       app.helpers do
         include Web::Helpers
       end
@@ -49,8 +49,25 @@ module SidekiqUniqueJobs
         erb(unique_template(:locks))
       end
 
+      app.get "/expiring_locks" do
+        @filter         = params[:filter] || "*"
+        @filter         = "*" if @filter == ""
+        @count          = (params[:count] || 100).to_i
+        @current_cursor = params[:cursor]
+        @prev_cursor    = params[:prev_cursor]
+
+        @total_size, @next_cursor, @locks = expiring_digests.page(
+          cursor: @current_cursor,
+          pattern: @filter,
+          page_size: @count,
+        )
+
+        erb(unique_template(:locks))
+      end
+
       app.get "/locks/delete_all" do
         digests.delete_by_pattern("*", count: digests.count)
+        expiring_digests.delete_by_pattern("*", count: digests.count)
         redirect_to :locks
       end
 
@@ -63,6 +80,7 @@ module SidekiqUniqueJobs
 
       app.get "/locks/:digest/delete" do
         digests.delete_by_digest(params[:digest])
+        expiring_digests.delete_by_digest(params[:digest])
         redirect_to :locks
       end
 
@@ -82,8 +100,9 @@ begin
   require "sidekiq/web" unless defined?(Sidekiq::Web)
 
   Sidekiq::Web.register(SidekiqUniqueJobs::Web)
-  Sidekiq::Web.tabs["Locks"]      = "locks"
-  Sidekiq::Web.tabs["Changelogs"] = "changelogs"
+  Sidekiq::Web.tabs["Locks"]          = "locks"
+  Sidekiq::Web.tabs["Expiring Locks"] = "expiring_locks"
+  Sidekiq::Web.tabs["Changelogs"]     = "changelogs"
   Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "locales")
 rescue NameError, LoadError => ex
   SidekiqUniqueJobs.logger.error(ex)

data/lib/sidekiq_unique_jobs.rb

@@ -72,6 +72,7 @@ require "sidekiq_unique_jobs/sidekiq_unique_ext"
 require "sidekiq_unique_jobs/on_conflict"
 require "sidekiq_unique_jobs/changelog"
 require "sidekiq_unique_jobs/digests"
+require "sidekiq_unique_jobs/expiring_digests"
 
 require "sidekiq_unique_jobs/config"
 require "sidekiq_unique_jobs/sidekiq_unique_jobs"

data/lib/tasks/changelog.rake

@@ -17,7 +17,7 @@ COMMIT_CHANGELOG_CMD = "git commit -a -m 'Update changelog'"
 desc "Generate a Changelog"
 task :changelog do
   sh("git checkout main")
-  sh(*CHANGELOG_CMD.push(ENV["CHANGELOG_GITHUB_TOKEN"]))
+  sh(*CHANGELOG_CMD.push(ENV.fetch("CHANGELOG_GITHUB_TOKEN", nil)))
   sh(ADD_CHANGELOG_CMD)
   sh(COMMIT_CHANGELOG_CMD)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-unique-jobs
 version: !ruby/object:Gem::Version
-  version: 7.1.8
+  version: 7.1.29
 platform: ruby
 authors:
 - Mikael Henriksson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2022-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: brpoplpush-redis_script
@@ -50,6 +50,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -59,7 +73,7 @@ dependencies:
         version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -69,7 +83,7 @@ dependencies:
         version: '5.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -116,6 +130,7 @@ files:
 - lib/sidekiq_unique_jobs/deprecation.rb
 - lib/sidekiq_unique_jobs/digests.rb
 - lib/sidekiq_unique_jobs/exceptions.rb
+- lib/sidekiq_unique_jobs/expiring_digests.rb
 - lib/sidekiq_unique_jobs/job.rb
 - lib/sidekiq_unique_jobs/json.rb
 - lib/sidekiq_unique_jobs/key.rb
@@ -144,6 +159,7 @@ files:
 - lib/sidekiq_unique_jobs/lua/delete_job_by_digest.lua
 - lib/sidekiq_unique_jobs/lua/find_digest_in_queues.lua
 - lib/sidekiq_unique_jobs/lua/lock.lua
+- lib/sidekiq_unique_jobs/lua/lock_until_expired.lua
 - lib/sidekiq_unique_jobs/lua/locked.lua
 - lib/sidekiq_unique_jobs/lua/queue.lua
 - lib/sidekiq_unique_jobs/lua/reap_orphans.lua
@@ -211,15 +227,11 @@ files:
 - lib/sidekiq_unique_jobs/web/views/lock.erb
 - lib/sidekiq_unique_jobs/web/views/locks.erb
 - lib/tasks/changelog.rake
-homepage: https://mhenrixon.github.io/sidekiq-unique-jobs
+homepage: https://github.com/mhenrixon/sidekiq-unique-jobs
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://mhenrixon.github.io/sidekiq-unique-jobs
-  bug_tracker_uri: https://github.com/mhenrixon/sidekiq-unique-jobs/issues
-  documentation_uri: https://mhenrixon.github.io/sidekiq-unique-jobs
-  source_code_uri: https://github.com/mhenrixon/sidekiq-unique-jobs
-  changelog_uri: https://github.com/mhenrixon/sidekiq-unique-jobs/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message: |
   IMPORTANT!
 
@@ -261,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.28
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Sidekiq middleware that prevents duplicates jobs