sidekiq 5.2.9 → 6.2.1

data/lib/sidekiq/web.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
-require 'erb'
 
-require 'sidekiq'
-require 'sidekiq/api'
-require 'sidekiq/paginator'
-require 'sidekiq/web/helpers'
+require "erb"
 
-require 'sidekiq/web/router'
-require 'sidekiq/web/action'
-require 'sidekiq/web/application'
+require "sidekiq"
+require "sidekiq/api"
+require "sidekiq/paginator"
+require "sidekiq/web/helpers"
 
-require 'rack/protection'
+require "sidekiq/web/router"
+require "sidekiq/web/action"
+require "sidekiq/web/application"
+require "sidekiq/web/csrf_protection"
 
-require 'rack/builder'
-require 'rack/file'
-require 'rack/session/cookie'
+require "rack/content_length"
+require "rack/builder"
+require "rack/static"
 
 module Sidekiq
   class Web
@@ -25,12 +25,12 @@ module Sidekiq
     ASSETS = "#{ROOT}/assets"
 
     DEFAULT_TABS = {
-      "Dashboard" => '',
-      "Busy"      => 'busy',
-      "Queues"    => 'queues',
-      "Retries"   => 'retries',
-      "Scheduled" => 'scheduled',
-      "Dead"      => 'morgue',
+      "Dashboard" => "",
+      "Busy" => "busy",
+      "Queues" => "queues",
+      "Retries" => "retries",
+      "Scheduled" => "scheduled",
+      "Dead" => "morgue"
     }
 
     class << self
@@ -38,14 +38,6 @@ module Sidekiq
         self
       end
 
-      def middlewares
-        @middlewares ||= []
-      end
-
-      def use(*middleware_args, &block)
-        middlewares << [middleware_args, block]
-      end
-
       def default_tabs
         DEFAULT_TABS
       end
@@ -64,39 +56,52 @@ module Sidekiq
       end
 
       def enable(*opts)
-        opts.each {|key| set(key, true) }
+        opts.each { |key| set(key, true) }
       end
 
       def disable(*opts)
-        opts.each {|key| set(key, false) }
+        opts.each { |key| set(key, false) }
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+
+      def use(*args, &block)
+        middlewares << [args, block]
       end
 
-      # Helper for the Sinatra syntax: Sidekiq::Web.set(:session_secret, Rails.application.secrets...)
       def set(attribute, value)
         send(:"#{attribute}=", value)
       end
 
-      attr_accessor :app_url, :session_secret, :redis_pool, :sessions
+      def sessions=(val)
+        puts "WARNING: Sidekiq::Web.sessions= is no longer relevant and will be removed in Sidekiq 7.0. #{caller(1..1).first}"
+      end
+
+      def session_secret=(val)
+        puts "WARNING: Sidekiq::Web.session_secret= is no longer relevant and will be removed in Sidekiq 7.0. #{caller(1..1).first}"
+      end
+
+      attr_accessor :app_url, :redis_pool
       attr_writer :locales, :views
     end
 
     def self.inherited(child)
-      child.app_url = self.app_url
-      child.session_secret = self.session_secret
-      child.redis_pool = self.redis_pool
-      child.sessions = self.sessions
+      child.app_url = app_url
+      child.redis_pool = redis_pool
     end
 
     def settings
       self.class.settings
     end
 
-    def use(*middleware_args, &block)
-      middlewares << [middleware_args, block]
+    def middlewares
+      @middlewares ||= self.class.middlewares
     end
 
-    def middlewares
-      @middlewares ||= Web.middlewares.dup
+    def use(*args, &block)
+      middlewares << [args, block]
     end
 
     def call(env)
@@ -113,29 +118,19 @@ module Sidekiq
     end
 
     def enable(*opts)
-      opts.each {|key| set(key, true) }
+      opts.each { |key| set(key, true) }
     end
 
     def disable(*opts)
-      opts.each {|key| set(key, false) }
+      opts.each { |key| set(key, false) }
     end
 
     def set(attribute, value)
       send(:"#{attribute}=", value)
     end
 
