vx-lib-consumer 0.2.1

data/lib/vx/lib/consumer/session.rb

@@ -0,0 +1,168 @@
+require 'bunny'
+require 'thread'
+
+module Vx
+  module Lib
+    module Consumer
+      class Session
+
+        include Instrument
+
+        @@session_lock  = Mutex.new
+
+        @@shutdown_lock = Mutex.new
+        @@shutdown      = ConditionVariable.new
+        @@live          = false
+
+        attr_reader :conn
+
+        def shutdown
+          @@shutdown_lock.synchronize do
+            @@live = false
+            @@shutdown.broadcast
+          end
+        end
+
+        def live?
+          @@live
+        end
+
+        def resume
+          @@live = true
+        end
+
+        def wait_shutdown(timeout = nil)
+          @@shutdown_lock.synchronize do
+            @@shutdown.wait(@@shutdown_lock, timeout)
+            not live?
+          end
+        end
+
+        def close
+          if open?
+            @@session_lock.synchronize do
+              instrument("closing_connection", info: conn_info)
+
+              instrument("close_connection", info: conn_info) do
+                begin
+                  conn.close
+                  while conn.status != :closed
+                    sleep 0.01
+                  end
+                rescue Bunny::ChannelError, Bunny::ClientTimeout => e
+                  Consumer.exception_handler(e, {})
+                end
+              end
+              @conn = nil
+            end
+          end
+        end
+
+        def open(options = {})
+          return self if open?
+
+          @@session_lock.synchronize do
+            unless open?
+              resume
+
+              @conn ||= Bunny.new(
+                nil,       # from ENV['RABBITMQ_URL']
+                heartbeat: Consumer.configuration.heartbeat,
+                automatically_recover: false
+              )
+
+              instrumentation = { info: conn_info }.merge(options)
+
+              instrument("start_connecting", instrumentation)
+
+              instrument("connect", instrumentation) do
+                conn.start
+                while conn.connecting?
+                  sleep 0.01
+                end
+              end
+            end
+          end
+
+          self
+        end
+
+        def open?
+          conn && conn.open? && conn.status == :open
+        end
+
+        def conn_info
+          if conn
+            "amqp://#{conn.user}@#{conn.host}:#{conn.port}/#{conn.vhost}"
+          else
+            "not connected"
+          end
+        end
+
+        def with_pub_channel
+          key = :vx_consumer_session_pub_channel
+          if ch = Thread.current[key]
+            yield ch
+          else
+            conn.with_channel do |c|
+              yield c
+            end
+          end
+        end
+
+        def allocate_pub_channel
+          assert_connection_is_open
+
+          key = :vx_consumer_session_pub_channel
+
+          if Thread.current[key]
+            yield
+          else
+            ch = conn.create_channel
+            assign_error_handlers_to_channel(ch)
+            Thread.current[key] = ch
+            begin
+              yield
+            ensure
+              ch = Thread.current[key]
+              ch.close if ch.open?
+              Thread.current[key] = nil
+            end
+          end
+        end
+
+        def declare_exchange(ch, name, options = nil)
+          assert_connection_is_open
+
+          options ||= {}
+          options = {} if name == ''.freeze
+
+          ch.exchange name, options
+        end
+
+        def declare_queue(ch, name, options = nil)
+          assert_connection_is_open
+
+          options ||= {}
+          ch.queue name, options
+        end
+
+        def assign_error_handlers_to_channel(ch)
+          ch.on_uncaught_exception {|e, c| ::Vx::Lib::Consumer.exception_handler(e, consumer: c) }
+          ch.on_error {|e, c| ::Vx::Lib::Consumer.exception_handler(e, consumer: c) }
+        end
+
+        private
+
+          def assert_connection_is_open
+            open? || raise(ConnectionDoesNotExistError)
+          end
+
+          def config
+            Consumer.configuration
+          end
+
+      end
+    end
+  end
+end

data/lib/vx/lib/consumer/subscribe.rb

