freddy 0.4.9 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8aee28c6b8c64e053dfd864eb43e05f4d350606c
-  data.tar.gz: 3cf659c4cb47be3b564fe992da89603c6c3649cf
+  metadata.gz: 204b0809f519d05653570d35444e705960059438
+  data.tar.gz: 288c0710940438afff7d86d1e55d5baeb1c4adc4
 SHA512:
-  metadata.gz: fcc93283eb0ff7d457ab33f4f4c87d1c6969a60b3fc7bda09b21cd4fa88fa198089d1b4317bab95bfb2b88a7ab6df2abb29af1bc42116954fa9bfa23027f84db
-  data.tar.gz: 46079754f78b019f506445d46040ff846e02568acd497a053dd0c1067a44a4329b18d5c3beefa8abfab7b0d55dcde9effc5e616112a15f54497a46818ee3313e
+  metadata.gz: 078ba7ed00fff8ace0932121c56d71f7bb0149fa56444cd6c3c68506d5a687a645a5a3551445b3e7320ae22fa636aee63031c5e6b809735ef9ebe81279f7af3a
+  data.tar.gz: e5ef6ddd2fd83dac05c97a5e005c019b46dada0759f901e0b3e9d390f0e995f9a50007b88a22681a60b6e9d2c5ed713f61aa97b31f5f2d29d2d200a1be86bf13

data/freddy.gemspec

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

data/lib/freddy.rb

@@ -1,18 +1,12 @@
 require 'json'
 require 'thread/pool'
+require 'hamster/mutable_hash'
 
-require_relative 'freddy/adapters'
-require_relative 'freddy/consumer'
-require_relative 'freddy/producer'
-require_relative 'freddy/request'
-require_relative 'freddy/payload'
-require_relative 'freddy/error_response'
-require_relative 'freddy/invalid_request_error'
-require_relative 'freddy/timeout_error'
-require_relative 'freddy/utils'
+Dir[File.dirname(__FILE__) + '/freddy/*.rb'].each(&method(:require))
 
 class Freddy
   FREDDY_TOPIC_EXCHANGE_NAME = 'freddy-topic'.freeze
+  DEFAULT_MAX_CONCURRENCY = 4
 
   # Creates a new freddy instance
   #
@@ -29,30 +23,84 @@ class Freddy
   #
   # @example
   #   Freddy.build(Logger.new(STDOUT), user: 'thumper', pass: 'howdy')
-  def self.build(logger = Logger.new(STDOUT), config = {})
+  def self.build(logger = Logger.new(STDOUT), max_concurrency: DEFAULT_MAX_CONCURRENCY, **config)
     connection = Adapters.determine.connect(config)
+    consume_thread_pool = Thread.pool(max_concurrency)
 
-    new(connection, logger, config.fetch(:max_concurrency, 4))
+    new(connection, logger, consume_thread_pool)
   end
 
-  attr_reader :channel, :consumer, :producer, :request
-
-  def initialize(connection, logger, max_concurrency)
+  def initialize(connection, logger, consume_thread_pool)
     @connection = connection
-    @channel  = connection.create_channel
-    @consume_thread_pool = Thread.pool(max_concurrency)
-    @producer = Producer.new channel, logger
-    @consumer = Consumer.new logger, @consume_thread_pool, @producer, @connection
-    @request  = Request.new channel, logger, @producer, @consumer
+    @logger = logger
+
+    @tap_into_consumer = Consumers::TapIntoConsumer.new(consume_thread_pool)
+    @respond_to_consumer = Consumers::RespondToConsumer.new(consume_thread_pool, @logger)
+
+    @send_and_forget_producer = Producers::SendAndForgetProducer.new(
+      connection.create_channel, logger
+    )
+    @send_and_wait_response_producer = Producers::SendAndWaitResponseProducer.new(
+      connection.create_channel, logger
+    )
   end
   private :initialize
 
