sidekiq 3.4.1 → 4.0.0

data/lib/sidekiq/fetch.rb

@@ -1,101 +1,34 @@
 require 'sidekiq'
-require 'sidekiq/util'
-require 'sidekiq/actor'
 
 module Sidekiq
-  ##
-  # The Fetcher blocks on Redis, waiting for a message to process
-  # from the queues.  It gets the message and hands it to the Manager
-  # to assign to a ready Processor.
-  class Fetcher
-    include Util
-    include Actor
-
-    TIMEOUT = 1
-
-    attr_reader :down
-
-    def initialize(mgr, options)
-      @down = nil
-      @mgr = mgr
-      @strategy = Fetcher.strategy.new(options)
-    end
-
-    # Fetching is straightforward: the Manager makes a fetch
-    # request for each idle processor when Sidekiq starts and
-    # then issues a new fetch request every time a Processor
-    # finishes a message.
-    #
-    # Because we have to shut down cleanly, we can't block
-    # forever and we can't loop forever.  Instead we reschedule
-    # a new fetch if the current fetch turned up nothing.
-    def fetch
-      watchdog('Fetcher#fetch died') do
-        return if Sidekiq::Fetcher.done?
-
-        begin
-          work = @strategy.retrieve_work
-          ::Sidekiq.logger.info("Redis is online, #{Time.now - @down} sec downtime") if @down
-          @down = nil
-
-          if work
-            @mgr.async.assign(work)
-          else
-            after(0) { fetch }
-          end
-        rescue => ex
-          handle_fetch_exception(ex)
-        end
+  class BasicFetch
+    # We want the fetch operation to timeout every few seconds so the thread
+    # can check if the process is shutting down.
+    TIMEOUT = 2
 
+    UnitOfWork = Struct.new(:queue, :job) do
+      def acknowledge
+        # nothing to do
       end
-    end
-
-    private
 
-    def pause
-      sleep(TIMEOUT)
-    end
+      def queue_name
+        queue.gsub(/.*queue:/, ''.freeze)
+      end
 
-    def handle_fetch_exception(ex)
-      if !@down
-        logger.error("Error fetching message: #{ex}")
-        ex.backtrace.each do |bt|
-          logger.error(bt)
+      def requeue
+        Sidekiq.redis do |conn|
+          conn.rpush("queue:#{queue_name}", job)
         end
       end
-      @down ||= Time.now
-      pause
-      after(0) { fetch }
-    rescue Task::TerminatedError
-      # If redis is down when we try to shut down, all the fetch backlog
-      # raises these errors.  Haven't been able to figure out what I'm doing wrong.
-    end
-
-    # Ugh.  Say hello to a bloody hack.
-    # Can't find a clean way to get the fetcher to just stop processing
-    # its mailbox when shutdown starts.
-    def self.done!
-      @done = true
-    end
-
-    def self.reset # testing only
-      @done = nil
     end
 
-    def self.done?
-      @done
-    end
-
-    def self.strategy
-      Sidekiq.options[:fetch] || BasicFetch
-    end
-  end
-
-  class BasicFetch
     def initialize(options)
       @strictly_ordered_queues = !!options[:strict]
       @queues = options[:queues].map { |q| "queue:#{q}" }
-      @unique_queues = @queues.uniq
+      if @strictly_ordered_queues
+        @queues = @queues.uniq
+        @queues << TIMEOUT
+      end
     end
 
     def retrieve_work
@@ -103,6 +36,22 @@ module Sidekiq
       UnitOfWork.new(*work) if work
     end
 
+    # Creating the Redis#brpop command takes into account any
+    # configured queue weights. By default Redis#brpop returns
+    # data from the first queue that has pending elements. We
+    # recreate the queue command each time we invoke Redis#brpop
+    # to honor weights and avoid queue starvation.
+    def queues_cmd
+      if @strictly_ordered_queues
+        @queues
+      else
+        queues = @queues.shuffle.uniq
+        queues << TIMEOUT
+        queues
+      end
+    end
+
+
     # By leaving this as a class method, it can be pluggable and used by the Manager actor. Making it
     # an instance method will make it async to the Fetcher actor
     def self.bulk_requeue(inprogress, options)
@@ -112,7 +61,7 @@ module Sidekiq
       jobs_to_requeue = {}
       inprogress.each do |unit_of_work|
         jobs_to_requeue[unit_of_work.queue_name] ||= []