@@ -0,0 +1,105 @@
+module Vx
+  module Lib
+    module Consumer
+      module Subscribe
+
+        def subscribe(options = {})
+          ch, q = bind(options)
+
+          subscriber = Subscriber.new(
+            ch,
+            q,
+            ch.generate_consumer_tag,
+            !params.ack
+          )
+          subscriber.vx_consumer_name = params.consumer_name
+          subscriber.queue_name       = q.name
+
+          subscriber.on_delivery do |delivery_info, properties, payload|
+            handle_delivery ch, delivery_info, properties, payload
+          end
+
+          q.subscribe_with(subscriber)
+        end
+
+        def handle_delivery(channel, delivery_info, properties, payload)
+          payload = decode_payload properties, payload
+
+          instrumentation = {
+            consumer:   params.consumer_name,
+            payload:    payload,
+            properties: properties,
+            channel:    channel.id
+          }
+
+          with_middlewares :sub, instrumentation do
+            instrument("start_processing", instrumentation)
+            instrument("process", instrumentation) do
+              allocate_pub_channel do
+                run_instance delivery_info, properties, payload, channel
+              end
+            end
+          end
+        end
+
+        def run_instance(delivery_info, properties, payload, channel)
+          new.tap do |inst|
+            inst.properties    = properties
+            inst.delivery_info = delivery_info
+            inst._channel      = channel
+          end.perform payload
+        end
+
+        private
+
+          def decode_payload(properties, payload)
+            Serializer.unpack(properties[:content_type], payload, params.model)
+          end
+
+          def bind(options = {})
+            qname = options[:queue] || params.queue_name
+
+            instrumentation = {
+              consumer: params.consumer_name
+            }
+
+            session.open
+
+            ch = session.conn.create_channel
+            session.assign_error_handlers_to_channel(ch)
+            ch.prefetch configuration.prefetch
+
+            x_name = ''
+
+            if params.exchange_name != ''
+              x = session.declare_exchange ch, params.exchange_name, params.exchange_options
+              x_name = x.name
+            end
+
+            q = session.declare_queue ch, qname, params.queue_options
+
+            instrumentation.merge!(
+              exchange:      x_name,
+              queue:         q.name,
+              queue_options: params.queue_options,
+            )
+
+            if x_name != ''
+              instrumentation.merge!(
+                exchange_options: params.exchange_options,
+                bind: params.bind_options
+              )
+              instrument("bind_queue", instrumentation) do
+                q.bind(x, params.bind_options)
+              end
+            else
+              instrument("using_default_exchange", instrumentation)
+            end
+
+            [ch, q]
+          end
+
+      end
+    end
+  end
+end

data/lib/vx/lib/consumer/subscriber.rb

@@ -0,0 +1,84 @@
+require 'thread'
+require 'bunny/consumer'
+
+module Vx
+  module Lib
+    module Consumer
+      class Subscriber < Bunny::Consumer
+
+        include Instrument
+
+        attr_accessor :vx_consumer_name, :queue_name
+
+        def initialize(*args)
+          super(*args)
+          @lock = Mutex.new
+        end
+
+        def graceful_shutdown
+          instrument('try_graceful_shutdown_consumer', consumer: vx_consumer_name)
+          in_progress do
+            cancel
+            instrument('graceful_shutdown_consumer', consumer: vx_consumer_name)
+          end
+        end
+
+        def try_graceful_shutdown
+          if @lock.try_lock
+            begin
+              instrument('graceful_shutdown_consumer', consumer: vx_consumer_name)
+              cancel
+            ensure
+              @lock.unlock
+            end
+            true
+          else
+            false
+          end
+        end
+
+        def in_progress
+          @lock.synchronize do
+            yield
+          end
+        end
+
+        def running?
+          @lock.locked?
+        end
+
+        def call(*args)
+          in_progress do
+            @on_delivery.call(*args) if @on_delivery
+            sleep 0
+          end
+        end
+
+        def cancel
+          instrument('cancel_consumer', consumer: vx_consumer_name, channel: channel.id)
+          unless closed?
+            super
+            channel.close unless closed?
+          end
+        end
+
+        def closed?
+          channel.closed?
+        end
+
+        def join
+          channel.work_pool.join
+        end
+
+        def wait_shutdown
+          Thread.new do
+            Thread.current.abort_on_exception = true
+            Consumer.wait_shutdown
+            cancel
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vx/lib/consumer/testing.rb

