sidekiq 6.2.2 → 8.1.5

data/lib/sidekiq/util.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-require "socket"
-require "securerandom"
-require "sidekiq/exception_handler"
-
-module Sidekiq
-  ##
-  # This module is part of Sidekiq core and not intended for extensions.
-  #
-
-  class RingBuffer
-    include Enumerable
-    extend Forwardable
-    def_delegators :@buf, :[], :each, :size
-
-    def initialize(size, default = 0)
-      @size = size
-      @buf = Array.new(size, default)
-      @index = 0
-    end
-
-    def <<(element)
-      @buf[@index % @size] = element
-      @index += 1
-      element
-    end
-
-    def buffer
-      @buf
-    end
-
-    def reset(default = 0)
-      @buf.fill(default)
-    end
-  end
-
-  module Util
-    include ExceptionHandler
-
-    def watchdog(last_words)
-      yield
-    rescue Exception => ex
-      handle_exception(ex, {context: last_words})
-      raise ex
-    end
-
-    def safe_thread(name, &block)
-      Thread.new do
-        Thread.current.name = name
-        watchdog(name, &block)
-      end
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    def redis(&block)
-      Sidekiq.redis(&block)
-    end
-
-    def tid
-      Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
-    end
-
-    def hostname
-      ENV["DYNO"] || Socket.gethostname
-    end
-
-    def process_nonce
-      @@process_nonce ||= SecureRandom.hex(6)
-    end
-
-    def identity
-      @@identity ||= "#{hostname}:#{::Process.pid}:#{process_nonce}"
-    end
-
-    def fire_event(event, options = {})
-      reverse = options[:reverse]
-      reraise = options[:reraise]
-
-      arr = Sidekiq.options[:lifecycle_events][event]
-      arr.reverse! if reverse
-      arr.each do |block|
-        block.call
-      rescue => ex
-        handle_exception(ex, {context: "Exception during Sidekiq lifecycle event.", event: event})
-        raise ex if reraise
-      end
-      arr.clear
-    end
-  end
-end