-    # Default values
-    set :sessions, true
-
-    attr_writer :sessions
-
-    def sessions
-      unless instance_variable_defined?("@sessions")
-        @sessions = self.class.sessions
-        @sessions = @sessions.to_hash.dup if @sessions.respond_to?(:to_hash)
-      end
-
-      @sessions
+    def sessions=(val)
+      puts "Sidekiq::Web#sessions= is no longer relevant and will be removed in Sidekiq 7.0. #{caller[2..2].first}"
     end
 
     def self.register(extension)
@@ -144,50 +139,19 @@ module Sidekiq
 
     private
 
-    def using?(middleware)
-      middlewares.any? do |(m,_)|
-        m.kind_of?(Array) && (m[0] == middleware || m[0].kind_of?(middleware))
-      end
-    end
-
-    def build_sessions
-      middlewares = self.middlewares
-
-      unless using?(::Rack::Protection) || ENV['RACK_ENV'] == 'test'
-        middlewares.unshift [[::Rack::Protection, { use: :authenticity_token }], nil]
-      end
-
-      s = sessions
-      return unless s
-
-      unless using? ::Rack::Session::Cookie
-        unless secret = Web.session_secret
-          require 'securerandom'
-          secret = SecureRandom.hex(64)
-        end
-
-        options = { secret: secret }
-        options = options.merge(s.to_hash) if s.respond_to? :to_hash
-
-        middlewares.unshift [[::Rack::Session::Cookie, options], nil]
-      end
-    end
-
     def build
-      build_sessions
-
-      middlewares = self.middlewares
       klass = self.class
+      m = middlewares
 
       ::Rack::Builder.new do
-        %w(stylesheets javascripts images).each do |asset_dir|
-          map "/#{asset_dir}" do
-            run ::Rack::File.new("#{ASSETS}/#{asset_dir}", { 'Cache-Control' => 'public, max-age=86400' })
-          end
-        end
-
-        middlewares.each {|middleware, block| use(*middleware, &block) }
-
+        use Rack::Static, urls: ["/stylesheets", "/images", "/javascripts"],
+                          root: ASSETS,
+                          cascade: true,
+                          header_rules: [
+                            [:all, {"Cache-Control" => "public, max-age=86400"}]
+                          ]
+        m.each { |middleware, block| use(*middleware, &block) }
+        use Sidekiq::Web::CsrfProtection unless $TESTING
         run WebApplication.new(klass)
       end
     end
@@ -196,18 +160,9 @@ module Sidekiq
   Sidekiq::WebApplication.helpers WebHelpers
   Sidekiq::WebApplication.helpers Sidekiq::Paginator
 
-  Sidekiq::WebAction.class_eval "def _render\n#{ERB.new(File.read(Web::LAYOUT)).src}\nend"
-end
-
-if defined?(::ActionDispatch::Request::Session) &&
-    !::ActionDispatch::Request::Session.method_defined?(:each)
-  # mperham/sidekiq#2460
-  # Rack apps can't reuse the Rails session store without
-  # this monkeypatch, fixed in Rails 5.
-  class ActionDispatch::Request::Session
-    def each(&block)
-      hash = self.to_hash
-      hash.each(&block)
+  Sidekiq::WebAction.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+    def _render
+      #{ERB.new(File.read(Web::LAYOUT)).src}
     end
-  end
+  RUBY
 end

data/lib/sidekiq/worker.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
-require 'sidekiq/client'
 
-module Sidekiq
+require "sidekiq/client"
 
+module Sidekiq
   ##
   # Include this module in your worker class and you can easily create
   # asynchronous jobs:
@@ -21,15 +21,124 @@ module Sidekiq
   #
   # Note that perform_async is a class method, perform is an instance method.
   module Worker
