sidekiq 3.5.4 → 7.2.0

data/lib/sidekiq/web.rb

@@ -1,36 +1,56 @@
-require 'erb'
-require 'yaml'
-require 'sinatra/base'
+# frozen_string_literal: true
 
-require 'sidekiq'
-require 'sidekiq/api'
-require 'sidekiq/paginator'
-require 'sidekiq/web_helpers'
+require "erb"
 
-module Sidekiq
-  class Web < Sinatra::Base
-    include Sidekiq::Paginator
+require "sidekiq"
+require "sidekiq/api"
+require "sidekiq/paginator"
+require "sidekiq/web/helpers"
 
-    enable :sessions
-    use Rack::Protection, :use => :authenticity_token unless ENV['RACK_ENV'] == 'test'
+require "sidekiq/web/router"
+require "sidekiq/web/action"
+require "sidekiq/web/application"
+require "sidekiq/web/csrf_protection"
 
-    set :root, File.expand_path(File.dirname(__FILE__) + "/../../web")
-    set :public_folder, proc { "#{root}/assets" }
-    set :views, proc { "#{root}/views" }
-    set :locales, ["#{root}/locales"]
+require "rack/content_length"
+require "rack/builder"
+require "rack/static"
 
-    helpers WebHelpers
+module Sidekiq
+  class Web
+    ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../web")
+    VIEWS = "#{ROOT}/views"
+    LOCALES = ["#{ROOT}/locales"]
+    LAYOUT = "#{VIEWS}/layout.erb"
+    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"
     }
 
+    if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+      CONTENT_LANGUAGE = "Content-Language"
+      CONTENT_SECURITY_POLICY = "Content-Security-Policy"
+      LOCATION = "Location"
+      X_CASCADE = "X-Cascade"
+    else
+      CONTENT_LANGUAGE = "content-language"
+      CONTENT_SECURITY_POLICY = "content-security-policy"
+      LOCATION = "location"
+      X_CASCADE = "x-cascade"
+    end
+
     class << self
+      def settings
+        self
+      end
+
       def default_tabs
         DEFAULT_TABS
       end
@@ -40,238 +60,115 @@ module Sidekiq
       end
       alias_method :tabs, :custom_tabs
 
-      attr_accessor :app_url
-    end
-
-    get "/busy" do
-      erb :busy
-    end
-
-    post "/busy" do
-      if params['identity']
-        p = Sidekiq::Process.new('identity' => params['identity'])
-        p.quiet! if params[:quiet]
-        p.stop! if params[:stop]
-      else
-        processes.each do |pro|
-          pro.quiet! if params[:quiet]
-          pro.stop! if params[:stop]
-        end
+      def custom_job_info_rows
+        @custom_job_info_rows ||= []
       end
-      redirect "#{root_path}busy"
-    end
-
-    get "/queues" do
-      @queues = Sidekiq::Queue.all
-      erb :queues
-    end
-
-    get "/queues/:name" do
-      halt 404 unless params[:name]
-      @count = (params[:count] || 25).to_i
-      @name = params[:name]
-      @queue = Sidekiq::Queue.new(@name)
-      (@current_page, @total_size, @messages) = page("queue:#{@name}", params[:page], @count)
-      @messages = @messages.map { |msg| Sidekiq::Job.new(msg, @name) }
-      erb :queue
-    end
-
-    post "/queues/:name" do
-      Sidekiq::Queue.new(params[:name]).clear
-      redirect "#{root_path}queues"
-    end
-
-    post "/queues/:name/delete" do
-      Sidekiq::Job.new(params[:key_val], params[:name]).delete
-      redirect_with_query("#{root_path}queues/#{params[:name]}")
-    end
-
-    get '/morgue' do
-      @count = (params[:count] || 25).to_i
-      (@current_page, @total_size, @dead) = page("dead", params[:page], @count, reverse: true)
-      @dead = @dead.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
-      erb :morgue
-    end
-
-    get "/morgue/:key" do
-      halt 404 unless params['key']
-      @dead = Sidekiq::DeadSet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}morgue" if @dead.nil?
-      erb :dead
-    end
-
-    post '/morgue' do
-      redirect request.path unless params['key']
 
-      params['key'].each do |key|
-        job = Sidekiq::DeadSet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
+      def locales
+        @locales ||= LOCALES
       end
-      redirect_with_query("#{root_path}morgue")
-    end
-
-    post "/morgue/all/delete" do
-      Sidekiq::DeadSet.new.clear
-      redirect "#{root_path}morgue"
-    end
 
-    post "/morgue/all/retry" do
-      Sidekiq::DeadSet.new.retry_all
-      redirect "#{root_path}morgue"
-    end
-
-    post "/morgue/:key" do
-      halt 404 unless params['key']
-      job = Sidekiq::DeadSet.new.fetch(*parse_params(params['key'])).first
-      retry_or_delete_or_kill job, params if job
-      redirect_with_query("#{root_path}morgue")
-    end
+      def views
+        @views ||= VIEWS
+      end
 
+      def enable(*opts)
+        opts.each { |key| set(key, true) }
+      end
 
-    get '/retries' do
-      @count = (params[:count] || 25).to_i
-      (@current_page, @total_size, @retries) = page("retry", params[:page], @count)
-      @retries = @retries.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
-      erb :retries
-    end
+      def disable(*opts)
+        opts.each { |key| set(key, false) }
+      end
 
-    get "/retries/:key" do
-      @retry = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}retries" if @retry.nil?
-      erb :retry
-    end
+      def middlewares
+        @middlewares ||= []
+      end
 
