mimi-messaging 0.1.12 → 1.0.0

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

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

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

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

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

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

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

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