sidekiq 5.1.3 → 6.4.1

data/Rakefile

@@ -1,8 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.warning = true
-  test.pattern = 'test/**/test_*.rb'
-end
-
-task :default => :test

data/bin/sidekiqctl

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'fileutils'
-
-class Sidekiqctl
-  DEFAULT_KILL_TIMEOUT = 10
-
-  attr_reader :stage, :pidfile, :kill_timeout
-
-  def self.print_usage
-    puts "#{File.basename($0)} - stop a Sidekiq process from the command line."
-    puts
-    puts "Usage: #{File.basename($0)} <command> <pidfile> <kill_timeout>"
-    puts " where <command> is either 'quiet' or 'stop'"
-    puts "       <pidfile> is path to a pidfile"
-    puts "       <kill_timeout> is number of seconds to wait until Sidekiq exits"
-    puts "       (default: #{Sidekiqctl::DEFAULT_KILL_TIMEOUT}), after which Sidekiq will be KILL'd"
-    puts
-    puts "Be sure to set the kill_timeout LONGER than Sidekiq's -t timeout.  If you want"
-    puts "to wait 60 seconds for jobs to finish, use `sidekiq -t 60` and `sidekiqctl stop"
-    puts " path_to_pidfile 61`"
-    puts
-  end
-
-  def initialize(stage, pidfile, timeout)
-    @stage = stage
-    @pidfile = pidfile
-    @kill_timeout = timeout
-
-    done('No pidfile given', :error) if !pidfile
-    done("Pidfile #{pidfile} does not exist", :warn) if !File.exist?(pidfile)
-    done('Invalid pidfile content', :error) if pid == 0
-
-    fetch_process
-
-    begin
-      send(stage)
-    rescue NoMethodError
-      done "Invalid command: #{stage}", :error
-    end
-  end
-
-  def fetch_process
-    Process.kill(0, pid)
-  rescue Errno::ESRCH
-    done "Process doesn't exist", :error
-  # We were not allowed to send a signal, but the process must have existed
-  # when Process.kill() was called.
-  rescue Errno::EPERM
-    return pid
-  end
-
-  def done(msg, error = nil)
-    puts msg
-    exit(exit_signal(error))
-  end
-
-  def exit_signal(error)
-    (error == :error) ? 1 : 0
-  end
-
-  def pid
-    @pid ||= File.read(pidfile).to_i
-  end
-
-  def quiet
-    `kill -TSTP #{pid}`
-  end
-
-  def stop
-    `kill -TERM #{pid}`
-    kill_timeout.times do
-      begin
-        Process.kill(0, pid)
-      rescue Errno::ESRCH
-        FileUtils.rm_f pidfile
-        done 'Sidekiq shut down gracefully.'
-      rescue Errno::EPERM
-        done 'Not permitted to shut down Sidekiq.'
-      end
-      sleep 1
-    end
-    `kill -9 #{pid}`
-    FileUtils.rm_f pidfile
-    done 'Sidekiq shut down forcefully.'
-  end
-  alias_method :shutdown, :stop
-end
-
-if ARGV.length < 2
-  Sidekiqctl.print_usage
-else
-  stage = ARGV[0]
-  pidfile = ARGV[1]
-  timeout = ARGV[2].to_i
-  timeout = Sidekiqctl::DEFAULT_KILL_TIMEOUT if timeout == 0
-
-  Sidekiqctl.new(stage, pidfile, timeout)
-end

data/code_of_conduct.md