-    post '/retries' do
-      redirect request.path unless params['key']
+      def use(*args, &block)
+        middlewares << [args, block]
+      end
 
-      params['key'].each do |key|
-        job = Sidekiq::RetrySet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
+      def set(attribute, value)
+        send(:"#{attribute}=", value)
       end
-      redirect_with_query("#{root_path}retries")
-    end
 
-    post "/retries/all/delete" do
-      Sidekiq::RetrySet.new.clear
-      redirect "#{root_path}retries"
+      attr_accessor :app_url, :redis_pool
+      attr_writer :locales, :views
     end
 
-    post "/retries/all/retry" do
-      Sidekiq::RetrySet.new.retry_all
-      redirect "#{root_path}retries"
+    def self.inherited(child)
+      child.app_url = app_url
+      child.redis_pool = redis_pool
     end
 
-    post "/retries/:key" do
-      job = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
-      retry_or_delete_or_kill job, params if job
-      redirect_with_query("#{root_path}retries")
+    def settings
+      self.class.settings
     end
 
-    get '/scheduled' do
-      @count = (params[:count] || 25).to_i
-      (@current_page, @total_size, @scheduled) = page("schedule", params[:page], @count)
-      @scheduled = @scheduled.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
-      erb :scheduled
+    def middlewares
+      @middlewares ||= self.class.middlewares
     end
 
-    get "/scheduled/:key" do
-      @job = Sidekiq::ScheduledSet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}scheduled" if @job.nil?
-      erb :scheduled_job_info
+    def use(*args, &block)
+      middlewares << [args, block]
     end
 
-    post '/scheduled' do
-      redirect request.path unless params['key']
-
-      params['key'].each do |key|
-        job = Sidekiq::ScheduledSet.new.fetch(*parse_params(key)).first
-        delete_or_add_queue job, params if job
-      end
-      redirect_with_query("#{root_path}scheduled")
+    def call(env)
+      app.call(env)
     end
 
-    post "/scheduled/:key" do
-      halt 404 unless params['key']
-      job = Sidekiq::ScheduledSet.new.fetch(*parse_params(params['key'])).first
-      delete_or_add_queue job, params if job
-      redirect_with_query("#{root_path}scheduled")
+    def self.call(env)
+      @app ||= new
+      @app.call(env)
     end
 
-    get '/' do
-      @redis_info = redis_info.select{ |k, v| REDIS_KEYS.include? k }
-      stats_history = Sidekiq::Stats::History.new((params[:days] || 30).to_i)
-      @processed_history = stats_history.processed
-      @failed_history = stats_history.failed
-      erb :dashboard
+    def app
+      @app ||= build
     end
 
-    REDIS_KEYS = %w(redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human)
-
-    get '/dashboard/stats' do
-      redirect "#{root_path}stats"
+    def enable(*opts)
+      opts.each { |key| set(key, true) }
     end
 
-    get '/stats' do
-      sidekiq_stats = Sidekiq::Stats.new
-      redis_stats   = redis_info.select { |k, v| REDIS_KEYS.include? k }
-
-      content_type :json
-      Sidekiq.dump_json(
-        sidekiq: {
-          processed:       sidekiq_stats.processed,
-          failed:          sidekiq_stats.failed,
-          busy:            sidekiq_stats.workers_size,
-          processes:       sidekiq_stats.processes_size,
-          enqueued:        sidekiq_stats.enqueued,
-          scheduled:       sidekiq_stats.scheduled_size,
-          retries:         sidekiq_stats.retry_size,
-          dead:            sidekiq_stats.dead_size,
-          default_latency: sidekiq_stats.default_queue_latency
-        },
-        redis: redis_stats
-      )
+    def disable(*opts)
+      opts.each { |key| set(key, false) }
     end
 
-    get '/stats/queues' do
-      queue_stats = Sidekiq::Stats::Queues.new
+    def set(attribute, value)
+      send(:"#{attribute}=", value)
+    end
 
-      content_type :json
-      Sidekiq.dump_json(
-        queue_stats.lengths
-      )
+    def self.register(extension)
+      extension.registered(WebApplication)
     end
 
     private
 
-    def retry_or_delete_or_kill job, params
-      if params['retry']
-        job.retry
-      elsif params['delete']
-        job.delete
-      elsif params['kill']
-        job.kill
-      end
-    end
-
-    def delete_or_add_queue job, params
-      if params['delete']
-        job.delete
-      elsif params['add_to_queue']
-        job.add_to_queue
+    def build
+      klass = self.class
+      m = middlewares
+
+      rules = []
+      rules = [[:all, {Rack::CACHE_CONTROL => "private, max-age=86400"}]] unless ENV["SIDEKIQ_WEB_TESTING"]
+
+      ::Rack::Builder.new do
+        use Rack::Static, urls: ["/stylesheets", "/images", "/javascripts"],
+          root: ASSETS,
+          cascade: true,
+          header_rules: rules
+        m.each { |middleware, block| use(*middleware, &block) }
+        use Sidekiq::Web::CsrfProtection unless $TESTING
+        run WebApplication.new(klass)
       end
     end
   end
-end
 
-if defined?(::ActionDispatch::Request::Session) &&
-    !::ActionDispatch::Request::Session.respond_to?(:each)
-  # mperham/sidekiq#2460
-  # Rack apps can't reuse the Rails session store without
-  # this monkeypatch
-  class ActionDispatch::Request::Session
-    def each(&block)
-      hash = self.to_hash
-      hash.each(&block)
+  Sidekiq::WebApplication.helpers WebHelpers
+  Sidekiq::WebApplication.helpers Sidekiq::Paginator
+
+  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_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