sidekiq 5.2.7 → 8.0.5

data/lib/sidekiq/web/router.rb

@@ -1,98 +1,89 @@
 # frozen_string_literal: true
-require 'rack'
 
-module Sidekiq
-  module WebRouter
-    GET = 'GET'
-    DELETE = 'DELETE'
-    POST = 'POST'
-    PUT = 'PUT'
-    PATCH = 'PATCH'
-    HEAD = 'HEAD'
-
-    ROUTE_PARAMS = 'rack.route_params'
-    REQUEST_METHOD = 'REQUEST_METHOD'
-    PATH_INFO = 'PATH_INFO'
-
-    def get(path, &block)
-      route(GET, path, &block)
-    end
+require "rack"
 
-    def post(path, &block)
-      route(POST, path, &block)
-    end
+module Sidekiq
+  class Web
+    # Provides an API to declare endpoints, along with a match
+    # API to dynamically route a request to an endpoint.
+    module Router
+      def head(path, &) = route(:head, path, &)
 
-    def put(path, &block)
-      route(PUT, path, &block)
-    end
+      def get(path, &) = route(:get, path, &)
 
-    def patch(path, &block)
-      route(PATCH, path, &block)
-    end
+      def post(path, &) = route(:post, path, &)
 
-    def delete(path, &block)
-      route(DELETE, path, &block)
-    end
+      def put(path, &) = route(:put, path, &)
 
-    def route(method, path, &block)
-      @routes ||= { GET => [], POST => [], PUT => [], PATCH => [], DELETE => [], HEAD => [] }
+      def patch(path, &) = route(:patch, path, &)
 
-      @routes[method] << WebRoute.new(method, path, block)
-      @routes[HEAD] << WebRoute.new(method, path, block) if method == GET
-    end
+      def delete(path, &) = route(:delete, path, &)
 
-    def match(env)
-      request_method = env[REQUEST_METHOD]
-      path_info = ::Rack::Utils.unescape env[PATH_INFO]
+      def route(*methods, path, &block)
+        methods.each do |method|
+          raise ArgumentError, "Invalid method #{method}. Must be one of #{@routes.keys.join(",")}" unless route_cache.has_key?(method)
+          route_cache[method] << Route.new(method, path, block)
+        end
+      end
 
-      # There are servers which send an empty string when requesting the root.
-      # These servers should be ashamed of themselves.
-      path_info = "/" if path_info == ""
+      def match(env)
+        request_method = env["REQUEST_METHOD"].downcase.to_sym
+        path_info = ::Rack::Utils.unescape_path env["PATH_INFO"]
 
-      @routes[request_method].each do |route|
-        if params = route.match(request_method, path_info)
-          env[ROUTE_PARAMS] = params
+        # There are servers which send an empty string when requesting the root.
+        # These servers should be ashamed of themselves.
+        path_info = "/" if path_info == ""
 
-          return WebAction.new(env, route.block)
+        route_cache[request_method].each do |route|
+          params = route.match(request_method, path_info)
+          if params
+            env["rack.route_params"] = params
+            return Action.new(env, route.block)
+          end
         end
+
+        nil
       end
 
-      nil
+      def route_cache
+        @@routes ||= {get: [], post: [], put: [], patch: [], delete: [], head: []}
+      end
     end
-  end
 
-  class WebRoute
-    attr_accessor :request_method, :pattern, :block, :name
+    class Route
+      attr_accessor :request_method, :pattern, :block, :name
 
-    NAMED_SEGMENTS_PATTERN = /\/([^\/]*):([^\.:$\/]+)/
+      NAMED_SEGMENTS_PATTERN = /\/([^\/]*):([^.:$\/]+)/
 
-    def initialize(request_method, pattern, block)
-      @request_method = request_method
-      @pattern = pattern
-      @block = block
-    end
+      def initialize(request_method, pattern, block)
+        @request_method = request_method
+        @pattern = pattern
+        @block = block
+      end
 
-    def matcher
-      @matcher ||= compile
-    end
+      def matcher
+        @matcher ||= compile
+      end
 
-    def compile
-      if pattern.match(NAMED_SEGMENTS_PATTERN)
-        p = pattern.gsub(NAMED_SEGMENTS_PATTERN, '/\1(?<\2>[^$/]+)')
+      def compile
+        if pattern.match?(NAMED_SEGMENTS_PATTERN)
+          p = pattern.gsub(NAMED_SEGMENTS_PATTERN, '/\1(?<\2>[^$/]+)')
 
-        Regexp.new("\\A#{p}\\Z")
-      else
-        pattern
+          Regexp.new("\\A#{p}\\Z")
+        else
+          pattern
+        end
       end
-    end
 
-    def match(request_method, path)
-      case matcher
-      when String
-        {} if path == matcher
-      else
-        if path_match = path.match(matcher)
-          Hash[path_match.names.map(&:to_sym).zip(path_match.captures)]
+      EMPTY = {}.freeze
+
+      def match(request_method, path)
+        case matcher
+        when String
+          EMPTY if path == matcher
+        else
+          path_match = path.match(matcher)
+          path_match&.named_captures&.transform_keys(&:to_sym)
         end
       end
     end

data/lib/sidekiq/web.rb

@@ -1,20 +1,12 @@
 # frozen_string_literal: true
-require 'erb'
 
