sidekiq 6.1.1

data/lib/sidekiq/cli.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+$stdout.sync = true
+
+require "yaml"
+require "singleton"
+require "optparse"
+require "erb"
+require "fileutils"
+
+require "sidekiq"
+require "sidekiq/launcher"
+require "sidekiq/util"
+
+module Sidekiq
+  class CLI
+    include Util
+    include Singleton unless $TESTING
+
+    attr_accessor :launcher
+    attr_accessor :environment
+
+    def parse(args = ARGV)
+      setup_options(args)
+      initialize_logger
+      validate!
+    end
+
+    def jruby?
+      defined?(::JRUBY_VERSION)
+    end
+
+    # Code within this method is not tested because it alters
+    # global process state irreversibly.  PRs which improve the
+    # test coverage of Sidekiq::CLI are welcomed.
+    def run(boot_app: true)
+      boot_application if boot_app
+
+      if environment == "development" && $stdout.tty? && Sidekiq.log_formatter.is_a?(Sidekiq::Logger::Formatters::Pretty)
+        print_banner
+      end
+      logger.info "Booted Rails #{::Rails.version} application in #{environment} environment" if rails_app?
+
+      self_read, self_write = IO.pipe
+      sigs = %w[INT TERM TTIN TSTP]
+      # USR1 and USR2 don't work on the JVM
+      sigs << "USR2" unless jruby?
+      sigs.each do |sig|
+        trap sig do
+          self_write.puts(sig)
+        end
+      rescue ArgumentError
+        puts "Signal #{sig} not supported"
+      end
+
+      logger.info "Running in #{RUBY_DESCRIPTION}"
+      logger.info Sidekiq::LICENSE
+      logger.info "Upgrade to Sidekiq Pro for more features and support: https://sidekiq.org" unless defined?(::Sidekiq::Pro)
+
+      # touch the connection pool so it is created before we
+      # fire startup and start multithreading.
+      ver = Sidekiq.redis_info["redis_version"]
+      raise "You are connecting to Redis v#{ver}, Sidekiq requires Redis v4.0.0 or greater" if ver < "4"
+
+      # Since the user can pass us a connection pool explicitly in the initializer, we
+      # need to verify the size is large enough or else Sidekiq's performance is dramatically slowed.
+      cursize = Sidekiq.redis_pool.size
+      needed = Sidekiq.options[:concurrency] + 2
+      raise "Your pool of #{cursize} Redis connections is too small, please increase the size to at least #{needed}" if cursize < needed
+
+      # cache process identity
+      Sidekiq.options[:identity] = identity
+
+      # Touch middleware so it isn't lazy loaded by multiple threads, #3043
+      Sidekiq.server_middleware
+
+      # Before this point, the process is initializing with just the main thread.
+      # Starting here the process will now have multiple threads running.
+      fire_event(:startup, reverse: false, reraise: true)
+
+      logger.debug { "Client Middleware: #{Sidekiq.client_middleware.map(&:klass).join(", ")}" }
+      logger.debug { "Server Middleware: #{Sidekiq.server_middleware.map(&:klass).join(", ")}" }
+
+      launch(self_read)
+    end
+
+    def launch(self_read)
+      if environment == "development" && $stdout.tty?
+        logger.info "Starting processing, hit Ctrl-C to stop"
+      end
+
+      @launcher = Sidekiq::Launcher.new(options)
+
+      begin
+        launcher.run
+
+        while (readable_io = IO.select([self_read]))
+          signal = readable_io.first[0].gets.strip
+          handle_signal(signal)
+        end
+      rescue Interrupt
+        logger.info "Shutting down"
+        launcher.stop
+        logger.info "Bye!"
+
+        # Explicitly exit so busy Processor threads won't block process shutdown.
+        #
+        # NB: slow at_exit handlers will prevent a timely exit if they take
+        # a while to run. If Sidekiq is getting here but the process isn't exiting,
+        # use the TTIN signal to determine where things are stuck.
+        exit(0)
+      end
+    end
+
+    def self.w
+      "\e[37m"
+    end
+
+    def self.r
+      "\e[31m"
+    end
+
+    def self.b
+      "\e[30m"
+    end
+
+    def self.reset
+      "\e[0m"
+    end
+
+    def self.banner
+      %{
+      #{w}         m,
+      #{w}         `$b
+      #{w}    .ss,  $$:         .,d$
+      #{w}    `$$P,d$P'    .,md$P"'
+      #{w}     ,$$$$$b#{b}/#{w}md$$$P^'
+      #{w}   .d$$$$$$#{b}/#{w}$$$P'
+      #{w}   $$^' `"#{b}/#{w}$$$'       #{r}____  _     _      _    _
+      #{w}   $:     ,$$:      #{r} / ___|(_) __| | ___| | _(_) __ _
+      #{w}   `b     :$$       #{r} \\___ \\| |/ _` |/ _ \\ |/ / |/ _` |
+      #{w}          $$:        #{r} ___) | | (_| |  __/   <| | (_| |
+      #{w}          $$         #{r}|____/|_|\\__,_|\\___|_|\\_\\_|\\__, |
+      #{w}        .d$$          #{r}                             |_|
+      #{reset}}
+    end
+
+    SIGNAL_HANDLERS = {
+      # Ctrl-C in terminal
+      "INT" => ->(cli) { raise Interrupt },
+      # TERM is the signal that Sidekiq must exit.
+      # Heroku sends TERM and then waits 30 seconds for process to exit.
+      "TERM" => ->(cli) { raise Interrupt },
+      "TSTP" => ->(cli) {
+        Sidekiq.logger.info "Received TSTP, no longer accepting new work"
+        cli.launcher.quiet
+      },
+      "TTIN" => ->(cli) {
+        Thread.list.each do |thread|
+          Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread.name}"
+          if thread.backtrace
+            Sidekiq.logger.warn thread.backtrace.join("\n")
+          else
+            Sidekiq.logger.warn "<no backtrace available>"
+          end
+        end
+      }
+    }
+    UNHANDLED_SIGNAL_HANDLER = ->(cli) { Sidekiq.logger.info "No signal handler registered, ignoring" }
+    SIGNAL_HANDLERS.default = UNHANDLED_SIGNAL_HANDLER
+
+    def handle_signal(sig)
+      Sidekiq.logger.debug "Got #{sig} signal"
+      SIGNAL_HANDLERS[sig].call(self)
+    end
+
+    private
+
+    def print_banner
+      puts "\e[31m"
+      puts Sidekiq::CLI.banner
+      puts "\e[0m"
+    end
+
+    def set_environment(cli_env)
+      # See #984 for discussion.
+      # APP_ENV is now the preferred ENV term since it is not tech-specific.
+      # Both Sinatra 2.0+ and Sidekiq support this term.
+      # RAILS_ENV and RACK_ENV are there for legacy support.
+      @environment = cli_env || ENV["APP_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    end
+
+    def symbolize_keys_deep!(hash)
+      hash.keys.each do |k|
+        symkey = k.respond_to?(:to_sym) ? k.to_sym : k
+        hash[symkey] = hash.delete k
+        symbolize_keys_deep! hash[symkey] if hash[symkey].is_a? Hash
+      end
+    end
+
+    alias_method :die, :exit
+    alias_method :☠, :exit
+
+    def setup_options(args)
+      # parse CLI options
+      opts = parse_options(args)
+
+      set_environment opts[:environment]
+
+      # check config file presence
+      if opts[:config_file]
+        unless File.exist?(opts[:config_file])
+          raise ArgumentError, "No such file #{opts[:config_file]}"
+        end
+      else
+        config_dir = if File.directory?(opts[:require].to_s)
+          File.join(opts[:require], "config")
+        else
+          File.join(options[:require], "config")
+        end
+
+        %w[sidekiq.yml sidekiq.yml.erb].each do |config_file|
+          path = File.join(config_dir, config_file)
+          opts[:config_file] ||= path if File.exist?(path)
+        end
+      end
+
+      # parse config file options
+      opts = parse_config(opts[:config_file]).merge(opts) if opts[:config_file]
+
+      # set defaults
+      opts[:queues] = ["default"] if opts[:queues].nil?
+      opts[:concurrency] = Integer(ENV["RAILS_MAX_THREADS"]) if opts[:concurrency].nil? && ENV["RAILS_MAX_THREADS"]
+
+      # merge with defaults
+      options.merge!(opts)
+    end
+
+    def options
+      Sidekiq.options
+    end
+
+    def boot_application
+      ENV["RACK_ENV"] = ENV["RAILS_ENV"] = environment
+
+      if File.directory?(options[:require])
+        require "rails"
+        if ::Rails::VERSION::MAJOR < 5
+          raise "Sidekiq no longer supports this version of Rails"
+        else
+          require "sidekiq/rails"
+          require File.expand_path("#{options[:require]}/config/environment.rb")
+        end
+        options[:tag] ||= default_tag
+      else
+        require options[:require]
+      end
+    end
+
+    def default_tag
+      dir = ::Rails.root
+      name = File.basename(dir)
+      prevdir = File.dirname(dir) # Capistrano release directory?
+      if name.to_i != 0 && prevdir
+        if File.basename(prevdir) == "releases"
+          return File.basename(File.dirname(prevdir))
+        end
+      end
+      name
+    end
+
+    def validate!
+      if !File.exist?(options[:require]) ||
+          (File.directory?(options[:require]) && !File.exist?("#{options[:require]}/config/application.rb"))
+        logger.info "=================================================================="
+        logger.info "  Please point Sidekiq to a Rails application or a Ruby file  "
+        logger.info "  to load your worker classes with -r [DIR|FILE]."
+        logger.info "=================================================================="
+        logger.info @parser
+        die(1)
+      end
+
+      [:concurrency, :timeout].each do |opt|
+        raise ArgumentError, "#{opt}: #{options[opt]} is not a valid value" if options.key?(opt) && options[opt].to_i <= 0
+      end
+    end
+
+    def parse_options(argv)
+      opts = {}
+      @parser = option_parser(opts)
+      @parser.parse!(argv)
+      opts
+    end
+
+    def option_parser(opts)
+      parser = OptionParser.new { |o|
+        o.on "-c", "--concurrency INT", "processor threads to use" do |arg|
+          opts[:concurrency] = Integer(arg)
+        end
+
+        o.on "-d", "--daemon", "Daemonize process" do |arg|
+          puts "ERROR: Daemonization mode was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
+        end
+
+        o.on "-e", "--environment ENV", "Application environment" do |arg|
+          opts[:environment] = arg
+        end
+
+        o.on "-g", "--tag TAG", "Process tag for procline" do |arg|
+          opts[:tag] = arg
+        end
+
+        o.on "-q", "--queue QUEUE[,WEIGHT]", "Queues to process with optional weights" do |arg|
+          queue, weight = arg.split(",")
+          parse_queue opts, queue, weight
+        end
+
+        o.on "-r", "--require [PATH|DIR]", "Location of Rails application with workers or file to require" do |arg|
+          opts[:require] = arg
+        end
+
+        o.on "-t", "--timeout NUM", "Shutdown timeout" do |arg|
+          opts[:timeout] = Integer(arg)
+        end
+
+        o.on "-v", "--verbose", "Print more verbose output" do |arg|
+          opts[:verbose] = arg
+        end
+
+        o.on "-C", "--config PATH", "path to YAML config file" do |arg|
+          opts[:config_file] = arg
+        end
+
+        o.on "-L", "--logfile PATH", "path to writable logfile" do |arg|
+          puts "ERROR: Logfile redirection was removed in Sidekiq 6.0, Sidekiq will only log to STDOUT"
+        end
+
+        o.on "-P", "--pidfile PATH", "path to pidfile" do |arg|
+          puts "ERROR: PID file creation was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
+        end
+
+        o.on "-V", "--version", "Print version and exit" do |arg|
+          puts "Sidekiq #{Sidekiq::VERSION}"
+          die(0)
+        end
+      }
+
+      parser.banner = "sidekiq [options]"
+      parser.on_tail "-h", "--help", "Show help" do
+        logger.info parser
+        die 1
+      end
+
+      parser
+    end
+
+    def initialize_logger
+      Sidekiq.logger.level = ::Logger::DEBUG if options[:verbose]
+    end
+
+    def parse_config(path)
+      opts = YAML.load(ERB.new(File.read(path)).result) || {}
+
+      if opts.respond_to? :deep_symbolize_keys!
+        opts.deep_symbolize_keys!
+      else
+        symbolize_keys_deep!(opts)
+      end
+
+      opts = opts.merge(opts.delete(environment.to_sym) || {})
+      opts.delete(:strict)
+
+      parse_queues(opts, opts.delete(:queues) || [])
+
+      opts
+    end
+
+    def parse_queues(opts, queues_and_weights)
+      queues_and_weights.each { |queue_and_weight| parse_queue(opts, *queue_and_weight) }
+    end
+
+    def parse_queue(opts, queue, weight = nil)
+      opts[:queues] ||= []
+      opts[:strict] = true if opts[:strict].nil?
+      raise ArgumentError, "queues: #{queue} cannot be defined twice" if opts[:queues].include?(queue)
+      [weight.to_i, 1].max.times { opts[:queues] << queue }
+      opts[:strict] = false if weight.to_i > 0
+    end
+
+    def rails_app?
+      defined?(::Rails) && ::Rails.respond_to?(:application)
+    end
+  end
+end
+
+require "sidekiq/systemd"

data/lib/sidekiq/client.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "sidekiq/middleware/chain"
+
+module Sidekiq
+  class Client
+    ##
+    # Define client-side middleware:
+    #
+    #   client = Sidekiq::Client.new
+    #   client.middleware do |chain|
+    #     chain.use MyClientMiddleware
+    #   end
+    #   client.push('class' => 'SomeWorker', 'args' => [1,2,3])
+    #
+    # All client instances default to the globally-defined
+    # Sidekiq.client_middleware but you can change as necessary.
+    #
+    def middleware(&block)
+      @chain ||= Sidekiq.client_middleware
+      if block_given?
+        @chain = @chain.dup
+        yield @chain
+      end
+      @chain
+    end
+
+    attr_accessor :redis_pool
+
+    # Sidekiq::Client normally uses the default Redis pool but you may
+    # pass a custom ConnectionPool if you want to shard your
+    # Sidekiq jobs across several Redis instances (for scalability
+    # reasons, e.g.)
+    #
+    #   Sidekiq::Client.new(ConnectionPool.new { Redis.new })
+    #
+    # Generally this is only needed for very large Sidekiq installs processing
+    # thousands of jobs per second.  I don't recommend sharding unless you
+    # cannot scale any other way (e.g. splitting your app into smaller apps).
+    def initialize(redis_pool = nil)
+      @redis_pool = redis_pool || Thread.current[:sidekiq_via_pool] || Sidekiq.redis_pool
+    end
+
+    ##
+    # The main method used to push a job to Redis.  Accepts a number of options:
+    #
+    #   queue - the named queue to use, default 'default'
+    #   class - the worker class to call, required
+    #   args - an array of simple arguments to the perform method, must be JSON-serializable
+    #   at - timestamp to schedule the job (optional), must be Numeric (e.g. Time.now.to_f)
+    #   retry - whether to retry this job if it fails, default true or an integer number of retries
+    #   backtrace - whether to save any error backtrace, default false
+    #
+    # If class is set to the class name, the jobs' options will be based on Sidekiq's default
+    # worker options. Otherwise, they will be based on the job class's options.
+    #
+    # Any options valid for a worker class's sidekiq_options are also available here.
+    #
+    # All options must be strings, not symbols.  NB: because we are serializing to JSON, all
+    # symbols in 'args' will be converted to strings.  Note that +backtrace: true+ can take quite a bit of
+    # space in Redis; a large volume of failing jobs can start Redis swapping if you aren't careful.
+    #
+    # Returns a unique Job ID.  If middleware stops the job, nil will be returned instead.
+    #
+    # Example:
+    #   push('queue' => 'my_queue', 'class' => MyWorker, 'args' => ['foo', 1, :bat => 'bar'])
+    #
+    def push(item)
+      normed = normalize_item(item)
+      payload = process_single(item["class"], normed)
+
+      if payload
+        raw_push([payload])
+        payload["jid"]
+      end
+    end
+
+    ##
+    # Push a large number of jobs to Redis. This method cuts out the redis
+    # network round trip latency.  I wouldn't recommend pushing more than
+    # 1000 per call but YMMV based on network quality, size of job args, etc.
+    # A large number of jobs can cause a bit of Redis command processing latency.
+    #
+    # Takes the same arguments as #push except that args is expected to be
+    # an Array of Arrays.  All other keys are duplicated for each job.  Each job
+    # is run through the client middleware pipeline and each job gets its own Job ID
+    # as normal.
+    #
+    # Returns an array of the of pushed jobs' jids.  The number of jobs pushed can be less
+    # than the number given if the middleware stopped processing for one or more jobs.
+    def push_bulk(items)
+      args = items["args"]
+      raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" unless args.is_a?(Array) && args.all?(Array)
+      return [] if args.empty? # no jobs to push
+
+      at = items.delete("at")
+      raise ArgumentError, "Job 'at' must be a Numeric or an Array of Numeric timestamps" if at && (Array(at).empty? || !Array(at).all?(Numeric))
+      raise ArgumentError, "Job 'at' Array must have same size as 'args' Array" if at.is_a?(Array) && at.size != args.size
+
+      normed = normalize_item(items)
+      payloads = args.map.with_index { |job_args, index|
+        copy = normed.merge("args" => job_args, "jid" => SecureRandom.hex(12), "enqueued_at" => Time.now.to_f)
+        copy["at"] = (at.is_a?(Array) ? at[index] : at) if at
+
+        result = process_single(items["class"], copy)
+        result || nil
+      }.compact
+
+      raw_push(payloads) unless payloads.empty?
+      payloads.collect { |payload| payload["jid"] }
+    end
+
+    # Allows sharding of jobs across any number of Redis instances.  All jobs
+    # defined within the block will use the given Redis connection pool.
+    #
+    #   pool = ConnectionPool.new { Redis.new }
+    #   Sidekiq::Client.via(pool) do
+    #     SomeWorker.perform_async(1,2,3)
+    #     SomeOtherWorker.perform_async(1,2,3)
+    #   end
+    #
+    # Generally this is only needed for very large Sidekiq installs processing
+    # thousands of jobs per second.  I do not recommend sharding unless
+    # you cannot scale any other way (e.g. splitting your app into smaller apps).
+    def self.via(pool)
+      raise ArgumentError, "No pool given" if pool.nil?
+      current_sidekiq_pool = Thread.current[:sidekiq_via_pool]
+      Thread.current[:sidekiq_via_pool] = pool
+      yield
+    ensure
+      Thread.current[:sidekiq_via_pool] = current_sidekiq_pool
+    end
+
+    class << self
+      def push(item)
+        new.push(item)
+      end
+
+      def push_bulk(items)
+        new.push_bulk(items)
+      end
+
+      # Resque compatibility helpers.  Note all helpers
+      # should go through Worker#client_push.
+      #
+      # Example usage:
+      #   Sidekiq::Client.enqueue(MyWorker, 'foo', 1, :bat => 'bar')
+      #
+      # Messages are enqueued to the 'default' queue.
+      #
+      def enqueue(klass, *args)
+        klass.client_push("class" => klass, "args" => args)
+      end
+
+      # Example usage:
+      #   Sidekiq::Client.enqueue_to(:queue_name, MyWorker, 'foo', 1, :bat => 'bar')
+      #
+      def enqueue_to(queue, klass, *args)
+        klass.client_push("queue" => queue, "class" => klass, "args" => args)
+      end
+
+      # Example usage:
+      #   Sidekiq::Client.enqueue_to_in(:queue_name, 3.minutes, MyWorker, 'foo', 1, :bat => 'bar')
+      #
+      def enqueue_to_in(queue, interval, klass, *args)
+        int = interval.to_f
+        now = Time.now.to_f
+        ts = (int < 1_000_000_000 ? now + int : int)
+
+        item = {"class" => klass, "args" => args, "at" => ts, "queue" => queue}
+        item.delete("at") if ts <= now
+
+        klass.client_push(item)
+      end
+
+      # Example usage:
+      #   Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 'foo', 1, :bat => 'bar')
+      #
+      def enqueue_in(interval, klass, *args)
+        klass.perform_in(interval, *args)
+      end
+    end
+
+    private
+
+    def raw_push(payloads)
+      @redis_pool.with do |conn|
+        conn.multi do
+          atomic_push(conn, payloads)
+        end
+      end
+      true
+    end
+
+    def atomic_push(conn, payloads)
+      if payloads.first.key?("at")
+        conn.zadd("schedule", payloads.map { |hash|
+          at = hash.delete("at").to_s
+          [at, Sidekiq.dump_json(hash)]
+        })
+      else
+        queue = payloads.first["queue"]
+        now = Time.now.to_f
+        to_push = payloads.map { |entry|
+          entry["enqueued_at"] = now
+          Sidekiq.dump_json(entry)
+        }
+        conn.sadd("queues", queue)
+        conn.lpush("queue:#{queue}", to_push)
+      end
+    end
+
+    def process_single(worker_class, item)
+      queue = item["queue"]
+
+      middleware.invoke(worker_class, item, queue, @redis_pool) do
+        item
+      end
+    end
+
+    def validate(item)
+      raise(ArgumentError, "Job must be a Hash with 'class' and 'args' keys: `#{item}`") unless item.is_a?(Hash) && item.key?("class") && item.key?("args")
+      raise(ArgumentError, "Job args must be an Array: `#{item}`") unless item["args"].is_a?(Array)
+      raise(ArgumentError, "Job class must be either a Class or String representation of the class name: `#{item}`") unless item["class"].is_a?(Class) || item["class"].is_a?(String)
+      raise(ArgumentError, "Job 'at' must be a Numeric timestamp: `#{item}`") if item.key?("at") && !item["at"].is_a?(Numeric)
+      raise(ArgumentError, "Job tags must be an Array: `#{item}`") if item["tags"] && !item["tags"].is_a?(Array)
+    end
+
+    def normalize_item(item)
+      # 6.0.0 push_bulk bug, #4321
+      # TODO Remove after a while...
+      item.delete("at") if item.key?("at") && item["at"].nil?
+
+      validate(item)
+      # raise(ArgumentError, "Arguments must be native JSON types, see https://github.com/mperham/sidekiq/wiki/Best-Practices") unless JSON.load(JSON.dump(item['args'])) == item['args']
+
+      # merge in the default sidekiq_options for the item's class and/or wrapped element
+      # this allows ActiveJobs to control sidekiq_options too.
+      defaults = normalized_hash(item["class"])
+      defaults = defaults.merge(item["wrapped"].get_sidekiq_options) if item["wrapped"].respond_to?("get_sidekiq_options")
+      item = defaults.merge(item)
+
+      raise(ArgumentError, "Job must include a valid queue name") if item["queue"].nil? || item["queue"] == ""
+
+      item["class"] = item["class"].to_s
+      item["queue"] = item["queue"].to_s
+      item["jid"] ||= SecureRandom.hex(12)
+      item["created_at"] ||= Time.now.to_f
+
+      item
+    end
+
+    def normalized_hash(item_class)
+      if item_class.is_a?(Class)
+        raise(ArgumentError, "Message must include a Sidekiq::Worker class, not class name: #{item_class.ancestors.inspect}") unless item_class.respond_to?("get_sidekiq_options")
+        item_class.get_sidekiq_options
+      else
+        Sidekiq.default_worker_options
+      end
+    end
+  end
+end