freddy-jruby 0.4.3 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f29ab8dfbedae9cbd544b20c86c7adf72d4859e
-  data.tar.gz: dd7c545605d297356f2fdb27b3fef5fda8735474
+  metadata.gz: 0e34103e16c546862a8431d62287eb20955795c4
+  data.tar.gz: 88d5d9f3ee6e6334c8ff3a2dbd4676bc0fe31528
 SHA512:
-  metadata.gz: 4674e17c54e5dee1b926bf6354987d5a7e2df079a39754d4ed9a332ec705e8046e5fe69112af09d95b0b1be0fa94288c70a12b45eb4f0d5a7c994df9b5024a1b
-  data.tar.gz: 20784cb06674e8c0135315dfa9566a0933258e3b8cd7f74a722f68e4d7ff9126cec68d3154211c875af128baa39b8a96a5fd56c95461390ac3a5192ee7f94313
+  metadata.gz: d6b8a1de5e524b4bfd2481152255e37dfcd5df68c7fb1f8849f60ac5581aff7b6e8fa84f1b76db3dc5cbb3884533a79e27e7cd16e1a993654c509e7e949828e6
+  data.tar.gz: 915a84bb6418a6d8cd8609734e7138aaa230bb1dd44a3ec303668a87817e7d31ea02f0d14b61442b7541dc0fb863f2a63d51cd28c3e93fd24bf6f0f290c90947

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
@@ -12,6 +12,12 @@ logger = Logger.new(STDOUT)
 freddy = Freddy.build(logger, host: 'localhost', port: 5672, user: 'guest', pass: 'guest')
 ```
 
+## Supported message queues
+
+These message queues have been tested and are working with Freddy. Other queues can be added easily:
+
+* [RabbitMQ](https://www.rabbitmq.com/)
+
 ## Delivering messages
 
 ### Simple delivery
@@ -125,16 +131,9 @@ The following operations are supported:
 
   * stop responding
 ```ruby
-responder_handler.cancel
+responder_handler.shutdown
 ```
 
-  * delete the destination
-```ruby
-responder_handler.destroy_destination
-```
-
-    * Primary use case is in tests to not leave dangling destinations. It deletes the destination even if there are responders for the same destination in other parts of the system. Use with caution in production code.
-
 
 ## Notes about concurrency
 

data/freddy.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   else
     spec.name          = "freddy"
   end
-  spec.version       = '0.4.3'
+  spec.version       = '0.4.9'
   spec.authors       = ["Urmas Talimaa"]
   spec.email         = ["urmas.talimaa@gmail.com"]
   spec.description   = %q{Messaging API}
@@ -25,11 +25,12 @@ Gem::Specification.new do |spec|
 
   if RUBY_PLATFORM == 'java'
     spec.add_dependency 'march_hare', '~> 2.12.0'
+    spec.add_dependency 'symbolizer'
   else
     spec.add_dependency "bunny", "2.2.0"
+    spec.add_dependency "oj", "~> 2.13"
   end
 
-  spec.add_dependency "symbolizer"
   spec.add_dependency "hamster", "~> 1.0.1.pre.rc3"
   spec.add_dependency "thread", "~> 0.2"
 end

data/lib/freddy.rb

@@ -1,83 +1,36 @@
-if RUBY_PLATFORM == 'java'
-  require 'march_hare'
-else
-  require 'bunny'
-end
-
 require 'json'
-require 'symbolizer'
 require 'thread/pool'
 
-require_relative 'freddy/adaptive_queue'
+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'
 
 class Freddy
-  class ErrorResponse < StandardError
-    DEFAULT_ERROR_MESSAGE = 'Use #response to get the error response'
-
-    attr_reader :response
-
-    def initialize(response)
-      @response = response
-      super(format_message(response) || DEFAULT_ERROR_MESSAGE)
-    end
-
-    private
-
-    def format_message(response)
-      return unless response.is_a?(Hash)
-
-      message = [response[:error], response[:message]].compact.join(': ')
-      message.empty? ? nil : message
-    end
-  end
-
-  class InvalidRequestError < ErrorResponse
-  end
-
-  class TimeoutError < ErrorResponse
-  end
-
   FREDDY_TOPIC_EXCHANGE_NAME = 'freddy-topic'.freeze
 
-  def self.format_backtrace(backtrace)
-    backtrace.map{ |x|
-      x.match(/^(.+?):(\d+)(|:in `(.+)')$/);
-      [$1,$2,$4]
-    }.join "\n"
-  end
-
-  def self.format_exception(exception)
-    "#{exception.exception}\n#{format_backtrace(exception.backtrace)}"
-  end
-
-  def self.notify(name, message, parameters={})
-    if defined? Airbrake
-      Airbrake.notify_or_ignore({
-        error_class: name,
-        error_message: message,
-        cgi_data: ENV.to_hash,
-        parameters: parameters
-      })
-    end
-  end
-
-  def self.notify_exception(exception, parameters={})
-    if defined? Airbrake
-      Airbrake.notify_or_ignore(exception, cgi_data: ENV.to_hash, parameters: parameters)
-    end
-  end
-
-  def self.build(logger = Logger.new(STDOUT), config)
-    if RUBY_PLATFORM == 'java'
-      connection = MarchHare.connect(config)
-    else
-      connection = Bunny.new(config)
-      connection.start
-      connection
-    end
+  # Creates a new freddy instance
+  #
+  # @param [Logger] logger
+  #   instance of a logger, defaults to the STDOUT logger
+  # @param [Hash] config
+  #   rabbitmq connection information
+  # @option config [String] :host ('localhost')
+  # @option config [Integer] :port (5672)
+  # @option config [String] :user ('guest')
+  # @option config [String] :pass ('guest')
+  #
+  # @return [Freddy]
+  #
+  # @example
+  #   Freddy.build(Logger.new(STDOUT), user: 'thumper', pass: 'howdy')
+  def self.build(logger = Logger.new(STDOUT), config = {})
+    connection = Adapters.determine.connect(config)
 
     new(connection, logger, config.fetch(:max_concurrency, 4))
   end