+  # Listens and responds to messages
+  #
+  # This consumes messages on a given destination. It is useful for messages
+  # that have to be processed once and then a result must be sent.
+  #
+  # @param [String] destination
+  #   the queue name
+  #
+  # @yieldparam [Hash<Symbol => Object>] message
+  #   Received message as a ruby hash with symbolized keys
+  # @yieldparam [#success, #error] handler
+  #   Handler for responding to messages. Use handler#success for successful
+  #   respone and handler#error for error response.
+  #
+  # @return [#shutdown]
+  #
+  # @example
+  #   freddy.respond_to 'RegistrationService' do |attributes, handler|
+  #     if id = register(attributes)
+  #       handler.success(id: id)
+  #     else
+  #       handler.error(message: 'Can not do')
+  #     end
+  #   end
   def respond_to(destination, &callback)
-    @consumer.respond_to destination, &callback
+    @logger.info "Listening for requests on #{destination}"
+
+    channel = @connection.create_channel
+    producer = Producers::ReplyProducer.new(channel, @logger)
+    handler_factory = MessageHandlers::Factory.new(producer, @logger)
+
+    @respond_to_consumer.consume(destination, channel, handler_factory, &callback)
   end
 
+  # Listens for messages without consuming them
+  #
+  # This listens for messages on a given destination or destinations without
+  # consuming them. It is useful for general messages that two or more clients
+  # are interested.
+  #
+  # @param [String] pattern
+  #   the destination pattern. Use `#` wildcard for matching 0 or more words.
+  #   Use `*` to match exactly one word.
+  #
+  # @yield [message] Yields received message to the block
+  #
+  # @return [#shutdown]
+  #
+  # @example
+  #   freddy.tap_into 'notifications.*' do |message|
+  #     puts "Notification showed #{message.inspect}"
+  #   end
   def tap_into(pattern, &callback)
-    @consumer.tap_into pattern, &callback
+    @logger.debug "Tapping into messages that match #{pattern}"
+    @tap_into_consumer.consume(pattern, @connection.create_channel, &callback)
   end
 
   # Sends a message to given destination
@@ -81,7 +129,7 @@ class Freddy
     opts = {}
     opts[:expiration] = (timeout * 1000).to_i if timeout > 0
 
-    @producer.produce destination, payload, opts
+    @send_and_forget_producer.produce(destination, payload, opts)
   end
 
   # Sends a message and waits for the response
@@ -117,8 +165,8 @@ class Freddy
     timeout = options.fetch(:timeout, 3)
     delete_on_timeout = options.fetch(:delete_on_timeout, true)
 
