sidekiq 4.1.4 → 4.2.10

data/lib/sidekiq/web.rb

@@ -1,26 +1,28 @@
 # frozen_string_literal: true
 require 'erb'
-require 'yaml'
-require 'sinatra/base'
 
 require 'sidekiq'
 require 'sidekiq/api'
 require 'sidekiq/paginator'
-require 'sidekiq/web_helpers'
+require 'sidekiq/web/helpers'
 
-module Sidekiq
-  class Web < Sinatra::Base
-    include Sidekiq::Paginator
+require 'sidekiq/web/router'
+require 'sidekiq/web/action'
+require 'sidekiq/web/application'
 
-    enable :sessions
-    use ::Rack::Protection, :use => :authenticity_token unless ENV['RACK_ENV'] == 'test'
+require 'rack/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/builder'
+require 'rack/file'
+require 'rack/session/cookie'
 
-    helpers WebHelpers
+module Sidekiq
+  class Web
+    ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../web")
+    VIEWS = "#{ROOT}/views".freeze
+    LOCALES = ["#{ROOT}/locales".freeze]
+    LAYOUT = "#{VIEWS}/layout.erb".freeze
+    ASSETS = "#{ROOT}/assets".freeze
 
     DEFAULT_TABS = {
       "Dashboard" => '',
@@ -32,6 +34,18 @@ module Sidekiq
     }
 
     class << self
+      def settings
+        self
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+
+      def use(*middleware_args, &block)
+        middlewares << [middleware_args, block]
+      end
+
       def default_tabs
         DEFAULT_TABS
       end
@@ -41,234 +55,155 @@ module Sidekiq
       end
       alias_method :tabs, :custom_tabs
 
-      attr_accessor :app_url
-    end
+      def locales
+        @locales ||= LOCALES
+      end
 
-    get "/busy" do
-      erb :busy
-    end
+      def views
+        @views ||= VIEWS
+      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 enable(*opts)
+        opts.each {|key| set(key, true) }
       end
-      redirect "#{root_path}busy"
-    end
 
-    get "/queues" do
-      @queues = Sidekiq::Queue.all
-      erb :queues
-    end
+      def disable(*opts)
+        opts.each {|key| set(key, false) }
+      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
+      # Helper for the Sinatra syntax: Sidekiq::Web.set(:session_secret, Rails.application.secrets...)
+      def set(attribute, value)
+        send(:"#{attribute}=", value)
+      end
 
-    post "/queues/:name" do
-      Sidekiq::Queue.new(params[:name]).clear
-      redirect "#{root_path}queues"
+      attr_accessor :app_url, :session_secret, :redis_pool, :sessions
+      attr_writer :locales, :views
     end
 
-    post "/queues/:name/delete" do
-      Sidekiq::Job.new(params[:key_val], params[:name]).delete
-      redirect_with_query("#{root_path}queues/#{params[:name]}")
+    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
 
-    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
+    def settings
+      self.class.settings
     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
+    def use(*middleware_args, &block)
+      middlewares << [middleware_args, block]
     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
-      end
-      redirect_with_query("#{root_path}morgue")
+    def middlewares
+      @middlewares ||= Web.middlewares.dup
     end
 
-    post "/morgue/all/delete" do
-      Sidekiq::DeadSet.new.clear
-      redirect "#{root_path}morgue"
+    def call(env)
+      app.call(env)
     end
 
-    post "/morgue/all/retry" do
-      Sidekiq::DeadSet.new.retry_all
-      redirect "#{root_path}morgue"
+    def self.call(env)
+      @app ||= new
+      @app.call(env)
     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")
+    def app
+      @app ||= build
     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
+    def enable(*opts)
+      opts.each {|key| set(key, true) }
     end
 
-    get "/retries/:key" do
-      @retry = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}retries" if @retry.nil?
-      erb :retry
+    def disable(*opts)
+      opts.each {|key| set(key, false) }
     end
 
-    post '/retries' do
-      redirect request.path unless params['key']
-
-      params['key'].each do |key|
-        job = Sidekiq::RetrySet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
-      end
-      redirect_with_query("#{root_path}retries")
+    def set(attribute, value)
+      send(:"#{attribute}=", value)
     end
 
-    post "/retries/all/delete" do
-      Sidekiq::RetrySet.new.clear
-      redirect "#{root_path}retries"
-    end
+    # Default values
+    set :sessions, true
 
-    post "/retries/all/retry" do
-      Sidekiq::RetrySet.new.retry_all
-      redirect "#{root_path}retries"
-    end
+    attr_writer :sessions
 
-    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")
-    end
+    def sessions
+      unless instance_variable_defined?("@sessions")
+        @sessions = self.class.sessions
+        @sessions = @sessions.to_hash.dup if @sessions.respond_to?(:to_hash)
+      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
+      @sessions
     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 self.register(extension)
+      extension.registered(WebApplication)
     end
 
-    post '/scheduled' do
-      redirect request.path unless params['key']
+    private
 
-      params['key'].each do |key|
-        job = Sidekiq::ScheduledSet.new.fetch(*parse_params(key)).first
-        delete_or_add_queue job, params if job
+    def using?(middleware)
+      middlewares.any? do |(m,_)|
+        m.kind_of?(Array) && (m[0] == middleware || m[0].kind_of?(middleware))
       end
-      redirect_with_query("#{root_path}scheduled")
     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")
-    end
+    def build_sessions
+      middlewares = self.middlewares
 
-    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
-    end
+      unless using?(::Rack::Protection) || ENV['RACK_ENV'] == 'test'
+        middlewares.unshift [[::Rack::Protection, { use: :authenticity_token }], nil]
+      end
 
