sidekiq 3.4.1 → 7.3.0

data/bin/sidekiqctl

@@ -1,93 +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.getpgid(pid)
-  rescue Errno::ESRCH
-    done "Process doesn't exist", :error
-  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 -USR1 #{pid}`
-  end
-
-  def stop
-    `kill -TERM #{pid}`
-    kill_timeout.times do
-      begin
-        Process.getpgid(pid)
-      rescue Errno::ESRCH
-        FileUtils.rm_f pidfile
-        done 'Sidekiq shut down gracefully.'
-      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/lib/generators/sidekiq/templates/worker_spec.rb.erb

@@ -1,6 +0,0 @@
-require 'rails_helper'
-<% module_namespacing do -%>
-RSpec.describe <%= class_name %>Worker, :type => :worker do
-    pending "add some examples to (or delete) #{__FILE__}"
-end
-<% end -%>

data/lib/generators/sidekiq/templates/worker_test.rb.erb

@@ -1,8 +0,0 @@
-require_relative 'test_helper'
-<% module_namespacing do -%>
-class <%= class_name %>WorkerTest < MiniTest::Unit::TestCase
-    def test_example
-      skip "add some examples to (or delete) #{__FILE__}"
-    end
-end
-<% end -%>

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/actor.rb

@@ -1,39 +0,0 @@
-module Sidekiq
-  module Actor
-
-    module ClassMethods
-      def trap_exit(*args)
-      end
-      def new_link(*args)
-        new(*args)
-      end
-    end
-
-    module InstanceMethods
-      def current_actor
-        self
-      end
-      def after(interval)
-      end
-      def alive?
-        @dead = false unless defined?(@dead)
-        !@dead
-      end
-      def terminate
-        @dead = true
-      end
-      def defer
-        yield
-      end
-    end
-
-    def self.included(klass)
-      if $TESTING
-        klass.__send__(:include, InstanceMethods)
-        klass.__send__(:extend, ClassMethods)
-      else
-        klass.__send__(:include, Celluloid)
-      end
-    end
-  end
-end

data/lib/sidekiq/core_ext.rb