-    @request.sync_request destination, payload, {
-      timeout: timeout, delete_on_timeout: delete_on_timeout
+    @send_and_wait_response_producer.produce destination, payload, {
+      timeout_in_seconds: timeout, delete_on_timeout: delete_on_timeout
     }
   end
 

data/lib/freddy/adapters/bunny_adapter.rb

@@ -24,6 +24,8 @@ class Freddy
       class Channel
         extend Forwardable
 
+        NO_ROUTE = 312
+
         def initialize(channel)
           @channel = channel
         end
@@ -34,9 +36,11 @@ class Freddy
           Queue.new(@channel.queue(*args))
         end
 
-        def on_return(&block)
+        def on_no_route(&block)
           default_exchange.on_return do |return_info, properties, content|
-            block.call(return_info[:reply_code], properties[:correlation_id])
+            if return_info[:reply_code] == NO_ROUTE
+              block.call(properties[:correlation_id])
+            end
           end
         end
       end

data/lib/freddy/adapters/march_hare_adapter.rb

@@ -23,6 +23,8 @@ class Freddy
       class Channel
         extend Forwardable
 
+        NO_ROUTE = 312
+
         def initialize(channel)
           @channel = channel
         end
@@ -33,10 +35,10 @@ class Freddy
           Queue.new(@channel.queue(*args))
         end
 
-        def on_return(&block)
+        def on_no_route(&block)
           @channel.on_return do |reply_code, _, exchange_name, _, properties|
-            if exchange_name != Freddy::FREDDY_TOPIC_EXCHANGE_NAME
-              block.call(reply_code, properties.correlation_id)
+            if exchange_name != Freddy::FREDDY_TOPIC_EXCHANGE_NAME && reply_code == NO_ROUTE
+              block.call(properties.correlation_id)
             end
           end
         end

data/lib/freddy/consumers.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/consumers/*.rb'].each(&method(:require))

data/lib/freddy/consumers/respond_to_consumer.rb

@@ -1,18 +1,16 @@
 class Freddy
   module Consumers
     class RespondToConsumer
-      def initialize(consume_thread_pool, producer, logger)
+      def initialize(consume_thread_pool, logger)
         @consume_thread_pool = consume_thread_pool
-        @producer = producer
         @logger = logger
       end
 
-      def consume(destination, channel, &block)
+      def consume(destination, channel, handler_factory, &block)
         consumer = consume_from_destination(destination, channel) do |delivery|
           log_receive_event(destination, delivery)
 
-          handler_class = MessageHandlers.for_type(delivery.type)
-          handler = handler_class.new(@producer, destination, @logger)
+          handler = handler_factory.build(delivery.type, destination)
 
           msg_handler = MessageHandler.new(handler, delivery)
           handler.handle_message delivery.payload, msg_handler, &block

data/lib/freddy/consumers/response_consumer.rb

@@ -7,6 +7,7 @@ class Freddy
       end
 
       def consume(queue, &block)
+        @logger.debug "Consuming messages on #{queue.name}"
         consumer = queue.subscribe do |delivery|
           process_message(queue, delivery, &block)
         end

data/lib/freddy/message_handlers.rb

@@ -1,13 +1,23 @@
 class Freddy
   module MessageHandlers
-    def self.for_type(type)
-      type == 'request' ? RequestHandler : StandardMessageHandler
+    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(producer, destination, logger)
+      def initialize(destination, logger)
         @destination = destination
-        @producer = producer
         @logger = logger
       end
 
@@ -39,7 +49,6 @@ class Freddy
 
         if !@correlation_id
           @logger.error "Received request without correlation_id"
-          Utils.notify_exception(e)
         else
           block.call payload, msg_handler
         end

data/lib/freddy/producers.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/producers/*.rb'].each(&method(:require))

data/lib/freddy/producers/reply_producer.rb

@@ -0,0 +1,22 @@
+class Freddy
+  module Producers
+    class ReplyProducer
+      CONTENT_TYPE = 'application/json'.freeze
+
+      def initialize(channel, logger)
+        @logger = logger
+        @exchange = channel.default_exchange
+      end
+
+      def produce(destination, payload, properties)
+        @logger.debug "Sending message #{payload.inspect} to #{destination}"
+
+        properties = properties.merge(
+          routing_key: destination, content_type: CONTENT_TYPE
+        )
+
+        @exchange.publish Payload.dump(payload), properties
+      end
+    end
+  end
+end

data/lib/freddy/producers/send_and_forget_producer.rb

@@ -0,0 +1,25 @@
+class Freddy
+  module Producers
+    class SendAndForgetProducer
+      CONTENT_TYPE = 'application/json'.freeze
+
+      def initialize(channel, logger)
+        @logger = logger
+        @exchange = channel.default_exchange
+        @topic_exchange = channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
+      end
+
+      def produce(destination, payload, properties)
+        @logger.debug "Sending message #{payload.inspect} to #{destination}"
+
+        properties = properties.merge(routing_key: destination, content_type: CONTENT_TYPE)
+        json_payload = Payload.dump(payload)
+
+        # Connection adapters handle thread safety for #publish themselves. No
+        # need to lock these.
+        @topic_exchange.publish json_payload, properties.dup
+        @exchange.publish json_payload, properties.dup
+      end
+    end
+  end
+end

data/lib/freddy/producers/send_and_wait_response_producer.rb

@@ -0,0 +1,89 @@
+class Freddy
+  module Producers
+    class SendAndWaitResponseProducer
+      CONTENT_TYPE = 'application/json'.freeze
+
+      def initialize(channel, logger)
+        @logger = logger
+        @channel = channel
+
+        @request_manager = RequestManager.new(@logger)
+
+        @exchange = @channel.default_exchange
+        @topic_exchange = @channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
+
+        @channel.on_no_route do |correlation_id|
+          @request_manager.no_route(correlation_id)
+        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
+
+      private
+
+      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
+        )
+
+        if delete_on_timeout
+          properties[:expiration] = (timeout_in_seconds * 1000).to_i
+        end
+
+        properties = properties.merge(
+          routing_key: destination, content_type: CONTENT_TYPE,
+          correlation_id: correlation_id, reply_to: @response_queue.name,
+          mandatory: true, type: 'request'
+        )
+        json_payload = Payload.dump(payload)
+
+        @logger.debug "Publishing request with payload #{payload.inspect} "\
+                      "to #{destination}, waiting for response on "\
+                      "#{@response_queue.name} with correlation_id #{correlation_id}"
+
+        # Connection adapters handle thread safety for #publish themselves. No
+        # need to lock these.
+        @topic_exchange.publish json_payload, properties.dup
+        @exchange.publish json_payload, properties.dup
+      end
+
+      def handle_response(delivery)
+        correlation_id = delivery.correlation_id
+
+        if request = @request_manager.delete(correlation_id)
+          process_response(request, delivery)
+        else
+          warning = "Got rpc response for correlation_id #{correlation_id} "\
+                    "but there is no requester"
+          @logger.warn message
+          Utils.notify 'NoRequesterForResponse', warning, correlation_id: correlation_id
+        end
+      end
+
+      def process_response(request, delivery)
+        @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
+    end
+  end
+end

data/lib/freddy/request_manager.rb

@@ -1,8 +1,9 @@
 class Freddy
   class RequestManager
 
-    def initialize(requests, logger)
-      @requests, @logger = requests, logger
+    def initialize(logger)
+      @requests = Hamster.mutable_hash
+      @logger = logger
     end
 
     def start
@@ -21,11 +22,19 @@ class Freddy
       end
     end
 
+    def store(correlation_id, opts)
+      @requests.store(correlation_id, opts)
+    end
+
+    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[:timeout]
+        timeout(key, value) if now > value[:expires_at]
       end
     end
 
@@ -36,7 +45,7 @@ class Freddy
       Utils.notify 'RequestTimeout', "Request timed out waiting for response from #{request[:destination]}", {
         correlation_id: correlation_id,
         destination: request[:destination],
-        timeout: request[:timeout]
+        expires_at: request[:expires_at]
       }
 
       request[:callback].call({error: 'RequestTimeout', message: 'Timed out waiting for response'}, nil)

data/spec/freddy/consumers/respond_to_consumer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Freddy::Consumers::RespondToConsumer do
+  let(:consumer) { described_class.new(thread_pool, logger) }
+
+  let(:connection)  { Freddy::Adapters.determine.connect(config) }
+  let(:thread_pool) { Thread.pool(1) }
+  let(:destination) { random_destination }
+  let(:payload)     { {pay: 'load'} }
+  let(:msg_handler) { double }
+
+  after do
+    connection.close
+  end
+
+  it "doesn't call passed block without any messages" do
+    consumer.consume destination, connection.create_channel, msg_handler do
+      @message_received = true
+    end
+    default_sleep
+
+    expect(@message_received).to be_falsy
+  end
+end

data/spec/freddy/freddy_spec.rb

@@ -18,7 +18,8 @@ describe Freddy do
       it 'removes the message from the queue after the timeout' do
         # Assume that there already is a queue. Otherwise will get an early
         # return.
-        freddy.channel.queue(destination)
+        consumer = freddy.respond_to(destination) { }
+        consumer.shutdown
 
         freddy.deliver(destination, {}, timeout: 0.1)
         sleep 0.2
@@ -35,7 +36,8 @@ describe Freddy do
       it 'keeps the message in the queue' do
         # Assume that there already is a queue. Otherwise will get an early
         # return.
-        freddy.channel.queue(destination)
+        consumer = freddy.respond_to(destination) { }
+        consumer.shutdown
 
         freddy.deliver(destination, {})
         default_sleep # to ensure everything is properly cleaned
@@ -67,21 +69,6 @@ describe Freddy do
       }
     end
 
-    it 'does not leak consumers' do
-      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
-
-      old_count = freddy.channel.consumers.keys.count
-
-      response1 = freddy.deliver_with_response(destination, {a: 'b'})
-      response2 = freddy.deliver_with_response(destination, {a: 'b'})
-
-      expect(response1).to eq(res: 'yey')
-      expect(response2).to eq(res: 'yey')
-
-      new_count = freddy.channel.consumers.keys.count
-      expect(new_count).to be(old_count + 1)
-    end
-
     it 'responds to the correct requester' do
       respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
 
@@ -95,17 +82,11 @@ describe Freddy do
 
     context 'when queue does not exist' do
       it 'gives a no route error' do
-        begin
-          Timeout::timeout(0.5) do
-            expect {
-              freddy.deliver_with_response(destination, {a: 'b'}, timeout: 3)
-            }.to raise_error(Freddy::InvalidRequestError) {|error|
-              expect(error.response).to eq(error: 'Specified queue does not exist')
-            }
-          end
-        rescue Timeout::Error
-          fail('Received a timeout error instead of the no route error')
-        end
+        expect {
+          freddy.deliver_with_response(destination, {a: 'b'}, timeout: 1)
+        }.to raise_error(Freddy::InvalidRequestError) {|error|
+          expect(error.response).to eq(error: 'Specified queue does not exist')
+        }
       end
     end
 
@@ -124,7 +105,8 @@ describe Freddy do
         it 'removes the message from the queue' do
           # Assume that there already is a queue. Otherwise will get an early
           # return.
-          freddy.channel.queue(destination)
+          consumer = freddy.respond_to(destination) { }
+          consumer.shutdown
 
           expect {
             freddy.deliver_with_response(destination, {}, timeout: 0.1)
@@ -143,7 +125,8 @@ describe Freddy do
         it 'removes the message from the queue' do
           # Assume that there already is a queue. Otherwise will get an early
           # return.
-          freddy.channel.queue(destination)
+          consumer = freddy.respond_to(destination) { }
+          consumer.shutdown
 
           expect {
             freddy.deliver_with_response(destination, {}, timeout: 0.1, delete_on_timeout: false)

data/spec/integration/concurrency_spec.rb

@@ -84,4 +84,26 @@ describe 'Concurrency' do
 
     expect(results.count).to eq(10)
   end
+
+  context 'concurrent executions of deliver_with_response' do
+    let(:nr_of_threads) { 50 }
+    let(:payload) { {pay: 'load'} }
+    let(:msg_counter) { Hamster.mutable_set }
+    let(:queue_name) { random_destination }
+
+    before do
+      spawn_echo_responder(freddy1, queue_name)
+    end
+
+    it 'is supported' do
+      nr_of_threads.times.map do |index|
+        Thread.new do
+          response = freddy1.deliver_with_response(queue_name, payload)
+          msg_counter << index
+          expect(response).to eq(payload)
+        end
+      end.each(&:join)
+      expect(msg_counter.count).to eq(nr_of_threads)
+    end
+  end
 end

data/spec/integration/logging_spec.rb

@@ -23,12 +23,15 @@ 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(/Received message on \S+ with payload {:pay=>"load"}/)
+    expect(logger1).to have_received(:debug).with(
+      /Received message on \S+ with payload {:pay=>"load"}/
+    )
   end
 
   it 'logs all produced messages' do
     expect(logger2).to have_received(:debug).with(/Consuming messages on \S+/)
-    expect(logger2).to have_received(:debug).with(/Publishing request to \S+, waiting for response on amq.gen-\S+ with correlation_id .*/)
-    expect(logger2).to have_received(:debug).with(/Producing message {:pay=>"load"} to \S+/)
+    expect(logger2).to have_received(:debug).with(
+      /Publishing request with payload {:pay=>"load"} to \S+, waiting for response on amq.gen-\S+ with correlation_id .*/
+    )
   end
 end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ require 'pry'
 require 'securerandom'
 require 'freddy'
 require 'logger'
