action_subscriber 1.0.3-java

data/lib/action_subscriber/middleware/error_handler.rb

@@ -0,0 +1,16 @@
+module ActionSubscriber
+  module Middleware
+    class ErrorHandler
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue => error
+        env.reject if env.subscriber.acknowledge_messages_after_processing?
+        ::ActionSubscriber.configuration.error_handler.call(error, env.to_h)
+      end
+    end
+  end
+end

data/lib/action_subscriber/middleware/router.rb

@@ -0,0 +1,17 @@
+module ActionSubscriber
+  module Middleware
+    class Router
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        subscriber = env.subscriber.new(env)
+
+        env.acknowledge if env.subscriber.acknowledge_messages_before_processing?
+        subscriber.public_send(env.action)
+        env.acknowledge if env.subscriber.acknowledge_messages_after_processing?
+      end
+    end
+  end
+end

data/lib/action_subscriber/middleware/runner.rb

@@ -0,0 +1,16 @@
+require 'middleware/runner'
+
+module ActionSubscriber
+  module Middleware
+    class Runner < ::Middleware::Runner
+      # Override the default middleware runner so we can ensure that the
+      # router is the last thing called in the stack.
+      #
+      def initialize(stack)
+        stack << ::ActionSubscriber::Middleware::Router
+
+        super(stack)
+      end
+    end
+  end
+end

data/lib/action_subscriber/rabbit_connection.rb

@@ -0,0 +1,40 @@
+require 'thread'
+
+module ActionSubscriber
+  module RabbitConnection
+    CONNECTION_MUTEX = ::Mutex.new
+
+    def self.connect!
+      CONNECTION_MUTEX.synchronize do
+        return @connection if @connection
+        if ::RUBY_PLATFORM == "java"
+          @connection = ::MarchHare.connect(connection_options)
+        else
+          @connection = ::Bunny.new(connection_options)
+          @connection.start
+        end
+        @connection
+      end
+    end
+
+    def self.connected?
+      connection && connection.connected?
+    end
+
+    def self.connection
+      connect!
+    end
+
+    def self.connection_options
+      {
+        :heartbeat                     => ::ActionSubscriber.configuration.heartbeat,
+        :hosts                         => ::ActionSubscriber.configuration.hosts,
+        :port                          => ::ActionSubscriber.configuration.port,
+        :continuation_timeout          => ::ActionSubscriber.configuration.timeout * 1_000.0, #convert sec to ms
+        :automatically_recover         => true,
+        :network_recovery_interval     => 1,
+        :recover_from_connection_close => true,
+      }
+    end
+  end
+end

data/lib/action_subscriber/railtie.rb

@@ -0,0 +1,13 @@
+module ActionSubscriber
+  class Railtie < ::Rails::Railtie
+    config.action_subscriber = ::ActionSubscriber.config
+
+    ::ActiveSupport.on_load(:active_record) do
+      require "action_subscriber/middleware/active_record/connection_management"
+      require "action_subscriber/middleware/active_record/query_cache"
+
+      ::ActionSubscriber.config.middleware.use ::ActionSubscriber::Middleware::ActiveRecord::ConnectionManagement
+      ::ActionSubscriber.config.middleware.use ::ActionSubscriber::Middleware::ActiveRecord::QueryCache
+    end
+  end
+end

data/lib/action_subscriber/rspec.rb

