mini-clean-lib 0.0.1

data/sidekiq-8.1.6/lib/sidekiq/sd_notify.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# The MIT License
+#
+# Copyright (c) 2017, 2018, 2019, 2020 Agis Anastasopoulos
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This is a copy of https://github.com/agis/ruby-sdnotify as of commit a7d52ee
+# The only changes made was "rehoming" it within the Sidekiq module to avoid
+# namespace collisions and applying standard's code formatting style.
+
+require "socket"
+
+# SdNotify is a pure-Ruby implementation of sd_notify(3). It can be used to
+# notify systemd about state changes. Methods of this package are no-op on
+# non-systemd systems (eg. Darwin).
+#
+# The API maps closely to the original implementation of sd_notify(3),
+# therefore be sure to check the official man pages prior to using SdNotify.
+#
+# @see https://www.freedesktop.org/software/systemd/man/sd_notify.html
+module Sidekiq
+  module SdNotify
+    # Exception raised when there's an error writing to the notification socket
+    class NotifyError < RuntimeError; end
+
+    READY = "READY=1"
+    RELOADING = "RELOADING=1"
+    STOPPING = "STOPPING=1"
+    STATUS = "STATUS="
+    ERRNO = "ERRNO="
+    MAINPID = "MAINPID="
+    WATCHDOG = "WATCHDOG=1"
+    FDSTORE = "FDSTORE=1"
+
+    def self.ready(unset_env = false)
+      notify(READY, unset_env)
+    end
+
+    def self.reloading(unset_env = false)
+      notify(RELOADING, unset_env)
+    end
+
+    def self.stopping(unset_env = false)
+      notify(STOPPING, unset_env)
+    end
+
+    # @param status [String] a custom status string that describes the current
+    #   state of the service
+    def self.status(status, unset_env = false)
+      notify("#{STATUS}#{status}", unset_env)
+    end
+
+    # @param errno [Integer]
+    def self.errno(errno, unset_env = false)
+      notify("#{ERRNO}#{errno}", unset_env)
+    end
+
+    # @param pid [Integer]
+    def self.mainpid(pid, unset_env = false)
+      notify("#{MAINPID}#{pid}", unset_env)
+    end
+
+    def self.watchdog(unset_env = false)
+      notify(WATCHDOG, unset_env)
+    end
+
+    def self.fdstore(unset_env = false)
+      notify(FDSTORE, unset_env)
+    end
+
+    # @return [Boolean] true if the service manager expects watchdog keep-alive
+    #   notification messages to be sent from this process.
+    #
+    # If the $WATCHDOG_USEC environment variable is set,
+    # and the $WATCHDOG_PID variable is unset or set to the PID of the current
+    # process
+    #
+    # @note Unlike sd_watchdog_enabled(3), this method does not mutate the
+    #   environment.
+    def self.watchdog?
+      wd_usec = ENV["WATCHDOG_USEC"]
+      wd_pid = ENV["WATCHDOG_PID"]
+
+      return false unless wd_usec
+
+      begin
+        wd_usec = Integer(wd_usec)
+      rescue
+        return false
+      end
+
+      return false if wd_usec <= 0
+      return true if !wd_pid || wd_pid == $$.to_s
+
+      false
+    end
+
+    # Notify systemd with the provided state, via the notification socket, if
+    # any.
+    #
+    # Generally this method will be used indirectly through the other methods
+    # of the library.
+    #
+    # @param state [String]
+    # @param unset_env [Boolean]
+    #
+    # @return [Fixnum, nil] the number of bytes written to the notification
+    #   socket or nil if there was no socket to report to (eg. the program wasn't
+    #   started by systemd)
+    #
+    # @raise [NotifyError] if there was an error communicating with the systemd
+    #   socket
+    #
+    # @see https://www.freedesktop.org/software/systemd/man/sd_notify.html
+    def self.notify(state, unset_env = false)
+      sock = ENV["NOTIFY_SOCKET"]
+
+      return nil unless sock
+
+      ENV.delete("NOTIFY_SOCKET") if unset_env
+
+      begin
+        Addrinfo.unix(sock, :DGRAM).connect do |s|
+          s.close_on_exec = true
+          s.write(state)
+        end
+      rescue => e
+        raise NotifyError, "#{e.class}: #{e.message}", e.backtrace
+      end
+    end
+  end
+end

