mimi-messaging 0.1.1

data/lib/mimi/messaging/request.rb

@@ -0,0 +1,56 @@
+module Mimi
+  module Messaging
+    class Request
+      attr_reader :request_processor, :delivery_info, :metadata, :raw_message, :params
+
+      def initialize(request_processor, d, m, p)
+        @request_processor = request_processor
+        @delivery_info = d
+        @metadata = m
+        @raw_message = p
+        @params = Params.new(Mimi::Messaging::Message.decode(@raw_message))
+      end
+
+      def method_name
+        metadata.headers && metadata.headers['method_name']
+      end
+
+      def type
+        request_processor.request_type(@delivery_info, @metadata, @raw_message)
+      end
+
+      def canonical_name
+        "#{type.to_s.upcase} #{request_processor.resource_name}\##{method_name}"
+      end
+
+      def params_symbolized
+        Hashie.symbolize_keys(params.to_hash)
+      end
+
+      def get?
+        type == :get
+      end
+
+      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)
+        request_processor.connection.post(
+          reply_to_queue_name, raw_message, correlation_id: metadata[:correlation_id]
+        )
+        @replied = true
+      end
+
+      def replied?
+        @replied
+      end
+
+      class Params < Hashie::Mash
+        def to_s
+          to_hash.to_s
+        end
+      end # class Params
+    end # class Request
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/request_processor.rb