@@ -0,0 +1,91 @@
+require 'rspec'
+
+module ActionSubscriber
+  module RSpec
+    class FakeChannel # A class that quacks like a RabbitMQ Channel
+      def ack(delivery_tag, acknowledge_multiple)
+        true
+      end
+
+      def reject(delivery_tag, requeue_message)
+        true
+      end
+    end
+
+    PROPERTIES_DEFAULTS = {
+      :channel => FakeChannel.new,
+      :content_type => "text/plain",
+      :delivery_tag => "XYZ",
+      :exchange => "events",
+      :message_id => "MSG-123",
+      :routing_key => "amigo.user.created",
+    }.freeze
+
+    # Create a new subscriber instance. Available options are:
+    #
+    #  * :acknowledger - the object that should receive ack/reject calls for this message (only useful for testing manual acknowledgment)
+    #  * :content_type - defaults to text/plain
+    #  * :encoded_payload - the encoded payload object to pass into the instance.
+    #  * :exchange - defaults to "events"
+    #  * :message_id - defaults to "MSG-123"
+    #  * :payload - the payload object to pass to the instance.
+    #  * :routing_key - defaults to amigo.user.created
+    #  * :subscriber - the class constant corresponding to the subscriber. `described_class` is the default.
+    #
+    # Example
+    #
+    #   describe UserSubscriber do
+    #     subject { mock_subscriber(:payload => proto) }
+    #
+    #     it 'logs the user create event' do
+    #       SomeLogger.should_receive(:log)
+    #       subject.created
+    #     end
+    #   end
+    #
+    def mock_subscriber(opts = {})
+      encoded_payload = opts.fetch(:encoded_payload) { double('encoded payload').as_null_object }
+      subscriber_class = opts.fetch(:subscriber) { described_class }
+      properties = PROPERTIES_DEFAULTS.merge(opts.slice(:channel,
+                                                        :content_type,
+                                                        :delivery_tag,
+                                                        :exchange,
+                                                        :message_id,
+                                                        :routing_key))
+
+
+      env = ActionSubscriber::Middleware::Env.new(subscriber_class, encoded_payload, properties)
+      env.payload = opts.fetch(:payload) { double('payload').as_null_object }
+
+      return subscriber_class.new(env)
+    end
+  end
+end
+
+::RSpec.configure do |config|
+  config.include ActionSubscriber::RSpec
+
+  shared_context 'action subscriber middleware env' do
+    let(:app) { Proc.new { |inner_env| inner_env } }
+    let(:env) { ActionSubscriber::Middleware::Env.new(UserSubscriber, 'encoded payload', message_properties) }
+    let(:message_properties) {{
+      :channel => ::ActionSubscriber::RSpec::FakeChannel.new,
+      :content_type => "text/plain",
+      :delivery_tag => "XYZ",
+      :exchange => "events",
+      :message_id => "MSG-123",
+      :routing_key => "amigo.user.created",
+    }}
+  end
+
+  shared_examples_for 'an action subscriber middleware' do
+    include_context 'action subscriber middleware env'
+
+    subject { described_class.new(app) }
+
+    it "calls the stack" do
+      expect(app).to receive(:call).with(env)
+      subject.call(env)
+    end
+  end
+end

data/lib/action_subscriber/subscribable.rb

@@ -0,0 +1,118 @@
+module ActionSubscriber
+  module Subscribable
+    def allow_low_priority_methods?
+      !!(::ActionSubscriber.configuration.allow_low_priority_methods)
+    end
+
+    def filter_low_priority_methods(methods)
+      if allow_low_priority_methods?
+        return methods
+      else
+        return methods - methods.grep(/_low/)
+      end
+    end
+
+    def generate_queue_name(method_name)
+      [
+        local_application_name,
+        remote_application_name,
+        resource_name,
+        method_name
+      ].compact.join('.')
+    end
+
+    def generate_routing_key_name(method_name)
+      [
+        remote_application_name,
+        resource_name,
+        method_name
+      ].compact.join('.')
+    end
+
+    def local_application_name(reload = false)
+      if reload || @_local_application_name.nil?
+        @_local_application_name = case
+                              when ENV['APP_NAME'] then
+                                ENV['APP_NAME'].to_s.dup
+                              when defined?(::Rails) then
+                                ::Rails.application.class.parent_name.dup
+                              else
+                                raise "Define an application name (ENV['APP_NAME'])"
+                              end
+
+        @_local_application_name.downcase!
+      end
+
+      @_local_application_name
+    end
+
+    def inspect
+      inspection_string = "#{self.name}\n"
+      exchange_names.each do |exchange_name|
+        inspection_string << "  -- exchange: #{exchange_name}\n"
+        subscribable_methods.each do |method|
+          inspection_string << "    -- method: #{method}\n"
+          inspection_string << "      -- queue:       #{queue_names[method]}\n"
+          inspection_string << "      -- routing_key: #{routing_key_names[method]}\n"
+          inspection_string << "\n"
+        end
+      end
+      return inspection_string
+    end
+
+    # Build the `queue` for a given method.
+    #
+    # If the queue name is not set, the queue name is
+    #   "local.remote.resoure.action"
+    #
+    # Example
+    #   "bob.alice.user.created"
+    #
+    def queue_name_for_method(method_name)
+      return queue_names[method_name] if queue_names[method_name]
+
+      queue_name = generate_queue_name(method_name)
+      queue_for(method_name, queue_name)
+      return queue_name
+    end
+
+    # The name of the resource respresented by this subscriber.
+    # If the class name were `UserSubscriber` the resource_name would be `user`.
+    #
+    def resource_name
+      @_resource_name ||= self.name.underscore.gsub(/_subscriber/, '').to_s
+    end
+
+    # Build the `routing_key` for a given method.
+    #
+    # If the routing_key name is not set, the routing_key name is
+    #   "remote.resoure.action"
+    #
+    # Example
+    #   "amigo.user.created"
+    #
+    def routing_key_name_for_method(method_name)
+      return routing_key_names[method_name] if routing_key_names[method_name]
+
+      routing_key_name = generate_routing_key_name(method_name)
+      routing_key_for(method_name, routing_key_name)
+      return routing_key_name
+    end
+
+    def subscribable_methods
+      return @_subscribable_methods if @_subscribable_methods
+
+      methods = instance_methods
+      methods -= ::Object.instance_methods
+
+      self.included_modules.each do |mod|
+        methods -= mod.instance_methods
+      end
+
+      @_subscribable_methods = filter_low_priority_methods(methods)
+      @_subscribable_methods.sort!
+
+      return @_subscribable_methods
+    end
+  end
+end