+require 'hamster/experimental/mutable_set'
 
 Thread.abort_on_exception = true
 
@@ -38,3 +39,9 @@ end
 def config
   {host: 'localhost', port: 5672, user: 'guest', pass: 'guest'}
 end
+
+def spawn_echo_responder(freddy, queue_name)
+  freddy.respond_to queue_name do |payload, msg_handler|
+    msg_handler.success(payload)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.5.0
 platform: ruby
 authors:
 - Urmas Talimaa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-16 00:00:00.000000000 Z
+date: 2016-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -116,7 +116,7 @@ files:
 - lib/freddy/adapters.rb
 - lib/freddy/adapters/bunny_adapter.rb
 - lib/freddy/adapters/march_hare_adapter.rb
-- lib/freddy/consumer.rb
+- lib/freddy/consumers.rb
 - lib/freddy/consumers/respond_to_consumer.rb
 - lib/freddy/consumers/response_consumer.rb
 - lib/freddy/consumers/tap_into_consumer.rb
@@ -126,18 +126,19 @@ files:
 - lib/freddy/message_handler.rb
 - lib/freddy/message_handlers.rb
 - lib/freddy/payload.rb
-- lib/freddy/producer.rb
-- lib/freddy/request.rb
+- lib/freddy/producers.rb
+- lib/freddy/producers/reply_producer.rb
+- lib/freddy/producers/send_and_forget_producer.rb
+- lib/freddy/producers/send_and_wait_response_producer.rb
 - lib/freddy/request_manager.rb
 - lib/freddy/responder_handler.rb
 - lib/freddy/sync_response_container.rb
 - lib/freddy/timeout_error.rb
 - lib/freddy/utils.rb