-        jobs_to_requeue[unit_of_work.queue_name] << unit_of_work.message
+        jobs_to_requeue[unit_of_work.queue_name] << unit_of_work.job
       end
 
       Sidekiq.redis do |conn|
@@ -122,35 +71,10 @@ module Sidekiq
           end
         end
       end
-      Sidekiq.logger.info("Pushed #{inprogress.size} messages back to Redis")
+      Sidekiq.logger.info("Pushed #{inprogress.size} jobs back to Redis")
     rescue => ex
       Sidekiq.logger.warn("Failed to requeue #{inprogress.size} jobs: #{ex.message}")
     end
 
-    UnitOfWork = Struct.new(:queue, :message) do
-      def acknowledge
-        # nothing to do
-      end
-
-      def queue_name
-        queue.gsub(/.*queue:/, '')
-      end
-
-      def requeue
-        Sidekiq.redis do |conn|
-          conn.rpush("queue:#{queue_name}", message)
-        end
-      end
-    end
-
-    # Creating the Redis#brpop command takes into account any
-    # configured queue weights. By default Redis#brpop returns
-    # data from the first queue that has pending elements. We
-    # recreate the queue command each time we invoke Redis#brpop
-    # to honor weights and avoid queue starvation.
-    def queues_cmd
-      queues = @strictly_ordered_queues ? @unique_queues.dup : @queues.shuffle.uniq
-      queues << Sidekiq::Fetcher::TIMEOUT
-    end
   end
 end

data/lib/sidekiq/launcher.rb

@@ -1,4 +1,4 @@
-require 'sidekiq/actor'
+# encoding: utf-8
 require 'sidekiq/manager'
 require 'sidekiq/fetch'
 require 'sidekiq/scheduled'
@@ -9,64 +9,116 @@ module Sidekiq
   # If any of these actors die, the Sidekiq process exits
   # immediately.
   class Launcher
-    include Actor
     include Util
 
-    trap_exit :actor_died
-
-    attr_reader :manager, :poller, :fetcher
+    attr_accessor :manager, :poller, :fetcher
 
     def initialize(options)
-      @condvar = Celluloid::Condition.new
-      @manager = Sidekiq::Manager.new_link(@condvar, options)
-      @poller = Sidekiq::Scheduled::Poller.new_link
-      @fetcher = Sidekiq::Fetcher.new_link(@manager, options)
-      @manager.fetcher = @fetcher
+      @manager = Sidekiq::Manager.new(options)
+      @poller = Sidekiq::Scheduled::Poller.new
       @done = false
       @options = options
     end
 
-    def actor_died(actor, reason)
-      # https://github.com/mperham/sidekiq/issues/2057#issuecomment-66485477
-      return if @done || !reason
+    def run
+      @thread = safe_thread("heartbeat", &method(:start_heartbeat))
+      @poller.start
+      @manager.start
+    end
 
-      Sidekiq.logger.warn("Sidekiq died due to the following error, cannot recover, process exiting")
-      handle_exception(reason)
-      exit(1)
+    # Stops this instance from processing any more jobs,
+    #
+    def quiet
+      @done = true
+      @manager.quiet
+      @poller.terminate
     end
 
-    def run
-      watchdog('Launcher#run') do
-        manager.async.start
-        poller.async.poll(true)
+    # Shuts down the process.  This method does not
+    # return until all work is complete and cleaned up.
+    # It can take up to the timeout to complete.
+    def stop
+      deadline = Time.now + @options[:timeout]
 
-        start_heartbeat
-      end
+      @done = true
+      @manager.quiet
+      @poller.terminate
+
+      @manager.stop(deadline)
+
+      # Requeue everything in case there was a worker who grabbed work while stopped
+      # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
+      strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+      strategy.bulk_requeue([], @options)
+
+      clear_heartbeat
     end
 
-    def stop
-      watchdog('Launcher#stop') do
-        @done = true
-        Sidekiq::Fetcher.done!
-        fetcher.terminate if fetcher.alive?
-        poller.terminate if poller.alive?
+    def stopping?
+      @done
+    end
 
-        manager.async.stop(:shutdown => true, :timeout => @options[:timeout])
-        @condvar.wait
-        manager.terminate
+    private unless $TESTING
 
