action_subscriber 1.0.3

data/lib/action_subscriber/bunny/subscriber.rb

@@ -0,0 +1,57 @@
+module ActionSubscriber
+  module Bunny
+    module Subscriber
+      def auto_pop!
+        # Because threadpools can be large we want to cap the number
+        # of times we will pop each time we poll the broker
+        times_to_pop = [::ActionSubscriber::Threadpool.ready_size, ::ActionSubscriber.config.times_to_pop].min
+        times_to_pop.times do
+          queues.each do |queue|
+            delivery_info, properties, encoded_payload = queue.pop(queue_subscription_options)
+            next unless encoded_payload # empty queue
+            ::ActiveSupport::Notifications.instrument "popped_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+            properties = {
+              :channel => queue.channel,
+              :content_type => properties[:content_type],
+              :delivery_tag => delivery_info.delivery_tag,
+              :exchange => delivery_info.exchange,
+              :message_id => nil,
+              :routing_key => delivery_info.routing_key,
+            }
+            env = ::ActionSubscriber::Middleware::Env.new(self, encoded_payload, properties)
+            enqueue_env(env)
+          end
+        end
+      end
+
+      def auto_subscribe!
+        queues.each do |queue|
+          queue.channel.prefetch(::ActionSubscriber.config.prefetch) if acknowledge_messages?
+          queue.subscribe(queue_subscription_options) do |delivery_info, properties, encoded_payload|
+            ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+            properties = {
+              :channel => queue.channel,
+              :content_type => properties.content_type,
+              :delivery_tag => delivery_info.delivery_tag,
+              :exchange => delivery_info.exchange,
+              :message_id => properties.message_id,
+              :routing_key => delivery_info.routing_key,
+            }
+            env = ::ActionSubscriber::Middleware::Env.new(self, encoded_payload, properties)
+            enqueue_env(env)
+          end
+        end
+      end
+
+      private
+
+      def enqueue_env(env)
+        ::ActionSubscriber::Threadpool.pool.async(env) do |env|
+          ::ActiveSupport::Notifications.instrument "process_event.action_subscriber", :subscriber => env.subscriber.to_s, :routing_key => env.routing_key do
+            ::ActionSubscriber.config.middleware.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_subscriber/configuration.rb

@@ -0,0 +1,68 @@
+module ActionSubscriber
+  class Configuration
+    attr_accessor :allow_low_priority_methods,
+                  :decoder,
+                  :default_exchange,
+                  :error_handler,
+                  :heartbeat,
+                  :timeout,
+                  :host,
+                  :hosts,
+                  :port,
+                  :prefetch,
+                  :times_to_pop,
+                  :threadpool_size
+
+    def initialize
+      self.allow_low_priority_methods = false
+      self.decoder = {
+        'application/json' => lambda { |payload| JSON.parse(payload) },
+        'text/plain' => lambda { |payload| payload.dup }
+      }
+      self.default_exchange = "events"
+      self.error_handler = lambda { |error, env_hash| raise }
+      self.heartbeat = 5
+      self.timeout = 1
+      self.host = 'localhost'
+      self.hosts = []
+      self.port = 5672
+      self.prefetch = 200
+      self.times_to_pop = 8
+      self.threadpool_size = 8
+    end
+
+    ##
+    # Instance Methods
+    #
+    def add_decoder(decoders)
+      decoders.each_pair do |content_type, decoder|
+        unless decoder.arity == 1
+          raise "ActionSubscriber decoders must have an arity of 1. The #{content_type} decoder was given with arity of #{decoder.arity}."
+        end
+      end
+
+      self.decoder.merge!(decoders)
+    end
+
+    def hosts
+      return @hosts if @hosts.size > 0
+      [ host ]
+    end
+
+    def middleware
+      @middleware ||= Middleware.initialize_stack
+    end
+
+    def inspect
+      inspection_string  = <<-INSPECT.strip_heredoc
+        Rabbit Host: #{host}
+        Rabbit Port: #{port}
+        Threadpool Size: #{threadpool_size}
+        Low Priority Subscriber: #{allow_low_priority_methods}
+        Decoders:
+      INSPECT
+      decoder.each_key { |key| inspection_string << "  --#{key}\n" }
+      return inspection_string
+    end
+  end
+end

data/lib/action_subscriber/default_routing.rb