@@ -88,19 +41,41 @@ 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 logger, @consume_thread_pool, @producer, @connection
     @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)
     @consumer.tap_into pattern, &callback
   end
 
+  # Sends a message to given destination
+  #
+  # This is *send and forget* type of delivery. It sends a message to given
+  # destination and does not wait for response. This is useful when there are
+  # multiple consumers that are using #tap_into or you just do not care about
+  # the response.
+  #
+  # @param [String] destination
+  #   the queue name
+  # @param [Hash] payload
+  #   the payload that can be serialized to json
+  # @param [Hash] options
+  #   the options for delivery
+  # @option options [Integer] :timeout (0)
+  #   discards the message after given seconds if nobody consumes it. Message
+  #   won't be discarded if timeout it set to 0 (default).
+  #
+  # @return [void]
+  #
+  # @example
+  #   freddy.deliver 'Metrics', user_id: 5, metric: 'signed_in'
   def deliver(destination, payload, options = {})
     timeout = options.fetch(:timeout, 0)
     opts = {}
@@ -109,6 +84,35 @@ class Freddy
     @producer.produce destination, payload, opts
   end
 
+  # Sends a message and waits for the response
+  #
+  # @param [String] destination
+  #   the queue name
+  # @param [Hash] payload
+  #   the payload that can be serialized to json
+  # @param [Hash] options
+  #   the options for delivery
+  # @option options [Integer] :timeout (3)
+  #   throws a time out exception after given seconds when there is no response
+  # @option options [Boolean] :delete_on_timeout (true)
+  #   discards the message when timeout error is raised
+  #
+  # @raise [Freddy::TimeoutError]
+  #   if nobody responded to the request
+  # @raise [Freddy::InvalidRequestError]
+  #   if the responder responded with an error response
+  #
+  # @return [Hash] the response
+  #
+  # @example
+  #   begin
+  #     response = freddy.deliver_with_response 'Users', type: 'fetch_all'
+  #     puts "Got response #{response}"
+  #   rescue Freddy::TimeoutError
+  #     puts "Service unavailable"
+  #   rescue Freddy::InvalidRequestError => e
+  #     puts "Got error response: #{e.response}"
+  #   end
   def deliver_with_response(destination, payload, options = {})
     timeout = options.fetch(:timeout, 3)
     delete_on_timeout = options.fetch(:delete_on_timeout, true)
