tochtli 0.5.0

data/lib/tochtli/reply_queue.rb

@@ -0,0 +1,129 @@
+module Tochtli
+  class ReplyQueue
+    attr_reader :connection, :logger, :queue
+
+    def initialize(rabbit_connection, logger=nil)
+      @connection              = rabbit_connection
+      @logger                  = logger || rabbit_connection.logger
+      @message_handlers        = {}
+      @message_timeout_threads = {}
+
+      subscribe
+    end
+
+    def name
+      @queue.name
+    end
+
+    def subscribe
+      channel  = @connection.channel
+      exchange = @connection.exchange
+
+      @queue               = channel.queue('', exclusive: true, auto_delete: true)
+      @original_queue_name = @queue.name
+      @queue.bind exchange, routing_key: @queue.name
+
+      @consumer = Consumer.new(self, channel, @queue)
+      @consumer.on_delivery(&method(:on_delivery))
+
+      @queue.subscribe_with(@consumer)
+    end
+
+    def reconnect(channel)
+      if @queue
+        channel.connection.logger.debug "Recovering reply queue binding (original: #{@original_queue_name}, current: #{@queue.name})"
+
+        # Re-bind queue after name change (auto-generated new on server has been re-generated)
+        exchange = @connection.create_exchange(channel)
+        @queue.unbind exchange, routing_key: @original_queue_name
+        @queue.bind exchange, routing_key: @queue.name
+      end
+
+      @original_queue_name = @queue.name
+    end
+
+    def register_message_handler(message, handler=nil, timeout=nil, &block)
+      @message_handlers[message.id] = handler || block
+      if timeout
+        timeout_thread                       = Thread.start do
+          sleep timeout
+          logger.warn "[#{Time.now} AMQP] TIMEOUT on message '#{message.id}' timeout: #{timeout}"
+          handle_timeout message
+        end
+        @message_timeout_threads[message.id] = timeout_thread
+      end
+    end
+
+    def on_delivery(delivery_info, metadata, payload)
+      class_name       = metadata.type.camelize.gsub(/[^a-zA-Z0-9\:]/, '_') # basic sanity
+      reply_class      = eval(class_name)
+      reply            = reply_class.new({}, metadata)
+      attributes       = JSON.parse(payload)
+      reply.attributes = attributes
+
+      logger.debug "[#{Time.now} AMQP] Replay for #{reply.properties.correlation_id}: #{reply.inspect}"
+
+      handle_reply reply
+
+    rescue Exception
+      logger.error $!
+      logger.error $!.backtrace.join("\n")
+    end
+
+    def handle_reply(reply, correlation_id=nil)
+      correlation_id ||= reply.properties.correlation_id if reply.is_a?(Tochtli::Message)
+      raise ArgumentError, "Correlated message ID expected" unless correlation_id
+      if (handler = @message_handlers.delete(correlation_id))
+        if (timeout_thread = @message_timeout_threads.delete(correlation_id))
+          timeout_thread.kill
+          timeout_thread.join # make sure timeout thread is dead
+        end
+
+        if !reply.is_a?(Tochtli::ErrorMessage) && !reply.is_a?(Exception)
+
+          begin
+
+            handler.call(reply)
+
+          rescue Exception
+            logger.error $!
+            logger.error $!.backtrace.join("\n")
+            handler.on_error($!)
+          end
+
+        else
+          handler.on_error(reply)
+        end
+
+      else
+        logger.error "[Tochtli::ReplyQueue] Unexpected message delivery '#{correlation_id}':\n\t#{reply.inspect})"
+      end
+    end
+
+    def handle_timeout(original_message)
+      if (handler = @message_handlers.delete(original_message.id))
+        @message_timeout_threads.delete(original_message.id)
+        handler.on_timeout original_message
+      else
+        raise "Internal error, timeout handler not found for message: #{original_message.id}, #{original_message.inspect}"
+      end
+    end
+
+    class Consumer < ::Bunny::Consumer
+      def initialize(reply_queue, *args)
+        super(*args)
+        @reply_queue = reply_queue
+      end
+
+      def recover_from_network_failure
+        super
+        @reply_queue.reconnect(@channel)
+      rescue Exception
+        logger = channel.connection.logger
+        logger.error $!
+        logger.error $!.backtrace.join("\n")
+        raise
+      end
+    end
+  end
+end

data/lib/tochtli/simple_validation.rb

@@ -0,0 +1,23 @@
+module Tochtli
+  module SimpleValidation
+    attr_reader :errors
+
+    def add_error(message)
+      @errors << message
+    end
+
+    def valid?
+      @errors = []
+      validate
+      !@errors || @errors.empty?
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    # abstract method
+    def validate
+    end
+  end
+end

data/lib/tochtli/test.rb

@@ -0,0 +1,9 @@
+module Tochtli
+  module Test
+    autoload :Helpers, 'tochtli/test/test_case'
+    autoload :Client, 'tochtli/test/client'
+    autoload :Controller, 'tochtli/test/controller'
+    autoload :Integration, 'tochtli/test/integration'
+    autoload :MemoryCache, 'tochtli/test/memory_cache'
+  end
+end