@@ -0,0 +1,26 @@
+module ActionSubscriber
+  module DefaultRouting
+    def queues
+      @_queues ||= []
+    end
+
+    def setup_queue!(method_name, exchange_name)
+      queue_name = queue_name_for_method(method_name)
+      routing_key_name = routing_key_name_for_method(method_name)
+
+      channel = ::ActionSubscriber::RabbitConnection.connection.create_channel
+      exchange = channel.topic(exchange_name)
+      queue = channel.queue(queue_name)
+      queue.bind(exchange, :routing_key => routing_key_name)
+      return queue
+    end
+
+    def setup_queues!
+      exchange_names.each do |exchange_name|
+        subscribable_methods.each do |method_name|
+          queues << setup_queue!(method_name, exchange_name)
+        end
+      end
+    end
+  end
+end

data/lib/action_subscriber/dsl.rb

@@ -0,0 +1,83 @@
+module ActionSubscriber
+  module DSL
+    def at_least_once!
+      @_acknowledge_messages = true
+      @_acknowledge_messages_after_processing = true
+    end
+
+    def at_most_once!
+      @_acknowledge_messages = true
+      @_acknowledge_messages_before_processing = true
+    end
+
+    def acknowledge_messages?
+      !!@_acknowledge_messages
+    end
+
+    def acknowledge_messages_after_processing?
+      !!@_acknowledge_messages_after_processing
+    end
+
+    def acknowledge_messages_before_processing?
+      !!@_acknowledge_messages_before_processing
+    end
+
+    # Explicitly set the name of the exchange
+    #
+    def exchange_names(*names)
+      @_exchange_names ||= []
+      @_exchange_names += names.flatten.map(&:to_s)
+
+      if @_exchange_names.empty?
+        return [ ::ActionSubscriber.config.default_exchange ]
+      else
+        return @_exchange_names.compact.uniq
+      end
+    end
+    alias_method :exchange, :exchange_names
+
+    def manual_acknowledgement!
+      @_acknowledge_messages = true
+    end
+
+    def no_acknowledgement!
+      @_acknowledge_messages = false
+    end
+
+    # Explicitly set the name of a queue for the given method route
+    #
+    # Ex.
+    #   queue_for :created, "derp.derp"
+    #   queue_for :updated, "foo.bar"
+    #
+    def queue_for(method, queue_name)
+      @_queue_names ||= {}
+      @_queue_names[method] = queue_name
+    end
+
+    def queue_names
+      @_queue_names ||= {}
+    end
+
+    def queue_subscription_options
+      @_queue_subscription_options ||= { :manual_ack => acknowledge_messages? }
+    end
+
+    def remote_application_name(name = nil)
+      @_remote_application_name = name if name
+      @_remote_application_name
+    end
+    alias_method :publisher, :remote_application_name
+
+    # Explicitly set the whole routing key to use for a given method route.
+    #
+    def routing_key_for(method, routing_key_name)
+      @_routing_key_names ||= {}
+      @_routing_key_names[method] = routing_key_name
+    end
+
+    def routing_key_names
+      @_routing_key_names ||= {}
+    end
+  end
+end

data/lib/action_subscriber/march_hare/subscriber.rb

@@ -0,0 +1,60 @@
+module ActionSubscriber
+  module MarchHare
+    module Subscriber
+      def auto_pop!
+        # Because threadpools can be large we want to cap the number
+        # of times we will pop each time we poll the broker
+        times_to_pop = [::ActionSubscriber::Threadpool.ready_size, ::ActionSubscriber.config.times_to_pop].min
+        times_to_pop.times do
+          queues.each do |queue|
+            header, encoded_payload = queue.pop(queue_subscription_options)
+            next unless encoded_payload
+            ::ActiveSupport::Notifications.instrument "popped_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+            properties = {
+              :channel => queue.channel,
+              :content_type => header.content_type,
+              :delivery_tag => header.delivery_tag,
+              :exchange => header.exchange,
+              :message_id => header.message_id,
+              :routing_key => header.routing_key,
+            }
+            env = ::ActionSubscriber::Middleware::Env.new(self, encoded_payload, properties)
+            enqueue_env(env)
+          end
+        end
+
+      rescue ::MarchHare::ChannelAlreadyClosed => e
+        # The connection has gone down, we can just try again on the next pop
+      end
+
+      def auto_subscribe!
+        queues.each do |queue|
+          queue.channel.prefetch = ::ActionSubscriber.config.prefetch if acknowledge_messages?
+          queue.subscribe(queue_subscription_options) do |header, encoded_payload|
+            ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+            properties = {
+              :channel => queue.channel,
+              :content_type => header.content_type,
+              :delivery_tag => header.delivery_tag,
+              :exchange => header.exchange,
+              :message_id => header.message_id,
+              :routing_key => header.routing_key,
+            }
+            env = ::ActionSubscriber::Middleware::Env.new(self, encoded_payload, properties)
+            enqueue_env(env)
+          end
+        end
+      end
+
+      private
+
+      def enqueue_env(env)
+        ::ActionSubscriber::Threadpool.pool.async(env) do |env|
+          ::ActiveSupport::Notifications.instrument "process_event.action_subscriber", :subscriber => env.subscriber.to_s, :routing_key => env.routing_key do
+            ::ActionSubscriber.config.middleware.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_subscriber/middleware.rb