-    REDIS_KEYS = %w(redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human)
+      s = sessions
+      return unless s
 
-    get '/dashboard/stats' do
-      redirect "#{root_path}stats"
-    end
+      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
 
-    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
-      )
+        middlewares.unshift [[::Rack::Session::Cookie, options], nil]
+      end
     end
 
-    get '/stats/queues' do
-      queue_stats = Sidekiq::Stats::Queues.new
+    def build
+      build_sessions
 
-      content_type :json
-      Sidekiq.dump_json(
-        queue_stats.lengths
-      )
-    end
+      middlewares = self.middlewares
+      klass = self.class
 
-    private
+      ::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
 
-    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
+        middlewares.each {|middleware, block| use(*middleware, &block) }
 
-    def delete_or_add_queue job, params
-      if params['delete']
-        job.delete
-      elsif params['add_to_queue']
-        job.add_to_queue
+        run WebApplication.new(klass)
       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.respond_to?(:each)
+    !::ActionDispatch::Request::Session.method_defined?(:each)
   # mperham/sidekiq#2460
   # Rack apps can't reuse the Rails session store without
-  # this monkeypatch
+  # this monkeypatch, fixed in Rails 5.
   class ActionDispatch::Request::Session
     def each(&block)
       hash = self.to_hash

data/lib/sidekiq/worker.rb

@@ -64,13 +64,13 @@ module Sidekiq
       #   numeric (like an activesupport time interval).
       def perform_in(interval, *args)
         int = interval.to_f
-        now = Time.now
-        ts = (int < 1_000_000_000 ? (now + interval).to_f : int)
+        now = Time.now.to_f
+        ts = (int < 1_000_000_000 ? now + int : int)
 
         item = { 'class' => self, 'args' => args, 'at' => ts }
 
         # Optimization to enqueue something now that is scheduled to go out now or in the past
-        item.delete('at'.freeze) if ts <= now.to_f
+        item.delete('at'.freeze) if ts <= now
 
         client_push(item)
       end

data/lib/sidekiq.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # encoding: utf-8
+# frozen_string_literal: true
 require 'sidekiq/version'
 fail "Sidekiq #{Sidekiq::VERSION} does not support Ruby versions below 2.0.0." if RUBY_PLATFORM != 'java' && RUBY_VERSION < '2.0.0'
 
@@ -28,9 +28,12 @@ module Sidekiq
       startup: [],
       quiet: [],
       shutdown: [],
+      heartbeat: [],
     },
     dead_max_jobs: 10_000,
-    dead_timeout_in_seconds: 180 * 24 * 60 * 60 # 6 months
+    dead_timeout_in_seconds: 180 * 24 * 60 * 60, # 6 months
+    reloader: proc { |&block| block.call },
+    executor: proc { |&block| block.call },
   }
 
   DEFAULT_WORKER_OPTIONS = {
@@ -146,12 +149,8 @@ module Sidekiq
     require 'sidekiq/middleware/server/logging'
 
     Middleware::Chain.new do |m|
-      m.add Middleware::Server::Logging
       m.add Middleware::Server::RetryJobs
-      if defined?(::ActiveRecord::Base)
-        require 'sidekiq/middleware/server/active_record'
-        m.add Sidekiq::Middleware::Server::ActiveRecord
-      end
+      m.add Middleware::Server::Logging
     end
   end
 
@@ -169,6 +168,7 @@ module Sidekiq
   def self.default_retries_exhausted=(prok)
     @default_retries_exhausted = prok
   end
+  @default_retries_exhausted = ->(job, ex) { }
   def self.default_retries_exhausted
     @default_retries_exhausted
   end

data/sidekiq.gemspec

@@ -10,17 +10,23 @@ Gem::Specification.new do |gem|
   gem.license       = "LGPL-3.0"
 
   gem.executables   = ['sidekiq', 'sidekiqctl']
-  gem.files         = `git ls-files | grep -Ev '^(myapp|examples)'`.split("\n")
-  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.files         = `git ls-files | grep -Ev '^(test|myapp|examples)'`.split("\n")
+  gem.test_files    = []
   gem.name          = "sidekiq"
   gem.require_paths = ["lib"]
   gem.version       = Sidekiq::VERSION
   gem.add_dependency                  'redis', '~> 3.2', '>= 3.2.1'
   gem.add_dependency                  'connection_pool', '~> 2.2', '>= 2.2.0'
   gem.add_dependency                  'concurrent-ruby', '~> 1.0'
-  gem.add_dependency                  'sinatra', '>= 1.4.7'
+  gem.add_dependency                  'rack-protection', '>= 1.5.0'
   gem.add_development_dependency      'redis-namespace', '~> 1.5', '>= 1.5.2'
-  gem.add_development_dependency      'minitest', '~> 5.7', '>= 5.7.0'
+  gem.add_development_dependency      'minitest', '~> 5.10', '>= 5.10.1'
   gem.add_development_dependency      'rake', '~> 10.0'
-  gem.add_development_dependency      'rails', '~> 4', '>= 3.2.0'
+  gem.add_development_dependency      'rails', '>= 3.2.0'
+
+  gem.add_development_dependency      'capybara', '~> 2.11'
+  gem.add_development_dependency      'poltergeist', '~> 1.12'
+  gem.add_development_dependency      'percy-capybara', '~> 2.3'
+  gem.add_development_dependency      'timecop', '~> 0.8'
+  gem.add_development_dependency      'mocha', '~> 1.1'
 end