data/lib/action_subscriber/threadpool.rb

@@ -0,0 +1,29 @@
+module ActionSubscriber
+  class Threadpool
+    ##
+    # Class Methods
+    #
+    def self.busy?
+      (pool.pool_size == pool.busy_size)
+    end
+
+    def self.perform_async(*args)
+      self.pool.async.perform(*args)
+    end
+
+    def self.pool
+      @pool ||= ::Lifeguard::InfiniteThreadpool.new(
+        :pool_size => ::ActionSubscriber.config.threadpool_size
+      )
+    end
+
+    def self.ready?
+      !busy?
+    end
+
+    def self.ready_size
+      ready_size = pool.pool_size - pool.busy_size
+      return ready_size >= 0 ? ready_size : 0
+    end
+  end
+end

data/lib/action_subscriber/version.rb

@@ -0,0 +1,3 @@
+module ActionSubscriber
+  VERSION = "1.0.3"
+end

data/spec/integration/basic_subscriber_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+class BasicPushSubscriber < ActionSubscriber::Base
+  BOOKED_MESSAGES = []
+  CANCELLED_MESSAGES = []
+
+  publisher :greg
+
+  # queue => alice.greg.basic_push.booked
+  # routing_key => greg.basic_push.booked
+  def booked
+    BOOKED_MESSAGES << payload
+  end
+
+  queue_for :cancelled, "basic.cancelled"
+  routing_key_for :cancelled, "basic.cancelled"
+
+  def cancelled
+    CANCELLED_MESSAGES << payload
+  end
+end
+
+describe "A Basic Subscriber using Push API", :integration => true do
+  let(:connection) { subscriber.connection }
+  let(:subscriber) { BasicPushSubscriber }
+
+  it "messages are routed to the right place" do
+    ::ActionSubscriber.start_queues
+
+    channel = connection.create_channel
+    exchange = channel.topic("events")
+    exchange.publish("Ohai Booked", :routing_key => "greg.basic_push.booked")
+    exchange.publish("Ohai Cancelled", :routing_key => "basic.cancelled")
+
+    ::ActionSubscriber.auto_pop!
+
+    expect(subscriber::BOOKED_MESSAGES).to eq(["Ohai Booked"])
+    expect(subscriber::CANCELLED_MESSAGES).to eq(["Ohai Cancelled"])
+
+    connection.close
+  end
+end

data/spec/lib/action_subscriber/base_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+class TestObject < ActionSubscriber::Base
+  exchange :events
+
+  def created
+  end
+end
+
+describe ActionSubscriber::Base do
+  describe "inherited" do
+    context "when a class has inherited from action subscriber base" do
+      it "adds the class to the intherited classes collection" do
+        expect(described_class.inherited_classes).to include(TestObject)
+      end
+    end
+  end
+end

data/spec/lib/action_subscriber/configuration_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ::ActionSubscriber::Configuration do
+  describe "default values" do
+    specify { expect(subject.allow_low_priority_methods).to eq(false) }
+    specify { expect(subject.default_exchange).to eq("events") }
+    specify { expect(subject.host).to eq("localhost") }
+    specify { expect(subject.port).to eq(5672) }
+    specify { expect(subject.threadpool_size).to eq(8) }
+  end
+
+  describe "add_decoder" do
+    it "add the decoder to the registry" do
+      subject.add_decoder({"application/protobuf" => lambda { |payload| "foo"} })
+      expect(subject.decoder).to include("application/protobuf")
+    end
+
+    it 'raises an error when decoder does not have arity of 1' do
+      expect {
+        subject.add_decoder("foo" => lambda { |*args|  })
+      }.to raise_error(/The foo decoder was given with arity of -1/)
+
+      expect {
+        subject.add_decoder("foo" => lambda {  })
+      }.to raise_error(/The foo decoder was given with arity of 0/)
+
+      expect {
+        subject.add_decoder("foo" => lambda { |a,b| })
+      }.to raise_error(/The foo decoder was given with arity of 2/)
+    end
+  end
+end