@@ -0,0 +1,49 @@
+require File.expand_path("../../consumer", __FILE__)
+
+module Vx
+  module Lib
+    module Consumer
+
+      module Testing
+
+        extend self
+
+        @@messages = Hash.new { |h,k| h[k] = [] }
+        @@messages_and_options = Hash.new { |h,k| h[k] = [] }
+
+        def messages
+          @@messages
+        end
+
+        def messages_and_options
+          @@messages_and_options
+        end
+
+        def clear
+          messages.clear
+          messages_and_options.clear
+        end
+      end
+
+      module Consumer::Publish
+
+        def publish(message, options = nil)
+          options ||= {}
+          Testing.messages[params.exchange_name] << message
+          Testing.messages_and_options[params.exchange_name] << [message, options]
+          self
+        end
+
+        def messages
+          Testing.messages[params.exchange_name]
+        end
+
+        def messages_and_options
+          Testing.messages_and_options[params.exchange_name]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/vx/lib/consumer/version.rb

@@ -0,0 +1,7 @@
+module Vx
+  module Lib
+    module Consumer
+      VERSION = "0.2.1"
+    end
+  end
+end

data/lib/vx/lib/consumer.rb

@@ -0,0 +1,138 @@
+%w{
+  version
+  error
+  configuration
+  instrument
+  session
+  params
+  serializer
+  subscriber
+  publish
+  subscribe
+  ack
+  rpc
+}.each do |f|
+  require File.expand_path("../consumer/#{f}", __FILE__)
+end
+
+module Vx
+  module Lib
+    module Consumer
+
+      attr_accessor :properties
+      attr_accessor :delivery_info
+      attr_accessor :_channel
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.extend Instrument
+        base.extend Publish
+        base.extend Subscribe
+        base.extend Rpc
+        base.send :include, Ack
+        base.send :include, Instrument
+      end
+
+      module ClassMethods
+        def params
+          @params ||= Params.new(self.name)
+        end
+
+        def exchange(*args)
+          params.exchange_options = args.last.is_a?(Hash) ? args.pop : nil
+          params.exchange_name    = args.first
+        end
+
+        def fanout
+          params.exchange_type = :fanout
+        end
+
+        def topic
+          params.exchange_type = :topic
+        end
+
+        def direct
+          params.exchange_type = :direct
+        end
+
+        def queue(*args)
+          params.queue_options = args.last.is_a?(Hash) ? args.pop : nil
+          params.queue_name    = args.first
+        end
+
+        def routing_key(name)
+          params.routing_key = name
+        end
+
+        def headers(value)
+          params.headers = value
+        end
+
+        def content_type(value)
+          params.content_type = value
+        end
+
+        def ack
+          params.ack = true
+        end
+
+        def model(value)
+          params.model = value
+        end
+
+        def session
+          Consumer.session
+        end
+
+        def allocate_pub_channel
+          Consumer.session.allocate_pub_channel { yield }
+        end
+
+        def configuration
+          Consumer.configuration
+        end
+
+        def with_middlewares(name, env, &block)
+          Consumer.configuration.builders[name].to_app(block).call(env)
+        end
+      end
+
+      extend self
+
+      @@session       = Session.new
+      @@configuration = Configuration.new
+
+      def shutdown
+        session.shutdown
+      end
+
+      def live?
+        session.live?
+      end
+
+      def wait_shutdown(timeout = nil)
+        session.wait_shutdown(timeout)
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def configuration
+        @@configuration
+      end
+
+      def session
+        @@session
+      end
+
+      def exception_handler(e, env)
+        unless env.is_a?(Hash)
+          env = {env: env}
+        end
+        configuration.on_error.call(e, env)
+      end
+
+    end
+  end
+end