Class: Karafka::BaseResponder

Inherits:
Object
  • Object
show all
Defined in:
lib/karafka/base_responder.rb

Overview

Base responder from which all Karafka responders should inherit Similar to Rails responders concept. It allows us to design flow from one app to another by isolating what responses should be sent (and where) based on a given action It differs from Rails responders in the way it works: in std http request we can have one response, here we can have unlimited number of them

It has a simple API for defining where should we respond (and if it is required)

Examples:

Basic usage (each registered topic is required to be used by default)

class Responder < BaseResponder
  topic :new_action

  def respond(data)
    respond_to :new_action, data
  end
end

Responding to a topic with extra options

class Responder < BaseResponder
  topic :new_action

  def respond(data)
    respond_to :new_action, data, partition_key: 'thing'
  end
end

Marking topic as not required (we won’t have to use it)

class Responder < BaseResponder
  topic :required_topic
  topic :new_action, required: false

  def respond(data)
    respond_to :required_topic, data
  end
end

Multiple times used topic

class Responder < BaseResponder
  topic :required_topic, multiple_usage: true

  def respond(data)
    data.each do |subset|
      respond_to :required_topic, subset
    end
  end
end

Accept multiple arguments to a respond method

class Responder < BaseResponder
  topic :users_actions
  topic :articles_viewed

  def respond(user, article)
    respond_to :users_actions, user
    respond_to :articles_viewed, article
  end
end

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(parser_class = Karafka::App.config.parser) ⇒ Karafka::BaseResponder

Creates a responder object

Parameters:

  • parser_class (Class) (defaults to: Karafka::App.config.parser) —

    parser class that we can use to generate appropriate string or nothing if we want to default to Karafka::Parsers::Json



95
96
97
98
 
# File 'lib/karafka/base_responder.rb', line 95

def initialize(parser_class = Karafka::App.config.parser)
  @parser_class = parser_class
  @messages_buffer = {}
end

Instance Attribute Details

#messages_buffer ⇒ Object (readonly)

Returns the value of attribute messages_buffer.



65
66
67
 
# File 'lib/karafka/base_responder.rb', line 65

def messages_buffer
  @messages_buffer
end

Class Method Details

.call(*data) ⇒ Object

A simple alias for easier standalone responder usage. Instead of building it with new.call it allows (in case of usin JSON parser) to just run it directly from the class level

Examples:

Send user data with a responder (uses default Karafka::Parsers::Json parser)

UsersCreatedResponder.call(@created_user)

Parameters:

  • data —

    Anything that we want to respond with



83
84
85
86
87
88
 
# File 'lib/karafka/base_responder.rb', line 83

def call(*data)
  # Just in case there were no topics defined for a responder, we initialize with
  # empty hash not to handle a nil case
  self.topics ||= {}
  new.call(*data)
end

.topic(topic_name, options = {}) ⇒ Object

Registers a topic as on to which we will be able to respond

Parameters:

  • topic_name (Symbol, String) —

    name of topic to which we want to respond

  • options (Hash) (defaults to: {}) —

    hash with optional configuration details



71
72
73
74
75
 
# File 'lib/karafka/base_responder.rb', line 71

def topic(topic_name, options = {})
  self.topics ||= {}
  topic_obj = Responders::Topic.new(topic_name, options.merge(registered: true))
  self.topics[topic_obj.name] = topic_obj
end

Instance Method Details

#call(*data) ⇒ Object

Note:

We know that validators should be executed also before sending data to topics, however the implementation gets way more complicated then, that’s why we check after everything was sent using responder

Performs respond and validates that all the response requirement were met

Examples:

Send user data with a responder (uses default Karafka::Parsers::Json parser)

UsersCreatedResponder.new.call(@created_user)

Send user data with a responder using non default Parser

UsersCreatedResponder.new(MyParser).call(@created_user)

Parameters:

  • data —

    Anything that we want to respond with



109
110
111
112
113
 
# File 'lib/karafka/base_responder.rb', line 109

def call(*data)
  respond(*data)
  validate!
  deliver!
end