@@ -118,6 +122,12 @@ class Freddy
     }
   end
 
+  # Closes the connection with message queue
+  #
+  # @return [void]
+  #
+  # @example
+  #   freddy.close
   def close
     @connection.close
   end

data/lib/freddy/adapters.rb

@@ -0,0 +1,13 @@
+class Freddy
+  module Adapters
+    def self.determine
+      if RUBY_PLATFORM == 'java'
+        require_relative 'adapters/march_hare_adapter'
+        MarchHareAdapter
+      else
+        require_relative 'adapters/bunny_adapter'
+        BunnyAdapter
+      end
+    end
+  end
+end

data/lib/freddy/adapters/bunny_adapter.rb

@@ -0,0 +1,67 @@
+require 'bunny'
+
+class Freddy
+  module Adapters
+    class BunnyAdapter
+      def self.connect(config)
+        bunny = Bunny.new(config)
+        bunny.start
+        new(bunny)
+      end
+
+      def initialize(bunny)
+        @bunny = bunny
+      end
+
+      def create_channel
+        Channel.new(@bunny.create_channel)
+      end
+
+      def close
+        @bunny.close
+      end
+
+      class Channel
+        extend Forwardable
+
+        def initialize(channel)
+          @channel = channel
+        end
+
+        def_delegators :@channel, :topic, :default_exchange, :consumers
+
+        def queue(*args)
+          Queue.new(@channel.queue(*args))
+        end
+
+        def on_return(&block)
+          default_exchange.on_return do |return_info, properties, content|
+            block.call(return_info[:reply_code], properties[:correlation_id])
+          end
+        end
+      end
+
+      class Queue
+        def initialize(queue)
+          @queue = queue
+        end
+
+        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
+end

data/lib/freddy/adapters/march_hare_adapter.rb

@@ -0,0 +1,68 @@
+require 'march_hare'
+
+class Freddy
+  module Adapters
+    class MarchHareAdapter
+      def self.connect(config)
+        hare = MarchHare.connect(config)
+        new(hare)
+      end
+
+      def initialize(hare)
+        @hare = hare
+      end
+
+      def create_channel
+        Channel.new(@hare.create_channel)
+      end
+
+      def close
+        @hare.close
+      end
+
+      class Channel
+        extend Forwardable
+
+        def initialize(channel)
+          @channel = channel
+        end
+
+        def_delegators :@channel, :topic, :default_exchange, :consumers
+
+        def queue(*args)
+          Queue.new(@channel.queue(*args))
+        end
+
+        def on_return(&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)
+            end
+          end
+        end
+      end
+
+      class Queue
+        def initialize(queue)
+          @queue = queue
+        end
+
+        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
+end

data/lib/freddy/consumer.rb

@@ -1,77 +1,33 @@
 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)
-      @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)
+    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 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 parse_payload(payload), delivery.routing_key
-        end
-      end
       @logger.debug "Tapping into messages that match #{pattern}"
