mimi-messaging 0.1.10

data/lib/mimi/messaging/model.rb

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

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

data/lib/mimi/messaging/msgpack/msgpack_ext.rb

@@ -0,0 +1,14 @@
+#
+# MessagePack extensions for common types
+#
+Mimi::Messaging::TypePacker.register(
+  Time,
+  from_bytes: -> (b) { Time.at(b.unpack('D').first).utc },
+  to_bytes: -> (v) { [v.utc.to_f].pack('D') }
+)
+
+Mimi::Messaging::TypePacker.register(
+  BigDecimal,
+  from_bytes: -> (b) { BigDecimal.new(b) },
+  to_bytes: -> (v) { v.to_s }
+)

data/lib/mimi/messaging/msgpack/type_packer.rb

@@ -0,0 +1,104 @@
+require 'msgpack'
+
+module Mimi
+  module Messaging
+    class TypePacker
+      APPLICATION_TYPE_EXT = 0x00
+
+      # Registers a new type packer for msgpack.
+      #
+      # @example
+      #   TypePacker.register(
+      #     Time,
+      #     from_bytes: -> (b) { Time.at(b.unpack('D').first) },
+      #     to_bytes: -> (v) { [v.to_f].pack('D') }
+      #   )
+      #
+      def self.register(type, opts = {})
+        raise ArgumentError, 'Invalid :from_bytes, proc expected' unless opts[:from_bytes].is_a?(Proc)
+        raise ArgumentError, 'Invalid :to_bytes, proc expected' unless opts[:to_bytes].is_a?(Proc)
+        type_name = type.to_s
+        params = opts.dup.merge(type: type, type_name: type_name)
+        type_packers[type] = params
+        type.send(:define_method, :to_msgpack_ext) { Mimi::Messaging::TypePacker.pack(self) }
+        MessagePack::DefaultFactory.register_type(
+          APPLICATION_TYPE_EXT,
+          type,
+          packer: :to_msgpack_ext
+        )
+
+        MessagePack::DefaultFactory.register_type(
+          APPLICATION_TYPE_EXT,
+          self,
+          unpacker: :unpack
+        )
+      end
+
+      # Returns a set of registered type packers
+      #
+      def self.type_packers
+        @type_packers ||= {}
+      end
+
+      # Pack a value using a type packer, registered for the value class
+      #
+      def self.pack(value)
+        type_packer = type_packers.values.find { |p| value.is_a?(p[:type]) }
+        raise "No packer registered for type #{value.class}" unless type_packer
+        bytes = type_packer[:to_bytes].call(value)
+        "#{type_packer[:type_name]}=#{bytes}"
+      end
+
+      # Unpack a value, using a registered type packer
+      #
+      def self.unpack(value)
+        type_name, _, bytes = value.partition('=') # splits "Type=bytes" into ['Type', '=', 'bytes']
+        type_packer = type_packers.values.find { |p| p[:type_name] == type_name }
+        raise "No unpacker registered for type #{type_name}" unless type_packer
+        type_packer[:from_bytes].call(bytes)
+      end
+
+      # def self.register_type_packer!
+      #   return if @type_packer_registered
+      #   # pk = MessagePack::Packer.new
+      #   # pk.register_type(APPLICATION_TYPE_EXT) { |v| TypePacker.pack(v) }
+      #   uk = MessagePack::Unpacker.new
+      #   uk.register_type(APPLICATION_TYPE_EXT) { |b| TypePacker.unpack(b) }
+      #   @type_packer_registered = true
+      # end
+    end # class TypePacker
+  end # module Messaging
+
+end # module Mimi
+
+
+
+# class A
+#   class B
+#     attr_reader :value
+#     def initialize(value)
+#       @value = value
+#     end
+#   end # class B
+# end # class A
+
+# TypePacker.register(
+#   Time,
+#   from_bytes: -> (b) { Time.at(b.unpack('D').first) },
+#   to_bytes: -> (v) { [v.to_f].pack('D') }
+# )
+
+# TypePacker.register(
+#   A::B,
+#   from_bytes: -> (b) { A::B.new(b.unpack('D').first) },
+#   to_bytes: -> (v) { [v.value.to_f].pack('D') }
+# )
+
+# TypePacker.register(
+#   DateTime,
+#   from_bytes: -> (b) { Time.at(b.unpack('D').first).to_datetime },
+#   to_bytes: -> (v) { [v.to_time.to_f].pack('D') }
+# )
+
+# m = "\x83\xA1a\xC7\r\x00Time=\x1D@\x95\xC7\x80\xCA\xD5A\xA1b\x02\xA1c\xC7\x11\x00DateTime=X@\x95\xC7\x80\xCA\xD5A"
+