+    ##
+    # The Options module is extracted so we can include it in ActiveJob::Base
+    # and allow native AJs to configure Sidekiq features/internals.
+    module Options
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.sidekiq_class_attribute :sidekiq_options_hash
+        base.sidekiq_class_attribute :sidekiq_retry_in_block
+        base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
+      end
+
+      module ClassMethods
+        ACCESSOR_MUTEX = Mutex.new
+
+        ##
+        # Allows customization for this type of Worker.
+        # Legal options:
+        #
+        #   queue - name of queue to use for this job type, default *default*
+        #   retry - enable retries for this Worker in case of error during execution,
+        #      *true* to use the default or *Integer* count
+        #   backtrace - whether to save any error backtrace in the retry payload to display in web UI,
+        #      can be true, false or an integer number of lines to save, default *false*
+        #
+        # In practice, any option is allowed.  This is the main mechanism to configure the
+        # options for a specific job.
+        def sidekiq_options(opts = {})
+          opts = opts.transform_keys(&:to_s) # stringify
+          self.sidekiq_options_hash = get_sidekiq_options.merge(opts)
+        end
+
+        def sidekiq_retry_in(&block)
+          self.sidekiq_retry_in_block = block
+        end
+
+        def sidekiq_retries_exhausted(&block)
+          self.sidekiq_retries_exhausted_block = block
+        end
+
+        def get_sidekiq_options # :nodoc:
+          self.sidekiq_options_hash ||= Sidekiq.default_worker_options
+        end
+
+        def sidekiq_class_attribute(*attrs)
+          instance_reader = true
+          instance_writer = true
+
+          attrs.each do |name|
+            synchronized_getter = "__synchronized_#{name}"
+
+            singleton_class.instance_eval do
+              undef_method(name) if method_defined?(name) || private_method_defined?(name)
+            end
+
+            define_singleton_method(synchronized_getter) { nil }
+            singleton_class.class_eval do
+              private(synchronized_getter)
+            end
+
+            define_singleton_method(name) { ACCESSOR_MUTEX.synchronize { send synchronized_getter } }
+
+            ivar = "@#{name}"
+
+            singleton_class.instance_eval do
+              m = "#{name}="
+              undef_method(m) if method_defined?(m) || private_method_defined?(m)
+            end
+            define_singleton_method("#{name}=") do |val|
+              singleton_class.class_eval do
+                ACCESSOR_MUTEX.synchronize do
+                  undef_method(synchronized_getter) if method_defined?(synchronized_getter) || private_method_defined?(synchronized_getter)
+                  define_method(synchronized_getter) { val }
+                end
+              end
+
+              if singleton_class?
+                class_eval do
+                  undef_method(name) if method_defined?(name) || private_method_defined?(name)
+                  define_method(name) do
+                    if instance_variable_defined? ivar
+                      instance_variable_get ivar
+                    else
+                      singleton_class.send name
+                    end
+                  end
+                end
+              end
+              val
+            end
+
+            if instance_reader
+              undef_method(name) if method_defined?(name) || private_method_defined?(name)
+              define_method(name) do
+                if instance_variable_defined?(ivar)
+                  instance_variable_get ivar
+                else
+                  self.class.public_send name
+                end
+              end
+            end
+
+            if instance_writer
+              m = "#{name}="
+              undef_method(m) if method_defined?(m) || private_method_defined?(m)
+              attr_writer name
+            end
+          end
+        end
+      end
+    end
+
     attr_accessor :jid
 
     def self.included(base)
-      raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? {|c| c.name == 'ActiveJob::Base' }
+      raise ArgumentError, "Sidekiq::Worker cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
 
+      base.include(Options)
       base.extend(ClassMethods)
-      base.sidekiq_class_attribute :sidekiq_options_hash
-      base.sidekiq_class_attribute :sidekiq_retry_in_block
-      base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
     end
 
     def logger
@@ -52,7 +161,7 @@ module Sidekiq
       end
 
       def perform_async(*args)
-        @klass.client_push(@opts.merge('args' => args, 'class' => @klass))
+        @klass.client_push(@opts.merge("args" => args, "class" => @klass))
       end
 
       # +interval+ must be a timestamp, numeric or something that acts
@@ -62,17 +171,15 @@ module Sidekiq
         now = Time.now.to_f
         ts = (int < 1_000_000_000 ? now + int : int)
 
-        payload = @opts.merge('class' => @klass, 'args' => args, 'at' => ts)
+        payload = @opts.merge("class" => @klass, "args" => args)
         # Optimization to enqueue something now that is scheduled to go out now or in the past
-        payload.delete('at') if ts <= now
+        payload["at"] = ts if ts > now
         @klass.client_push(payload)
       end
       alias_method :perform_at, :perform_in
     end
 
     module ClassMethods