-- spec/freddy/consumer_spec.rb
+- spec/freddy/consumers/respond_to_consumer_spec.rb
 - spec/freddy/error_response_spec.rb
 - spec/freddy/freddy_spec.rb
 - spec/freddy/message_handler_spec.rb
-- spec/freddy/request_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
 - spec/integration/concurrency_spec.rb
@@ -168,11 +169,10 @@ signing_key:
 specification_version: 4
 summary: API for inter-application messaging supporting acknowledgements and request-response
 test_files:
-- spec/freddy/consumer_spec.rb
+- spec/freddy/consumers/respond_to_consumer_spec.rb
 - spec/freddy/error_response_spec.rb
 - spec/freddy/freddy_spec.rb
 - spec/freddy/message_handler_spec.rb
-- spec/freddy/request_spec.rb
 - spec/freddy/responder_handler_spec.rb
 - spec/freddy/sync_response_container_spec.rb
 - spec/integration/concurrency_spec.rb

data/lib/freddy/consumer.rb

@@ -1,33 +0,0 @@
-require_relative 'responder_handler'
-require_relative 'message_handler'
-require_relative 'delivery'
-require_relative 'consumers/tap_into_consumer'
-require_relative 'consumers/respond_to_consumer'
-require_relative 'consumers/response_consumer'
-
-class Freddy
-  class Consumer
-    def initialize(logger, consume_thread_pool, producer, connection)
-      @logger = logger
-      @connection = connection
-      @tap_into_consumer = Consumers::TapIntoConsumer.new(consume_thread_pool)
-      @respond_to_consumer = Consumers::RespondToConsumer.new(consume_thread_pool, producer, @logger)
-      @response_consumer = Consumers::ResponseConsumer.new(@logger)
-    end
-
-    def response_consume(queue, &block)
-      @logger.debug "Consuming messages on #{queue.name}"
-      @response_consumer.consume(queue, &block)
-    end
-
-    def tap_into(pattern, &block)
-      @logger.debug "Tapping into messages that match #{pattern}"
-      @tap_into_consumer.consume(pattern, @connection.create_channel, &block)
-    end
-
-    def respond_to(destination, &block)
-      @logger.info "Listening for requests on #{destination}"
-      @respond_to_consumer.consume(destination, @connection.create_channel, &block)
-    end
-  end
-end

