freddy-jruby 0.5.1 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 304a469e602a811401b7e58433f7adc482b35798
-  data.tar.gz: 959e5d55ea51de9e6f42bc4a85abe767125ee5eb
+  metadata.gz: 0b6494076ba5683b88c6381cd4fe89140d4cb877
+  data.tar.gz: 8dcea8a4f75bba5192ec372998a822f9fbc4ab70
 SHA512:
-  metadata.gz: 49d8f58e7ecb635cd784486ecdf78a1316745b3de5d17aa5f60f9f6fb478aacf0be5191511f40429438de0d5a53ea188c617e26f5be0345834d87c43b63a3c82
-  data.tar.gz: 1f61a010e7a14caf92e7ce3990f888e7d0383786a8bc30a1e4a697c411b1a43b0f53743dec3564ab028a0ff13b5c13f5b7639f5da4c8fc50eb7f6c046a60e1c1
+  metadata.gz: 4d05477dbd8e2aec9e0e4044edef0720dfaad0c96f9c2ece269c32388fb412332c0573ff44fc7926885bcafa4fa0e4c9895f7f17abadc9768b81cda3579de4fd
+  data.tar.gz: e49f5287155ad988a10474366f13e9b371712abedd9f6c3f46082d5ae57a73f2f1b78cfe04b42131e96e2a30b2a67af933be83322642d7325ebde0ffcf40e4a1

data/.gitignore

@@ -3,3 +3,4 @@ Gemfile.lock
 pkg
 .tags
 .tags1
+coverage

data/.travis.yml

@@ -1,7 +1,10 @@
 language: ruby
 rvm:
   - 2.1.0
-  - jruby-9.0.0.0
+  - jruby-9.0.4.0
+addons:
+  code_climate:
+    repo_token: 1f3842b985fdeff6a36168165d491ca5f444667e9381a85c899a61706a9dd285
 services:
   - rabbitmq
 before_script:

data/Gemfile