data/lib/tochtli/test/client.rb

@@ -0,0 +1,28 @@
+require_relative 'test_case'
+
+module Tochtli
+  module Test
+    module Client
+      extend UnitTestSupport if defined?(::Test::Unit)
+      include Tochtli::Test::Helpers
+      
+      def before_setup
+        super
+        @logger      = Tochtli.logger
+        @client      = Tochtli::RabbitClient.new(@connection, @logger)
+        @reply_queue = @client.reply_queue
+      end
+
+      def create_reply(reply_class, original_message, attributes)
+        properties = TestMessageProperties.new(nil, reply_class.generate_id, original_message.id)
+        reply_class.new(attributes, properties)
+      end
+
+      def handle_reply(reply_class, original_message, attributes)
+        reply = create_reply(reply_class, original_message, attributes)
+        @reply_queue.handle_reply reply
+        reply
+      end
+    end
+  end
+end

data/lib/tochtli/test/controller.rb

@@ -0,0 +1,66 @@
+require_relative 'test_case'
+
+module Tochtli
+  module Test
+    module Controller
+      module ControllerClassSupport
+        def included(base)
+          super
+          base.class_eval do
+            extend Uber::InheritableAttr
+            inheritable_attr :controller_class
+
+            def self.tests(controller_class)
+              self.controller_class = controller_class
+            end
+          end
+        end
+      end
+
+      extend UnitTestSupport if defined?(::Test::Unit)
+      extend ControllerClassSupport
+      include Tochtli::Test::Helpers
+
+      class RoutingNotFound < StandardError
+      end
+
+
+      def before_setup
+        super
+        @cache  = Object.const_defined?(:ActiveSupport) ? ActiveSupport::Cache::MemoryStore.new : Tochtli::Test::MemoryCache.new
+        @logger = Tochtli.logger
+        self.class.controller_class.setup(@connection, @cache, @logger)
+        @dispatcher = self.class.controller_class.dispatcher
+        @message_index = 0
+      end
+
+      def after_teardown
+        self.class.controller_class.stop
+        super
+      end
+
+      def publish(message)
+        @message_index += 1
+        delivery_info  = TestDeliveryInfo.new(message.routing_key)
+        properties     = TestMessageProperties.new("test.reply", @message_index)
+        payload        = message.to_json
+
+        @message, @reply = nil
+
+        unless @dispatcher.process_message(delivery_info, properties, payload, {})
+          if (reply = @connection.publications.first) && reply[:message].is_a?(Tochtli::ErrorMessage)
+            raise "Process error: #{reply[:message].message}"
+          else
+            raise RoutingNotFound, "Message #{message.class.name} not processed by #{self.class.controller_class} - #{message.inspect}."
+          end
+        end
+
+        reply = @connection.publications.first
+        if reply && reply[:routing_key] == "test.reply" && reply[:correlation_id] == @message_index
+          @connection.publications.shift
+          @reply = reply[:message]
+        end
+      end
+    end
+  end
+end

data/lib/tochtli/test/integration.rb

@@ -0,0 +1,78 @@
+require_relative 'test_case'
+
+module Tochtli
+  # Ensure all queues are temporary
+  BaseController.queue_durable     = false
+  BaseController.queue_auto_delete = true
+
+  module Test
+    module Integration
+      extend UnitTestSupport if defined?(::Test::Unit)
+
+      def before_setup
+        super
+        @logger             = Tochtli.logger
+        @logger.level       = Logger::DEBUG
+        @client             = Tochtli::RabbitClient.new(nil, @logger)
+        @connection         = @client.rabbit_connection
+        @controller_manager = Tochtli::ControllerManager.instance
+        @controller_manager.setup(connection: @connection, logger: @logger)
+        @controller_manager.start(:all)
+
+        # Reply support
+        @mutex = Mutex.new
+        @cv    = ConditionVariable.new
+      end
+
+      def after_teardown
+        begin
+          @controller_manager.stop if @controller_manager
+        rescue Timeout::Error
+          warn "Unable to stop controller manager: #{$!} [#{$!.class}]"
+        end
+        super
+      end
+
+      private
+
+      def publish(message, options={})
+        @reply               = nil
+        timeout              = options.fetch(:timeout, 1.0)
+        @reply_message_class = options[:expect]
+        @reply_handler       = options[:reply_handler]
+
+        if @reply_message_class || @reply_handler
+          handler = @reply_handler || method(:synchronous_reply_handler)
+          if handler.is_a?(Proc)
+            @client.reply_queue.register_message_handler message, &handler
+          else
+            @client.reply_queue.register_message_handler message, handler, timeout
+          end
+        end
+
+        @client.publish message
+
+        if @reply_message_class && !@reply_handler
+          synchronous_timeout_handler(message, timeout)
+        end
+      end
+
+      def synchronous_reply_handler(reply)
+        assert_kind_of @reply_message_class, reply, "Unexpected reply"
+        @mutex.synchronize do
+          @reply = reply
+          @cv.signal
+        end
+      end
+
+      def synchronous_timeout_handler(message, timeout)
+        @mutex.synchronize { @cv.wait(@mutex, timeout) unless @reply }
+
+        raise "Reply on #{message.class.name} timeout" unless @reply
+        raise @reply.message if @reply.is_a?(Tochtli::ErrorMessage)
+
+        @reply
+      end
+    end
+  end
+end

