module Sidekiq

# File lib/sidekiq.rb, line 106
def self.[](key)
  @config[key]
end

# File lib/sidekiq.rb, line 110
def self.[]=(key, val)
  @config[key] = val
end

# File lib/sidekiq.rb, line 303
def self.average_scheduled_poll_interval=(interval)
  self[:average_scheduled_poll_interval] = interval
end

# File lib/sidekiq.rb, line 209
def self.client_middleware
  @client_chain ||= Middleware::Chain.new(self)
  yield @client_chain if block_given?
  @client_chain
end

# File lib/sidekiq.rb, line 60
def self.concurrency=(val)
  self[:concurrency] = Integer(val)
end

# File lib/sidekiq.rb, line 151
def self.configure_client
  yield self unless server?
end

# File lib/sidekiq.rb, line 141
def self.configure_server
  yield self if server?
end

# File lib/sidekiq.rb, line 250
def self.death_handlers
  self[:death_handlers]
end

# File lib/sidekiq.rb, line 84
def self.default_error_handler(ex, ctx)
  logger.warn(dump_json(ctx)) unless ctx.empty?
  logger.warn("#{ex.class.name}: #{ex.message}")
  logger.warn(ex.backtrace.join("\n")) unless ex.backtrace.nil?
end

# File lib/sidekiq.rb, line 237
def self.default_job_options
  @default_job_options ||= {"retry" => true, "queue" => "default"}
end

# File lib/sidekiq.rb, line 229
def self.default_job_options=(hash)
  @default_job_options = default_job_options.merge(hash.transform_keys(&:to_s))
end

# File lib/sidekiq.rb, line 221
def self.default_server_middleware
  Middleware::Chain.new(self)
end

# File lib/sidekiq.rb, line 233
def self.default_worker_options # deprecated
  @default_job_options ||= {"retry" => true, "queue" => "default"}
end

# File lib/sidekiq.rb, line 225
def self.default_worker_options=(hash) # deprecated
  @default_job_options = default_job_options.merge(hash.transform_keys(&:to_s))
end

# File lib/sidekiq.rb, line 258
def self.dump_json(object)
  JSON.generate(object)
end

# File lib/sidekiq.rb, line 294
def self.ent?
  defined?(Sidekiq::Enterprise)
end

# File lib/sidekiq.rb, line 314
def self.error_handlers
  self[:error_handlers]
end

# File lib/sidekiq.rb, line 118
def self.fetch(*args, &block)
  @config.fetch(*args, &block)
end

# File lib/sidekiq.rb, line 122
def self.handle_exception(ex, ctx = {})
  self[:error_handlers].each do |handler|
    handler.call(ex, ctx)
  rescue => ex
    logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
    logger.error ex
    logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
  end
end

# File lib/sidekiq.rb, line 254
def self.load_json(string)
  JSON.parse(string)
end

# File lib/sidekiq.rb, line 262
def self.log_formatter
  @log_formatter ||= if ENV["DYNO"]
    Sidekiq::Logger::Formatters::WithoutTimestamp.new
  else
    Sidekiq::Logger::Formatters::Pretty.new
  end
end

# File lib/sidekiq.rb, line 270
def self.log_formatter=(log_formatter)
  @log_formatter = log_formatter
  logger.formatter = log_formatter
end

# File lib/sidekiq.rb, line 275
def self.logger
  @logger ||= Sidekiq::Logger.new($stdout, level: :info)
end

# File lib/sidekiq.rb, line 279
def self.logger=(logger)
  if logger.nil?
    self.logger.level = Logger::FATAL
    return self.logger
  end

  logger.extend(Sidekiq::LoggingUtils)

  @logger = logger
end

# File lib/sidekiq.rb, line 114
def self.merge!(hash)
  @config.merge!(hash)
end

# File lib/sidekiq.rb, line 326
def self.on(event, &block)
  raise ArgumentError, "Symbols only please: #{event}" unless event.is_a?(Symbol)
  raise ArgumentError, "Invalid event name: #{event}" unless self[:lifecycle_events].key?(event)
  self[:lifecycle_events][event] << block
