evrone-common-amqp 0.0.1

data/lib/evrone/common/amqp/consumer/ack.rb

@@ -0,0 +1,19 @@
+module Evrone
+  module Common
+    module AMQP
+      module Consumer::Ack
+
+        def ack!(multiple = false)
+          self.class.session.channel.ack delivery_info.delivery_tag, multiple
+          debug "commit ##{delivery_info.delivery_tag.to_i}"
+        end
+
+        def nack!(multiple = false, requeue = false)
+          self.class.session.channel.ack delivery_info.delivery_tag, multiple, requeue
+          debug "reject ##{delivery_info.delivery_tag.to_i}"
+        end
+
+      end
+    end
+  end
+end

data/lib/evrone/common/amqp/consumer/configuration.rb

@@ -0,0 +1,93 @@
+require 'ostruct'
+require 'thread'
+
+module Evrone
+  module Common
+    module AMQP
+      module Consumer::Configuration
+
+        @@consumer_configuration_lock = Mutex.new
+
+        def consumer_configuration
+          @consumer_configuration || reset_consumer_configuration!
+        end
+
+        def reset_consumer_configuration!
+          @@consumer_configuration_lock.synchronize do
+            @consumer_configuration =
+              OpenStruct.new(exchange:      OpenStruct.new(options: {}),
+                             queue:         OpenStruct.new(options: {}),
+                             consumer_name: make_consumer_name,
+                             ack:           false,
+                             content_type:  nil)
+          end
+        end
+
+        %w{ exchange queue }.each do |m|
+          define_method m do |*name|
+            options = name.last.is_a?(Hash) ? name.pop : {}
+            consumer_configuration.__send__(m).name    = name.first
+            consumer_configuration.__send__(m).options = options
+          end
+
+          define_method "#{m}_name" do
+            consumer_configuration.__send__(m).name || consumer_name
+          end
+
+          define_method "#{m}_options" do
+            consumer_configuration.__send__(m).options
+          end
+        end
+
+        def routing_key(name = nil)
+          consumer_configuration.routing_key = name if name
+          consumer_configuration.routing_key
+        end
+
+        def headers(values = nil)
+          consumer_configuration.headers = values unless values == nil
+          consumer_configuration.headers
+        end
+
+        def model(value = nil)
+          consumer_configuration.model = value unless value == nil
+          consumer_configuration.model
+        end
+
+        def content_type(value = nil)
+          consumer_configuration.content_type = value if value
+          consumer_configuration.content_type
+        end
+
+        def ack(value = nil)
+          consumer_configuration.ack = value unless value == nil
+          consumer_configuration.ack
+        end
+
+        def consumer_name
+          consumer_configuration.consumer_name
+        end
+
+        def bind_options
+          consumer_configuration.bind_options ||
+            @@consumer_configuration_lock.synchronize do
+              opts = {}
+              opts[:routing_key] = routing_key if routing_key
+              opts[:headers]     = headers     if headers
+              consumer_configuration.bind_options = opts
+            end
+        end
+
+        private
+
+          def make_consumer_name
+            to_s.scan(/[A-Z][a-z]*/).join("_")
+                .downcase
+                .gsub(/_/, '.')
+                .gsub(/\.consumer$/, '')
+          end
+
+      end
+    end
+  end
+end

data/lib/evrone/common/amqp/consumer/publish.rb

@@ -0,0 +1,32 @@
+module Evrone
+  module Common
+    module AMQP
+      module Consumer::Publish
+
+        def publish(message, options = nil)
+          session.open
+
+          options ||= {}
+          options[:routing_key]  = routing_key if routing_key && !options.key?(:routing_key)
+          options[:headers]      = headers     if headers && !options.key?(:headers)
+          options[:content_type] ||= content_type || config.content_type
+
+          x = declare_exchange
+
+          with_middleware :publishing, message: message, exchange: x do |opts|
+            m = serialize_message opts[:message], options[:content_type]
+            x.publish m, options
+          end
+
+          debug "published #{message.inspect} to #{x.name}"
+          self
+        end
+
+        def serialize_message(message, content_type)
+          Common::AMQP::Formatter.pack(content_type, message)
+        end
+
+      end
+    end
+  end
+end

