mimi-messaging 0.1.12 → 1.2.2

data/lib/mimi/messaging/connection.rb

@@ -1,182 +0,0 @@
-require 'bunny'
-
-module Mimi
-  module Messaging
-    class Connection
-      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],
-          logger: Mimi::Messaging.logger
-        }
-        @connection = Bunny.new(bunny_params)
-      end
-
-      # Starts the connection, opening actual connection to RabbitMQ
-      #
-      def start
-        @connection.start
-      end
-
-      # Stops the connection
-      #
-      def stop
-        @connection.close
-        @channel_pool = {}
-      end
-
-      def started?
-        @connection.status == :open
-      end
-
-      def channel
-        raise ConnectionError unless started?
-        @channel_pool[Thread.current.object_id] ||= create_channel
-      end
-
-      def create_channel(opts = {})
-        Channel.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 Channel
-        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 = @connection.create_channel(nil, options[:concurrency])
-          @mutex = Mutex.new
-        end
-
-        def create_queue(name, opts = {})
-          @channel.queue(name, opts)
-        end
-
-        def reply_queue
-          @reply_queue ||= create_queue('', exclusive: true)
-        end
-
-        def ack(tag)
-          @channel.ack(tag)
-        end
-
-        def fanout(name)
-          @channel.fanout(name)
-        end
-
-        def active?
-          @channel && @channel.active
-        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 = {})
-          x = @channel.default_exchange
-          params = { routing_key: queue_name }.merge(params.dup)
-          publish(x, raw_message, params)
-        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 = {})
-          correlation_id = Time.now.utc.to_f.to_s
-          params = params.dup.merge(
-            reply_to: reply_queue.name,
-            correlation_id: correlation_id
-          )
-          post(queue_name, raw_message, params)
-          response = nil
-          begin
-            Timeout.timeout(params[:timeout] || DEFAULT_GET_TIMEOUT) do
-              loop do
-                d, m, p = reply_queue.pop
-                next if d && m.correlation_id != correlation_id
-                response = [d, m, p] if d
-                break if response
-                sleep 0.001 # s
-              end
-            end
-          rescue Timeout::Error
-            # respond with nil
-          end
-          response
-        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 = {})
-          x = @channel.fanout(fanout_name)
-          publish(x, raw_message, params)
-        end
-
-        private
-
-        def publish(exchange, raw_message, params = {})
-          # HACK: Connection-level mutex reduces throughoutput, hopefully improves stability (ku)
-          @mutex.synchronize do
-            # TODO: may be make publishing an atomic operation using a separate thread? (ku)
-            exchange.publish(raw_message, params)
-          end
-        rescue StandardError => e
-          # Raising fatal error:
-          unless Thread.main == Thread.current
-            Thread.main.raise ConnectionError, "failed to publish message in a child thread: #{e}"
-          end
-          raise ConnectionError, "failed to publish message: #{e}"
-        end
-      end # class Channel
-    end # class Connection
-  end # module Messaging
-end # module Mimi

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/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