mimi-messaging 0.1.12 → 1.0.0

data/lib/mimi/messaging/listener.rb

@@ -1,72 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,13 +0,0 @@
-#
-# 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

@@ -1,153 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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)
-        reply_to_queue_name = metadata[:reply_to]
-        raw_message = Mimi::Messaging::Message.encode(data)
-        @response = Mimi::Messaging::Message.new(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

@@ -1,92 +0,0 @@
-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

data/lib/mimi/messaging/model.rb

@@ -1,27 +0,0 @@
-module Mimi
-  module Messaging
-    class Model < Mimi::Messaging::Message
-      def self.default_queue_name
-        Mimi::Messaging::RequestProcessor.class_name_to_resource_name(self, 'model')
-      end
-
-      methods :create, :update, :show, :destroy, :list
-
-      def update(params = {})
-        self.replace(self.class.update(params.merge(id: id)))
-      end
-
-      def save
-        update(self)
-      end
-
-      def self.find(id)
-        show(id: id)
-      end
-
-      def self.all
-        list.list
-      end
-    end
-  end # module Messaging
-end # module Mimi