data/lib/sidekiq/web/csrf_protection.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-# this file originally based on authenticity_token.rb from the sinatra/rack-protection project
-#
-# The MIT License (MIT)
-#
-# Copyright (c) 2011-2017 Konstantin Haase
-# Copyright (c) 2015-2017 Zachary Scott
-#
-# 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.
-
-require "securerandom"
-require "base64"
-require "rack/request"
-
-module Sidekiq
-  class Web
-    class CsrfProtection
-      def initialize(app, options = nil)
-        @app = app
-      end
-
-      def call(env)
-        accept?(env) ? admit(env) : deny(env)
-      end
-
-      private
-
-      def admit(env)
-        # On each successful request, we create a fresh masked token
-        # which will be used in any forms rendered for this request.
-        s = session(env)
-        s[:csrf] ||= SecureRandom.base64(TOKEN_LENGTH)
-        env[:csrf_token] = mask_token(s[:csrf])
-        @app.call(env)
-      end
-
-      def safe?(env)
-        %w[GET HEAD OPTIONS TRACE].include? env["REQUEST_METHOD"]
-      end
-
-      def logger(env)
-        @logger ||= (env["rack.logger"] || ::Logger.new(env["rack.errors"]))
-      end
-
-      def deny(env)
-        logger(env).warn "attack prevented by #{self.class}"
-        [403, {"Content-Type" => "text/plain"}, ["Forbidden"]]
-      end
-
-      def session(env)
-        env["rack.session"] || fail(<<~EOM)
-          Sidekiq::Web needs a valid Rack session for CSRF protection. If this is a Rails app,
-          make sure you mount Sidekiq::Web *inside* your application routes:
-
-
-          Rails.application.routes.draw do
-            mount Sidekiq::Web => "/sidekiq"
-            ....
-          end
-
-
-          If this is a Rails app in API mode, you need to enable sessions.
-
-            https://guides.rubyonrails.org/api_app.html#using-session-middlewares
-
-          If this is a bare Rack app, use a session middleware before Sidekiq::Web:
-
-            # first, use IRB to create a shared secret key for sessions and commit it
-            require 'securerandom'; File.open(".session.key", "w") {|f| f.write(SecureRandom.hex(32)) }
-
-            # now use the secret with a session cookie middleware
-            use Rack::Session::Cookie, secret: File.read(".session.key"), same_site: true, max_age: 86400
-            run Sidekiq::Web
-
-        EOM
-      end
-
-      def accept?(env)
-        return true if safe?(env)
-
-        giventoken = ::Rack::Request.new(env).params["authenticity_token"]
-        valid_token?(env, giventoken)
-      end
-
-      TOKEN_LENGTH = 32
-
-      # Checks that the token given to us as a parameter matches
-      # the token stored in the session.
-      def valid_token?(env, giventoken)
-        return false if giventoken.nil? || giventoken.empty?
-
-        begin
-          token = decode_token(giventoken)
-        rescue ArgumentError # client input is invalid
-          return false
-        end
-
-        sess = session(env)
-        localtoken = sess[:csrf]
-
-        # Checks that Rack::Session::Cookie actualy contains the csrf toekn
-        return false if localtoken.nil?
-
-        # Rotate the session token after every use
-        sess[:csrf] = SecureRandom.base64(TOKEN_LENGTH)
-
-        # See if it's actually a masked token or not. We should be able
-        # to handle any unmasked tokens that we've issued without error.
-
-        if unmasked_token?(token)
-          compare_with_real_token token, localtoken
-        elsif masked_token?(token)
-          unmasked = unmask_token(token)
-          compare_with_real_token unmasked, localtoken
-        else
-          false # Token is malformed
-        end
-      end
-
-      # Creates a masked version of the authenticity token that varies
-      # on each request. The masking is used to mitigate SSL attacks
-      # like BREACH.
-      def mask_token(token)
-        token = decode_token(token)
-        one_time_pad = SecureRandom.random_bytes(token.length)
-        encrypted_token = xor_byte_strings(one_time_pad, token)
-        masked_token = one_time_pad + encrypted_token
-        Base64.strict_encode64(masked_token)
-      end
-
-      # Essentially the inverse of +mask_token+.
-      def unmask_token(masked_token)
-        # Split the token into the one-time pad and the encrypted
-        # value and decrypt it
-        token_length = masked_token.length / 2
-        one_time_pad = masked_token[0...token_length]
-        encrypted_token = masked_token[token_length..-1]
-        xor_byte_strings(one_time_pad, encrypted_token)
-      end
-
-      def unmasked_token?(token)
-        token.length == TOKEN_LENGTH
-      end
-
-      def masked_token?(token)
-        token.length == TOKEN_LENGTH * 2
-      end
-
-      def compare_with_real_token(token, local)
-        ::Rack::Utils.secure_compare(token.to_s, decode_token(local).to_s)
-      end
-
-      def decode_token(token)
-        Base64.strict_decode64(token)
-      end
-
-      def xor_byte_strings(s1, s2)
-        s1.bytes.zip(s2.bytes).map { |(c1, c2)| c1 ^ c2 }.pack("c*")
-      end
-    end
-  end
-end