-      ACCESSOR_MUTEX = Mutex.new
-
       def delay(*args)
         raise ArgumentError, "Do not call .delay on a Sidekiq::Worker class, call .perform_async"
       end
@@ -90,7 +197,7 @@ module Sidekiq
       end
 
       def perform_async(*args)
-        client_push('class' => self, 'args' => args)
+        client_push("class" => self, "args" => args)
       end
 
       # +interval+ must be a timestamp, numeric or something that acts
@@ -100,10 +207,10 @@ module Sidekiq
         now = Time.now.to_f
         ts = (int < 1_000_000_000 ? now + int : int)
 
-        item = { 'class' => self, 'args' => args, 'at' => ts }
+        item = {"class" => self, "args" => args}
 
         # Optimization to enqueue something now that is scheduled to go out now or in the past
-        item.delete('at') if ts <= now
+        item["at"] = ts if ts > now
 
         client_push(item)
       end
@@ -122,99 +229,16 @@ module Sidekiq
       #
       # In practice, any option is allowed.  This is the main mechanism to configure the
       # options for a specific job.
-      def sidekiq_options(opts={})
-        # stringify
-        self.sidekiq_options_hash = get_sidekiq_options.merge(Hash[opts.map{|k, v| [k.to_s, v]}])
-      end
-
-      def sidekiq_retry_in(&block)
-        self.sidekiq_retry_in_block = block
-      end
-
-      def sidekiq_retries_exhausted(&block)
-        self.sidekiq_retries_exhausted_block = block
-      end
-
-      def get_sidekiq_options # :nodoc:
-        self.sidekiq_options_hash ||= Sidekiq.default_worker_options
+      def sidekiq_options(opts = {})
+        super
       end
 
       def client_push(item) # :nodoc:
-        pool = Thread.current[:sidekiq_via_pool] || get_sidekiq_options['pool'] || Sidekiq.redis_pool
-        # stringify
-        item.keys.each do |key|
-          item[key.to_s] = item.delete(key)
-        end
+        pool = Thread.current[:sidekiq_via_pool] || get_sidekiq_options["pool"] || Sidekiq.redis_pool
+        stringified_item = item.transform_keys(&:to_s)
 
-        Sidekiq::Client.new(pool).push(item)
+        Sidekiq::Client.new(pool).push(stringified_item)
       end
-
-      def sidekiq_class_attribute(*attrs)
-        instance_reader = true
-        instance_writer = true
-
-        attrs.each do |name|
-          synchronized_getter = "__synchronized_#{name}"
-
-          singleton_class.instance_eval do
-            undef_method(name) if method_defined?(name) || private_method_defined?(name)
-          end
-
-          define_singleton_method(synchronized_getter) { nil }
-          singleton_class.class_eval do
-            private(synchronized_getter)
-          end
-
-          define_singleton_method(name) { ACCESSOR_MUTEX.synchronize { send synchronized_getter } }
-
-          ivar = "@#{name}"
-
-          singleton_class.instance_eval do
-            m = "#{name}="
-            undef_method(m) if method_defined?(m) || private_method_defined?(m)
-          end
-          define_singleton_method("#{name}=") do |val|
-            singleton_class.class_eval do
-              ACCESSOR_MUTEX.synchronize do
-                undef_method(synchronized_getter) if method_defined?(synchronized_getter) || private_method_defined?(synchronized_getter)
-                define_method(synchronized_getter) { val }
-              end
-            end
-
-            if singleton_class?
-              class_eval do
-                undef_method(name) if method_defined?(name) || private_method_defined?(name)
-                define_method(name) do
-                  if instance_variable_defined? ivar
-                    instance_variable_get ivar
-                  else
-                    singleton_class.send name
-                  end
-                end
-              end
-            end
-            val
-          end
-
-          if instance_reader
-            undef_method(name) if method_defined?(name) || private_method_defined?(name)
-            define_method(name) do
-              if instance_variable_defined?(ivar)
-                instance_variable_get ivar
-              else
-                self.class.public_send name
-              end
-            end
-          end
-
-          if instance_writer
-            m = "#{name}="
-            undef_method(m) if method_defined?(m) || private_method_defined?(m)
-            attr_writer name
-          end
-        end
-      end
-
     end
   end
 end