freddy 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c9e0020e6933bdc25c5845a3bad630dc56b4ae9
-  data.tar.gz: 55da31d069e4dd316260d37a0db00965a737039e
+  metadata.gz: ec35bbe29d804ef1930904b88277dc9bcd6722e7
+  data.tar.gz: 045d21384a3ed02bbe66c41a01f25a5cde723c1e
 SHA512:
-  metadata.gz: 78b24b50ec3a7779572c1a45ce1b59d6ce345a058dda2c6781048b65a5312f210cb4595fc678450ea9a73dbf95951a902598def1e1bad3493071b4f903db1e5f
-  data.tar.gz: 7ee8fd7a118ef27a164becdf4bab34b977ba31dada15040233aff1807c56648d6b0dd1d58ce691a0bf3f563304d0f94a7201ac1b14c625a86b318b2d56a978e5
+  metadata.gz: cc2ec82ebe76f48b5e78ac3a695d71d16d49ca42bc08762c4b8c2b35c9c66a86c48fb8e743601bfb31c3c580e4906404f60122fa44e0269de51c4c9485af43d9
+  data.tar.gz: fdb43cf87cfdd043f785b827957b9309562a79637af82e9dccbacf62cc62f6f622e1b5b28019c55dda586fdcd2cc3803cbe101b7b81780267f3a6ae7addeddde

data/README.md

@@ -1,6 +1,6 @@
 # Messaging API supporting acknowledgements and request-response
 
