mimi-messaging 0.1.10

data/lib/mimi/messaging/errors.rb

@@ -0,0 +1,19 @@
+module Mimi
+  module Messaging
+    class ConnectionError < StandardError
+    end # class ConnectionError
+
+    class RequestError < StandardError
+      attr_accessor :params
+
+      def initialize(message = 'failed to process request', params = {})
+        @message = message
+        @params = params.dup
+      end
+
+      def to_s
+        @message
+      end
+    end # class RequestError
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/listener.rb

@@ -0,0 +1,72 @@
+module Mimi
+  module Messaging
+    class Listener < RequestProcessor
+      DEFAULT_DURABLE_QUEUE_OPTIONS = {
+        exclusive: false,
+        durable: true,
+        auto_delete: false
+      }
+
+      DEFAULT_TEMPORARY_QUEUE_OPTIONS = {
+        exclusive: true,
+        durable: false,
+        auto_delete: true
+      }
+
+      abstract!
+
+      queue_options DEFAULT_TEMPORARY_QUEUE_OPTIONS
+
+      def self.queue(name = nil, opts = {})
+        return super unless name
+        queue_name(name)
+        if name && name != ''
+          queue_options(DEFAULT_DURABLE_QUEUE_OPTIONS.merge(opts))
+        else
+          queue_options(DEFAULT_TEMPORARY_QUEUE_OPTIONS.merge(opts))
+        end
+      end
+
+      def self.default_queue_name
+        ''
+      end
+
+      # Sets or gets notification resource name
+      #
+      def self.notification(name = nil, _opts = {})
+        notification_name name
+        true
+      end
+
+      # Sets or gets queue name
+      #
+      def self.notification_name(name = nil)
+        if name && @notification_name
+          raise "#{self} has already registered '#{@notification_name}' as notification name"
+        end
+        (@notification_name ||= name) || default_notification_name
+      end
+
+      # Default (inferred) notification name
+      #
+      def self.default_notification_name
+        class_name_to_resource_name(name, 'listener')
+      end
+
+      def self.resource_name
+        notification_name
+      end
+
+      def self.request_type(_d, _m, _p)
+        :broadcast
+      end
+
+      def self.construct_queue
+        exchange = channel.fanout(resource_name)
+        q = channel.create_queue(queue_name, queue_options)
+        q.bind(exchange)
+        q
+      end
+    end # class Listener
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/message.rb

@@ -0,0 +1,74 @@
+require 'json'
+require 'msgpack'
+
+module Mimi
+  module Messaging
+    class Message < Hashie::Mash
+      def self.queue(name, _opts = {})
+        @queue_name = name
+      end
+
+      def self.queue_name
+        @queue_name || default_queue_name
+      end
+
+      def self.default_queue_name
+        Mimi::Messaging::RequestProcessor.class_name_to_resource_name(self, 'message')
+      end
+
+      def self.get(name, data = {}, opts = {})
+        headers = {
+          method_name: name.to_s,
+          Mimi::Messaging::CONTEXT_ID_KEY => Mimi::Messaging.logger.context_id
+        }
+        _d, _m, response = Mimi::Messaging.get(
+          queue_name, encode(data), opts.deep_merge(headers: headers)
+        )
+        raise Timeout::Error unless response
+        message = new(decode(response))
+        raise RequestError.new(message.error, Message.new(message.params)) if message.error?
+        message
+      end
+
+      def self.post(name, data = {}, opts = {})
+        headers = {
+          method_name: name.to_s,
+          Mimi::Messaging::CONTEXT_ID_KEY => Mimi::Messaging.logger.context_id
+        }
+        Mimi::Messaging.post(
+          queue_name, encode(data), opts.deep_merge(headers: headers)
+        )
+      end
+
+      def self.add_method(name, &block)
+        self.class.instance_eval do
+          define_method(name, &block)
+        end
+      end
+
+      def self.methods(*names)
+        names.each do |method_name|
+          add_method(method_name) do |*params|
+            get(method_name, *params)
+          end
+          add_method("#{method_name}!") do |*params|
+            post(method_name, *params)
+            nil
+          end
+        end
+      end
+
+      def self.encode(data)
+        MessagePack.pack(data) # data.to_json
+      end
+
+      def self.decode(raw_message)
+        MessagePack.unpack(raw_message) # JSON.parse(raw_message)
+      end
+
+      def to_s
+        to_hash.to_s
+      end
+    end # class Message
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/mock.rb