@@ -1,50 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of
-fostering an open and welcoming community, we pledge to respect all people who
-contribute through reporting issues, posting feature requests, updating
-documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free
-experience for everyone, regardless of level of experience, gender, gender
-identity and expression, sexual orientation, disability, personal appearance,
-body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic
-  addresses, without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to
-fairly and consistently applying these principles to every aspect of managing
-this project. Project maintainers who do not follow or enforce the Code of
-Conduct may be permanently removed from the project team.
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project maintainer at mperham AT gmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. Maintainers are
-obligated to maintain confidentiality with regard to the reporter of an
-incident.
-
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 1.3.0, available at
-[http://contributor-covenant.org/version/1/3/0/][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/3/0/

data/lib/generators/sidekiq/worker_generator.rb

@@ -1,49 +0,0 @@
-require 'rails/generators/named_base'
-
-module Sidekiq
-  module Generators # :nodoc:
-    class WorkerGenerator < ::Rails::Generators::NamedBase # :nodoc:
-      desc 'This generator creates a Sidekiq Worker in app/workers and a corresponding test'
-
-      check_class_collision suffix: 'Worker'
-
-      def self.default_generator_root
-        File.dirname(__FILE__)
-      end
-
-      def create_worker_file
-        template 'worker.rb.erb', File.join('app/workers', class_path, "#{file_name}_worker.rb")
-      end
-
-      def create_test_file
-        if defined?(RSpec)
-          create_worker_spec
-        else
-          create_worker_test
-        end
-      end
-
-      private
-
-      def create_worker_spec
-        template_file = File.join(
-            'spec/workers',
-            class_path,
-            "#{file_name}_worker_spec.rb"
-        )
-        template 'worker_spec.rb.erb', template_file
-      end
-
-      def create_worker_test
-        template_file = File.join(
-            'test/workers',
-            class_path,
-            "#{file_name}_worker_test.rb"
-        )
-        template 'worker_test.rb.erb', template_file
-      end
-
-
-    end
-  end
-end

data/lib/sidekiq/core_ext.rb

@@ -1 +0,0 @@
-raise "no longer used, will be removed in 5.1"

data/lib/sidekiq/logging.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-require 'time'
-require 'logger'
-require 'fcntl'
-
-module Sidekiq
-  module Logging
-
-    class Pretty < Logger::Formatter
-      SPACE = " "
-
-      # Provide a call() method that returns the formatted message.
-      def call(severity, time, program_name, message)
-        "#{time.utc.iso8601(3)} #{::Process.pid} TID-#{Sidekiq::Logging.tid}#{context} #{severity}: #{message}\n"
-      end
-
-      def context
-        c = Thread.current[:sidekiq_context]
-        " #{c.join(SPACE)}" if c && c.any?
-      end
-    end
-
-    class WithoutTimestamp < Pretty
-      def call(severity, time, program_name, message)
-        "#{::Process.pid} TID-#{Sidekiq::Logging.tid}#{context} #{severity}: #{message}\n"
-      end
-    end
-
-    def self.tid
-      Thread.current['sidekiq_tid'] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
-    end
-
-    def self.job_hash_context(job_hash)
-      # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-      # attribute to expose the underlying thing.
-      klass = job_hash['wrapped'] || job_hash["class"]
-      bid = job_hash['bid']
-      "#{klass} JID-#{job_hash['jid']}#{" BID-#{bid}" if bid}"
-    end
-
-    def self.with_job_hash_context(job_hash, &block)
-      with_context(job_hash_context(job_hash), &block)
-    end
-
-    def self.with_context(msg)
-      Thread.current[:sidekiq_context] ||= []
-      Thread.current[:sidekiq_context] << msg
-      yield
-    ensure
-      Thread.current[:sidekiq_context].pop
-    end
-
-    def self.initialize_logger(log_target = STDOUT)
-      oldlogger = defined?(@logger) ? @logger : nil
-      @logger = Logger.new(log_target)
-      @logger.level = Logger::INFO
-      @logger.formatter = ENV['DYNO'] ? WithoutTimestamp.new : Pretty.new
-      oldlogger.close if oldlogger && !$TESTING # don't want to close testing's STDOUT logging
-      @logger
-    end
-
-    def self.logger
-      defined?(@logger) ? @logger : initialize_logger
-    end
-
-    def self.logger=(log)
-      @logger = (log ? log : Logger.new(File::NULL))
-    end
-
-    # This reopens ALL logfiles in the process that have been rotated
-    # using logrotate(8) (without copytruncate) or similar tools.
-    # A +File+ object is considered for reopening if it is:
-    #   1) opened with the O_APPEND and O_WRONLY flags
-    #   2) the current open file handle does not match its original open path
-    #   3) unbuffered (as far as userspace buffering goes, not O_SYNC)
-    # Returns the number of files reopened
-    def self.reopen_logs
-      to_reopen = []
-      append_flags = File::WRONLY | File::APPEND
-
-      ObjectSpace.each_object(File) do |fp|
-        begin
-          if !fp.closed? && fp.stat.file? && fp.sync && (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
-            to_reopen << fp
-          end
-        rescue IOError, Errno::EBADF
-        end
-      end
-
-      nr = 0
-      to_reopen.each do |fp|
-        orig_st = begin
-          fp.stat
-        rescue IOError, Errno::EBADF
-          next
-        end
-
-        begin
-          b = File.stat(fp.path)
-          next if orig_st.ino == b.ino && orig_st.dev == b.dev
-        rescue Errno::ENOENT
-        end
-
-        begin
-          File.open(fp.path, 'a') { |tmpfp| fp.reopen(tmpfp) }
-          fp.sync = true
-          nr += 1
-        rescue IOError, Errno::EBADF
-          # not much we can do...
-        end
-      end
-      nr
-    rescue RuntimeError => ex
-      # RuntimeError: ObjectSpace is disabled; each_object will only work with Class, pass -X+O to enable
-      puts "Unable to reopen logs: #{ex.message}"
-    end
-
-    def logger
-      Sidekiq::Logging.logger
-    end
-  end
-end

data/lib/sidekiq/middleware/server/active_record.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-module Sidekiq
-  module Middleware
-    module Server
-      class ActiveRecord
-
-        def initialize
-          # With Rails 5+ we must use the Reloader **always**.
-          # The reloader handles code loading and db connection management.
-          if defined?(::Rails) && ::Rails::VERSION::MAJOR >= 5
-            raise ArgumentError, "Rails 5 no longer needs or uses the ActiveRecord middleware."
-          end
-        end
-
-        def call(*args)
-          yield
-        ensure
-          ::ActiveRecord::Base.clear_active_connections!
-        end
-      end
-    end
-  end
-end