data/lib/evrone/common/amqp/consumer/subscribe.rb

@@ -0,0 +1,67 @@
+module Evrone
+  module Common
+    module AMQP
+      module Consumer::Subscribe
+
+        def subscribe
+          session.open
+
+          session.with_channel do
+            x = declare_exchange
+            q = declare_queue
+
+            with_middleware(:subscribing, exchange: x, queue: q) do |_|
+              debug "subscribing to #{q.name}:#{x.name} using #{bind_options.inspect}"
+              q.bind(x, bind_options)
+              debug "successfuly subscribed to #{q.name}:#{x.name}"
+
+              subscription_loop q
+            end
+
+            debug "shutdown"
+          end
+        end
+
+        private
+
+          def subscription_loop(q)
+            loop do
+              break if shutdown?
+
+              delivery_info, properties, payload = q.pop(ack: ack)
+
+              if payload
+                result = nil
+
+                debug "recieve ##{delivery_info.delivery_tag.to_i} #{payload.inspect}"
+                result = run_instance delivery_info, properties, payload
+                debug "done ##{delivery_info.delivery_tag.to_i}"
+
+                break if result == :shutdown
+              else
+                sleep config.pool_timeout
+              end
+            end
+          end
+
+          def run_instance(delivery_info, properties, payload)
+            payload = deserialize_message properties, payload
+
+            with_middleware(:recieving, payload: payload) do |opts|
+              new.tap do |inst|
+                inst.properties    = properties
+                inst.delivery_info = delivery_info
+              end.perform opts[:payload]
+            end
+          end
+
+          def deserialize_message(properties, payload)
+            Common::AMQP::Formatter.unpack properties[:content_type],
+                                           model,
+                                           payload
+          end
+
+      end
+    end
+  end
+end

data/lib/evrone/common/amqp/formatter.rb

@@ -0,0 +1,109 @@
+require 'json'
+require 'stringio'
+
+module Evrone
+  module Common
+    module AMQP
+
+      class Formatter
+
+        @@formats = {}
+
+        class Format
+
+          attr_reader :content_type
+
+          def initialize(content_type)
+            @content_type = content_type
+          end
+
+          def pack(&block)
+            @pack = block if block_given?
+            @pack
+          end
+
+          def unpack(&block)
+            @unpack = block if block_given?
+            @unpack
+          end
+
+        end
+
+        class << self
+
+          def formats
+            @@formats
+          end
+
+          def define(content_type, &block)
+            fmt = Format.new content_type
+            fmt.instance_eval(&block)
+            formats.merge! content_type => fmt
+          end
+
+          def lookup(content_type)
+            formats[content_type]
+          end
+
+          def pack(content_type, body)
+            if fmt = lookup(content_type)
+              fmt.pack.call(body)
+            end
+          end
+
+          def unpack(content_type, model, body)
+            if fmt = lookup(content_type)
+              fmt.unpack.call(body, model)
+            end
+          end
+
+        end
+
+        define 'text/plain' do
+
+          pack do |body|
+            body.to_s
+          end
+
+          unpack do |body, _|
+            body
+          end
+        end
+
+        define 'application/json' do
+
+          pack do |body|
+            body.to_json
+          end
+
+          unpack do |payload, model|
+            if model && model.respond_to?(:from_json)
+              model.from_json payload
+            else
+              JSON.parse(payload)
+            end
+          end
+        end
+
+        define 'application/x-protobuf' do
+
+          pack do |body|
+            StringIO.open do |io|
+              body.serialize(io)
+              io.rewind
+              io.read
+            end
+          end
+
+          unpack do |payload, model|
+            raise ModelDoesNotExists unless model
+            m.parse payload
+          end
+
+          class ModelDoesNotExists < Exception ; end
+        end
+      end
+
+    end
+  end
+end

data/lib/evrone/common/amqp/mixins/logger.rb

@@ -0,0 +1,17 @@
+module Evrone
+  module Common
+    module AMQP
+      module Logger
+
+        %w{ debug info warn }.each do |m|
+          define_method m do |msg|
+            if log = Common::AMQP.logger
+              log.send(m, "[AMQP] #{msg}")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/evrone/common/amqp/mixins/with_middleware.rb