-[![Build Status](https://travis-ci.org/salemove/node-freddy.svg?branch=master)](https://travis-ci.org/salemove/node-freddy)
+[![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)
 
 ## Setup

data/freddy.gemspec

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

data/lib/freddy/adapters/bunny_adapter.rb

@@ -48,7 +48,8 @@ class Freddy
 
         def subscribe(&block)
           @queue.subscribe do |info, properties, payload|
-            block.call(payload, Delivery.new(properties, info.routing_key))
+            parsed_payload = Payload.parse(payload)
+            block.call(Delivery.new(parsed_payload, properties, info.routing_key))
           end
         end
 

data/lib/freddy/adapters/march_hare_adapter.rb

@@ -49,7 +49,8 @@ class Freddy
 
         def subscribe(&block)
           @queue.subscribe do |meta, payload|
-            block.call(payload, Delivery.new(meta, meta.routing_key))
+            parsed_payload = Payload.parse(payload)
+            block.call(Delivery.new(parsed_payload, meta, meta.routing_key))
           end
         end
 

data/lib/freddy/consumer.rb

@@ -1,69 +1,32 @@
 require_relative 'responder_handler'
 require_relative 'message_handler'
-require_relative 'request'
 require_relative 'delivery'
+require_relative 'consumers/tap_into_consumer'
+require_relative 'consumers/respond_to_consumer'
+require_relative 'consumers/response_consumer'
 
 class Freddy
   class Consumer
-
-    class EmptyConsumer < Exception
-    end
-
-    def initialize(channel, logger, consume_thread_pool)
+    def initialize(channel, logger, consume_thread_pool, producer)
       @channel, @logger = channel, logger
-      @topic_exchange = @channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
-      @consume_thread_pool = consume_thread_pool
-      @dedicated_thread_pool = Thread.pool(1) # used only internally
-    end
-
-    def consume(destination, options = {}, &block)
-      raise EmptyConsumer unless block
-      consume_from_queue create_queue(destination), options, &block
-    end
-
-    def consume_from_queue(queue, options = {}, &block)
-      consume_using_pool(queue, options, @consume_thread_pool, &block)
+      @tap_into_consumer = Consumers::TapIntoConsumer.new(consume_thread_pool, channel)
+      @respond_to_consumer = Consumers::RespondToConsumer.new(consume_thread_pool, channel, producer, @logger)
+      @response_consumer = Consumers::ResponseConsumer.new(@logger)
     end
 
-    def dedicated_consume(queue, &block)
-      consume_using_pool(queue, {}, @dedicated_thread_pool, &block)
+    def response_consume(queue, &block)
+      @logger.debug "Consuming messages on #{queue.name}"
+      @response_consumer.consume(queue, &block)
     end
 
     def tap_into(pattern, &block)
-      queue = create_queue('', exclusive: true).bind(@topic_exchange, routing_key: pattern)
-      consumer = queue.subscribe do |payload, delivery|
-        @consume_thread_pool.process do
-          block.call Payload.parse(payload), delivery.routing_key
-        end
-      end
       @logger.debug "Tapping into messages that match #{pattern}"
-      ResponderHandler.new consumer, @consume_thread_pool
-    end
-
-    private
-
-    def consume_using_pool(queue, options, pool, &block)
-      consumer = queue.subscribe do |payload, delivery|
-        pool.process do
-          parsed_payload = Payload.parse(payload)
-          log_receive_event(queue.name, parsed_payload, delivery.correlation_id)
-          block.call parsed_payload, delivery
-        end
-      end
-      @logger.debug "Consuming messages on #{queue.name}"
-      ResponderHandler.new consumer, pool
-    end
-
-    def create_queue(destination, options={})
-      @channel.queue(destination, options)
+      @tap_into_consumer.consume(pattern, &block)
     end
 
-    def log_receive_event(queue_name, payload, correlation_id)
-      if defined?(Logasm) && @logger.is_a?(Logasm)
-        @logger.debug "Received message", queue: queue_name, payload: payload, correlation_id: correlation_id
-      else
-        @logger.debug "Received message on #{queue_name} with payload #{payload} with correlation_id #{correlation_id}"
-      end
+    def respond_to(destination, &block)
+      @logger.info "Listening for requests on #{destination}"
+      @respond_to_consumer.consume(destination, &block)
     end
   end
 end

data/lib/freddy/consumers/respond_to_consumer.rb

@@ -0,0 +1,59 @@
+class Freddy
+  module Consumers
+    class RespondToConsumer
+      def initialize(consume_thread_pool, channel, producer, logger)
+        @consume_thread_pool = consume_thread_pool
+        @channel = channel
+        @producer = producer
+        @logger = logger
+        @response_queue_lock = Mutex.new
+      end
+
+      def consume(destination, &block)
+        ensure_response_queue_exists
+
+        consumer = consume_from_destination(destination) do |delivery|
+          log_receive_event(destination, delivery)
+
+          handler_class = MessageHandlers.for_type(delivery.type)
+          handler = handler_class.new(@producer, destination, @logger)
+
+          msg_handler = MessageHandler.new(handler, delivery)
+          handler.handle_message delivery.payload, msg_handler, &block
+        end
+
+        ResponderHandler.new(consumer, @consume_thread_pool)
+      end
+
+      private
+
+      def consume_from_destination(destination, &block)
+        @channel.queue(destination).subscribe do |delivery|
+          process_message(delivery, &block)
+        end
+      end
+
+      def process_message(delivery, &block)
+        @consume_thread_pool.process do
+          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
+
+      def ensure_response_queue_exists
+        return @response_queue if defined?(@response_queue)
+
+        @response_queue_lock.synchronize do
+          @response_queue = @channel.queue('', exclusive: true)
+        end
+      end
+    end
+  end
+end

data/lib/freddy/consumers/response_consumer.rb

@@ -0,0 +1,34 @@
+class Freddy
+  module Consumers
+    class ResponseConsumer
+      def initialize(logger)
+        @logger = logger
+        @dedicated_thread_pool = Thread.pool(1)
+      end
+
+      def consume(queue, &block)
+        consumer = queue.subscribe do |delivery|
+          process_message(queue, delivery, &block)
+        end
+        ResponderHandler.new(consumer, @dedicated_thread_pool)
+      end
+
+      private
+
+      def process_message(queue, delivery, &block)
+        @dedicated_thread_pool.process do
+          log_receive_event(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

@@ -0,0 +1,33 @@
+class Freddy
+  module Consumers
+    class TapIntoConsumer
+      def initialize(consume_thread_pool, channel)
+        @consume_thread_pool = consume_thread_pool
+        @channel = channel
+        @topic_exchange = @channel.topic(Freddy::FREDDY_TOPIC_EXCHANGE_NAME)
+      end
+
+      def consume(pattern, &block)
+        consumer = create_queue(pattern).subscribe do |delivery|
+          process_message(delivery, &block)
+        end
+
+        ResponderHandler.new(consumer, @consume_thread_pool)
+      end
+
+      private
+
+      def create_queue(pattern)
+        @channel
+          .queue('', exclusive: true)
+          .bind(@topic_exchange, routing_key: pattern)
+      end
+
+      def process_message(delivery, &block)
+        @consume_thread_pool.process do
+          block.call delivery.payload, delivery.routing_key
+        end
+      end
+    end
+  end
+end

data/lib/freddy/delivery.rb

@@ -1,8 +1,9 @@
 class Freddy
   class Delivery
-    attr_reader :metadata, :routing_key
+    attr_reader :routing_key, :payload
 
-    def initialize(metadata, routing_key)
+    def initialize(payload, metadata, routing_key)
+      @payload = payload
       @metadata = metadata
       @routing_key = routing_key
     end
@@ -10,5 +11,13 @@ class Freddy
     def correlation_id
       @metadata.correlation_id
     end
+
+    def type
+      @metadata.type
+    end
+
+    def reply_to
+      @metadata.reply_to
+    end
   end
 end

data/lib/freddy/message_handler.rb

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

data/lib/freddy/payload.rb

@@ -23,7 +23,7 @@ class Freddy
 
     class OjAdapter
       def self.parse(payload)
-        Oj.load(payload, symbol_keys: true)
+        Oj.strict_load(payload, symbol_keys: true)
       end
 
       def self.dump(payload)

data/lib/freddy/request.rb

@@ -11,12 +11,6 @@ class Freddy
   class Request
     NO_ROUTE = 312
 
-    class EmptyRequest < Exception
-    end
-
-    class EmptyResponder < Exception
-    end
-
     def initialize(channel, logger, producer, consumer)
       @channel, @logger = channel, logger
       @producer, @consumer = producer, consumer
@@ -30,7 +24,6 @@ class Freddy
       end
 
       @listening_for_responses_lock = Mutex.new
-      @response_queue_lock = Mutex.new
     end
 
     def sync_request(destination, payload, opts)
@@ -63,33 +56,14 @@ class Freddy
       )
     end
 
-    def respond_to(destination, &block)
-      raise EmptyResponder unless block
-
-      ensure_response_queue_exists
-      @logger.info "Listening for requests on #{destination}"
-      responder_handler = @consumer.consume destination do |payload, delivery|
-        handler = MessageHandlers.for_type(delivery.metadata.type).new(@producer, destination, @logger)
-
-        msg_handler = MessageHandler.new(handler, delivery)
-        handler.handle_message payload, msg_handler, &block
-      end
-      responder_handler
-    end
-
     private
 
-    def create_response_queue
-      @channel.queue("", exclusive: true)
-    end
+    def handle_response(delivery)
+      correlation_id = delivery.correlation_id
 
-    def handle_response(payload, delivery)
-      correlation_id = delivery.metadata.correlation_id
-      request = @request_map[correlation_id]
-      if request
+      if request = @request_map.delete(correlation_id)
         @logger.debug "Got response for request to #{request[:destination]} with correlation_id #{correlation_id}"
-        @request_map.delete correlation_id
-        request[:callback].call payload, delivery
+        request[:callback].call delivery.payload, delivery
       else
         @logger.warn "Got rpc response for correlation_id #{correlation_id} but there is no requester"
         Utils.notify 'NoRequesterForResponse', "Got rpc response but there is no requester", correlation_id: correlation_id
@@ -100,24 +74,14 @@ class Freddy
       Utils.notify_exception(e, destination: request[:destination], correlation_id: correlation_id)
     end
 
-    def ensure_response_queue_exists
-      @response_queue_lock.synchronize do
-        @response_queue ||= create_response_queue
-      end
-    end
-
     def ensure_listening_to_responses
+      return @listening_for_responses if defined?(@listening_for_responses)
+
       @listening_for_responses_lock.synchronize do
-        if @listening_for_responses
-          true
-        else
-          ensure_response_queue_exists
-          @request_manager.start
-          @consumer.dedicated_consume @response_queue do |payload, delivery|
-            handle_response payload, delivery
-          end
-          @listening_for_responses = true
-        end
+        @response_queue ||= @channel.queue("", exclusive: true)
+        @request_manager.start
+        @consumer.response_consume(@response_queue, &method(:handle_response))
+        @listening_for_responses = true
       end
     end
   end

data/lib/freddy/sync_response_container.rb

@@ -23,7 +23,7 @@ class Freddy
         raise Timeout::Error, 'execution expired'
       elsif @response[:error] == 'RequestTimeout'
         raise TimeoutError.new(@response)
-      elsif !@delivery || @delivery.metadata.type == 'error'
+      elsif !@delivery || @delivery.type == 'error'
         raise InvalidRequestError.new(@response)
       else
         @response

data/lib/freddy.rb

@@ -41,14 +41,14 @@ class Freddy
     @connection = connection
     @channel  = connection.create_channel
     @consume_thread_pool = Thread.pool(max_concurrency)
-    @consumer = Consumer.new channel, logger, @consume_thread_pool
     @producer = Producer.new channel, logger
+    @consumer = Consumer.new channel, logger, @consume_thread_pool, @producer
     @request  = Request.new channel, logger, @producer, @consumer
   end
   private :initialize
 
   def respond_to(destination, &callback)
-    @request.respond_to destination, &callback
+    @consumer.respond_to destination, &callback
   end
 
   def tap_into(pattern, &callback)

data/spec/freddy/consumer_spec.rb

@@ -10,12 +10,8 @@ describe Freddy::Consumer do
 
   after { freddy.close }
 
-  it 'raises exception when no consumer is provided' do
-    expect { consumer.consume destination }.to raise_error described_class::EmptyConsumer
-  end
-
   it "doesn't call passed block without any messages" do
-    consumer.consume destination do
+    consumer.respond_to destination do
       @message_received = true
     end
     default_sleep

data/spec/freddy/message_handler_spec.rb

@@ -4,9 +4,7 @@ describe Freddy::MessageHandler do
   subject(:handler) { described_class.new(adapter, delivery) }
 
   let(:adapter) { double }
-  let(:delivery) { double(metadata: metadata) }
-  let(:metadata) { double(reply_to: reply_to, correlation_id: 'abc') }
-
+  let(:delivery) { double(reply_to: reply_to, correlation_id: 'abc') }
   let(:reply_to) { double }
 
   describe '#success' do

data/spec/freddy/request_spec.rb

@@ -10,10 +10,6 @@ describe Freddy::Request do
 
   after { freddy.close }
 
-  it 'raises empty responder exception when responding without callback' do
-    expect {@responder = request.respond_to destination }.to raise_error described_class::EmptyResponder
-  end
-
   context 'requesting from multiple threads' do
     let(:nr_of_threads) { 50 }
 

data/spec/integration/logging_spec.rb

@@ -23,7 +23,6 @@ describe 'Logging' do
 
   it 'logs all consumed messages' do
     expect(logger1).to have_received(:info).with(/Listening for requests on \S+/)
-    expect(logger1).to have_received(:debug).with(/Consuming messages on \S+/)
     expect(logger1).to have_received(:debug).with(/Received message on \S+ with payload {:pay=>"load"}/)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors:
 - Urmas Talimaa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-26 00:00:00.000000000 Z
+date: 2015-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,6 +117,9 @@ files:
 - lib/freddy/adapters/bunny_adapter.rb
 - lib/freddy/adapters/march_hare_adapter.rb
 - lib/freddy/consumer.rb
+- lib/freddy/consumers/respond_to_consumer.rb
+- lib/freddy/consumers/response_consumer.rb
+- lib/freddy/consumers/tap_into_consumer.rb
 - lib/freddy/delivery.rb
 - lib/freddy/error_response.rb
 - lib/freddy/invalid_request_error.rb