-      ResponderHandler.new consumer, @channel
-    end
-
-    private
-
-    def consume_using_pool(queue, options, pool, &block)
-      consumer = queue.subscribe do |payload, delivery|
-        pool.process do
-          parsed_payload = parse_payload(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, @channel
-    end
-
-    def parse_payload(payload)
-      if payload == 'null'
-        {}
-      else
-        Symbolizer.symbolize(JSON(payload))
-      end
-    end
-
-    def create_queue(destination, options={})
-      AdaptiveQueue.new(@channel.queue(destination, options))
+      @tap_into_consumer.consume(pattern, @connection.create_channel, &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, @connection.create_channel, &block)
     end
   end
 end

data/lib/freddy/consumers/respond_to_consumer.rb

@@ -0,0 +1,47 @@
+class Freddy
+  module Consumers
+    class RespondToConsumer
+      def initialize(consume_thread_pool, producer, logger)
+        @consume_thread_pool = consume_thread_pool
+        @producer = producer
+        @logger = logger
+      end
+
+      def consume(destination, channel, &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)
+
+          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, channel, &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
+    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,35 @@
+class Freddy
+  module Consumers
+    class TapIntoConsumer
+      def initialize(consume_thread_pool)
+        @consume_thread_pool = consume_thread_pool
+      end
+
+      def consume(pattern, channel, &block)
+        queue = create_queue(pattern, channel)
+
+        consumer = queue.subscribe do |delivery|
+          process_message(delivery, &block)
+        end
+
+        ResponderHandler.new(consumer, @consume_thread_pool)
+      end
+
+      private
+
+      def create_queue(pattern, channel)
+        topic_exchange = channel.topic(Freddy::FREDDY_TOPIC_EXCHANGE_NAME)
+
+        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/error_response.rb

@@ -0,0 +1,21 @@
+class Freddy
+  class ErrorResponse < StandardError
+    DEFAULT_ERROR_MESSAGE = 'Use #response to get the error response'
+
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(format_message(response) || DEFAULT_ERROR_MESSAGE)
+    end
+
+    private
+
+    def format_message(response)
+      return unless response.is_a?(Hash)
+
+      message = [response[:error], response[:message]].compact.join(': ')
+      message.empty? ? nil : message
+    end
+  end
+end

data/lib/freddy/invalid_request_error.rb

@@ -0,0 +1,4 @@
+class Freddy
+  class InvalidRequestError < ErrorResponse
+  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/message_handlers.rb

@@ -14,8 +14,8 @@ class Freddy
       def handle_message(payload, msg_handler, &block)
         block.call payload, msg_handler
       rescue Exception => e
-        @logger.error "Exception occured while processing message from #{Freddy.format_exception(e)}"
-        Freddy.notify_exception(e, destination: @destination)
+        @logger.error "Exception occured while processing message from #{Utils.format_exception(e)}"
+        Utils.notify_exception(e, destination: @destination)
       end
 
       def success(*)
@@ -39,13 +39,13 @@ class Freddy
 
         if !@correlation_id
           @logger.error "Received request without correlation_id"
-          Freddy.notify_exception(e)
+          Utils.notify_exception(e)
         else
           block.call payload, msg_handler
         end
       rescue Exception => e
-        @logger.error "Exception occured while handling the request with correlation_id #{@correlation_id}: #{Freddy.format_exception(e)}"
-        Freddy.notify_exception(e, correlation_id: @correlation_id, destination: @destination)
+        @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)

data/lib/freddy/payload.rb

@@ -0,0 +1,46 @@
+begin
+  require 'oj'
+rescue LoadError
+  require 'symbolizer'
+  require 'json'
+end
+
+class Freddy
+  class Payload
+    def self.parse(payload)
+      return {} if payload == 'null'
+
+      json_handler.parse(payload)
+    end
+
+    def self.dump(payload)
+      json_handler.dump(payload)
+    end
+
+    def self.json_handler
+      @_json_handler ||= defined?(Oj) ? OjAdapter : JsonAdapter
+    end
+
+    class OjAdapter
+      def self.parse(payload)
+        Oj.strict_load(payload, symbol_keys: true)
+      end
+
+      def self.dump(payload)
+        Oj.dump(payload, mode: :compat)
+      end
+    end
+
+    class JsonAdapter
+      def self.parse(payload)
+        # MRI has :symbolize_keys, but JRuby does not. Not adding it at the
+        # moment.
+        Symbolizer.symbolize(JSON.parse(payload))
+      end
+
+      def self.dump(payload)
+        JSON.dump(payload)
+      end
+    end
+  end
+end

data/lib/freddy/producer.rb

@@ -17,26 +17,10 @@ class Freddy
       @logger.debug "Producing message #{payload.inspect} to #{destination}"
 
       properties = properties.merge(routing_key: destination, content_type: CONTENT_TYPE)
-      json_payload = payload.to_json
+      json_payload = Payload.dump(payload)
 
       @topic_exchange.publish json_payload, properties.dup
       @exchange.publish json_payload, properties.dup
     end