@@ -0,0 +1,195 @@
+require_relative 'request_processor/dsl'
+require_relative 'request_processor/context'
+
+module Mimi
+  module Messaging
+    class RequestProcessor
+      extend DSL
+      include Context
+
+      abstract!
+      queue_options exclusive: false, auto_delete: true
+
+      RequestError = Mimi::Messaging::RequestError
+
+      def self.inherited(request_processor_class)
+        request_processor_class.parent = self
+        Mimi::Messaging.register_request_processor_class(request_processor_class)
+      end
+
+      def self.resource_name
+        queue_name
+      end
+
+      def self.request_type(_d, metadata, _p)
+        metadata.reply_to ? :get : :post
+      end
+
+      def self.started?
+        !@consumer.nil?
+      end
+
+      def self.connection
+        @connection ||= Mimi::Messaging.connection_for(resource_name)
+      end
+
+      def self.channel
+        @channel ||= connection.create_channel(options)
+      end
+
+      def self.construct_queue
+        channel.create_queue(queue_name, queue_options)
+      end
+
+      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 = @queue.subscribe(manual_ack: true) do |d, m, p|
+          begin
+            new(d, m, p)
+          rescue StandardError => e
+            logger.error e.to_s
+            logger.debug e.backtrace.join("\n")
+          ensure
+            @consumer.channel.ack(d.delivery_tag) if @consumer.channel && @consumer.channel.active
+          end
+        end
+      end
+
+      def self.stop
+        return if abstract?
+        raise "#{name} already stopped" unless started?
+        @consumer.cancel if @consumer
+        @consumer = nil
+        @queue = nil
+        @channel = nil
+        @connection = nil
+      end
+
+      def initialize(d, m, p)
+        @request = Mimi::Messaging::Request.new(self.class, d, m, p)
+        @result = nil
+        method_name = request.method_name
+        begin
+          catch(:halt) do
+            @result = __execute_method(method_name)
+          end
+        rescue StandardError => e
+          __execute_error_handlers(e)
+        end
+      end
+
+      # Request logger
+      #
+      # Usage:
+      #   options log_requests: true
+      # Or:
+      #   options log_requests: { log_level: :info }
+      #
+      before do
+        opts = self.class.options[:log_requests]
+        next unless opts
+        message = "#{request.canonical_name}: #{params}"
+        level = opts.is_a?(Hash) ? (opts[:log_level] || 'debug') : 'debug'
+        logger.send level.to_sym, message
+      end
+
+      # Request benchmark logger
+      #
+      # Usage:
+      #   options log_benchmarks: true
+      # Or:
+      #   options log_benchmarks: { log_level: :info }
+      #
+      around do |b|
+        opts = self.class.options[:log_benchmarks]
+        t_start = Time.now
+        b.call
+        next unless opts
+        message = "#{request.canonical_name}: completed in %.1fms" % [(Time.now - t_start) * 1000.0]
+        level = opts.is_a?(Hash) ? (opts[:log_level] || 'debug') : 'debug'
+        logger.send level.to_sym, message
+      end
+
+      # Default error handler for StandardError and its descendants
+      #
+      error StandardError do |e|
+        logger.error "#{request.canonical_name}: #{e} (#{e.class})"
+        logger.debug((e.backtrace || ['<no backtrace>']).join("\n"))
+        halt
+      end
+
+      private
+
+      attr_reader :request
+
+      def __execute_method(method_name)
+        unless method_name && method_name.is_a?(String)
+          raise 'RequestProcessor method name is not specified in the request'
+        end
+        method_name = method_name.to_sym
+        unless self.class.exposed_methods.include?(method_name)
+          raise "RequestProcessor method (\##{method_name}) is not exposed"
+        end
+
+        method = self.class.instance_method(method_name.to_sym)
+        accepted_params = request.params_symbolized.only(*method.parameters.map(&:last))
+        result = nil
+        method_block = proc do
+          args = [method_name]
+          args << accepted_params unless accepted_params.empty?
+          catch(:halt) do
+            result = send(*args)
+          end
+        end
+        self.class.filters(:before).each { |f| __execute(&f[:block]) }
+        wrapped_block = self.class.filters(:around).reduce(method_block) do |a, e|
+          __bind(a, &e[:block])
+        end
+        wrapped_block.call
+        self.class.filters(:after, false).each { |f| __execute(&f[:block]) }
+        result
+      end
+
+      def __execute_error_handlers(error)
+        catch(:halt) do
+          result = self.class.filters(:error, false).reduce(error) do |a, e|
+            if e[:args].any? { |error_klass| a.is_a?(error_klass) }
+              __execute(a, &e[:block])
+            else
+              a
+            end
+          end
+          logger.error "Error '#{error}' (#{error.class}) unprocessed by error handlers " \
+            "(result=#{result.class})"
+        end
+      rescue StandardError => e
+        logger.error "Error raised by error handler '#{request.canonical_name}': #{e}"
+        logger.debug e.backtrace.join("\n")
+      end
+
+      def reply(_data = {})
+        logger.warn "#{self.class}#reply not implemented"
+        halt
+      end
+
+      def halt
+        throw :halt
+      end
+
+      def params
+        request.params
+      end
+
+      def logger
+        Mimi::Messaging.logger
+      end
+
+      def self.logger
+        Mimi::Messaging.logger
+      end
+    end # class RequestProcessor
+  end # module Messaging
+end # module Mimi

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

@@ -0,0 +1,39 @@
+module Mimi
+  module Messaging
+    class RequestProcessor
+      module Context
+        attr_reader :self_before_instance_eval
+
+        private
+
+        #
+        # Binds passed block and block parameters to the context
+        #
+        # @return [Proc] bound block
+        #
+        def __bind(*args, &block)
+          proc { __execute(*args, &block) }
+        end
+
+        # Executes block within context
+        #
+        def __execute(*args, &block)
+          @self_before_instance_eval ||= []
+          block_self = eval 'self', block.binding
+          @self_before_instance_eval.push(block_self)
+          instance_exec(*args, &block)
+        ensure
+          @self_before_instance_eval.pop
+        end
+
+        def method_missing(method, *args, &block)
+          if @self_before_instance_eval
+            @self_before_instance_eval.last.send method, *args, &block
+          else
+            super
+          end
+        end
+      end # module Context
+    end # class RequestProcessor
+  end # module Messaging
+end # module Mimi

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