@@ -0,0 +1,13 @@
+#
+# Replaces real Connection and Channel with MockConnection and MockChannel
+# that stubs connections to RabbitMQ.
+#
+# Replaces RequestProcessor with MockRequestProcessor
+#
+
+require_relative 'mock/connection'
+require_relative 'mock/request_processor'
+require_relative 'mock/request'
+
+Mimi::Messaging.send :remove_const, :Connection
+Mimi::Messaging::Connection = Mimi::Messaging::MockConnection

data/lib/mimi/messaging/mock/connection.rb

@@ -0,0 +1,153 @@
+require 'bunny'
+
+module Mimi
+  module Messaging
+    class MockConnection
+      attr_reader :queue_prefix
+
+      # Creates a Connection with given connection params
+      #
+      # @param params [Hash] Connection params as accepted by Bunny
+      # @param params[:queue_prefix] [String] (optional) Use this connection for all communication
+      #                                       related to queues, having names starting with given
+      #                                       prefix
+      #
+      def initialize(params = {})
+        @queue_prefix = params[:queue_prefix]
+        @channel_pool = {}
+        bunny_params = {
+          host: params[:mq_host],
+          port: params[:mq_port],
+          username: params[:mq_username],
+          password: params[:mq_password],
+          vhost: params[:mq_vhost]
+        }
+        @connection = { mock_connection: bunny_params }
+      end
+
+      # Starts the connection, opening actual connection to RabbitMQ
+      #
+      def start
+        @started = true
+      end
+
+      # Stops the connection
+      #
+      def stop
+        @channel_pool = {}
+        @started = false
+      end
+
+      def started?
+        @started
+      end
+
+      def channel
+        raise ConnectionError unless started?
+        @channel_pool[Thread.current.object_id] ||= create_channel
+      end
+
+      def create_channel(opts = {})
+        MockChannel.new(@connection, opts)
+      end
+
+      def reply_queue
+        raise ConnectionError unless started?
+        channel.reply_queue
+      end
+
+      def post(queue_name, raw_message, params = {})
+        channel.post(queue_name, raw_message, params)
+      end
+
+      def get(queue_name, raw_message, params = {})
+        channel.get(queue_name, raw_message, params)
+      end
+
+      def broadcast(queue_name, raw_message, params = {})
+        channel.broadcast(queue_name, raw_message, params)
+      end
+
+      class MockQueue
+        def initialize(*)
+        end
+      end
+
+      class MockChannel
+        attr_reader :options, :connection
+
+        DEFAULT_OPTIONS = {
+          concurrency: 1
+        }
+        DEFAULT_GET_TIMEOUT = 60 # seconds
+
+        def initialize(connection, opts = {})
+          @connection = connection
+          @options = DEFAULT_OPTIONS.merge(opts)
+          @channel = { mock_channel: @connection, opts: options[:concurrency] }
+          @mutex = Mutex.new
+        end
+
+        def create_queue(name, opts = {})
+          MockQueue.new(name, opts)
+        end
+
+        def reply_queue
+          @reply_queue ||= create_queue('', exclusive: true)
+        end
+
+        def ack(tag)
+          raise "Not implemented"
+        end
+
+        def fanout(name)
+          raise "Not implemented"
+        end
+
+        def active?
+          true
+        end
+
+        # Sends a raw RabbitMQ message to a given direct exchange
+        #
+        # @param queue_name [String] Queue name to send the message to
+        # @param raw_message [String]
+        # @param params [Hash] Message params (metadata)
+        #
+        def post(queue_name, raw_message, params = {})
+          true
+        end
+
+        # Sends a raw RabbitMQ message to a given direct exchange and listens for response
+        #
+        # @param queue_name [String] Queue name to send the message to
+        # @param raw_message [String]
+        # @param params [Hash] Message params (metadata)
+        #
+        # @param params[:timeout] [Integer] (optional) Timeout in seconds
+        #
+        # @return [nil,Array]
+        #
+        def get(queue_name, raw_message, params = {})
+          nil
+        end
+
+        # Sends a raw RabbitMQ message to a given fanout exchange
+        #
+        # @param fanout_name [String] Fanout exchange name to send the message to
+        # @param raw_message [String]
+        # @param params [Hash] Message params (metadata)
+        #
+        def broadcast(fanout_name, raw_message, params = {})
+          true
+        end
+
+        private
+
+        def publish(exchange, raw_message, params = {})
+          true
+        end
+      end # class Channel
+    end # class Connection
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/mock/request.rb