-        # Requeue everything in case there was a worker who grabbed work while stopped
-        # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
-        Sidekiq::Fetcher.strategy.bulk_requeue([], @options)
+    JVM_RESERVED_SIGNALS = ['USR1', 'USR2'] # Don't Process#kill if we get these signals via the API
 
-        stop_heartbeat
-      end
+    def heartbeat(k, data, json)
+      results = Sidekiq::CLI::PROCTITLES.map {|x| x.(self, data) }
+      results.compact!
+      $0 = results.join(' ')
+
+      ❤(k, json)
     end
 
-    private
+    def ❤(key, json)
+      fails = procd = 0
+      begin
+        Processor::FAILURE.update {|curr| fails = curr; 0 }
+        Processor::PROCESSED.update {|curr| procd = curr; 0 }
+
+        workers_key = "#{key}:workers".freeze
+        nowdate = Time.now.utc.strftime("%Y-%m-%d".freeze)
+        Sidekiq.redis do |conn|
+          conn.pipelined do
+            conn.incrby("stat:processed".freeze, procd)
+            conn.incrby("stat:processed:#{nowdate}", procd)
+            conn.incrby("stat:failed".freeze, fails)
+            conn.incrby("stat:failed:#{nowdate}", fails)
+            conn.del(workers_key)
+            Processor::WORKER_STATE.each_pair do |tid, hash|
+              conn.hset(workers_key, tid, Sidekiq.dump_json(hash))
+            end
+          end
+        end
+        fails = procd = 0
+
+        _, _, _, msg = Sidekiq.redis do |conn|
+          conn.pipelined do
+            conn.sadd('processes', key)
+            conn.hmset(key, 'info', json, 'busy', Processor::WORKER_STATE.size, 'beat', Time.now.to_f)
+            conn.expire(key, 60)
+            conn.rpop("#{key}-signals")
+          end
+        end
+
+        return unless msg
+
+        if JVM_RESERVED_SIGNALS.include?(msg)
+          Sidekiq::CLI.instance.handle_signal(msg)
+        else
+          ::Process.kill(msg, $$)
+        end
+      rescue => e
+        # ignore all redis/network issues
+        logger.error("heartbeat: #{e.message}")
+        # don't lose the counts if there was a network issue
+        PROCESSED.increment(procd)
+        FAILURE.increment(fails)
+      end
+    end
 
     def start_heartbeat
-      key = identity
+      k = identity
       data = {
         'hostname' => hostname,
         'started_at' => Time.now.to_f,
@@ -74,16 +126,24 @@ module Sidekiq
         'tag' => @options[:tag] || '',
         'concurrency' => @options[:concurrency],
         'queues' => @options[:queues].uniq,
-        'labels' => Sidekiq.options[:labels],
-        'identity' => identity,
+        'labels' => @options[:labels],
+        'identity' => k,
       }
       # this data doesn't change so dump it to a string
       # now so we don't need to dump it every heartbeat.
       json = Sidekiq.dump_json(data)
-      manager.heartbeat(key, data, json)
+
+      while true
+        heartbeat(k, data, json)
+        sleep 5
+      end
+      Sidekiq.logger.info("Heartbeat stopping...")
     end
 
-    def stop_heartbeat
+    def clear_heartbeat
+      # Remove record from Redis since we are shutting down.
+      # Note we don't stop the heartbeat thread; if the process
+      # doesn't actually exit, it'll reappear in the Web UI.
       Sidekiq.redis do |conn|
         conn.pipelined do
           conn.srem('processes', identity)

data/lib/sidekiq/manager.rb

@@ -1,155 +1,96 @@
 # encoding: utf-8
 require 'sidekiq/util'
-require 'sidekiq/actor'
 require 'sidekiq/processor'
 require 'sidekiq/fetch'
+require 'thread'
 
 module Sidekiq
 
   ##
-  # The main router in the system.  This
-  # manages the processor state and accepts messages
-  # from Redis to be dispatched to an idle processor.
+  # The Manager is the central coordination point in Sidekiq, controlling
+  # the lifecycle of the Processors and feeding them jobs as necessary.
+  #
+  # Tasks:
+  #
+  # 1. start: Spin up Processors.
+  # 3. processor_died: Handle job failure, throw away Processor, create new one.
+  # 4. quiet: shutdown idle Processors.
+  # 5. stop: hard stop the Processors by deadline.
+  #
+  # Note that only the last task requires its own Thread since it has to monitor
+  # the shutdown process.  The other tasks are performed by other threads.
   #
   class Manager
     include Util
