sidekiq 8.0.10 → 8.1.3

data/lib/sidekiq/testing.rb

@@ -1,334 +1,2 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "sidekiq"
-
-module Sidekiq
-  class Testing
-    class TestModeAlreadySetError < RuntimeError; end
-    class << self
-      attr_accessor :__global_test_mode
-
-      # Calling without a block sets the global test mode, affecting
-      # all threads. Calling with a block only affects the current Thread.
-      def __set_test_mode(mode)
-        if block_given?
-          # Reentrant testing modes will lead to a rat's nest of code which is
-          # hard to reason about. You can set the testing mode once globally and
-          # you can override that global setting once per-thread.
-          raise TestModeAlreadySetError, "Nesting test modes is not supported" if __local_test_mode
-
-          self.__local_test_mode = mode
-          begin
-            yield
-          ensure
-            self.__local_test_mode = nil
-          end
-        else
-          self.__global_test_mode = mode
-        end
-      end
-
-      def __test_mode
-        __local_test_mode || __global_test_mode
-      end
-
-      def __local_test_mode
-        Thread.current[:__sidekiq_test_mode]
-      end
-
-      def __local_test_mode=(value)
-        Thread.current[:__sidekiq_test_mode] = value
-      end
-
-      def disable!(&block)
-        __set_test_mode(:disable, &block)
-      end
-
-      def fake!(&block)
-        __set_test_mode(:fake, &block)
-      end
-
-      def inline!(&block)
-        __set_test_mode(:inline, &block)
-      end
-
-      def enabled?
-        __test_mode != :disable
-      end
-
-      def disabled?
-        __test_mode == :disable
-      end
-
-      def fake?
-        __test_mode == :fake
-      end
-
-      def inline?
-        __test_mode == :inline
-      end
-
-      def server_middleware
-        @server_chain ||= Middleware::Chain.new(Sidekiq.default_configuration)
-        yield @server_chain if block_given?
-        @server_chain
-      end
-    end
-  end
-
-  # Default to fake testing to keep old behavior
-  Sidekiq::Testing.fake!
-
-  class EmptyQueueError < RuntimeError; end
-
-  module TestingClient
-    private def atomic_push(conn, payloads)
-      if Sidekiq::Testing.fake?
-        payloads.each do |job|
-          job = Sidekiq.load_json(Sidekiq.dump_json(job))
-          job["enqueued_at"] = ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond) unless job["at"]
-          Queues.push(job["queue"], job["class"], job)
-        end
-        true
-      elsif Sidekiq::Testing.inline?
-        payloads.each do |job|
-          klass = Object.const_get(job["class"])
-          job["id"] ||= SecureRandom.hex(12)
-          job_hash = Sidekiq.load_json(Sidekiq.dump_json(job))
-          klass.process_job(job_hash)
-        end
-        true
-      else
-        super
-      end
-    end
-  end
-
-  Sidekiq::Client.prepend TestingClient
-
-  module Queues
-    ##
-    # The Queues class is only for testing the fake queue implementation.
-    # There are 2 data structures involved in tandem. This is due to the
-    # Rspec syntax of change(HardJob.jobs, :size). It keeps a reference
-    # to the array. Because the array was derived from a filter of the total
-    # jobs enqueued, it appeared as though the array didn't change.
-    #
-    # To solve this, we'll keep 2 hashes containing the jobs. One with keys based
-    # on the queue, and another with keys of the job type, so the array for
-    # HardJob.jobs is a straight reference to a real array.
-    #
-    # Queue-based hash:
-    #
-    # {
-    #   "default"=>[
-    #     {
-    #       "class"=>"TestTesting::HardJob",
-    #       "args"=>[1, 2],
-    #       "retry"=>true,
-    #       "queue"=>"default",
-    #       "jid"=>"abc5b065c5c4b27fc1102833",
-    #       "created_at"=>1447445554.419934
-    #     }
-    #   ]
-    # }
-    #
-    # Job-based hash:
-    #
-    # {
-    #   "TestTesting::HardJob"=>[
-    #     {
-    #       "class"=>"TestTesting::HardJob",
-    #       "args"=>[1, 2],
-    #       "retry"=>true,
-    #       "queue"=>"default",
-    #       "jid"=>"abc5b065c5c4b27fc1102833",
-    #       "created_at"=>1447445554.419934
-    #     }
-    #   ]
-    # }
-    #
-    # Example:
-    #
-    #   require 'sidekiq/testing'
-    #
-    #   assert_equal 0, Sidekiq::Queues["default"].size
-    #   HardJob.perform_async(:something)
-    #   assert_equal 1, Sidekiq::Queues["default"].size
-    #   assert_equal :something, Sidekiq::Queues["default"].first['args'][0]
-    #
-    # You can also clear all jobs:
-    #
-    #   assert_equal 0, Sidekiq::Queues["default"].size
-    #   HardJob.perform_async(:something)
-    #   Sidekiq::Queues.clear_all
-    #   assert_equal 0, Sidekiq::Queues["default"].size
-    #
-    # This can be useful to make sure jobs don't linger between tests:
-    #
-    #   RSpec.configure do |config|
-    #     config.before(:each) do
-    #       Sidekiq::Queues.clear_all
-    #     end
-    #   end
-    #
-    class << self
-      def [](queue)
-        jobs_by_queue[queue]
-      end
-
-      def push(queue, klass, job)
-        jobs_by_queue[queue] << job
-        jobs_by_class[klass] << job
-      end
-
-      def jobs_by_queue
-        @jobs_by_queue ||= Hash.new { |hash, key| hash[key] = [] }
-      end
-
-      def jobs_by_class
-        @jobs_by_class ||= Hash.new { |hash, key| hash[key] = [] }
-      end
-      alias_method :jobs_by_worker, :jobs_by_class
-
-      def delete_for(jid, queue, klass)
-        jobs_by_queue[queue.to_s].delete_if { |job| job["jid"] == jid }
-        jobs_by_class[klass].delete_if { |job| job["jid"] == jid }
-      end
-
-      def clear_for(queue, klass)
-        jobs_by_queue[queue.to_s].clear
-        jobs_by_class[klass].clear
-      end
-
-      def clear_all
-        jobs_by_queue.clear
-        jobs_by_class.clear
-      end
-    end
-  end
-
-  module Job
-    ##
-    # The Sidekiq testing infrastructure overrides perform_async
-    # so that it does not actually touch the network.  Instead it
-    # stores the asynchronous jobs in a per-class array so that
-    # their presence/absence can be asserted by your tests.
-    #
-    # This is similar to ActionMailer's :test delivery_method and its
-    # ActionMailer::Base.deliveries array.
-    #
-    # Example:
-    #
-    #   require 'sidekiq/testing'
-    #
-    #   assert_equal 0, HardJob.jobs.size
-    #   HardJob.perform_async(:something)
-    #   assert_equal 1, HardJob.jobs.size
-    #   assert_equal :something, HardJob.jobs[0]['args'][0]
-    #
-    # You can also clear and drain all job types:
-    #
-    #   Sidekiq::Job.clear_all # or .drain_all
-    #
-    # This can be useful to make sure jobs don't linger between tests:
-    #
-    #   RSpec.configure do |config|
-    #     config.before(:each) do
-    #       Sidekiq::Job.clear_all
-    #     end
-    #   end
-    #
-    # or for acceptance testing, i.e. with cucumber:
-    #
-    #   AfterStep do
-    #     Sidekiq::Job.drain_all
-    #   end
-    #
-    #   When I sign up as "foo@example.com"
-    #   Then I should receive a welcome email to "foo@example.com"
-    #
-    module ClassMethods
-      # Queue for this worker
-      def queue
-        get_sidekiq_options["queue"]
-      end
-
-      # Jobs queued for this worker
-      def jobs
-        Queues.jobs_by_class[to_s]
-      end
-
-      # Clear all jobs for this worker
-      def clear
-        Queues.clear_for(queue, to_s)
-      end
-
-      # Drain and run all jobs for this worker
-      def drain
-        while jobs.any?
-          next_job = jobs.first
-          Queues.delete_for(next_job["jid"], next_job["queue"], to_s)
-          process_job(next_job)
-        end
-      end
-
-      # Pop out a single job and perform it
-      def perform_one
-        raise(EmptyQueueError, "perform_one called with empty job queue") if jobs.empty?
-        next_job = jobs.first
-        Queues.delete_for(next_job["jid"], next_job["queue"], to_s)
-        process_job(next_job)
-      end
-
-      def process_job(job)
-        instance = new
-        instance.jid = job["jid"]
-        instance.bid = job["bid"] if instance.respond_to?(:bid=)
-        Sidekiq::Testing.server_middleware.invoke(instance, job, job["queue"]) do
-          execute_job(instance, job["args"])
-        end
-      end
-
-      def execute_job(worker, args)
-        worker.perform(*args)
-      end
-    end
-
-    class << self
-      def jobs # :nodoc:
-        Queues.jobs_by_queue.values.flatten
-      end
-
-      # Clear all queued jobs
-      def clear_all
-        Queues.clear_all
-      end
-
-      # Drain (execute) all queued jobs
-      def drain_all
-        while jobs.any?
-          job_classes = jobs.map { |job| job["class"] }.uniq
-
-          job_classes.each do |job_class|
-            Object.const_get(job_class).drain
-          end
-        end
-      end
-    end
-  end
-
-  module TestingExtensions
-    def jobs_for(klass)
-      jobs.select do |job|
-        marshalled = job["args"][0]
-        marshalled.index(klass.to_s) && YAML.safe_load(marshalled)[0] == klass
-      end
-    end
-  end
-end
-
-if defined?(::Rails) && Rails.respond_to?(:env) && !Rails.env.test? && !$TESTING # rubocop:disable Style/GlobalVars
-  warn("⛔️ WARNING: Sidekiq testing API enabled, but this is not the test environment.  Your jobs will not go to Redis.", uplevel: 1)
-end
+Sidekiq.testing!(:fake)
+warn('⛔️ `require "sidekiq/testing"` is deprecated and will be removed in Sidekiq 9.0. See https://sidekiq.org/wiki/Testing#new-api')