@@ -1,8 +1,7 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-group :test, :development do
-  gem 'rspec'
-  gem 'pry'
-end
+gem 'rspec'
+gem 'pry'
+gem 'codeclimate-test-reporter'
 
 gemspec

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://travis-ci.org/salemove/freddy.svg?branch=master)](https://travis-ci.org/salemove/freddy)
 [![Code Climate](https://codeclimate.com/github/salemove/freddy/badges/gpa.svg)](https://codeclimate.com/github/salemove/freddy)
+[![Test Coverage](https://codeclimate.com/github/salemove/freddy/badges/coverage.svg)](https://codeclimate.com/github/salemove/freddy/coverage)
 
 ## Setup
 

data/freddy.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   else
     spec.name          = "freddy"
   end
-  spec.version       = '0.5.1'
+  spec.version       = '0.5.6'
   spec.authors       = ["Urmas Talimaa"]
   spec.email         = ["urmas.talimaa@gmail.com"]
   spec.description   = %q{Messaging API}

data/lib/freddy.rb

@@ -34,7 +34,7 @@ class Freddy
     @connection = connection
     @logger = logger
 
-    @tap_into_consumer = Consumers::TapIntoConsumer.new(consume_thread_pool)
+    @tap_into_consumer = Consumers::TapIntoConsumer.new(consume_thread_pool, @logger)
     @respond_to_consumer = Consumers::RespondToConsumer.new(consume_thread_pool, @logger)
 
     @send_and_forget_producer = Producers::SendAndForgetProducer.new(
@@ -75,9 +75,11 @@ class Freddy
 
     channel = @connection.create_channel
     producer = Producers::ReplyProducer.new(channel, @logger)
-    handler_factory = MessageHandlers::Factory.new(producer, @logger)
+    handler_adapter_factory = MessageHandlerAdapters::Factory.new(producer)
 
-    @respond_to_consumer.consume(destination, channel, handler_factory, &callback)
+    @respond_to_consumer.consume(
+      destination, channel, handler_adapter_factory, &callback
+    )
   end
 
   # Listens for messages without consuming them

data/lib/freddy/adapters.rb

@@ -9,5 +9,22 @@ class Freddy
         BunnyAdapter
       end
     end
+
+    module Shared
+      class Queue
+        def initialize(queue)
+          @queue = queue
+        end
+
+        def bind(*args)
+          @queue.bind(*args)
+          self
+        end
+
+        def name
+          @queue.name
+        end
+      end
+    end
   end
 end

data/lib/freddy/adapters/bunny_adapter.rb

@@ -45,26 +45,13 @@ class Freddy
         end
       end
 
-      class Queue
-        def initialize(queue)
-          @queue = queue
-        end
-
+      class Queue < Shared::Queue
         def subscribe(&block)
           @queue.subscribe do |info, properties, payload|
             parsed_payload = Payload.parse(payload)
             block.call(Delivery.new(parsed_payload, properties, info.routing_key))
           end
         end
-
-        def bind(*args)
-          @queue.bind(*args)
-          self
-        end
-
-        def name
-          @queue.name
-        end
       end
     end
   end

data/lib/freddy/adapters/march_hare_adapter.rb

@@ -44,26 +44,13 @@ class Freddy
         end
       end
 
-      class Queue
-        def initialize(queue)
-          @queue = queue
-        end
-
+      class Queue < Shared::Queue
         def subscribe(&block)
           @queue.subscribe do |meta, payload|
             parsed_payload = Payload.parse(payload)
             block.call(Delivery.new(parsed_payload, meta, meta.routing_key))
           end
         end
-
-        def bind(*args)
-          @queue.bind(*args)
-          self
-        end
-
-        def name
-          @queue.name
-        end
       end
     end
   end

data/lib/freddy/consumers.rb

@@ -1 +1,13 @@
+class Freddy
+  module Consumers
+    def self.log_receive_event(logger, queue_name, delivery)
+      if defined?(Logasm) && logger.is_a?(Logasm)
+        logger.debug "Received message", queue: queue_name, payload: delivery.payload, correlation_id: delivery.correlation_id
+      else
+        logger.debug "Received message on #{queue_name} with payload #{delivery.payload} with correlation_id #{delivery.correlation_id}"
+      end
+    end
+  end
+end
+
 Dir[File.dirname(__FILE__) + '/consumers/*.rb'].each(&method(:require))

data/lib/freddy/consumers/respond_to_consumer.rb

@@ -6,14 +6,14 @@ class Freddy
         @logger = logger
       end
 
-      def consume(destination, channel, handler_factory, &block)
+      def consume(destination, channel, handler_adapter_factory, &block)
         consumer = consume_from_destination(destination, channel) do |delivery|
-          log_receive_event(destination, delivery)
+          Consumers.log_receive_event(@logger, destination, delivery)
 
-          handler = handler_factory.build(delivery.type, destination)
+          adapter = handler_adapter_factory.for(delivery)
 
-          msg_handler = MessageHandler.new(handler, delivery)
-          handler.handle_message delivery.payload, msg_handler, &block
+          msg_handler = MessageHandler.new(adapter, delivery)
+          block.call(delivery.payload, msg_handler)
         end
 
         ResponderHandler.new(consumer, @consume_thread_pool)
@@ -32,14 +32,6 @@ class Freddy
           block.call(delivery)
         end
       end
-
-      def log_receive_event(destination, delivery)
-        if defined?(Logasm) && @logger.is_a?(Logasm)
-          @logger.debug "Received message", queue: destination, payload: delivery.payload, correlation_id: delivery.correlation_id
-        else
-          @logger.debug "Received message on #{destination} with payload #{delivery.payload} with correlation_id #{delivery.correlation_id}"
-        end
-      end
     end
   end
 end

data/lib/freddy/consumers/response_consumer.rb

@@ -18,18 +18,10 @@ class Freddy
 
       def process_message(queue, delivery, &block)
         @dedicated_thread_pool.process do
-          log_receive_event(queue.name, delivery)
+          Consumers.log_receive_event(@logger, queue.name, delivery)
           block.call(delivery)
         end
       end
-
-      def log_receive_event(queue_name, delivery)
-        if defined?(Logasm) && @logger.is_a?(Logasm)
-          @logger.debug "Received message", queue: queue_name, payload: delivery.payload, correlation_id: delivery.correlation_id
-        else
-          @logger.debug "Received message on #{queue_name} with payload #{delivery.payload} with correlation_id #{delivery.correlation_id}"
-        end
-      end
     end
   end
 end

data/lib/freddy/consumers/tap_into_consumer.rb

@@ -1,7 +1,8 @@
 class Freddy
   module Consumers
     class TapIntoConsumer
-      def initialize(consume_thread_pool)
+      def initialize(consume_thread_pool, logger)
+        @logger = logger
         @consume_thread_pool = consume_thread_pool
       end
 
@@ -9,7 +10,7 @@ class Freddy
         queue = create_queue(pattern, channel)
 
         consumer = queue.subscribe do |delivery|
-          process_message(delivery, &block)
+          process_message(queue, delivery, &block)
         end
 
         ResponderHandler.new(consumer, @consume_thread_pool)
@@ -25,8 +26,9 @@ class Freddy
           .bind(topic_exchange, routing_key: pattern)
       end
 
-      def process_message(delivery, &block)
+      def process_message(queue, delivery, &block)
         @consume_thread_pool.process do
+          Consumers.log_receive_event(@logger, queue.name, delivery)
           block.call delivery.payload, delivery.routing_key
         end
       end

data/lib/freddy/message_handler.rb

@@ -1,19 +1,16 @@
 class Freddy
   class MessageHandler
-    attr_reader :correlation_id
-
     def initialize(adapter, delivery)
       @adapter = adapter
       @delivery = delivery
-      @correlation_id = @delivery.correlation_id
     end
 
     def success(response = nil)
-      @adapter.success(@delivery.reply_to, response)
+      @adapter.success(@delivery, response)
     end
 
-    def error(error = {error: "Couldn't process message"})
-      @adapter.error(@delivery.reply_to, error)
+    def error(response = {error: "Couldn't process message"})
+      @adapter.error(@delivery, response)
     end
   end
 end

data/lib/freddy/message_handler_adapaters.rb

@@ -0,0 +1,50 @@
+class Freddy
+  module MessageHandlerAdapters
+    class Factory
+      def initialize(producer)
+        @no_op_handler = NoOpHandler.new
+        @request_handler = RequestHandler.new(producer)
+      end
+
+      def for(delivery)
+        if delivery.type == 'request'
+          @request_handler
+        else
+          @no_op_handler
+        end
+      end
+    end
+
+    class NoOpHandler
+      def success(*)
+        # NOP
+      end
+
+      def error(*)
+        # NOP
+      end
+    end
+
+    class RequestHandler
+      def initialize(producer)
+        @producer = producer
+      end
+
+      def success(delivery, response)
+        send_response(delivery, response, type: 'success')
+      end
+
+      def error(delivery, response)
+        send_response(delivery, response, type: 'error')
+      end
+
+      private
+
+      def send_response(delivery, response, opts = {})
+        @producer.produce delivery.reply_to.force_encoding('utf-8'), response, {
+          correlation_id: delivery.correlation_id
+        }.merge(opts)
+      end
+    end
+  end
+end

data/lib/freddy/producers/send_and_wait_response_producer.rb

@@ -17,27 +17,21 @@ class Freddy
         end
 
         @response_queue = @channel.queue("", exclusive: true)
-        @request_manager.start
 
         @response_consumer = Consumers::ResponseConsumer.new(@logger)
         @response_consumer.consume(@response_queue, &method(:handle_response))
       end
 
-      def produce(destination, payload, properties)
-        timeout_in_seconds = properties.fetch(:timeout_in_seconds)
-        container = SyncResponseContainer.new
-        async_request destination, payload, properties, &container
-        container.wait_for_response(timeout_in_seconds + 0.1)
-      end
+      def produce(destination, payload, timeout_in_seconds:, delete_on_timeout:, **properties)
+        correlation_id = SecureRandom.uuid
 
-      private
+        container = SyncResponseContainer.new(
+          on_timeout(correlation_id, destination, timeout_in_seconds)
+        )
 
-      def async_request(destination, payload, timeout_in_seconds:, delete_on_timeout:, **properties, &block)
-        correlation_id = SecureRandom.uuid
         @request_manager.store(correlation_id,
-          callback: block,
-          destination: destination,
-          expires_at: Time.now + timeout_in_seconds
+          callback: container,
+          destination: destination
         )
 
         if delete_on_timeout
@@ -59,6 +53,8 @@ class Freddy
         # need to lock these.
         @topic_exchange.publish json_payload, properties.dup
         @exchange.publish json_payload, properties.dup
+
+        container.wait_for_response(timeout_in_seconds)
       end
 
       def handle_response(delivery)
@@ -78,11 +74,23 @@ class Freddy
         @logger.debug "Got response for request to #{request[:destination]} "\
                       "with correlation_id #{delivery.correlation_id}"
         request[:callback].call(delivery.payload, delivery)
-      rescue => e
-        @logger.error "Exception occured while handling the response of "\
-                      "request made to #{request[:destination]} with "\
-                      "correlation_id #{correlation_id}: #{Utils.format_exception(e)}"
-        Utils.notify_exception(e, destination: request[:destination], correlation_id: correlation_id)
+      end
+
+      def on_timeout(correlation_id, destination, timeout_in_seconds)
+        Proc.new do
+          @logger.warn "Request timed out waiting response from #{destination}"\
+                       ", correlation id #{correlation_id}"
+
+          Utils.notify 'RequestTimeout',
+            "Request timed out waiting for response from #{destination}",
+            {
+              correlation_id: correlation_id,
+              destination: destination,
+              timeout_in_seconds: timeout_in_seconds
+            }
+
+          @request_manager.delete(correlation_id)
+        end
       end
     end
   end

data/lib/freddy/request_manager.rb

@@ -1,20 +1,10 @@
 class Freddy
   class RequestManager
-
     def initialize(logger)
       @requests = Hamster.mutable_hash
       @logger = logger
     end
 
-    def start
-      @timeout_thread = Thread.new do
-        while true do
-          clear_timeouts Time.now
-          sleep 0.05
-        end
-      end
-    end
-
     def no_route(correlation_id)
       if request = @requests[correlation_id]
         @requests.delete correlation_id
@@ -29,26 +19,5 @@ class Freddy
     def delete(correlation_id)
       @requests.delete(correlation_id)
     end
-
-    private
-
-    def clear_timeouts(now)
-      @requests.each do |key, value|
-        timeout(key, value) if now > value[:expires_at]
-      end
-    end
-
-    def timeout(correlation_id, request)
-      @requests.delete correlation_id
-
-      @logger.warn "Request timed out waiting response from #{request[:destination]}, correlation id #{correlation_id}"
-      Utils.notify 'RequestTimeout', "Request timed out waiting for response from #{request[:destination]}", {
-        correlation_id: correlation_id,
-        destination: request[:destination],
-        expires_at: request[:expires_at]
-      }
-
-      request[:callback].call({error: 'RequestTimeout', message: 'Timed out waiting for response'}, nil)
-    end
   end
 end

data/lib/freddy/sync_response_container.rb

@@ -3,41 +3,36 @@ require 'timeout'
 
 class Freddy
   class SyncResponseContainer
-    def initialize
+    def initialize(on_timeout)
       @mutex = Mutex.new
+      @resource = ConditionVariable.new
+      @on_timeout = on_timeout
     end
 
     def call(response, delivery)
+      if response.nil?
+        raise StandardError, 'unexpected nil value for response'
+      end
+
       @response = response
       @delivery = delivery
-      @mutex.synchronize { @waiting.wakeup }
+      @mutex.synchronize { @resource.signal }
     end
 
     def wait_for_response(timeout)
-      @mutex.synchronize do
-        @waiting = Thread.current
-        @mutex.sleep(timeout)
-      end
+      @mutex.synchronize { @response || @resource.wait(@mutex, timeout) }
 
-      if @response.nil?
-        raise Timeout::Error, 'execution expired'
-      elsif @response[:error] == 'RequestTimeout'
-        raise TimeoutError.new(@response)
+      if !@response
+        @on_timeout.call
+        raise TimeoutError.new(
+          error: 'RequestTimeout',
+          message: 'Timed out waiting for response'
+        )
       elsif !@delivery || @delivery.type == 'error'
         raise InvalidRequestError.new(@response)
       else
         @response
       end
     end
-
-    private
-
-    def to_proc
-      Proc.new {|*args| self.call(*args)}
-    end
-
-    def filled?
-      !@response.nil?
-    end
   end
 end

data/lib/freddy/utils.rb

@@ -1,12 +1,10 @@
 class Freddy
   class Utils
     def self.format_exception(exception)
-      backtrace = exception.backtrace.map do |x|
-        x.match(/^(.+?):(\d+)(|:in `(.+)')$/);
-        [$1, $2, $4]
-      end.join("\n")
+      message = exception.message
+      backtrace = exception.backtrace.join("\n")
 
-      "#{exception.exception}\n#{backtrace}"
+      "#{message}\n#{backtrace}"
     end
 
     def self.notify(name, message, parameters={})

data/spec/freddy/consumers_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Freddy::Consumers do
+  describe '.log_receive_event' do
+    subject { described_class.log_receive_event(logger, queue_name, delivery) }
+
+    let(:queue_name) { 'salemove' }
+    let(:delivery) do
+      instance_double(Freddy::Delivery,
+        payload: {key: 'value'},
+        correlation_id: 'a1b2'
+      )
+    end
+
+    context 'when configured with logasm logger' do
+      let(:logger) { logasm_class.new }
+      let(:logasm_class) { Class.new }
+
+      before do
+        stub_const('::Logasm', logasm_class)
+      end
+
+      it 'logs the received event' do
+        expect(logger).to receive(:debug).with('Received message',
+          queue: 'salemove', payload: {key: 'value'}, correlation_id: 'a1b2'
+        )
+
+        subject
+      end
+    end
+
+    context 'when configured with regular logger' do
+      let(:logger) { Logger.new('/dev/null') }
+
+      it 'logs the received event' do
+        expect(logger).to receive(:debug)
+          .with('Received message on salemove with payload {:key=>"value"} with correlation_id a1b2')
+
+        subject
+      end
+    end
+  end
+end

data/spec/freddy/message_handler_spec.rb

@@ -4,12 +4,11 @@ describe Freddy::MessageHandler do
   subject(:handler) { described_class.new(adapter, delivery) }
 
   let(:adapter) { double }
-  let(:delivery) { double(reply_to: reply_to, correlation_id: 'abc') }
-  let(:reply_to) { double }
+  let(:delivery) { double }
 
   describe '#success' do
     it 'delegates to the adapter' do
-      expect(adapter).to receive(:success).with(reply_to, x: 'y')
+      expect(adapter).to receive(:success).with(delivery, x: 'y')
 
       subject.success(x: 'y')
     end
@@ -17,7 +16,7 @@ describe Freddy::MessageHandler do
 
   describe '#error' do
     it 'delegates to the adapter' do
-      expect(adapter).to receive(:error).with(reply_to, error: 'text')
+      expect(adapter).to receive(:error).with(delivery, error: 'text')
 
       subject.error(error: 'text')
     end

data/spec/freddy/sync_response_container_spec.rb

@@ -1,13 +1,54 @@
 require 'spec_helper'
 
 describe Freddy::SyncResponseContainer do
-  let(:container) { described_class.new }
+  let(:container) { described_class.new(on_timeout) }
+  let(:on_timeout) { Proc.new {} }
 
   context 'when timeout' do
     subject { container.wait_for_response(0.01) }
 
     it 'raises timeout error' do
-      expect { subject }.to raise_error(Timeout::Error, 'execution expired')
+      expect { subject }.to raise_error do |error|
+        expect(error).to be_a(Freddy::TimeoutError)
+        expect(error.response).to eq(
+          error: 'RequestTimeout',
+          message: 'Timed out waiting for response'
+        )
+      end
+    end
+  end
+
+  context 'when nil response' do
+    let(:delivery) { {} }
+
+    it 'raises timeout error' do
+      expect {
+        container.call(nil, delivery)
+      }.to raise_error(StandardError, 'unexpected nil value for response')
+    end
+  end
+
+  describe '#wait_for_response' do
+    let(:timeout) { 2 }
+    let(:response) { {msg: 'response'} }
+    let(:delivery) { OpenStruct.new(type: 'success') }
+
+    context 'when called after #call' do
+      let(:max_wait_time_in_seconds) { 0.5 }
+
+      before do
+        container.call(response, delivery)
+      end
+
+      it 'returns response' do
+        expect(container.wait_for_response(timeout)).to eq(response)
+      end
+
+      it 'does not wait for timeout' do
+        expect {
+          container.wait_for_response(timeout)
+        }.to change(Time, :now).by_at_most(max_wait_time_in_seconds)
+      end
     end
   end
 end

data/spec/freddy/utils_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Freddy::Utils do
+  describe '.format_exception' do
+    subject { described_class.format_exception(exception) }
+
+    let(:exception) { double(backtrace: backtrace, message: message) }
+    let(:message)   { 'format exception test' }
+    let(:backtrace) { ['line1', 'line2', 'line3'] }
+
+    it 'format the exception' do
+      should eq "format exception test\n" \
+        "line1\n" \
+        "line2\n" \
+        'line3'
+    end
+  end
+
+  describe '.notify' do
+    subject { described_class.notify(error_class, error_message, parameters) }
+
+    let(:env_attributes) { double }
+    let(:error_class)    { double }
+    let(:error_message)  { double }
+    let(:parameters)     { double }
+
+    context 'when Airbrake is defined' do
+      let(:airbrake) { double }
+
+      before do
+        allow(ENV).to receive(:to_hash) { env_attributes }
+        stub_const('::Airbrake', airbrake)
+      end
+
+      it 'notifies airbrake' do
+        expect(airbrake).to receive(:notify_or_ignore).with(
+          error_class: error_class,
+          error_message: error_message,
+          cgi_data: env_attributes,
+          parameters: parameters
+        )
+
+        subject
+      end
+    end
+
+    context 'when Airbrake is not defined' do
+      it 'does nothing' do
+        should eq(nil)
+      end
+    end
+  end
+
+  describe '.notify_exception' do
+    subject { described_class.notify_exception(exception, {a: 'b'}) }
+
+    let(:exception) { double }
+
+    context 'when Airbrake is defined' do
+      let(:airbrake) { double }
+
+      before do
+        stub_const('::Airbrake', airbrake)
+      end
+
+      it 'notifies airbrake' do
+        expect(airbrake).to receive(:notify_or_ignore) do |ex, content|
+          expect(ex).to eq(exception)
+          expect(content[:cgi_data]).to be_instance_of(Hash)
+          expect(content[:parameters]).to eq(a: 'b')
+        end
+
+        subject
+      end
+    end
+
+    context 'when Airbrake is not defined' do
+      it 'does nothing' do
+        should eq(nil)
+      end
+    end
+  end
+end

data/spec/integration/reply_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'Reply' do
+  let(:freddy) { Freddy.build(logger, config) }
+
+  let(:destination) { random_destination }
+  let(:request_payload) { {req: 'load'} }
+  let(:response_payload) { {res: 'load'} }
+
+  after { freddy.close }
+
+  context 'when a synchronized request' do
+    before do
+      freddy.respond_to(destination) do |payload, msg_handler|
+        msg_handler.success(response_payload)
+      end
+    end
+
+    it 'sends reply' do
+      response = freddy.deliver_with_response(destination, request_payload)
+      expect(response).to eq(response_payload)
+    end
+
+    it 'does not send the reply to the topic queue' do
+      freddy.tap_into 'amq.*' do |payload|
+        @message_received = true
+      end
+
+      freddy.deliver_with_response(destination, request_payload)
+      default_sleep
+
+      expect(@message_received).to be_falsy
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,16 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'codeclimate-test-reporter'
+SimpleCov.start do
+  formatter SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+    CodeClimate::TestReporter::Formatter
+  ])
+  add_filter '/spec/'
+end
+
 require 'pry'
 require 'securerandom'
 require 'freddy'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy-jruby
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.6
 platform: ruby
 authors:
 - Urmas Talimaa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -124,7 +124,7 @@ files:
 - lib/freddy/error_response.rb
 - lib/freddy/invalid_request_error.rb
 - lib/freddy/message_handler.rb
-- lib/freddy/message_handlers.rb
+- lib/freddy/message_handler_adapaters.rb
 - lib/freddy/payload.rb
 - lib/freddy/producers.rb
 - lib/freddy/producers/reply_producer.rb
@@ -136,13 +136,16 @@ files:
 - lib/freddy/timeout_error.rb
 - lib/freddy/utils.rb
 - spec/freddy/consumers/respond_to_consumer_spec.rb
+- spec/freddy/consumers_spec.rb
 - spec/freddy/error_response_spec.rb
 - spec/freddy/freddy_spec.rb
 - spec/freddy/message_handler_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
+- spec/freddy/utils_spec.rb
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
+- spec/integration/reply_spec.rb
 - spec/spec_helper.rb
 homepage:
 licenses:
@@ -170,11 +173,14 @@ specification_version: 4
 summary: API for inter-application messaging supporting acknowledgements and request-response
 test_files:
 - spec/freddy/consumers/respond_to_consumer_spec.rb
+- spec/freddy/consumers_spec.rb
 - spec/freddy/error_response_spec.rb
 - spec/freddy/freddy_spec.rb
 - spec/freddy/message_handler_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
+- spec/freddy/utils_spec.rb
 - spec/integration/concurrency_spec.rb
 - spec/integration/logging_spec.rb
+- spec/integration/reply_spec.rb
 - spec/spec_helper.rb

data/lib/freddy/message_handlers.rb

@@ -1,77 +0,0 @@
-class Freddy
-  module MessageHandlers
-    class Factory
-      def initialize(producer, logger)
-        @producer = producer
-        @logger = logger
-      end
-
-      def build(type, destination)
-        if type == 'request'
-          RequestHandler.new(@producer, destination, @logger)
-        else
-          StandardMessageHandler.new(destination, @logger)
-        end
-      end
-    end
-
-    class StandardMessageHandler
-      def initialize(destination, logger)
-        @destination = destination
-        @logger = logger
-      end
-
-      def handle_message(payload, msg_handler, &block)
-        block.call payload, msg_handler
-      rescue Exception => e
-        @logger.error "Exception occured while processing message from #{Utils.format_exception(e)}"
-        Utils.notify_exception(e, destination: @destination)
-      end
-
-      def success(*)
-        # NOP
-      end
-
-      def error(*)
-        # NOP
-      end
-    end
-
-    class RequestHandler
-      def initialize(producer, destination, logger)
-        @producer = producer
-        @logger = logger
-        @destination = destination
-      end
-
-      def handle_message(payload, msg_handler, &block)
-        @correlation_id = msg_handler.correlation_id
-
-        if !@correlation_id
-          @logger.error "Received request without correlation_id"
-        else
-          block.call payload, msg_handler
-        end
-      rescue Exception => e
-        @logger.error "Exception occured while handling the request with correlation_id #{@correlation_id}: #{Utils.format_exception(e)}"
-        Utils.notify_exception(e, correlation_id: @correlation_id, destination: @destination)
-      end
-
-      def success(reply_to, response)
-        send_response(reply_to, response, type: 'success')
-      end
-
-      def error(reply_to, response)
-        send_response(reply_to, response, type: 'error')
-      end
-
-      private
-
-      def send_response(reply_to, response, opts = {})
-        @producer.produce reply_to.force_encoding('utf-8'), response, {
-          correlation_id: @correlation_id
-        }.merge(opts)
-      end
-    end
-  end
-end