-
-    def on_return(&block)
-      if @exchange.respond_to? :on_return # Bunny
-        @exchange.on_return do |return_info, properties, content|
-          block.call(return_info[:reply_code], properties[:correlation_id])
-        end
-      elsif @channel.respond_to? :on_return # Hare
-        @channel.on_return do |reply_code, _, exchange_name, _, properties|
-          if exchange_name != Freddy::FREDDY_TOPIC_EXCHANGE_NAME
-            block.call(reply_code, properties.correlation_id)
-          end
-        end
-      else
-        raise OnReturnNotImplemented.new "AMQP implementation doesn't implement on_return"
-      end
-    end
   end
 end

data/lib/freddy/request.rb

@@ -11,26 +11,19 @@ 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
       @request_map = Hamster.mutable_hash
       @request_manager = RequestManager.new @request_map, @logger
 
-      @producer.on_return do |reply_code, correlation_id|
+      @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
-      @response_queue_lock = Mutex.new
     end
 
     def sync_request(destination, payload, opts)
@@ -63,61 +56,32 @@ 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
-      AdaptiveQueue.new @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"
-        Freddy.notify 'NoRequesterForResponse', "Got rpc response but there is no requester", correlation_id: correlation_id
+        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}: #{Freddy.format_exception e}"
-      Freddy.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
+      @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
-        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/request_manager.rb

@@ -33,7 +33,7 @@ class Freddy
       @requests.delete correlation_id
 
       @logger.warn "Request timed out waiting response from #{request[:destination]}, correlation id #{correlation_id}"