data/lib/tochtli/test/memory_cache.rb

@@ -0,0 +1,22 @@
+require 'mini_cache'
+
+module Tochtli
+  module Test
+    # a simple proxy to replicate ActiveSupport cache interface using mini store
+    class MemoryCache
+      attr_reader :store
+
+      def initialize
+        @store = MiniCache::Store.new
+      end
+
+      def write(name, value)
+        store.set(name, value)
+      end
+
+      def read(name)
+        store.get(name)
+      end
+    end
+  end
+end

data/lib/tochtli/test/test_case.rb

@@ -0,0 +1,191 @@
+require_relative 'test_unit' if defined?(::Test::Unit)
+
+module Tochtli
+  module Test
+    module Helpers
+      extend UnitTestSupport if defined?(::Test::Unit)
+
+      def before_setup
+        super
+        @connection    = TestRabbitConnection.new
+      end
+
+      def assert_published(message_class, attributes={})
+        publication = @connection.get_publication
+        assert !publication.nil?, "No message published"
+        @message = publication[:message]
+        assert_kind_of message_class, @message
+        attributes.each do |attr_name, value|
+          assert_equal value, @message.send(attr_name), "Message attribute :#{attr_name} value does not match"
+        end
+        yield @message if block_given?
+        @message
+      end
+
+      def expect_published(message_class, attributes={})
+        @connection.callback do
+          assert_published message_class, attributes
+          yield @message
+        end
+      end
+    end
+
+    class TestRabbitConnection
+      attr_reader :channel, :exchange, :publications
+
+      def initialize
+        @channel      = TestRabbitChannel.new(self)
+        @exchange     = TestRabbitExchange.new
+        @publications = []
+        @queues       = {}
+      end
+
+      def exchange_name
+        @exchange.name
+      end
+
+      def reply_queue
+        @reply_queue ||= Tochtli::ReplyQueue.new(self)
+      end
+
+      def publish(routing_key, message, options={})
+        @publications << options.merge(routing_key: routing_key, message: message)
+        run_callback
+      end
+
+      def get_publication
+        @publications.shift
+      end
+
+      def callback(&block)
+        @callback = block
+      end
+
+      def run_callback
+        if @callback
+          @callback.call
+          @callback = nil
+        end
+      end
+
+      def logger
+        Logger.new(STDOUT)
+      end
+
+      def queue(name=nil, routing_keys=[], options={})
+        queue = @queues[name]
+        unless queue
+          @queues[name] = queue = TestQueue.new(@channel, name, options)
+        end
+        queue
+      end
+
+      def queue_exists?(name)
+        @queues.has_key?(name)
+      end
+
+      def create_channel(consumer_pool_size = 1)
+        TestRabbitChannel.new(self)
+      end
+    end
+
+    class TestRabbitChannel
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def queue(name, options={})
+        @connection.queue(name, [], options)
+      end
+
+      [:topic, :fanout, :direct].each do |type|
+        define_method type do |name, options|
+          TestRabbitExchange.new(name, options)
+        end
+      end
+
+      def generate_consumer_tag
+        "test-consumer-tag-#{rand(1000)}"
+      end
+    end
+
+    class TestRabbitExchange
+      attr_reader :name
+
+      def initialize(name='test.exchange', options={})
+        @name = name
+      end
+    end
+
+    class TestQueue
+      attr_reader :channel, :name, :options, :routing_key
+
+      def initialize(channel, name, options)
+        @name    = name
+        @channel = channel
+        @options = options
+      end
+
+      def bind(exchange, options)
+        @routing_key = options[:routing_key]
+      end
+
+      def subscribe(*args)
+        TestConsumer.new
+      end
+
+      def subscribe_with(*args)
+        TestConsumer.new
+      end
+    end
+
+    class TestConsumer
+      def cancel
+        TestConsumer.new
+      end
+    end
+
+    class TestDeliveryInfo
+      attr_reader :routing_key, :exchange
+
+      def initialize(routing_key, exchange='TestExchange')
+        @routing_key = routing_key
+        @exchange    = exchange
+      end
+
+      def [](key)
+        send(key)
+      end
+    end
+
+    class TestMessageProperties
+      attr_reader :reply_to, :message_id, :correlation_id
+
+      def initialize(reply_to, message_id=nil, correlation_id=nil)
+        @reply_to       = reply_to
+        @message_id     = message_id
+        @correlation_id = correlation_id
+      end
+
+      def [](key)
+        send(key)
+      end
+    end
+
+    class TestMessageHandler
+      attr_reader :reply, :timeout_message, :error
+
+      def call(reply)
+        @reply = reply
+      end
+
+      def on_timeout(original_message=nil)
+        @timeout_message = original_message
+      end
+
+      def on_error(error)
+        @error = error
+      end
+    end
+  end
+end