-require 'sidekiq'
-require 'sidekiq/api'
-require 'sidekiq/paginator'
-require 'sidekiq/web/helpers'
-
-require 'sidekiq/web/router'
-require 'sidekiq/web/action'
-require 'sidekiq/web/application'
-
-require 'rack/protection'
-
-require 'rack/builder'
-require 'rack/file'
-require 'rack/session/cookie'
+require "erb"
+require "securerandom"
+require "rack/builder"
+require "rack/static"
+require "sidekiq"
+require "sidekiq/api"
+require "sidekiq/web/config"
 
 module Sidekiq
   class Web
@@ -25,189 +17,105 @@ 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",
+      "Metrics" => "metrics",
+      "Profiles" => "profiles"
     }
 
-    class << self
-      def settings
-        self
-      end
-
-      def middlewares
-        @middlewares ||= []
-      end
+    @@config = Sidekiq::Web::Config.new
 
-      def use(*middleware_args, &block)
-        middlewares << [middleware_args, block]
+    class << self
+      def configure
+        if block_given?
+          yield @@config
+        else
+          @@config
+        end
       end
 
-      def default_tabs
-        DEFAULT_TABS
+      def app_url=(url)
+        @@config.app_url = url
       end
 
-      def custom_tabs
-        @custom_tabs ||= {}
-      end
-      alias_method :tabs, :custom_tabs
+      def tabs = @@config.tabs
 
-      def locales
-        @locales ||= LOCALES
-      end
+      def locales = @@config.locales
 
-      def views
-        @views ||= VIEWS
-      end
+      def views = @@config.views
 
-      def enable(*opts)
-        opts.each {|key| set(key, true) }
-      end
+      def custom_job_info_rows = @@config.custom_job_info_rows
 
-      def disable(*opts)
-        opts.each {|key| set(key, false) }
+      def redis_pool
+        @pool || Sidekiq.default_configuration.redis_pool
       end
 
-      # Helper for the Sinatra syntax: Sidekiq::Web.set(:session_secret, Rails.application.secrets...)
-      def set(attribute, value)
-        send(:"#{attribute}=", value)
+      def redis_pool=(pool)
+        @pool = pool
       end
 
-      attr_accessor :app_url, :session_secret, :redis_pool, :sessions
-      attr_writer :locales, :views
-    end
+      def middlewares = @@config.middlewares
 
-    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
-    end
+      def use(*args, &block) = @@config.middlewares << [args, block]
 
-    def settings
-      self.class.settings
+      def register(*args, **kw, &block)
+        Sidekiq.logger.warn { "`Sidekiq::Web.register` is deprecated, use `Sidekiq::Web.configure {|cfg| cfg.register(...) }`" }
+        @@config.register(*args, **kw, &block)
+      end
     end
 
-    def use(*middleware_args, &block)
-      middlewares << [middleware_args, block]
+    # Allow user to say
+    #   run Sidekiq::Web
+    # rather than:
+    #   run Sidekiq::Web.new
+    def self.call(env)
+      @inst ||= new
+      @inst.call(env)
     end
 
-    def middlewares
-      @middlewares ||= Web.middlewares.dup
+    # testing, internal use only
+    def self.reset!
+      @@config.reset!
+      @inst = nil
     end
 
     def call(env)
+      env[:web_config] = Sidekiq::Web.configure
+      env[:csp_nonce] = SecureRandom.hex(8)
+      env[:redis_pool] = self.class.redis_pool
       app.call(env)
     end
 
-    def self.call(env)
-      @app ||= new
-      @app.call(env)
-    end
-
     def app
-      @app ||= build
-    end
-
-    def enable(*opts)
-      opts.each {|key| set(key, true) }
-    end
-
-    def disable(*opts)
-      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
-    end
-
-    def self.register(extension)
-      extension.registered(WebApplication)
+      @app ||= build(@@config)
     end
 
     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
+    def build(cfg)
+      cfg.freeze
+      m = cfg.middlewares
 
-        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
+      rules = []
+      rules = [[:all, {"cache-control" => "private, max-age=86400"}]] unless ENV["SIDEKIQ_WEB_TESTING"]
 
       ::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) }
-
-        run WebApplication.new(klass)
+        use Rack::Static, urls: ["/stylesheets", "/images", "/javascripts"],
+          root: ASSETS,
+          cascade: true,
+          header_rules: rules
+        m.each { |middleware, block| use(*middleware, &block) }
+        use CsrfProtection if cfg[:csrf]
+        run Sidekiq::Web::Application.new(self.class)
       end
     end
   end
-
-  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)
-    end
-  end
-end
+require "sidekiq/web/router"
+require "sidekiq/web/action"
+require "sidekiq/web/application"

data/lib/sidekiq/worker_compatibility_alias.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  # Sidekiq::Job is a new alias for Sidekiq::Worker as of Sidekiq 6.3.0.
+  # Use `include Sidekiq::Job` rather than `include Sidekiq::Worker`.
+  #
+  # The term "worker" is too generic and overly confusing, used in several
+  # different contexts meaning different things. Many people call a Sidekiq
+  # process a "worker". Some people call the thread that executes jobs a
+  # "worker". This change brings Sidekiq closer to ActiveJob where your job
+  # classes extend ApplicationJob.
+  Worker = Job
+end