freddy 0.3.0

data/lib/freddy/delivery.rb

@@ -0,0 +1,10 @@
+class Freddy
+  class Delivery
+    attr_reader :info, :properties
+
+    def initialize(info, properties)
+      @info = info
+      @properties = properties
+    end
+  end
+end

data/lib/freddy/message_handler.rb

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

data/lib/freddy/message_handlers.rb

@@ -0,0 +1,67 @@
+class Freddy
+  module MessageHandlers
+    def self.for_type(type)
+      type == 'request' ? RequestHandler : StandardMessageHandler
+    end
+
+    class StandardMessageHandler
+      def initialize(producer, logger)
+        @producer = producer
+        @logger = logger
+      end
+
+      def handle_message(payload, msg_handler, &block)
+        block.call payload, msg_handler
+      rescue Exception => e
+        destination = msg_handler.destination
+        @logger.error "Exception occured while processing message from #{destination}: #{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, logger)
+        @producer = producer
+        @logger = logger
+      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, destination: msg_handler.destination, correlation_id: @correlation_id)
+      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,28 @@
+require_relative 'request'
+require 'json'
+
+class Freddy
+  class Producer
+    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(*args, &block)
+      @exchange.on_return(*args, &block)
+    end
+  end
+end

data/lib/freddy/request.rb

@@ -0,0 +1,106 @@
+require_relative 'producer'
+require_relative 'consumer'
+require_relative 'request_manager'
+require_relative 'sync_response_container'
+require_relative 'message_handlers'
+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)
+      @channel, @logger = channel, logger
+      @producer, @consumer = Producer.new(channel, logger), Consumer.new(channel, logger)
+      @listening_for_responses = false
+      @request_map = Hamster.mutable_hash
+      @request_manager = RequestManager.new @request_map, @logger
+
+      @producer.on_return do |return_info, properties, content|
+        if return_info[:reply_code] == NO_ROUTE
+          @request_manager.no_route(properties[:correlation_id])
+        end
+      end
+    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, timeout:, delete_on_timeout:, **options, &block)
+      listen_for_responses unless @listening_for_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
+      @response_queue = create_response_queue unless @response_queue
+      @logger.debug "Listening for requests on #{destination}"
+
+      responder_handler = @consumer.consume destination do |payload, delivery|
+        handler = MessageHandlers.for_type(delivery.properties[:type]).new(@producer, @logger)
+
+        msg_handler = MessageHandler.new(handler, delivery)
+        handler.handle_message payload, msg_handler, &block
+      end
+      responder_handler
+    end
+
+    private
+
+    def create_response_queue
+      @channel.queue("", exclusive: true)
+    end
+
+    def handle_response(payload, delivery)
+      correlation_id = delivery.properties[: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
+        message = "Got rpc response for correlation_id #{correlation_id} but there is no requester"
+        @logger.warn message
+        Freddy.notify 'NoRequesterForResponse', message, 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 listen_for_responses
+      @listening_for_responses = true
+      @response_queue = create_response_queue unless @response_queue
+      @request_manager.start
+      @consumer.consume_from_queue @response_queue do |payload, delivery|
+        handle_response payload, delivery
+      end
+    end
+
+  end
+end

data/lib/freddy/request_manager.rb

@@ -0,0 +1,41 @@
+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
+
+      message = "Request #{correlation_id} timed out waiting response from #{request[:destination]} with timeout #{request[:timeout]}"
+      @logger.warn message
+      Freddy.notify 'RequestTimeout', message, request: correlation_id, destination: request[:destination], timeout: request[:timeout]
+      request[:callback].call({error: 'Timed out waiting for response'}, nil)
+    end
+  end
+end

data/lib/freddy/responder_handler.rb

@@ -0,0 +1,30 @@
+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
+
+    def join
+      @channel.work_pool.join
+    end
+
+    def shutdown
+      @channel.work_pool.shutdown
+    end
+
+  end
+end

data/lib/freddy/sync_response_container.rb

@@ -0,0 +1,32 @@
+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 !@delivery || @delivery.properties[:type] == 'error'
+        raise ErrorResponse.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/spec/freddy/consumer_spec.rb

@@ -0,0 +1,23 @@
+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 }
+
+  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
+      @message_received = true
+    end
+    default_sleep
+
+    expect(@message_received).to be_falsy
+  end
+end

