mimi-messaging 0.1.1

data/lib/mimi/messaging/errors.rb

@@ -0,0 +1,19 @@
+module Mimi
+  module Messaging
+    class ConnectionError < StandardError
+    end # class ConnectionError
+
+    class RequestError < StandardError
+      attr_accessor :params
+
+      def initialize(message = 'failed to process request', params = {})
+        @message = message
+        @params = params.dup
+      end
+
+      def to_s
+        @message
+      end
+    end # class RequestError
+  end # module Messaging
+end # module Mimi

data/lib/mimi/messaging/listener.rb

@@ -0,0 +1,72 @@
+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/message.rb

@@ -0,0 +1,66 @@
+require 'json'
+require 'msgpack'
+
+module Mimi
+  module Messaging
+    class Message < Hashie::Mash
+      def self.queue(name, _opts = {})
+        @queue_name = name
+      end
+
+      def self.queue_name
+        @queue_name || default_queue_name
+      end
+
+      def self.default_queue_name
+        Mimi::Messaging::RequestProcessor.class_name_to_resource_name(self, 'message')
+      end
+
+      def self.get(name, data = {}, opts = {})
+        d, m, response = Mimi::Messaging.get(
+          queue_name, encode(data), opts.deep_merge(headers: { method_name: name.to_s })
+        )
+        raise Timeout::Error unless response
+        message = new(decode(response))
+        raise RequestError.new(message.error, Message.new(message.params)) if message.error?
+        message
+      end
+
+      def self.post(name, data = {}, opts = {})
+        Mimi::Messaging.post(
+          queue_name, encode(data), opts.deep_merge(headers: { method_name: name.to_s })
+        )
+      end
+
+      def self.add_method(name, &block)
+        self.class.instance_eval do
+          define_method(name, &block)
+        end
+      end
+
+      def self.methods(*names)
+        names.each do |method_name|
+          add_method(method_name) do |*params|
+            get(method_name, *params)
+          end
+          add_method("#{method_name}!") do |*params|
+            post(method_name, *params)
+            nil
+          end
+        end
+      end
+
+      def self.encode(data)
+        MessagePack.pack(data) # data.to_json
+      end
+
+      def self.decode(raw_message)
+        MessagePack.unpack(raw_message) # JSON.parse(raw_message)
+      end
+
+      def to_s
+        to_hash.to_s
+      end
+    end # class Message
+  end # module Messaging
+end # module Mimi

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,96 @@
+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 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/notification.rb

@@ -0,0 +1,31 @@
+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 = {})
+        Mimi::Messaging.broadcast(
+          notification_name, Message.encode(data), opts.merge(headers: { method_name: name.to_s })
+        )
+      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/packer.rb

@@ -0,0 +1,92 @@
+require 'msgpack'
+
+class TypePacker
+  APPLICATION_TYPE_EXT = 0x00
+
+  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) { TypePacker.pack(self) }
+    MessagePack::DefaultFactory.register_type(
+      APPLICATION_TYPE_EXT,
+      type,
+      packer: :to_msgpack_ext,
+      # unpacker: :from_msgpack_ext
+    )
+
+    MessagePack::DefaultFactory.register_type(
+      APPLICATION_TYPE_EXT,
+      self,
+      unpacker: :unpack,
+      # unpacker: :from_msgpack_ext
+    )
+
+    # pk = MessagePack::Packer.new
+    # pk.register_type(APPLICATION_TYPE_EXT, type, :to_msgpack_ext) # { |v| TypePacker.pack(v) }
+
+    # register_type_packer!
+  end
+
+  def self.type_packers
+    @type_packers ||= {}
+  end
+
+  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
+
+  def self.unpack(value)
+    vp = value.partition('=') # splits "Type=bytes" into ['Type', '=', 'bytes']
+    type_name = vp.first
+    bytes = vp.last
+    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
+
+
+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/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