Class: Sqewer::MiddlewareStack

Inherits:
Object
  • Object
show all
Defined in:
lib/sqewer/middleware_stack.rb

Overview

Allows arbitrary wrapping of the job deserialization and job execution procedures

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ MiddlewareStack

Creates a new MiddlewareStack. Once created, handlers can be added using :<<



12
13
14
 
# File 'lib/sqewer/middleware_stack.rb', line 12

def initialize
  @handlers = []
end

Class Method Details

.default ⇒ MiddlewareStack

Returns the default middleware stack, which is empty (an instance of None).

Returns:



7
8
9
 
# File 'lib/sqewer/middleware_stack.rb', line 7

def self.default
  @instance ||= new
end

Instance Method Details

#<<(handler) ⇒ void

This method returns an undefined value.

Adds a handler. The handler should respond to :around_deserialization and #around_execution.

Parameters:

  • handler (#around_deserializarion, #around_execution) —

    The middleware item to insert



20
21
22
23
 
# File 'lib/sqewer/middleware_stack.rb', line 20

def <<(handler)
  @handlers << handler
  # TODO: cache the wrapping proc
end

#around_deserialization(serializer, message_id, message_body, message_attributes, &inner_block) ⇒ Object 



36
37
38
39
40
41
42
43
 
# File 'lib/sqewer/middleware_stack.rb', line 36

def around_deserialization(serializer, message_id, message_body, message_attributes, &inner_block)
  return yield if @handlers.empty?

  responders = @handlers.select{|e| e.respond_to?(:around_deserialization) }
  responders.reverse.inject(inner_block) {|outer_block, middleware_object|
    ->{ middleware_object.public_send(:around_deserialization, serializer, message_id, message_body, message_attributes, &outer_block) }
  }.call
end

#around_execution(job, context, &inner_block) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
 
# File 'lib/sqewer/middleware_stack.rb', line 25

def around_execution(job, context, &inner_block)
  return yield if @handlers.empty?

  responders = @handlers.select{|e| e.respond_to?(:around_execution) }
  responders.reverse.inject(inner_block) {|outer_block, middleware_object|
    ->{
      middleware_object.public_send(:around_execution, job, context, &outer_block)
    }
  }.call
end