@@ -0,0 +1,16 @@
+module Evrone
+  module Common
+    module AMQP
+      module WithMiddleware
+        def with_middleware(name, env, &block)
+          builder = Common::AMQP.config.public_send("#{name}_builder")
+          if builder
+            builder.to_app(block).call env
+          else
+            yield env
+          end
+        end
+      end
+    end
+  end
+end

data/lib/evrone/common/amqp/session.rb

@@ -0,0 +1,154 @@
+require 'bunny'
+require 'thread'
+
+module Evrone
+  module Common
+    module AMQP
+      class Session
+
+        include Common::AMQP::Logger
+
+        CHANNEL_KEY = :evrone_amqp_channel
+
+        @@session_lock = Mutex.new
+
+        attr_reader :conn
+
+        class << self
+          def shutdown
+            @shutdown = true
+          end
+
+          def shutdown?
+            @shutdown == true
+          end
+
+          def resume
+            @shutdown = false
+          end
+        end
+
+        def close
+          if open?
+            @@session_lock.synchronize do
+              info "closing connection"
+              begin
+                conn.close
+              rescue Bunny::ChannelError => e
+                warn e
+              end
+              info "wait..."
+              while conn.status != :closed
+                sleep 0.01
+              end
+              @conn = nil
+              info "connection closed"
+            end
+          end
+        end
+
+        def open
+          return self if open?
+
+          @@session_lock.synchronize do
+            self.class.resume
+
+            @conn ||= Bunny.new config.url, heartbeat: :server
+
+            unless conn.open?
+              info "connecting to #{conn_info}"
+              conn.start
+              info "wait connection to #{conn_info}"
+              while conn.connecting?
+                sleep 0.01
+              end
+              info "connected successfuly (#{server_name})"
+            end
+          end
+
+          self
+        end
+
+        def open?
+          conn && conn.open? && conn.status == :open
+        end
+
+        def declare_exchange(name, options = nil)
+          assert_connection_is_open
+
+          options  ||= {}
+          name     ||= config.default_exchange_name
+          ch         = options.delete(:channel) || channel
+          type, opts = get_exchange_type_and_options options
+          ch.exchange name, opts.merge(type: type)
+        end
+
+        def declare_queue(name, options = nil)
+          assert_connection_is_open
+
+          options ||= {}
+          ch = options.delete(:channel) || channel
+          name, opts = get_queue_name_and_options(name, options)
+          ch.queue name, opts
+        end
+
+        def channel
+          assert_connection_is_open
+
+          Thread.current[CHANNEL_KEY] || conn.default_channel
+        end
+
+        def with_channel
+          assert_connection_is_open
+
+          old,new = nil
+          begin
+            old,new = Thread.current[CHANNEL_KEY], conn.create_channel
+            Thread.current[CHANNEL_KEY] = new
+            yield
+          ensure
+            Thread.current[CHANNEL_KEY] = old
+            new.close if new && new.open?
+          end
+        end
+
+        def conn_info
+          if conn
+            "#{conn.user}:#{conn.host}:#{conn.port}/#{conn.vhost}"
+          end
+        end
+
+        def server_name
+          if conn
+            p = conn.server_properties || {}
+            "#{p["product"]}/#{p["version"]}"
+          end
+        end
+
+        def config
+          Common::AMQP.config
+        end
+
+        private
+
+          def get_exchange_type_and_options(options)
+            options = config.default_exchange_options.merge(options || {})
+            type = options.delete(:type) || config.default_exchange_type
+            [type, options]
+          end
+
+          def get_queue_name_and_options(name, options)
+            name  ||= AMQ::Protocol::EMPTY_STRING
+            [name, config.default_queue_options.merge(options || {})]
+          end
+
+          def assert_connection_is_open
+            open? || raise(ConnectionDoesNotExist.new "you need to run #{to_s}#open")
+          end
+
+          class ConnectionDoesNotExist < ::Exception ; end
+
+      end
+    end
+  end
+end