data/lib/mimi/messaging/notification.rb

@@ -0,0 +1,35 @@
+module Mimi
+  module Messaging
+    class Notification < Hashie::Mash
+      def self.notification(name, _opts = {})
+        @notification_name = name
+      end
+
+      def self.notification_name
+        @notification_name || default_notification_name
+      end
+
+      def self.default_notification_name
+        Mimi::Messaging::RequestProcessor.class_name_to_resource_name(self, 'notification')
+      end
+
+      def self.broadcast(name, data = {}, opts = {})
+        headers = {
+          method_name: name.to_s,
+          Mimi::Messaging::CONTEXT_ID_KEY => Mimi::Messaging.logger.context_id
+        }
+        Mimi::Messaging.broadcast(
+          notification_name, Message.encode(data), opts.merge(headers: headers)
+        )
+      end
+
+      def broadcast(name, opts = {})
+        self.class.broadcast(name, self, opts)
+      end
+
+      def to_s
+        to_hash.to_s
+      end
+    end # class Notification
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/provider.rb

@@ -0,0 +1,48 @@
+module Mimi
+  module Messaging
+    class Provider < RequestProcessor
+      abstract!
+      queue_options exclusive: false, auto_delete: true
+
+      def self.default_queue_name
+        class_name_to_resource_name(name, 'provider')
+      end
+
+      def initialize(d, m, p)
+        super
+        begin
+          catch(:halt) do
+            reply(@result) unless request.replied?
+          end
+        rescue StandardError => e
+          __execute_error_handlers(e)
+        end
+        if request.get? && !request.replied?
+          logger.error "No response sent to #{request.canonical_name}"
+        end
+      end
+
+      # Default error handler for RequestError and its descendants
+      #
+      error RequestError do |e|
+        logger.warn "#{request.canonical_name}: #{e} (#{e.params})"
+        reply error: e.message, params: e.params
+      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"))
+        reply error: e.message
+      end
+
+      private
+
+      def reply(data = {})
+        request.send_response(data)
+        halt
+      end
+    end # class Provider
+  end # module Messaging
+end # module Mimi

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,216 @@
+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_mutex = Mutex.new
+        @consumer_mutex.synchronize do
+          @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_mutex.synchronize do
+                @consumer.channel.ack(d.delivery_tag) if @consumer.channel && @consumer.channel.active
+              end
+            end
+          end
+        end
+        # consumer created, mutex released
+      end
+
+      def self.stop
+        return if abstract?
+        raise "#{name} already stopped" unless started?
+        @consumer_mutex.synchronize do
+          @consumer.cancel if @consumer
+        end
+        @consumer = nil
+        @queue = nil
+        @channel = nil
+        @connection = nil
+      end
+
+      def initialize(d, m, p)
+        initialize_logging_context!(m.headers)
+        @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
+
+      # Initializes logging context.
+      #
+      # Starts a new logging contenxt or inherits a context id from the message headers.
+      #
+      # @param headers [Hash,nil] message headers
+      #
+      def initialize_logging_context!(headers)
+        context_id = (headers || {})[Mimi::Messaging::CONTEXT_ID_KEY]
+        return logger.new_context! unless context_id
+        logger.context_id = context_id
+      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