data/sidekiq-8.1.6/lib/sidekiq/systemd.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#
+# Sidekiq's systemd integration allows Sidekiq to inform systemd:
+#  1. when it has successfully started
+#  2. when it is starting shutdown
+#  3. periodically for a liveness check with a watchdog thread
+#
+module Sidekiq
+  def self.start_watchdog
+    usec = Integer(ENV["WATCHDOG_USEC"])
+    return Sidekiq.logger.error("systemd Watchdog too fast: " + usec) if usec < 1_000_000
+
+    sec_f = usec / 1_000_000.0
+    # "It is recommended that a daemon sends a keep-alive notification message
+    # to the service manager every half of the time returned here."
+    ping_f = sec_f / 2
+    Sidekiq.logger.info "Pinging systemd watchdog every #{ping_f.round(1)} sec"
+    Thread.new do
+      loop do
+        sleep ping_f
+        Sidekiq::SdNotify.watchdog
+      end
+    end
+  end
+end

data/sidekiq-8.1.6/lib/sidekiq/test_api.rb

@@ -0,0 +1,331 @@
+# 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
+
+  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

data/sidekiq-8.1.6/lib/sidekiq/testing/inline.rb

@@ -0,0 +1,2 @@
+Sidekiq.testing!(:inline)
+warn('⛔️ `require "sidekiq/testing/inline"` is deprecated and will be removed in Sidekiq 9.0. See https://sidekiq.org/wiki/Testing#new-api')

data/sidekiq-8.1.6/lib/sidekiq/testing.rb

@@ -0,0 +1,3 @@
+require "sidekiq"
+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/sidekiq-8.1.6/lib/sidekiq/transaction_aware_client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "sidekiq/client"
+
+module Sidekiq
+  class TransactionAwareClient
+    def initialize(pool: nil, config: nil)
+      @redis_client = Client.new(pool: pool, config: config)
+      @transaction_backend =
+        if ActiveRecord.version >= Gem::Version.new("7.2")
+          ActiveRecord.method(:after_all_transactions_commit)
+        else
+          AfterCommitEverywhere.method(:after_commit)
+        end
+    end
+
+    def batching?
+      Thread.current[:sidekiq_batch]
+    end
+
+    def push(item)
+      # 6160 we can't support both Sidekiq::Batch and transactions.
+      return @redis_client.push(item) if batching?
+
+      # pre-allocate the JID so we can return it immediately and
+      # save it to the database as part of the transaction.
+      item["jid"] ||= SecureRandom.hex(12)
+      @transaction_backend.call { @redis_client.push(item) }
+      item["jid"]
+    end
+
+    ##
+    # We don't provide transactionality for push_bulk because we don't want
+    # to hold potentially hundreds of thousands of job records in memory due to
+    # a long running enqueue process.
+    def push_bulk(items)
+      @redis_client.push_bulk(items)
+    end
+  end
+end
+
+##
+# Use `Sidekiq.transactional_push!` in your sidekiq.rb initializer
+module Sidekiq
+  def self.transactional_push!
+    if ActiveRecord.version < Gem::Version.new("7.2")
+      begin
+        require "after_commit_everywhere"
+      rescue LoadError
+        raise %q(You need ActiveRecord >= 7.2 or to add `gem "after_commit_everywhere"` to your Gemfile to use Sidekiq's transactional client)
+      end
+    end
+
+    Sidekiq.default_job_options["client_class"] = Sidekiq::TransactionAwareClient
+    Sidekiq::JobUtil::TRANSIENT_ATTRIBUTES << "client_class"
+    true
+  end
+end

data/sidekiq-8.1.6/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/sidekiq-8.1.6/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