-    include Actor
-    trap_exit :processor_died
 
-    attr_reader :ready
-    attr_reader :busy
-    attr_accessor :fetcher
+    attr_reader :workers
+    attr_reader :options
 
-    SPIN_TIME_FOR_GRACEFUL_SHUTDOWN = 1
-    JVM_RESERVED_SIGNALS = ['USR1', 'USR2'] # Don't Process#kill if we get these signals via the API
-
-    def initialize(condvar, options={})
+    def initialize(options={})
       logger.debug { options.inspect }
       @options = options
       @count = options[:concurrency] || 25
-      @done_callback = nil
-      @finished = condvar
+      raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
 
-      @in_progress = {}
-      @threads = {}
       @done = false
-      @busy = []
-      @ready = @count.times.map do
-        p = Processor.new_link(current_actor)
-        p.proxy_id = p.object_id
-        p
+      @workers = Set.new
+      @count.times do
+        @workers << Processor.new(self)
       end
+      @plock = Mutex.new
     end
 
-    def stop(options={})
-      watchdog('Manager#stop died') do
-        should_shutdown = options[:shutdown]
-        timeout = options[:timeout]
-
-        @done = true
-
-        logger.info { "Terminating #{@ready.size} quiet workers" }
-        @ready.each { |x| x.terminate if x.alive? }
-        @ready.clear
-
-        return if clean_up_for_graceful_shutdown
-
-        hard_shutdown_in timeout if should_shutdown
+    def start
+      @workers.each do |x|
+        x.start
       end
     end
 
-    def clean_up_for_graceful_shutdown
-      if @busy.empty?
-        shutdown
-        return true
-      end
+    def quiet
+      return if @done
+      @done = true
 
-      after(SPIN_TIME_FOR_GRACEFUL_SHUTDOWN) { clean_up_for_graceful_shutdown }
-      false
+      logger.info { "Terminating quiet workers" }
+      @workers.each { |x| x.terminate }
+      fire_event(:quiet, true)
     end
 
-    def start
-      @ready.each { dispatch }
-    end
+    def stop(deadline)
+      quiet
+      fire_event(:shutdown, true)
 
-    def when_done(&blk)
-      @done_callback = blk
-    end
+      # some of the shutdown events can be async,
+      # we don't have any way to know when they're done but
+      # give them a little time to take effect
+      sleep 0.5
+      return if @workers.empty?
 
-    def processor_done(processor)
-      watchdog('Manager#processor_done died') do
-        @done_callback.call(processor) if @done_callback
-        @in_progress.delete(processor.object_id)
-        @threads.delete(processor.object_id)
-        @busy.delete(processor)
-        if stopped?
-          processor.terminate if processor.alive?
-          shutdown if @busy.empty?
-        else
-          @ready << processor if processor.alive?
-        end
-        dispatch
+      logger.info { "Pausing to allow workers to finish..." }
+      remaining = deadline - Time.now
+      while remaining > 0.5
+        return if @workers.empty?
+        sleep 0.5
+        remaining = deadline - Time.now
       end
-    end
+      return if @workers.empty?
 
-    def processor_died(processor, reason)
-      watchdog("Manager#processor_died died") do
-        @in_progress.delete(processor.object_id)
-        @threads.delete(processor.object_id)
-        @busy.delete(processor)
-
-        unless stopped?
-          p = Processor.new_link(current_actor)
-          p.proxy_id = p.object_id
-          @ready << p
-          dispatch
-        else
-          shutdown if @busy.empty?
-        end
-      end
+      hard_shutdown
     end
 
-    def assign(work)
-      watchdog("Manager#assign died") do
-        if stopped?
-          # Race condition between Manager#stop if Fetcher
-          # is blocked on redis and gets a message after
-          # all the ready Processors have been stopped.
-          # Push the message back to redis.
-          work.requeue
-        else
-          processor = @ready.pop
-          @in_progress[processor.object_id] = work
-          @busy << processor
-          processor.async.process(work)
-        end
+    def processor_stopped(processor)
+      @plock.synchronize do
+        @workers.delete(processor)
       end
     end
 