data/lib/freddy/producer.rb

@@ -1,26 +0,0 @@
-require_relative 'request'
-require 'json'
-
-class Freddy
-  class Producer
-    OnReturnNotImplemented = Class.new(NoMethodError)
-
-    CONTENT_TYPE = 'application/json'.freeze
-
-    def initialize(channel, logger)
-      @channel, @logger = channel, logger
-      @exchange = @channel.default_exchange
-      @topic_exchange = @channel.topic Freddy::FREDDY_TOPIC_EXCHANGE_NAME
-    end
-
-    def produce(destination, payload, properties={})
-      @logger.debug "Producing message #{payload.inspect} to #{destination}"
-
-      properties = properties.merge(routing_key: destination, content_type: CONTENT_TYPE)
-      json_payload = Payload.dump(payload)
-
-      @topic_exchange.publish json_payload, properties.dup
-      @exchange.publish json_payload, properties.dup
-    end
-  end
-end

data/lib/freddy/request.rb

@@ -1,88 +0,0 @@
-require_relative 'producer'
-require_relative 'consumer'
-require_relative 'request_manager'
-require_relative 'sync_response_container'
-require_relative 'message_handlers'
-require 'thread'
-require 'securerandom'
-require 'hamster/mutable_hash'
-
-class Freddy
-  class Request
-    NO_ROUTE = 312
-
-    def initialize(channel, logger, producer, consumer)
-      @channel, @logger = channel, logger
-      @producer, @consumer = producer, consumer
-      @request_map = Hamster.mutable_hash
-      @request_manager = RequestManager.new @request_map, @logger
-
-      @channel.on_return do |reply_code, correlation_id|
-        if reply_code == NO_ROUTE
-          @request_manager.no_route(correlation_id)
-        end
-      end
-
-      @listening_for_responses_lock = Mutex.new
-    end
-
-    def sync_request(destination, payload, opts)
-      timeout_seconds = opts.fetch(:timeout)
-      container = SyncResponseContainer.new
-      async_request destination, payload, opts, &container
-      container.wait_for_response(timeout_seconds + 0.1)
-    end
-
-    def async_request(destination, payload, options, &block)
-      timeout = options.fetch(:timeout)
-      delete_on_timeout = options.fetch(:delete_on_timeout)
-      options.delete(:timeout)
-      options.delete(:delete_on_timeout)
-
-      ensure_listening_to_responses
-
-      correlation_id = SecureRandom.uuid
-      @request_map.store(correlation_id, callback: block, destination: destination, timeout: Time.now + timeout)
-
-      @logger.debug "Publishing request to #{destination}, waiting for response on #{@response_queue.name} with correlation_id #{correlation_id}"
-
-      if delete_on_timeout
-        options[:expiration] = (timeout * 1000).to_i
-      end
-
-      @producer.produce destination, payload, options.merge(
-        correlation_id: correlation_id, reply_to: @response_queue.name,
-        mandatory: true, type: 'request'
-      )
-    end
-
-    private
-
-    def handle_response(delivery)
-      correlation_id = delivery.correlation_id
-
-      if request = @request_map.delete(correlation_id)
-        @logger.debug "Got response for request to #{request[:destination]} with correlation_id #{correlation_id}"
-        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
-      end
-    rescue Exception => e
-      destination_report = request ? "to #{request[:destination]}" : ''
-      @logger.error "Exception occured while handling the response of request made #{destination_report} with correlation_id #{correlation_id}: #{Utils.format_exception e}"
-      Utils.notify_exception(e, destination: request[:destination], correlation_id: correlation_id)
-    end
-
-    def ensure_listening_to_responses
-      return @listening_for_responses if defined?(@listening_for_responses)
-
-      @listening_for_responses_lock.synchronize do
-        @response_queue ||= @channel.queue("", exclusive: true)
-        @request_manager.start
-        @consumer.response_consume(@response_queue, &method(:handle_response))
-        @listening_for_responses = true
-      end
-    end
-  end
-end