@@ -0,0 +1,18 @@
+require "action_subscriber/middleware/decoder"
+require "action_subscriber/middleware/env"
+require "action_subscriber/middleware/error_handler"
+require "action_subscriber/middleware/router"
+require "action_subscriber/middleware/runner"
+
+module ActionSubscriber
+  module Middleware
+    def self.initialize_stack
+      builder = ::Middleware::Builder.new(:runner_class => ::ActionSubscriber::Middleware::Runner)
+
+      builder.use ErrorHandler
+      builder.use Decoder
+
+      builder
+    end
+  end
+end

data/lib/action_subscriber/middleware/active_record/connection_management.rb

@@ -0,0 +1,17 @@
+module ActionSubscriber
+  module Middleware
+    module ActiveRecord
+      class ConnectionManagement
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        ensure
+          ::ActiveRecord::Base.clear_active_connections!
+        end
+      end
+    end
+  end
+end

data/lib/action_subscriber/middleware/active_record/query_cache.rb

@@ -0,0 +1,29 @@
+module ActionSubscriber
+  module Middleware
+    module ActiveRecord
+      class QueryCache
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          enabled = ::ActiveRecord::Base.connection.query_cache_enabled
+          connection_id = ::ActiveRecord::Base.connection_id
+          ::ActiveRecord::Base.connection.enable_query_cache!
+
+          @app.call(env)
+        ensure
+          restore_query_cache_settings(connection_id, enabled)
+        end
+
+      private
+
+        def restore_query_cache_settings(connection_id, enabled)
+          ::ActiveRecord::Base.connection_id = connection_id
+          ::ActiveRecord::Base.connection.clear_query_cache
+          ::ActiveRecord::Base.connection.disable_query_cache! unless enabled
+        end
+      end
+    end
+  end
+end

data/lib/action_subscriber/middleware/decoder.rb

@@ -0,0 +1,33 @@
+module ActionSubscriber
+  module Middleware
+    class Decoder
+      attr_reader :env
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+
+        env.payload = decoder? ? decoder.call(encoded_payload) : encoded_payload.dup
+
+        @app.call(env)
+      end
+
+      private
+
+      def decoder
+        ActionSubscriber.config.decoder[env.content_type]
+      end
+
+      def decoder?
+        decoder.present?
+      end
+
+      def encoded_payload
+        env.encoded_payload
+      end
+    end
+  end
+end

data/lib/action_subscriber/middleware/env.rb

@@ -0,0 +1,65 @@
+module ActionSubscriber
+  module Middleware
+    class Env
+      attr_accessor :payload
+
+      attr_reader :content_type,
+                  :encoded_payload,
+                  :exchange,
+                  :message_id,
+                  :routing_key,
+                  :subscriber
+
+      ##
+      # @param subscriber [Class] the class that will handle this message
+      # @param encoded_payload [String] the payload as it was received from RabbitMQ
+      # @param properties [Hash] that must contain the following keys (as symbols)
+      #         :channel => RabbitMQ channel for doing acknowledgement
+      #         :content_type => String
+      #         :delivery_tag => String (the message identifier to send back to rabbitmq for acknowledgement)
+      #         :exchange => String
+      #         :message_id => String
+      #         :routing_key => String
+      
+      def initialize(subscriber, encoded_payload, properties)
+        @channel = properties.fetch(:channel)
+        @content_type = properties.fetch(:content_type)
+        @delivery_tag = properties.fetch(:delivery_tag)
+        @encoded_payload = encoded_payload
+        @exchange = properties.fetch(:exchange)
+        @message_id = properties.fetch(:message_id)
+        @routing_key = properties.fetch(:routing_key)
+        @subscriber = subscriber
+      end
+
+      def acknowledge
+        acknowledge_multiple_messages = false
+        @channel.ack(@delivery_tag, acknowledge_multiple_messages)
+      end
+
+      # Return the last element of the routing key to indicate which action
+      # to route the payload to
+      #
+      def action
+        routing_key.split('.').last.to_s
+      end
+
+      def reject
+        requeue_message = true
+        @channel.reject(@delivery_tag, requeue_message)
+      end
+
+      def to_hash
+        {
+          :action => action,
+          :content_type => content_type,
+          :exchange => exchange,
+          :routing_key => routing_key,
+          :payload => payload
+        }
+      end
+      alias_method :to_h, :to_hash
+
+    end
+  end
+end