-    # A hack worthy of Rube Goldberg.  We need to be able
-    # to hard stop a working thread.  But there's no way for us to
-    # get handle to the underlying thread performing work for a processor
-    # so we have it call us and tell us.
-    def real_thread(proxy_id, thr)
-      @threads[proxy_id] = thr
-    end
-
-    PROCTITLES = [
-      proc { 'sidekiq'.freeze },
-      proc { Sidekiq::VERSION },
-      proc { |mgr, data| data['tag'] },
-      proc { |mgr, data| "[#{mgr.busy.size} of #{data['concurrency']} busy]" },
-      proc { |mgr, data| "stopping" if mgr.stopped? },
-    ]
-
-    def heartbeat(key, data, json)
-      results = PROCTITLES.map {|x| x.(self, data) }
-      results.compact!
-      $0 = results.join(' ')
-
-      ❤(key, json)
-      after(5) do
-        heartbeat(key, data, json)
+    def processor_died(processor, reason)
+      @plock.synchronize do
+        @workers.delete(processor)
+        unless @done
+          p = Processor.new(self)
+          @workers << p
+          p.start
+        end
       end
     end
 
@@ -159,77 +100,34 @@ module Sidekiq
 
     private
 
-    def ❤(key, json)
-      begin
-        _, _, _, msg = Sidekiq.redis do |conn|
-          conn.multi do
-            conn.sadd('processes', key)
-            conn.hmset(key, 'info', json, 'busy', @busy.size, 'beat', Time.now.to_f)
-            conn.expire(key, 60)
-            conn.rpop("#{key}-signals")
-          end
-        end
-
-        return unless msg
-
-        if JVM_RESERVED_SIGNALS.include?(msg)
-          Sidekiq::CLI.instance.handle_signal(msg)
-        else
-          ::Process.kill(msg, $$)
-        end
-      rescue => e
-        # ignore all redis/network issues
-        logger.error("heartbeat: #{e.message}")
+    def hard_shutdown
+      # We've reached the timeout and we still have busy workers.
+      # They must die but their jobs shall live on.
+      cleanup = nil
+      @plock.synchronize do
+        cleanup = @workers.dup
       end
-    end
 
-    def hard_shutdown_in(delay)
-      logger.info { "Pausing up to #{delay} seconds to allow workers to finish..." }
+      if cleanup.size > 0
+        jobs = cleanup.map {|p| p.job }.compact
 
-      after(delay) do
-        watchdog("Manager#hard_shutdown_in died") do
-          # We've reached the timeout and we still have busy workers.
-          # They must die but their messages shall live on.
-          logger.warn { "Terminating #{@busy.size} busy worker threads" }
-          logger.warn { "Work still in progress #{@in_progress.values.inspect}" }
+        logger.warn { "Terminating #{cleanup.size} busy worker threads" }
+        logger.warn { "Work still in progress #{jobs.inspect}" }
 
-          requeue
-
-          @busy.each do |processor|
-            if processor.alive? && t = @threads.delete(processor.object_id)
-              t.raise Shutdown
-            end
-          end
-
-          @finished.signal
-        end
+        # Re-enqueue unfinished jobs
+        # NOTE: You may notice that we may push a job back to redis before
+        # the worker thread is terminated. This is ok because Sidekiq's
+        # contract says that jobs are run AT LEAST once. Process termination
+        # is delayed until we're certain the jobs are back in Redis because
+        # it is worse to lose a job than to run it twice.
+        strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+        strategy.bulk_requeue(jobs, @options)
       end
-    end
-
-    def dispatch
-      return if stopped?
-      # This is a safety check to ensure we haven't leaked
-      # processors somehow.
-      raise "BUG: No processors, cannot continue!" if @ready.empty? && @busy.empty?
-      raise "No ready processor!?" if @ready.empty?
 
-      @fetcher.async.fetch
-    end
-
-    def shutdown
-      requeue
-      @finished.signal
+      cleanup.each do |processor|
+        processor.kill
+      end
     end
 
-    def requeue
-      # Re-enqueue terminated jobs
-      # NOTE: You may notice that we may push a job back to redis before
-      # the worker thread is terminated. This is ok because Sidekiq's
-      # contract says that jobs are run AT LEAST once. Process termination
-      # is delayed until we're certain the jobs are back in Redis because
-      # it is worse to lose a job than to run it twice.
-      Sidekiq::Fetcher.strategy.bulk_requeue(@in_progress.values, @options)
-      @in_progress.clear
-    end
   end
 end