data/lib/sidekiq/tui/controls.rb

@@ -0,0 +1,53 @@
+module Sidekiq
+  class TUI
+    module Controls
+      # Defines data for input handling and for displaying controls.
+      # :code is the key code for input handling.
+      # :display and :description are shown in the controls area, with different
+      #   styling between them. If :display is omitted, :code is displayed instead.
+      # :action is a lambda to execute when the control is triggered.
+      # :refresh means the action requires immediate refreshing of data
+      #
+      # Conventions: dangerous/irreversible actions should use UPPERCASE codes.
+      # The Shift button means "I'm sure".
+      GLOBAL = [
+        {code: "?", display: "?", description: "Help", action: ->(tui, tab) { tui.show_help }},
+        {code: "left", display: "←/→", description: "Select Tab", action: ->(tui, tab) { tui.navigate(:left) }, refresh: true},
+        {code: "right", action: ->(tui, tab) { tui.navigate(:right) }, refresh: true},
+        {code: "q", description: "Quit", action: ->(tui, tab) { :quit }},
+        {code: "c", modifiers: ["ctrl"], action: ->(tui, tab) { :quit }}
+      ].freeze
+
+      SHARED = {
+        pageable: [
+          {code: "h", display: "h/l", description: "Prev/Next Page",
+           action: ->(tui, tab) { tab.prev_page }, refresh: true},
+          {code: "l", action: ->(tui, tab) { tab.next_page }, refresh: true}
+        ],
+        selectable: [
+          {code: "k", display: "j/k", description: "Prev/Next Row",
+           action: ->(tui, tab) { tab.navigate_row(:up) }},
+          {code: "j", action: ->(tui, tab) { tab.navigate_row(:down) }},
+          {code: "x", description: "Select", action: ->(tui, tab) { tab.toggle_select }},
+          {code: "A", modifiers: ["shift"], display: "A", description: "Select All",
+           action: ->(tui, tab) { tab.toggle_select(:all) }}
+        ],
+        filterable: [
+          {code: "/", display: "/", description: "Filter", action: ->(tui, tab) { tab.start_filtering }},
+          {code: "backspace", action: ->(tui, tab) { tab.remove_last_char_from_filter }, refresh: true},
+          {code: "enter", action: ->(tui, tab) { tab.stop_filtering }, refresh: true},
+          {code: "esc", action: ->(tui, tab) { tab.stop_and_clear_filtering }, refresh: true}
+        ]
+      }.freeze
+
+      # Returns an array of symbols for functionality which this tab implements
+      def features
+        []
+      end
+
+      def controls
+        GLOBAL + SHARED.slice(*features).values.flatten
+      end
+    end
+  end
+end