data/lib/sidekiq/worker.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-require "sidekiq/client"
-
-module Sidekiq
-  ##
-  # Include this module in your worker class and you can easily create
-  # asynchronous jobs:
-  #
-  #   class HardWorker
-  #     include Sidekiq::Worker
-  #
-  #     def perform(*args)
-  #       # do some work
-  #     end
-  #   end
-  #
-  # Then in your Rails app, you can do this:
-  #
-  #   HardWorker.perform_async(1, 2, 3)
-  #
-  # Note that perform_async is a class method, perform is an instance method.
-  module Worker
-    ##
-    # The Options module is extracted so we can include it in ActiveJob::Base
-    # and allow native AJs to configure Sidekiq features/internals.
-    module Options
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.sidekiq_class_attribute :sidekiq_options_hash
-        base.sidekiq_class_attribute :sidekiq_retry_in_block
-        base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
-      end
-
-      module ClassMethods
-        ACCESSOR_MUTEX = Mutex.new
-
-        ##
-        # Allows customization for this type of Worker.
-        # Legal options:
-        #
-        #   queue - name of queue to use for this job type, default *default*
-        #   retry - enable retries for this Worker in case of error during execution,
-        #      *true* to use the default or *Integer* count
-        #   backtrace - whether to save any error backtrace in the retry payload to display in web UI,
-        #      can be true, false or an integer number of lines to save, default *false*
-        #
-        # In practice, any option is allowed.  This is the main mechanism to configure the
-        # options for a specific job.
-        def sidekiq_options(opts = {})
-          opts = opts.transform_keys(&:to_s) # stringify
-          self.sidekiq_options_hash = get_sidekiq_options.merge(opts)
-        end
-
-        def sidekiq_retry_in(&block)
-          self.sidekiq_retry_in_block = block
-        end
-
-        def sidekiq_retries_exhausted(&block)
-          self.sidekiq_retries_exhausted_block = block
-        end
-
-        def get_sidekiq_options # :nodoc:
-          self.sidekiq_options_hash ||= Sidekiq.default_worker_options
-        end
-
-        def sidekiq_class_attribute(*attrs)
-          instance_reader = true
-          instance_writer = true
-
-          attrs.each do |name|
-            synchronized_getter = "__synchronized_#{name}"
-
-            singleton_class.instance_eval do
-              undef_method(name) if method_defined?(name) || private_method_defined?(name)
-            end
-
-            define_singleton_method(synchronized_getter) { nil }
-            singleton_class.class_eval do
-              private(synchronized_getter)
-            end
-
-            define_singleton_method(name) { ACCESSOR_MUTEX.synchronize { send synchronized_getter } }
-
-            ivar = "@#{name}"
-
-            singleton_class.instance_eval do
-              m = "#{name}="
-              undef_method(m) if method_defined?(m) || private_method_defined?(m)
-            end
-            define_singleton_method("#{name}=") do |val|
-              singleton_class.class_eval do
-                ACCESSOR_MUTEX.synchronize do
-                  undef_method(synchronized_getter) if method_defined?(synchronized_getter) || private_method_defined?(synchronized_getter)
-                  define_method(synchronized_getter) { val }
-                end
-              end
-
-              if singleton_class?
-                class_eval do
-                  undef_method(name) if method_defined?(name) || private_method_defined?(name)
-                  define_method(name) do
-                    if instance_variable_defined? ivar
-                      instance_variable_get ivar
-                    else
-                      singleton_class.send name
-                    end
-                  end
-                end
-              end
-              val
-            end
-
-            if instance_reader
-              undef_method(name) if method_defined?(name) || private_method_defined?(name)
-              define_method(name) do
-                if instance_variable_defined?(ivar)
-                  instance_variable_get ivar
-                else
-                  self.class.public_send name
-                end
-              end
-            end
-
-            if instance_writer
-              m = "#{name}="
-              undef_method(m) if method_defined?(m) || private_method_defined?(m)
-              attr_writer name
-            end
-          end
-        end
-      end
-    end
-
-    attr_accessor :jid
-
-    def self.included(base)
-      raise ArgumentError, "Sidekiq::Worker cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
-
-      base.include(Options)
-      base.extend(ClassMethods)
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    # This helper class encapsulates the set options for `set`, e.g.
-    #
-    #     SomeWorker.set(queue: 'foo').perform_async(....)
-    #
-    class Setter
-      def initialize(klass, opts)
-        @klass = klass
-        @opts = opts
-      end
-
-      def set(options)
-        @opts.merge!(options)
-        self
-      end
-
-      def perform_async(*args)
-        @klass.client_push(@opts.merge("args" => args, "class" => @klass))
-      end
-
-      # +interval+ must be a timestamp, numeric or something that acts
-      #   numeric (like an activesupport time interval).
-      def perform_in(interval, *args)
-        int = interval.to_f
-        now = Time.now.to_f
-        ts = (int < 1_000_000_000 ? now + int : int)
-
-        payload = @opts.merge("class" => @klass, "args" => args)
-        # Optimization to enqueue something now that is scheduled to go out now or in the past
-        payload["at"] = ts if ts > now
-        @klass.client_push(payload)
-      end
-      alias_method :perform_at, :perform_in
-    end
-
-    module ClassMethods
-      def delay(*args)
-        raise ArgumentError, "Do not call .delay on a Sidekiq::Worker class, call .perform_async"
-      end
-
-      def delay_for(*args)
-        raise ArgumentError, "Do not call .delay_for on a Sidekiq::Worker class, call .perform_in"
-      end
-
-      def delay_until(*args)
-        raise ArgumentError, "Do not call .delay_until on a Sidekiq::Worker class, call .perform_at"
-      end
-
-      def set(options)
-        Setter.new(self, options)
-      end
-
-      def perform_async(*args)
-        client_push("class" => self, "args" => args)
-      end
-
-      # +interval+ must be a timestamp, numeric or something that acts
-      #   numeric (like an activesupport time interval).
-      def perform_in(interval, *args)
-        int = interval.to_f
-        now = Time.now.to_f
-        ts = (int < 1_000_000_000 ? now + int : int)
-
-        item = {"class" => self, "args" => args}
-
-        # Optimization to enqueue something now that is scheduled to go out now or in the past
-        item["at"] = ts if ts > now
-
-        client_push(item)
-      end
-      alias_method :perform_at, :perform_in
-
-      ##
-      # Allows customization for this type of Worker.
-      # Legal options:
-      #
-      #   queue - use a named queue for this Worker, default 'default'
-      #   retry - enable the RetryJobs middleware for this Worker, *true* to use the default
-      #      or *Integer* count
-      #   backtrace - whether to save any error backtrace in the retry payload to display in web UI,
-      #      can be true, false or an integer number of lines to save, default *false*
-      #   pool - use the given Redis connection pool to push this type of job to a given shard.
-      #
-      # In practice, any option is allowed.  This is the main mechanism to configure the
-      # options for a specific job.
-      def sidekiq_options(opts = {})
-        super
-      end
-
-      def client_push(item) # :nodoc:
-        pool = Thread.current[:sidekiq_via_pool] || get_sidekiq_options["pool"] || Sidekiq.redis_pool
-        stringified_item = item.transform_keys(&:to_s)
-
-        Sidekiq::Client.new(pool).push(stringified_item)
-      end
-    end
-  end
-end

