freddy 0.4.4 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ecb2f4ec6c6f60c98794bf27eb96435bf6ff6c5
-  data.tar.gz: c9e9d05eb2b43589c85d38610778b861498c6446
+  metadata.gz: 1c9e0020e6933bdc25c5845a3bad630dc56b4ae9
+  data.tar.gz: 55da31d069e4dd316260d37a0db00965a737039e
 SHA512:
-  metadata.gz: bf8de81be9694937033dc1fba0013319093c96fc09a07792f6185b9164a5ebcb6bd399d82eb031efdcdd949015fa8e14735e1ac96e161e3cc2fb4edd8d67a53b
-  data.tar.gz: 6547d13beb561b67f21967299a4d6c9f9a67768cccf1f1b15da13a5d042933f171c8ab043df17dc846785229816ebadb45dab0f0b8162ebf18933cd15de970b3
+  metadata.gz: 78b24b50ec3a7779572c1a45ce1b59d6ce345a058dda2c6781048b65a5312f210cb4595fc678450ea9a73dbf95951a902598def1e1bad3493071b4f903db1e5f
+  data.tar.gz: 7ee8fd7a118ef27a164becdf4bab34b977ba31dada15040233aff1807c56648d6b0dd1d58ce691a0bf3f563304d0f94a7201ac1b14c625a86b318b2d56a978e5

data/README.md

@@ -131,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.4'
+  spec.version       = '0.4.6'
   spec.authors       = ["Urmas Talimaa"]
   spec.email         = ["urmas.talimaa@gmail.com"]
   spec.description   = %q{Messaging API}

data/lib/freddy.rb

@@ -1,83 +1,36 @@
-if RUBY_PLATFORM == 'java'
-  require 'march_hare'
-else
-  require 'bunny'
-end
-
 require 'json'
 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
@@ -92,6 +45,7 @@ class Freddy
     @producer = Producer.new channel, logger
     @request  = Request.new channel, logger, @producer, @consumer
   end
+  private :initialize
 
   def respond_to(destination, &callback)
     @request.respond_to destination, &callback
@@ -101,6 +55,27 @@ class Freddy
     @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,66 @@
+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|
+            block.call(payload, Delivery.new(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,67 @@
+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|
+            block.call(payload, Delivery.new(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

@@ -37,7 +37,7 @@ class Freddy
         end
       end
       @logger.debug "Tapping into messages that match #{pattern}"
-      ResponderHandler.new consumer, @channel
+      ResponderHandler.new consumer, @consume_thread_pool
     end
 
     private
@@ -51,11 +51,11 @@ class Freddy
         end
       end
       @logger.debug "Consuming messages on #{queue.name}"
-      ResponderHandler.new consumer, @channel
+      ResponderHandler.new consumer, pool
     end
 
     def create_queue(destination, options={})
-      AdaptiveQueue.new(@channel.queue(destination, options))
+      @channel.queue(destination, options)
     end
 
     def log_receive_event(queue_name, payload, correlation_id)

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_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/producer.rb

@@ -22,21 +22,5 @@ class Freddy
       @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

@@ -23,7 +23,7 @@ class Freddy
       @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
@@ -80,7 +80,7 @@ class Freddy
     private
 
     def create_response_queue
-      AdaptiveQueue.new @channel.queue("", exclusive: true)
+      @channel.queue("", exclusive: true)
     end
 
     def handle_response(payload, delivery)
@@ -92,12 +92,12 @@ class Freddy
         request[:callback].call 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)
+      @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_response_queue_exists

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,18 +1,27 @@
+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'
         raise InvalidRequestError.new(@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/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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freddy
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: ruby
 authors:
 - Urmas Talimaa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-24 00:00:00.000000000 Z
+date: 2015-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,9 +113,13 @@ 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/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
@@ -124,12 +128,15 @@ files:
 - 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
@@ -164,6 +171,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