data/lib/sidekiq/tui/filtering.rb

@@ -0,0 +1,53 @@
+module Sidekiq
+  class TUI
+    module Filtering
+      def filtering?
+        @data[:filtering]
+      end
+
+      def current_filter
+        @data[:filter]
+      end
+
+      def start_filtering
+        @data[:filtering] = true
+        @data[:filter] = ""
+      end
+
+      def stop_filtering
+        return unless @data[:filtering]
+
+        @data[:filtering] = false
+        @data[:selected] = []
+      end
+
+      def stop_and_clear_filtering
+        return unless @data[:filtering]
+
+        @data[:filtering] = false
+        @data[:filter] = nil
+        @data[:selected] = []
+        on_filter_change
+      end
+
+      def remove_last_char_from_filter
+        return unless @data[:filtering]
+
+        @data[:filter] = @data[:filter].empty? ? "" : @data[:filter][0..-2]
+        on_filter_change
+      end
+
+      def append_to_filter(string)
+        return unless @data[:filtering]
+
+        @data[:filter] += string
+        @data[:selected] = []
+        on_filter_change
+      end
+
+      def on_filter_change
+        # callback for subclasses
+      end
+    end
+  end
+end

data/lib/sidekiq/tui/tabs/base_tab.rb

@@ -0,0 +1,187 @@
+module Sidekiq
+  class TUI
+    class BaseTab
+      include Controls
+
+      attr_reader :name
+      attr_reader :data
+
+      def initialize(parent)
+        @parent = parent
+        @name = self.class.name.split("::").last
+        reset_data
+      end
+
+      def t(*)
+        @parent.t(*)
+      end
+
+      def reset_data
+        @data = {selected: [], selected_row_index: 0}
+      end
+
+      def error
+        @data[:error]
+      end
+
+      def error=(e)
+        @data[:error] = e
+      end
+
+      def selected?(entry)
+        @data[:selected].index(entry.id)
+      end
+
+      def filtering?
+        false
+      end
+
+      def each_selection(unselect: true, &)
+        sel = @data[:selected]
+        finished = []
+        if !sel.empty?
+          sel.each do |id|
+            yield id
+            # When processing multiple items in bulk, we want to unselect
+            # each row if its operation succeeds so our UI will not
+            # re-process rows 1-3 if row 4 fails.
+            finished << id
+          end
+        else
+          ids = @data.dig(:table, :row_ids)
+          return if !ids || ids.empty?
+          yield ids[@data[:selected_row_index]]
+        end
+      ensure
+        @data[:selected] = sel - finished if unselect
+      end
+
+      # Navigate the row selection up or down in the current tab's table.
+      # @param direction [Symbol] :up or :down
+      def navigate_row(direction)
+        ids = @data.dig(:table, :row_ids)
+        return if !ids || ids.empty?
+
+        index_change = (direction == :down) ? 1 : -1
+        @data[:selected_row_index] = (@data[:selected_row_index] + index_change) % ids.count
+      end
+
+      def prev_page
+        opts = @data.dig(:table, :pager)
+        return unless opts
+        return if opts.page < 2
+
+        @data[:table][:pager] = Sidekiq::TUI::PageOptions.new(opts.page - 1, opts.size)
+      end
+
+      def next_page
+        np = @data.dig(:table, :next_page)
+        return unless np
+        opts = @data.dig(:table, :pager)
+        return unless opts
+
+        @data[:table][:pager] = Sidekiq::TUI::PageOptions.new(np, opts.size)
+      end
+
+      def toggle_select(which = :current)
+        sel = @data[:selected]
+        # log(which, sel)
+        if which == :current
+          x = @data[:table][:row_ids][@data[:selected_row_index]]
+          if sel.index(x)
+            # already checked, uncheck it
+            sel.delete(x)
+          else
+            sel << x
+          end
+        elsif sel.empty?
+          @data[:selected] = @data[:table][:row_ids]
+        else
+          sel.clear
+        end
+      end
+
+      def refresh_data_for_stats
+        stats = Sidekiq::Stats.new
+        @data[:stats] = {
+          processed: stats.processed,
+          failed: stats.failed,
+          busy: stats.workers_size,
+          enqueued: stats.enqueued,
+          retries: stats.retry_size,
+          scheduled: stats.scheduled_size,
+          dead: stats.dead_size
+        }
+      end
+
+      def render_table(tui, frame, area)
+        page = @data.dig(:table, :current_page) || 1
+        rows = @data.dig(:table, :rows) || []
+        total = @data.dig(:table, :total) || 0
+        footer = ["", "Page: #{page}", "Count: #{rows.size}", "Total: #{total}"]
+        footer << "Selected: #{@data[:selected].size}" unless @data[:selected].empty?
+
+        defaults = {
+          title: "TableName",
+          footer: footer
+        }
+        if features.include?(:selectable)
+          defaults.merge!({
+            highlight_symbol: "➡️",
+            selected_row: @data[:selected_row_index],
+            row_highlight_style: tui.style(fg: :white, bg: :blue)
+          })
+        end
+        hash = defaults.merge(yield)
+        hash[:block] ||= tui.block(title: hash.delete(:title), borders: :all)
+        table = tui.table(**hash)
+        frame.render_widget(table, area)
+      end
+
+      def render_stats_section(tui, frame, area)
+        stats = @data[:stats]
+
+        keys = ["Processed", "Failed", "Busy", "Enqueued", "Retries", "Scheduled", "Dead"]
+        values = [
+          stats[:processed],
+          stats[:failed],
+          stats[:busy],
+          stats[:enqueued],
+          stats[:retries],
+          stats[:scheduled],
+          stats[:dead]
+        ]
+
+        # Format keys and values with spacing
+        keys_line = keys.map { |k| t(k).to_s.ljust(12) }.join("  ")
+        values_line = values.map { |v| v.to_s.ljust(12) }.join("  ")
+
+        frame.render_widget(
+          tui.paragraph(
+            text: [keys_line, values_line],
+            block: tui.block(title: "Statistics", borders: [:all])
+          ),
+          area
+        )
+      end
+
+      # TODO Implement I18n delimiter
+      def number_with_delimiter(number, options = {})
+        precision = options[:precision] || 0
+        number.round(precision)
+      end
+
+      def format_memory(rss_kb)
+        return "0" if rss_kb.nil? || rss_kb == 0
+
+        if rss_kb < 100_000
+          "#{number_with_delimiter(rss_kb)} KB"
+        elsif rss_kb < 10_000_000
+          "#{number_with_delimiter((rss_kb / 1024.0).to_i)} MB"
+        else
+          "#{number_with_delimiter(rss_kb / (1024.0 * 1024.0), precision: 1)} GB"
+        end
+      end
+    end
+  end
+end