@@ -0,0 +1,18 @@
+module Mimi
+  module Messaging
+    class Request
+      attr_reader :response
+
+      def send_response(data = {})
+        return if !get? || replied?
+        raise ArgumentError, 'Invalid response format, Hash is expected' unless data.is_a?(Hash)
+        raw_message = Mimi::Messaging::Message.encode(data)
+        @response = Mimi::Messaging::Message.decode(raw_message)
+        request_processor.connection.post(
+          reply_to_queue_name, raw_message, correlation_id: metadata[:correlation_id]
+        )
+        @replied = true
+      end
+    end # class Request
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/mock/request_processor.rb

@@ -0,0 +1,92 @@
+module Mimi
+  module Messaging
+    class RequestProcessor
+      attr_reader :result, :request
+
+      def self.started?
+        !@consumer.nil?
+      end
+
+      # Mock start
+      #
+      def self.start
+        return if abstract?
+        raise "#{name} already started" if started?
+        logger.debug "#{self} starting to serve '#{resource_name}' (#{exposed_methods})"
+        @queue = construct_queue
+        @consumer_mutex = Mutex.new
+        @consumer_mutex.synchronize do
+          @consumer = true
+        end
+        # consumer created, mutex released
+      end
+
+      # Mock stop
+      #
+      def self.stop
+        return if abstract?
+        raise "#{name} already stopped" unless started?
+        @consumer_mutex.synchronize do
+          @consumer = nil
+        end
+        @consumer = nil
+        @queue = nil
+        @channel = nil
+        @connection = nil
+      end
+
+      # MockRequestProcessor helper GET methods
+      #
+      # @param method_name [Symbol]
+      # @param message [Hash]
+      #
+      # @return [Mimi::Messaging::Message]
+      #
+      def self.get(method_name, message)
+        metadata    = Mimi::Messaging::Message.new(
+          correlation_id: 1,
+          reply_to: 'mock_client',
+          headers: {
+            'method_name' =>  method_name.to_s,
+            'c' => 'mock-context'
+          }
+        )
+        d           = Mimi::Messaging::Message.new()
+        raw_message = Mimi::Messaging::Message.new(message).to_msgpack
+        request_processor = new(d, metadata, raw_message)
+        request_processor.request.response
+      end
+
+      # MockRequestProcessor helper POST method
+      #
+      # @param method_name [Symbol]
+      # @param message [Hash]
+      #
+      # @return [Mimi::Messaging::Message]
+      #
+      def self.post(method_name, message)
+        metadata    = Mimi::Messaging::Message.new(
+          headers: {
+            'method_name' =>  method_name.to_s,
+            'c' => 'context-id'
+          }
+        )
+        d           = Mimi::Messaging::Message.new()
+        raw_message = Mimi::Messaging::Message.new(message)
+        request_processor = new(d, metadata, raw_message)
+        nil
+      end
+
+      # MockRequestProcessor helper BROADCAST method
+      #
+      # @param method_name [Symbol]
+      # @param message [Hash]
+      #
+      # @return [Mimi::Messaging::Message]
+      #
+      def self.broadcast(method_name, message)
+        post(method_name, message)
+      end
+    end # class RequestProcessor
+  end # module Messaging
+end # module Mimi