-      Freddy.notify 'RequestTimeout', "Request timed out waiting for response from #{request[:destination]}", {
+      Utils.notify 'RequestTimeout', "Request timed out waiting for response from #{request[:destination]}", {
         correlation_id: correlation_id,
         destination: request[:destination],
         timeout: request[:timeout]

data/lib/freddy/responder_handler.rb

@@ -1,21 +1,24 @@
 class Freddy
   class ResponderHandler
-
-    def initialize(consumer, channel)
+    def initialize(consumer, consume_thread_pool)
       @consumer = consumer
-      @channel = channel
+      @consume_thread_pool = consume_thread_pool
     end
 
-    def cancel
+    # Shutdown responder
+    #
+    # Stop responding to messages immediately, Waits until all workers are
+    # finished and then returns.
+    #
+    # @return [void]
+    #
+    # @example
+    #   responder = freddy.respond_to 'Queue' do |msg, handler|
+    #   end
+    #   responder.shutdown
+    def shutdown
       @consumer.cancel
-    end
-
-    def queue
-      @consumer.queue
-    end
-
-    def destroy_destination
-      @consumer.queue.delete
+      @consume_thread_pool.wait(:done)
     end
   end
 end

data/lib/freddy/sync_response_container.rb

@@ -1,20 +1,29 @@
+require 'thread'
 require 'timeout'
 
 class Freddy
   class SyncResponseContainer
+    def initialize
+      @mutex = Mutex.new
+    end
+
     def call(response, delivery)
       @response = response
       @delivery = delivery
+      @mutex.synchronize { @waiting.wakeup }
     end
 
     def wait_for_response(timeout)
-      Timeout::timeout(timeout) do
-        sleep 0.001 until filled?
+      @mutex.synchronize do
+        @waiting = Thread.current
+        @mutex.sleep(timeout)
       end
 
-      if @response[:error] == 'RequestTimeout'
+      if @response.nil?
+        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/timeout_error.rb

@@ -0,0 +1,4 @@
+class Freddy
+  class TimeoutError < ErrorResponse
+  end
+end

data/lib/freddy/utils.rb

@@ -0,0 +1,32 @@
+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")
+
+      "#{exception.exception}\n#{backtrace}"
+    end
+
+    def self.notify(name, message, parameters={})
+      return unless defined?(Airbrake)
+
+      Airbrake.notify_or_ignore(
+        error_class: name,
+        error_message: message,
+        cgi_data: ENV.to_hash,
+        parameters: parameters
+      )
+    end
+
+    def self.notify_exception(exception, parameters={})
+      return unless defined?(Airbrake)
+
+      Airbrake.notify_or_ignore(exception,
+        cgi_data: ENV.to_hash,
+        parameters: parameters
+      )
+    end
+  end
+end

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/freddy/responder_handler_spec.rb

@@ -8,15 +8,49 @@ describe Freddy::ResponderHandler do
 
   after { freddy.close }
 
-  it 'can cancel listening for messages' do
-    consumer_handler = freddy.respond_to destination do
-      @messages_count ||= 0
-      @messages_count += 1
+  describe '#shutdown' do
+    it 'lets ongoing workers to finish' do
+      count = 0
+
+      consumer_handler = freddy.respond_to destination do
+        sleep 0.1
+        count += 1
+      end
+      deliver
+
+      sleep 0.05
+      consumer_handler.shutdown
+
+      expect(count).to eq(1)
+    end
+
+    it 'does not accept new jobs' do
+      count = 0
+
+      consumer_handler = freddy.respond_to destination do
+        count += 1
+      end
+
+      consumer_handler.shutdown
+      deliver
+
+      expect(count).to eq(0)
     end
-    deliver
-    consumer_handler.cancel
-    deliver
 
-    expect(@messages_count).to eq 1
+    it 'does not touch other handlers' do
+      count = 0
+
+      freddy.respond_to destination do
+        count += 1
+      end
+
+      consumer_handler2 = freddy.respond_to random_destination do
+        count += 1
+      end
+      consumer_handler2.shutdown
+
+      deliver
+      expect(count).to eq(1)
+    end
   end
 end

data/spec/freddy/sync_response_container_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Freddy::SyncResponseContainer do
+  let(:container) { described_class.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')
+    end
+  end
+end

data/spec/integration/concurrency_spec.rb

@@ -62,4 +62,26 @@ describe 'Concurrency' do
     expect(received1).to be(true)
     expect(received2).to be(true)
   end
+
+  it 'supports adding multiple #tap_into listeners' do
+    results = 10.times.map do |id|
+      Thread.new do
+        freddy1.tap_into "tap_into.listener.#{id}" do
+        end
+      end
+    end.map(&:join)
+
+    expect(results.count).to eq(10)
+  end
+
+  it 'supports adding multiple #respond_to listeners' do
+    results = 10.times.map do |id|
+      Thread.new do
+        freddy1.respond_to "respond_to.listener.#{id}" do
+        end
+      end
+    end.map(&:join)
+
+    expect(results.count).to eq(10)
+  end
 end

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-jruby
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.9
 platform: ruby
 authors:
 - Urmas Talimaa
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-11-14 00:00:00.000000000 Z
+date: 2015-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -113,22 +113,33 @@ files:
 - Rakefile
 - freddy.gemspec
 - lib/freddy.rb
-- lib/freddy/adaptive_queue.rb
+- lib/freddy/adapters.rb
+- 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
 - lib/freddy/message_handler.rb
 - lib/freddy/message_handlers.rb
+- lib/freddy/payload.rb
 - lib/freddy/producer.rb
 - lib/freddy/request.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/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
 - spec/integration/logging_spec.rb
 - spec/spec_helper.rb
@@ -163,6 +174,7 @@ test_files:
 - 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
 - spec/integration/logging_spec.rb
 - spec/spec_helper.rb

data/lib/freddy/adaptive_queue.rb

@@ -1,34 +0,0 @@
-class Freddy
-  class AdaptiveQueue
-    def initialize(queue)
-      @queue = queue
-    end
-
-    def subscribe(&block)
-      if hare?
-        @queue.subscribe do |meta, payload|
-          block.call(payload, Delivery.new(meta, meta.routing_key))
-        end
-      else
-        @queue.subscribe do |info, properties, payload|
-          block.call(payload, Delivery.new(properties, info.routing_key))
-        end
-      end
-    end
-
-    def bind(*args)
-      @queue.bind(*args)
-      self
-    end
-
-    def name
-      @queue.name
-    end
-
-    private
-
-    def hare?
-      RUBY_PLATFORM == 'java'
-    end
-  end
-end