end

# File lib/sidekiq.rb, line 96
def self.options
  logger.warn "`config.options[:key] = value` is deprecated, use `config[:key] = value`: #{caller(1..2)}"
  @config
end

# File lib/sidekiq.rb, line 101
def self.options=(opts)
  logger.warn "config.options = hash` is deprecated, use `config.merge!(hash)`: #{caller(1..2)}"
  @config = opts
end

# File lib/sidekiq.rb, line 290
def self.pro?
  defined?(Sidekiq::Pro)
end

# File lib/sidekiq.rb, line 73
def self.queues=(val)
  self[:queues] = Array(val).each_with_object([]) do |qstr, memo|
    name, weight = qstr.split(",")
    self[:strict] = false if weight.to_i > 0
    [weight.to_i, 1].max.times do
      memo << name
    end
  end
end

# File lib/sidekiq.rb, line 159
def self.redis
  raise ArgumentError, "requires a block" unless block_given?
  redis_pool.with do |conn|
    retryable = true
    begin
      yield conn
    rescue RedisConnection.adapter::BaseError => ex
      # 2550 Failover can cause the server to become a replica, need
      # to disconnect and reopen the socket to get back to the primary.
      # 4495 Use the same logic if we have a "Not enough replicas" error from the primary
      # 4985 Use the same logic when a blocking command is force-unblocked
      # The same retry logic is also used in client.rb
      if retryable && ex.message =~ /READONLY|NOREPLICAS|UNBLOCKED/
        conn.disconnect!
        retryable = false
        retry
      end
      raise
    end
  end
end

# File lib/sidekiq.rb, line 201
def self.redis=(hash)
  @redis = if hash.is_a?(ConnectionPool)
    hash
  else
    RedisConnection.create(hash)
  end
end

# File lib/sidekiq.rb, line 181
def self.redis_info
  redis do |conn|
    # admin commands can't go through redis-namespace starting
    # in redis-namespace 2.0
    if conn.respond_to?(:namespace)
      conn.redis.info
    else
      conn.info
    end
  rescue RedisConnection.adapter::CommandError => ex
    # 2850 return fake version when INFO command has (probably) been renamed
    raise unless /unknown command/.match?(ex.message)
    FAKE_INFO
  end
end

# File lib/sidekiq.rb, line 197
def self.redis_pool
  @redis ||= RedisConnection.create
end

# File lib/sidekiq.rb, line 155
def self.server?
  defined?(Sidekiq::CLI)
end

# File lib/sidekiq.rb, line 215
def self.server_middleware
  @server_chain ||= default_server_middleware
  yield @server_chain if block_given?
  @server_chain
end

# File lib/sidekiq/systemd.rb, line 8
def self.start_watchdog
  usec = Integer(ENV["WATCHDOG_USEC"])
  return Sidekiq.logger.error("systemd Watchdog too fast: " + usec) if usec < 1_000_000

  sec_f = usec / 1_000_000.0
  # "It is recommended that a daemon sends a keep-alive notification message
  # to the service manager every half of the time returned here."
  ping_f = sec_f / 2
  Sidekiq.logger.info "Pinging systemd watchdog every #{ping_f.round(1)} sec"
  Thread.new do
    loop do
      sleep ping_f
      Sidekiq::SdNotify.watchdog
    end
  end
end

# File lib/sidekiq.rb, line 332
def self.strict_args!(mode = :raise)
  self[:on_complex_arguments] = mode
end

# File lib/sidekiq/transaction_aware_client.rb, line 33
def self.transactional_push!
  begin
    require "after_commit_everywhere"
  rescue LoadError
    Sidekiq.logger.error("You need to add after_commit_everywhere to your Gemfile to use Sidekiq's transactional client")
    raise
  end

  default_job_options["client_class"] = Sidekiq::TransactionAwareClient
  Sidekiq::JobUtil::TRANSIENT_ATTRIBUTES << "client_class"
  true
end

# File lib/sidekiq.rb, line 55
def self.❨╯°□°❩╯︵┻━┻
  puts "Calm down, yo."
end