freddy-jruby 0.4.3

data/lib/freddy/message_handlers.rb

@@ -0,0 +1,68 @@
+class Freddy
+  module MessageHandlers
+    def self.for_type(type)
+      type == 'request' ? RequestHandler : StandardMessageHandler
+    end
+
+    class StandardMessageHandler
+      def initialize(producer, destination, logger)
+        @destination = destination
+        @producer = producer
+        @logger = logger
+      end
+
+      def handle_message(payload, msg_handler, &block)
+        block.call payload, msg_handler
+      rescue Exception => e
+        @logger.error "Exception occured while processing message from #{Freddy.format_exception(e)}"
+        Freddy.notify_exception(e, destination: @destination)
+      end
+
+      def success(*)
+        # NOP
+      end
+
+      def error(*)
+        # NOP
+      end
+    end
+
+    class RequestHandler
+      def initialize(producer, destination, logger)
+        @producer = producer
+        @logger = logger
+        @destination = destination
+      end
+
+      def handle_message(payload, msg_handler, &block)
+        @correlation_id = msg_handler.correlation_id
+
+        if !@correlation_id
+          @logger.error "Received request without correlation_id"
+          Freddy.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)
+      end
+
+      def success(reply_to, response)
+        send_response(reply_to, response, type: 'success')
+      end
+
+      def error(reply_to, response)
+        send_response(reply_to, response, type: 'error')
+      end
+
+      private
+
+      def send_response(reply_to, response, opts = {})
+        @producer.produce reply_to.force_encoding('utf-8'), response, {
+          correlation_id: @correlation_id
+        }.merge(opts)
+      end
+    end
+  end
+end

data/lib/freddy/producer.rb

@@ -0,0 +1,42 @@
+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.to_json
+
+      @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

@@ -0,0 +1,124 @@
+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
+
+    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|
+        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)
+      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
+
+    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(payload, delivery)
+      correlation_id = delivery.metadata.correlation_id
+      request = @request_map[correlation_id]
+      if request
+        @logger.debug "Got response for request to #{request[:destination]} with correlation_id #{correlation_id}"
+        @request_map.delete correlation_id
+        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
+      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
+    end
+
+    def ensure_listening_to_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
+      end
+    end
+  end
+end

data/lib/freddy/request_manager.rb

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

data/lib/freddy/responder_handler.rb

@@ -0,0 +1,21 @@
+class Freddy
+  class ResponderHandler
+
+    def initialize(consumer, channel)
+      @consumer = consumer
+      @channel = channel
+    end
+
+    def cancel
+      @consumer.cancel
+    end
+
+    def queue
+      @consumer.queue
+    end
+
+    def destroy_destination
+      @consumer.queue.delete
+    end
+  end
+end

data/lib/freddy/sync_response_container.rb

@@ -0,0 +1,34 @@
+require 'timeout'
+
+class Freddy
+  class SyncResponseContainer
+    def call(response, delivery)
+      @response = response
+      @delivery = delivery
+    end
+
+    def wait_for_response(timeout)
+      Timeout::timeout(timeout) do
+        sleep 0.001 until filled?
+      end
+
+      if @response[:error] == 'RequestTimeout'
+        raise TimeoutError.new(@response)
+      elsif !@delivery || @delivery.metadata.type == 'error'
+        raise InvalidRequestError.new(@response)
+      else
+        @response
+      end
+    end
+
+    private
+
+    def to_proc
+      Proc.new {|*args| self.call(*args)}
+    end
+
+    def filled?
+      !@response.nil?
+    end
+  end
+end

data/lib/freddy.rb

@@ -0,0 +1,124 @@
+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/consumer'
+require_relative 'freddy/producer'
+require_relative 'freddy/request'
+
+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
+
+    new(connection, logger, config.fetch(:max_concurrency, 4))
+  end
+
+  attr_reader :channel, :consumer, :producer, :request
+
+  def initialize(connection, logger, max_concurrency)
+    @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
+    @request  = Request.new channel, logger, @producer, @consumer
+  end
+
+  def respond_to(destination, &callback)
+    @request.respond_to destination, &callback
+  end
+
+  def tap_into(pattern, &callback)
+    @consumer.tap_into pattern, &callback
+  end
+
+  def deliver(destination, payload, options = {})
+    timeout = options.fetch(:timeout, 0)
+    opts = {}
+    opts[:expiration] = (timeout * 1000).to_i if timeout > 0
+
+    @producer.produce destination, payload, opts
+  end
+
+  def deliver_with_response(destination, payload, options = {})
+    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
+    }
+  end
+
+  def close
+    @connection.close
+  end
+end