data/web/assets/stylesheets/application-dark.css

@@ -1,147 +0,0 @@
-html, body {
-  background-color: #333 !important;
-  color: #ddd;
-}
-
-a,
-.title,
-.summary_bar ul .count,
-span.current-interval,
-.navbar .navbar-brand {
-  color: #c04;
-}
-
-.history-graph + .active,
-.beacon .dot {
-  background-color: #c04;
-}
-
-.navbar .navbar-brand:hover {
-  color: #ddd;
-}
-
-.navbar .navbar-brand .status {
-  color: #ddd;
-}
-
-.navbar-default .navbar-nav > li > a {
-  color: #ddd;
-}
-
-.navbar-inverse {
-  background-color: #222;
-  border-color: #555;
-}
-
-table {
-  background-color: #282828;
-}
-
-.table-striped > tbody > tr:nth-of-type(odd) {
-  background-color: #333;
-}
-
-.table-bordered,
-.table-bordered > tbody > tr > td,
-.table-bordered > tbody > tr > th,
-.table-bordered > tfoot > tr > td,
-.table-bordered > tfoot > tr > th,
-.table-bordered > thead > tr > td,
-.table-bordered > thead > tr > th {
-  border: 1px solid #555;
-}
-
-.table-hover > tbody > tr:hover {
-  background-color: #444;
-}
-
-.alert {
-  border: none;
-  color: #ddd;
-}
-
-.alert-success {
-  background-color: #484;
-}
-
-.alert-danger {
-  background-color: #980035;
-}
-
-.alert-info {
-  background-color: #31708f;
-}
-
-a:link,
-a:active,
-a:hover {
-  color: #ddd;
-}
-
-input {
-  background-color: #444;
-  color: #ccc;
-  padding: 3px;
-}
-
-.summary_bar .summary {
-  background-color: #222;
-  border: 1px solid #555;
-
-  box-shadow: 0 0 5px rgba(255, 255, 255, 0.1);
-}
-
-.navbar-default {
-  background-color: #222;
-  border-color: #555;
-}
-
-.navbar-default .navbar-nav > .active > a,
-.navbar-default .navbar-nav > .active > a:focus,
-.navbar-default .navbar-nav > .active > a:hover {
-  color: #ddd;
-  background-color: #333;
-}
-
-.navbar-default .navbar-nav > li > a:hover {
-  color: #ddd;
-}
-
-.pagination > li > a,
-.pagination > li > a:hover,
-.pagination > li > span {
-  color: #ddd;
-  background-color: #333;
-  border-color: #555;
-}
-.pagination > .disabled > a,
-.pagination > .disabled > a:focus,
-.pagination > .disabled > a:hover,
-.pagination > .disabled > span,
-.pagination > .disabled > span:focus,
-.pagination > .disabled > span:hover {
-  color: #ddd;
-  background-color: #333;
-  border-color: #555;
-}
-
-.stat {
-  border: 1px solid rgba(255, 255, 255, 0.1);
-}
-
-.rickshaw_graph .detail {
-  background: rgba(255, 255, 255, .1)
-}
-.rickshaw_graph .x_tick {
-  border-color: rgba(255, 255, 255, .2);
-}
-
-.rickshaw_graph .y_ticks.glow text {
-  fill: #ddd;
-  color: #ddd;
-}
-
-.info-circle {
-  color: #222;
-  background-color: #888;
-}