mimi-messaging 0.1.9 → 1.1.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/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,18 +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)
-        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

@@ -1,92 +0,0 @@
-module Mimi
-  module Messaging
-    class RequestProcessor
-      attr_reader :result
-
-      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.result
-      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

data/lib/mimi/messaging/model_provider.rb

@@ -1,100 +0,0 @@
-module Mimi
-  module Messaging
-    class ModelProvider < Mimi::Messaging::Provider
-      abstract!
-
-      def self.model(model_class, options = {})
-        raise "#{self} already serves model #{@model_class}" if @model_class
-        @model_class = model_class
-        @model_options = options
-        @model_methods_only = options[:only] ? [*(options[:only])] : nil
-        @model_methods_except = options[:except] ? [*(options[:except])] : nil
-      end
-
-      def self.exposed_methods
-        model_methods = Mimi::Messaging::ModelProvider.public_instance_methods(false).dup
-        methods_hidden = []
-        methods_hidden = model_methods - model_methods.only(*@model_methods_only) if @model_methods_only
-        methods_hidden = model_methods.only(*@model_methods_except) if @model_methods_except
-        m = super
-        m - methods_hidden
-      end
-
-      def self.model_class
-        @model_class || raise("#{self} has no defined model")
-      end
-
-      def self.serialize(method_name = nil, &block)
-        if method_name && block_given?
-          raise "Only one of method_name or block is accepted by #{self}.serialize"
-        end
-        @serialize = method_name.to_sym if method_name
-        @serialize = block if block_given?
-        @serialize || parent_property(:serialize) || :as_json
-      end
-
-      def self.scope(&block)
-        @scope = block if block_given?
-        @scope || -> (r) { r }
-      end
-
-      def self.permitted_params(*names)
-        @permitted_params = names.map(&:to_sym) if names.size > 0
-        @permitted_params || model_class.attribute_names.map(&:to_sym)
-      end
-
-      def create
-        serialize model_class_scoped.create!(permitted_params)
-      end
-
-      def update(id:)
-        model = model_class_scoped.find(id)
-        model.update!(permitted_params)
-        serialize model
-      end
-
-      def show(id:)
-        serialize model_class_scoped.find(id)
-      end
-
-      def find
-        serialize model_class_scoped.find_by!(params)
-      end
-
-      def destroy(id:)
-        model_class_scoped.find(id)
-        raise "#{self.class}#destroy is not implemented"
-      end
-
-      def list
-        reply list: model_class_scoped.all.map { |v| serialize v }
-      end
-
-      private
-
-      def permitted_params
-        params.except('id').only(*self.class.permitted_params.map(&:to_s)).to_hash
-      end
-
-      def model_class
-        self.class.model_class
-      end
-
-      def model_class_scoped
-        scope_block = self.class.scope
-        __execute(model_class, &scope_block)
-      end
-
-      def serialize(model_instance, opts = nil)
-        opts ||= params
-        if self.class.serialize.is_a?(Symbol)
-          model_instance.send(self.class.serialize, opts)
-        elsif self.class.serialize.is_a?(Proc)
-          self.class.serialize.call(model_instance, opts)
-        else
-          raise "#{self.class}#serialize is neither a Symbol or Proc"
-        end
-      end
-    end # class ModelProvider
-  end # module Messaging
-end # module Mimi