@@ -1,105 +0,0 @@
-begin
-  require 'active_support/core_ext/class/attribute'
-rescue LoadError
-
-  # A dumbed down version of ActiveSupport's
-  # Class#class_attribute helper.
-  class Class
-    def class_attribute(*attrs)
-      instance_writer = true
-
-      attrs.each do |name|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def self.#{name}() nil end
-          def self.#{name}?() !!#{name} end
-
-          def self.#{name}=(val)
-            singleton_class.class_eval do
-              define_method(:#{name}) { val }
-            end
-
-            if singleton_class?
-              class_eval do
-                def #{name}
-                  defined?(@#{name}) ? @#{name} : singleton_class.#{name}
-                end
-              end
-            end
-            val
-          end
-
-          def #{name}
-            defined?(@#{name}) ? @#{name} : self.class.#{name}
-          end
-
-          def #{name}?
-            !!#{name}
-          end
-        RUBY
-
-        attr_writer name if instance_writer
-      end
-    end
-
-    private
-    def singleton_class?
-      ancestors.first != self
-    end
-  end
-end
-
-begin
-  require 'active_support/core_ext/hash/keys'
-  require 'active_support/core_ext/hash/deep_merge'
-rescue LoadError
-  class Hash
-    def stringify_keys
-      keys.each do |key|
-        self[key.to_s] = delete(key)
-      end
-      self
-    end if !{}.respond_to?(:stringify_keys)
-
-    def symbolize_keys
-      keys.each do |key|
-        self[(key.to_sym rescue key) || key] = delete(key)
-      end
-      self
-    end if !{}.respond_to?(:symbolize_keys)
-
-    def deep_merge(other_hash, &block)
-      dup.deep_merge!(other_hash, &block)
-    end if !{}.respond_to?(:deep_merge)
-
-    def deep_merge!(other_hash, &block)
-      other_hash.each_pair do |k,v|
-        tv = self[k]
-        if tv.is_a?(Hash) && v.is_a?(Hash)
-          self[k] = tv.deep_merge(v, &block)
-        else
-          self[k] = block && tv ? block.call(k, tv, v) : v
-        end
-      end
-      self
-    end if !{}.respond_to?(:deep_merge!)
-  end
-end
-
-begin
-  require 'active_support/core_ext/string/inflections'
-rescue LoadError
-  class String
-    def constantize
-      names = self.split('::')
-      names.shift if names.empty? || names.first.empty?
-
-      constant = Object
-      names.each do |name|
-        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-      end
-      constant
-    end
-  end if !"".respond_to?(:constantize)
-end
-
-

data/lib/sidekiq/exception_handler.rb

@@ -1,30 +0,0 @@
-require 'sidekiq'
-
-module Sidekiq
-  module ExceptionHandler
-
-    class Logger
-      def call(ex, ctxHash)
-        Sidekiq.logger.warn(ctxHash) if !ctxHash.empty?
-        Sidekiq.logger.warn "#{ex.class.name}: #{ex.message}"
-        Sidekiq.logger.warn ex.backtrace.join("\n") unless ex.backtrace.nil?
-      end
-
-      # Set up default handler which just logs the error
-      Sidekiq.error_handlers << Sidekiq::ExceptionHandler::Logger.new
-    end
-
-    def handle_exception(ex, ctxHash={})
-      Sidekiq.error_handlers.each do |handler|
-        begin
-          handler.call(ex, ctxHash)
-        rescue => ex
-          Sidekiq.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
-          Sidekiq.logger.error ex
-          Sidekiq.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
-        end
-      end
-    end
-
-  end
-end

data/lib/sidekiq/extensions/action_mailer.rb

@@ -1,56 +0,0 @@
-require 'sidekiq/extensions/generic_proxy'
-
-module Sidekiq
-  module Extensions
-    ##
-    # Adds 'delay', 'delay_for' and `delay_until` methods to ActionMailer to offload arbitrary email
-    # delivery to Sidekiq.  Example:
-    #
-    #    UserMailer.delay.send_welcome_email(new_user)
-    #    UserMailer.delay_for(5.days).send_welcome_email(new_user)
-    #    UserMailer.delay_until(5.days.from_now).send_welcome_email(new_user)
-    class DelayedMailer
-      include Sidekiq::Worker
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        msg = target.public_send(method_name, *args)
-        # The email method can return nil, which causes ActionMailer to return
-        # an undeliverable empty message.
-        if msg
-          deliver(msg)
-        else
-          raise "#{target.name}##{method_name} returned an undeliverable mail object"
-        end
-      end
-
-      private
-
-      def deliver(msg)
-        if msg.respond_to?(:deliver_now)
-          # Rails 4.2/5.0
-          msg.deliver_now
-        else
-          # Rails 3.2/4.0/4.1
-          msg.deliver
-        end
-      end
-    end
-
-    module ActionMailer
-      def sidekiq_delay(options={})
-        Proxy.new(DelayedMailer, self, options)
-      end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedMailer, self, options.merge('at' => Time.now.to_f + interval.to_f))
-      end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedMailer, self, options.merge('at' => timestamp.to_f))
-      end
-      alias_method :delay, :sidekiq_delay
-      alias_method :delay_for, :sidekiq_delay_for
-      alias_method :delay_until, :sidekiq_delay_until
-    end
-
-  end
-end

data/lib/sidekiq/extensions/active_record.rb

@@ -1,39 +0,0 @@
-require 'sidekiq/extensions/generic_proxy'
-
-module Sidekiq
-  module Extensions
-    ##
-    # Adds 'delay', 'delay_for' and `delay_until` methods to ActiveRecord to offload instance method
-    # execution to Sidekiq.  Examples:
-    #
-    # User.recent_signups.each { |user| user.delay.mark_as_awesome }
-    #
-    # Please note, this is not recommended as this will serialize the entire
-    # object to Redis.  Your Sidekiq jobs should pass IDs, not entire instances.
-    # This is here for backwards compatibility with Delayed::Job only.
-    class DelayedModel
-      include Sidekiq::Worker
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.__send__(method_name, *args)
-      end
-    end
-
-    module ActiveRecord
-      def sidekiq_delay(options={})
-        Proxy.new(DelayedModel, self, options)
-      end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedModel, self, options.merge('at' => Time.now.to_f + interval.to_f))
-      end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedModel, self, options.merge('at' => timestamp.to_f))
-      end
-      alias_method :delay, :sidekiq_delay
-      alias_method :delay_for, :sidekiq_delay_for
-      alias_method :delay_until, :sidekiq_delay_until
-    end
-
-  end
-end