data/spec/freddy/freddy_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe Freddy do
+  let(:freddy) { described_class.build(logger, config) }
+
+  let(:destination)  { random_destination }
+  let(:destination2) { random_destination }
+  let(:payload)      { {pay: 'load'} }
+
+  def respond_to(&block)
+    freddy.respond_to(destination, &block)
+  end
+
+  context 'when making a send-and-forget request' do
+    context 'with timeout' 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)
+
+        freddy.deliver(destination, {}, timeout: 0.1)
+        sleep 0.2
+
+        processed_after_timeout = false
+        respond_to { processed_after_timeout = true }
+        default_sleep
+
+        expect(processed_after_timeout).to be(false)
+      end
+    end
+
+    context 'without timeout' 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)
+
+        freddy.deliver(destination, {})
+        default_sleep # to ensure everything is properly cleaned
+
+        processed_after_timeout = false
+        respond_to { processed_after_timeout = true }
+        default_sleep
+
+        expect(processed_after_timeout).to be(true)
+      end
+    end
+  end
+
+  context 'when making a synchronized request' do
+    it 'returns response as soon as possible' do
+      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
+      response = freddy.deliver_with_response(destination, {a: 'b'})
+
+      expect(response).to eq(res: 'yey')
+    end
+
+    it 'raises an error if the message was errored' do
+      respond_to { |payload, msg_handler| msg_handler.error(error: 'not today') }
+
+      expect {
+        freddy.deliver_with_response(destination, payload)
+      }.to raise_error(Freddy::ErrorResponse) {|error|
+        expect(error.response).to eq(error: 'not today')
+      }
+    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') }
+
+      response = freddy.deliver_with_response(destination, payload)
+      expect(response).to eq(res: 'yey')
+
+      expect {
+        freddy.deliver_with_response(destination2, payload)
+      }.to raise_error(Freddy::ErrorResponse)
+    end
+
+    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::ErrorResponse) {|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
+      end
+    end
+
+    context 'on timeout' do
+      it 'gives timeout error' do
+        respond_to { |payload, msg_handler| sleep 0.2 }
+
+        expect {
+          freddy.deliver_with_response(destination, {a: 'b'}, timeout: 0.1)
+        }.to raise_error(Freddy::ErrorResponse) {|error|
+          expect(error.response).to eq(error: 'Timed out waiting for response')
+        }
+      end
+
+      context 'with delete_on_timeout is set to true' 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)
+
+          expect {
+            freddy.deliver_with_response(destination, {}, timeout: 0.1)
+          }.to raise_error(Freddy::ErrorResponse)
+          default_sleep # to ensure everything is properly cleaned
+
+          processed_after_timeout = false
+          respond_to { processed_after_timeout = true }
+          default_sleep
+
+          expect(processed_after_timeout).to be(false)
+        end
+      end
+
+      context 'with delete_on_timeout is set to false' 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)
+
+          expect {
+            freddy.deliver_with_response(destination, {}, timeout: 0.1, delete_on_timeout: false)
+          }.to raise_error(Freddy::ErrorResponse)
+          default_sleep # to ensure everything is properly cleaned
+
+          processed_after_timeout = false
+          respond_to { processed_after_timeout = true }
+          default_sleep
+
+          expect(processed_after_timeout).to be(true)
+        end
+      end
+    end
+  end
+
+  describe 'when tapping' do
+    def tap(custom_destination = destination, &block)
+      freddy.tap_into(custom_destination, &block)
+    end
+
+    it 'receives messages' do
+      tap {|msg| @tapped_message = msg }
+      deliver
+
+      wait_for { @tapped_message }
+      expect(@tapped_message).to eq(payload)
+    end
+
+    it 'has the destination' do
+      tap "somebody.*.love" do |message, destination|
+        @destination = destination
+      end
+      deliver "somebody.to.love"
+
+      wait_for { @destination }
+      expect(@destination).to eq("somebody.to.love")
+    end
+
+    it "doesn't consume the message" do
+      tap { @tapped = true }
+      respond_to { @message_received = true }
+
+      deliver
+
+      wait_for { @tapped }
+      wait_for { @message_received }
+      expect(@tapped).to be(true)
+      expect(@message_received).to be(true)
+    end
+
+    it "allows * wildcard" do
+      tap("somebody.*.love") { @tapped = true }
+
+      deliver "somebody.to.love"
+
+      wait_for { @tapped }
+      expect(@tapped).to be(true)
+    end
+
+    it "* matches only one word" do
+      tap("somebody.*.love") { @tapped = true }
+
+      deliver "somebody.not.to.love"
+
+      default_sleep
+      expect(@tapped).to be_falsy
+    end
+
+    it "allows # wildcard" do
+      tap("i.#.free") { @tapped = true }
+
+      deliver "i.want.to.break.free"
+
+      wait_for { @tapped }
+      expect(@tapped).to be(true)
+    end
+  end
+end