class Sidekiq::Middleware::Chain

def add(klass, *args)

Parameters:
  • *args (Array) -- Set of arguments to pass to every instance of your middleware
  • klass (Class) -- Your middleware class
  • def add(klass, *args)
      remove(klass)
      entries << Entry.new(@config, klass, *args)
    end

    def clear

    def clear
      entries.clear
    end

    def copy_for(capsule)

    def copy_for(capsule)
      chain = Sidekiq::Middleware::Chain.new(capsule)
      chain.instance_variable_set(:@entries, entries.dup)
      chain
    end

    def each(&block)

    Iterate through each middleware in the chain
    def each(&block)
      entries.each(&block)
    end

    def empty?

    Returns:
    • (Boolean) - if the chain contains no middleware
    def empty?
      @entries.nil? || @entries.empty?
    end

    def entries

    def entries
      @entries ||= []
    end

    def exists?(klass)

    Returns:
    • (Boolean) - if the given class is already in the chain
    def exists?(klass)
      any? { |entry| entry.klass == klass }
    end

    def initialize(config = nil) # :nodoc:

    Other tags:
      Api: - private
    def initialize(config = nil) # :nodoc:
      @config = config
      @entries = nil
      yield self if block_given?
    end

    def insert_after(oldklass, newklass, *args)

    Useful if one middleware must run after another middleware.
    Inserts +newklass+ after +oldklass+ in the chain.
    def insert_after(oldklass, newklass, *args)
      i = entries.index { |entry| entry.klass == newklass }
      new_entry = i.nil? ? Entry.new(@config, newklass, *args) : entries.delete_at(i)
      i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
      entries.insert(i + 1, new_entry)
    end

    def insert_before(oldklass, newklass, *args)

    Useful if one middleware must run before another middleware.
    Inserts +newklass+ before +oldklass+ in the chain.
    def insert_before(oldklass, newklass, *args)
      i = entries.index { |entry| entry.klass == newklass }
      new_entry = i.nil? ? Entry.new(@config, newklass, *args) : entries.delete_at(i)
      i = entries.index { |entry| entry.klass == oldklass } || 0
      entries.insert(i, new_entry)
    end

    def invoke(*args, &block)

    Other tags:
      Api: - private
    def invoke(*args, &block)
      return yield if empty?
      chain = retrieve
      traverse(chain, 0, args, &block)
    end

    def prepend(klass, *args)

    Identical to {#add} except the middleware is added to the front of the chain.
    def prepend(klass, *args)
      remove(klass)
      entries.insert(0, Entry.new(@config, klass, *args))
    end

    def remove(klass)

    Parameters:
    • klass (Class) --
    def remove(klass)
      entries.delete_if { |entry| entry.klass == klass }
    end

    def retrieve

    def retrieve
      map(&:make_new)
    end

    def traverse(chain, index, args, &block)

    def traverse(chain, index, args, &block)
      if index >= chain.size
        yield
      else
        chain[index].call(*args) do
          traverse(chain, index + 1, args, &block)
        end
      end
    end