data/spec/freddy/consumer_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Freddy::Consumer do
-  let(:freddy) { Freddy.build(logger, config) }
-
-  let(:destination) { random_destination }
-  let(:payload)     { {pay: 'load'} }
-
-  let(:consumer) { freddy.consumer }
-
-  after { freddy.close }
-
-  it "doesn't call passed block without any messages" do
-    consumer.respond_to destination do
-      @message_received = true
-    end
-    default_sleep
-
-    expect(@message_received).to be_falsy
-  end
-end

data/spec/freddy/request_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Freddy::Request do
-  let(:freddy) { Freddy.build(logger, config) }
-
-  let(:destination) { random_destination }
-  let(:payload)     { {pay: 'load'} }
-
-  let(:request) { freddy.request }
-
-  after { freddy.close }
-
-  context 'requesting from multiple threads' do
-    let(:nr_of_threads) { 50 }
-
-    before do
-      freddy.respond_to 'thread-queue' do |payload, msg_handler|
-        msg_handler.success(payload)
-      end
-    end
-
-    it 'handles multiple threads' do
-      require 'hamster/experimental/mutable_set'
-      msg_counter = Hamster.mutable_set
-      nr_of_threads.times.map do |index|
-        Thread.new do
-          response = freddy.deliver_with_response 'thread-queue', payload
-          msg_counter << index
-          expect(response).to eq(payload)
-        end
-      end.each(&:join)
-      expect(msg_counter.count).to eq(nr_of_threads)
-    end
-
-  end
-
-end