data/lib/sidekiq/extensions/class_methods.rb

@@ -1,39 +0,0 @@
-require 'sidekiq/extensions/generic_proxy'
-
-module Sidekiq
-  module Extensions
-    ##
-    # Adds 'delay', 'delay_for' and `delay_until` methods to all Classes to offload class method
-    # execution to Sidekiq.  Examples:
-    #
-    # User.delay.delete_inactive
-    # Wikipedia.delay.download_changes_for(Date.today)
-    #
-    class DelayedClass
-      include Sidekiq::Worker
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.__send__(method_name, *args)
-      end
-    end
-
-    module Klass
-      def sidekiq_delay(options={})
-        Proxy.new(DelayedClass, self, options)
-      end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedClass, self, options.merge('at' => Time.now.to_f + interval.to_f))
-      end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedClass, self, options.merge('at' => timestamp.to_f))
-      end
-      alias_method :delay, :sidekiq_delay
-      alias_method :delay_for, :sidekiq_delay_for
-      alias_method :delay_until, :sidekiq_delay_until
-    end
-
-  end
-end
-
-Module.__send__(:include, Sidekiq::Extensions::Klass) unless defined?(::Rails)

data/lib/sidekiq/extensions/generic_proxy.rb

@@ -1,24 +0,0 @@
-require 'yaml'
-
-module Sidekiq
-  module Extensions
-    class Proxy < BasicObject
-      def initialize(performable, target, options={})
-        @performable = performable
-        @target = target
-        @opts = options
-      end
-
-      def method_missing(name, *args)
-        # Sidekiq has a limitation in that its message must be JSON.
-        # JSON can't round trip real Ruby objects so we use YAML to
-        # serialize the objects to a String.  The YAML will be converted
-        # to JSON and then deserialized on the other side back into a
-        # Ruby object.
-        obj = [@target, name, args]
-        @performable.client_push({ 'class' => @performable, 'args' => [::YAML.dump(obj)] }.merge(@opts))
-      end
-    end
-
-  end
-end

data/lib/sidekiq/logging.rb

@@ -1,104 +0,0 @@
-require 'time'
-require 'logger'
-
-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-#{Thread.current.object_id.to_s(36)}#{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-#{Thread.current.object_id.to_s(36)}#{context} #{severity}: #{message}\n"
-      end
-    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('/dev/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,13 +0,0 @@
-module Sidekiq
-  module Middleware
-    module Server
-      class ActiveRecord
-        def call(*args)
-          yield
-        ensure
-          ::ActiveRecord::Base.clear_active_connections!
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Sidekiq
-  module Middleware
-    module Server
-      class Logging
-
-        def call(worker, item, queue)
-          # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-          # attribute to expose the underlying thing.
-          klass = item['wrapped'] || worker.class.to_s
-
-          Sidekiq::Logging.with_context("#{klass} JID-#{item['jid']}#{" BID-#{item['bid']}" if item['bid']}") do
-            begin
-              start = Time.now
-              logger.info { "start" }
-              yield
-              logger.info { "done: #{elapsed(start)} sec" }
-            rescue Exception
-              logger.info { "fail: #{elapsed(start)} sec" }
-              raise
-            end
-          end
-        end
-
-        def elapsed(start)
-          (Time.now - start).round(3)
-        end
-
-        def logger
-          Sidekiq.logger
-        end
-      end
-    end
-  end
-end
-