@@ -0,0 +1,121 @@
+module Mimi
+  module Messaging
+    class RequestProcessor
+      module DSL
+        attr_accessor :parent
+
+        # Returns the property of the parent class
+        #
+        def parent_property(*args)
+          return nil unless @parent
+          return nil unless @parent.respond_to?(args.first)
+          @parent.send(*args)
+        end
+
+        # Sets queue name and options
+        #
+        def queue(name, options = {})
+          queue_name name
+          queue_options options
+          true
+        end
+
+        # Sets or gets queue name
+        #
+        def queue_name(name = nil)
+          raise "#{self} has already registered '#{@queue_name}' as queue name" if name && @queue_name
+          (@queue_name ||= name) || default_queue_name
+        end
+
+        # Default (inferred) queue name
+        #
+        def default_queue_name
+          nil
+        end
+
+        # Sets or gets queue options
+        #
+        def queue_options(opts = {})
+          @queue_options ||= {}
+          @queue_options = @queue_options.merge(opts.dup)
+          (parent_property(:queue_options) || {}).merge(@queue_options)
+        end
+
+        # Sets provider options
+        #
+        def options(opts = {})
+          @options ||= {}
+          @options = @options.merge(opts.dup)
+          (parent_property(:options) || {}).merge(@options)
+        end
+
+        def exposed_methods
+          m = public_instance_methods(false)
+          m += parent.exposed_methods if parent
+          m
+        end
+
+        # Explicitly registers this request processor as abstract
+        #
+        def abstract!
+          @abstract = true
+        end
+
+        # Is this provider abstract or configured to process requests?
+        #
+        def abstract?
+          @abstract
+        end
+
+        #
+        #
+        def before(*args, &block)
+          register_filter(:before, args, block)
+        end
+
+        #
+        #
+        def around(*args, &block)
+          register_filter(:around, args, block)
+        end
+
+        #
+        #
+        def after(*args, &block)
+          register_filter(:after, args, block)
+        end
+
+        #
+        #
+        def error(*args, &block)
+          register_filter(:error, args, block)
+        end
+
+        def register_filter(type, args, block)
+          @filters ||= { before: [], around: [], after: [], error: [] }
+          @filters[type] << { args: args, block: block }
+        end
+
+        def filters(type, parent_first = true)
+          @filters ||= { before: [], around: [], after: [], error: [] }
+          if parent_first
+            (parent_property(:filters, type) || []) + @filters[type]
+          else
+            @filters[type] + (parent_property(:filters, type, false) || [])
+          end
+        end
+
+        # Converts class name to a resource name (camelize with dots).
+        #
+        # @example
+        #   "ModuleA::ClassB" #=> "module_a.class_b"
+        #
+        def class_name_to_resource_name(v, suffix = nil)
+          v = v.to_s.gsub('::', '.').gsub(/([^\.])([A-Z])/, '\1_\2').downcase
+          v = v.sub(/_?#{suffix}\z/, '') if suffix
+          v
+        end
+      end # module DSL
+    end # class RequestProcessor
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/version.rb

@@ -0,0 +1,5 @@
+module Mimi
+  module Messaging
+    VERSION = '0.1.1'.freeze
+  end
+end

data/mimi-messaging.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mimi/messaging/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mimi-messaging'
+  spec.version       = Mimi::Messaging::VERSION
+  spec.authors       = ['Alex Kukushkin']
+  spec.email         = ['alex@kukushk.in']
+
+  spec.summary       = 'Communications via RabbitMQ for mimi'
+  spec.description   = 'Communications via RabbitMQ for mimi'
+  spec.homepage      = 'https://github.com/kukushkin/mimi-messaging'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'mimi-core', '~> 0.1'
+  spec.add_dependency 'bunny', '~> 2.3'
+  spec.add_dependency 'msgpack', '~> 0.7'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry', '~> 0.10'
+end