action_subscriber 2.5.0.pre-java → 3.0.0-java

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ require 'action_subscriber/rspec'
 # Silence the Logger
 $TESTING = true
 ::ActionSubscriber::Logging.initialize_logger(nil)
+::ActionSubscriber.setup_default_connection!
 
 RSpec.configure do |config|
   config.mock_with :rspec do |mocks|
@@ -23,14 +24,17 @@ RSpec.configure do |config|
 
   config.before(:each, :integration => true) do
     $messages = Set.new
-    draw_routes if respond_to?(:draw_routes)
-    ::ActionSubscriber::RabbitConnection.subscriber_connection
-    ::ActionSubscriber.setup_queues!
+    draw_routes
+    ::ActionSubscriber.setup_subscriptions!
   end
   config.after(:each, :integration => true) do
     ::ActionSubscriber.stop_subscribers!
-    ::ActionSubscriber::RabbitConnection.subscriber_disconnect!
     ::ActionSubscriber.instance_variable_set("@route_set", nil)
+    ::ActionSubscriber.instance_variable_set("@route_set_block", nil)
+  end
+  config.after(:suite) do
+    ::ActionSubscriber.stop_subscribers!
+    ::ActionSubscriber::RabbitConnection.subscriber_disconnect!
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_subscriber
 version: !ruby/object:Gem::Version
-  version: 2.5.0.pre
+  version: 3.0.0
 platform: java
 authors:
 - Brian Stien
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-09-09 00:00:00.000000000 Z
+date: 2016-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -84,6 +84,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  name: active_publisher
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -213,9 +227,6 @@ files:
 - lib/action_subscriber/middleware/router.rb
 - lib/action_subscriber/middleware/runner.rb
 - lib/action_subscriber/preload.rb
-- lib/action_subscriber/publisher.rb
-- lib/action_subscriber/publisher/async.rb
-- lib/action_subscriber/publisher/async/in_memory_adapter.rb
 - lib/action_subscriber/rabbit_connection.rb
 - lib/action_subscriber/railtie.rb
 - lib/action_subscriber/route.rb
@@ -235,8 +246,8 @@ files:
 - spec/integration/custom_actions_spec.rb
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
-- spec/integration/inferred_routes_spec.rb
 - spec/integration/manual_acknowledgement_spec.rb
+- spec/integration/multiple_connections_spec.rb
 - spec/integration/multiple_threadpools_spec.rb
 - spec/lib/action_subscriber/base_spec.rb
 - spec/lib/action_subscriber/configuration_spec.rb
@@ -248,9 +259,6 @@ files:
 - spec/lib/action_subscriber/middleware/error_handler_spec.rb
 - spec/lib/action_subscriber/middleware/router_spec.rb
 - spec/lib/action_subscriber/middleware/runner_spec.rb
-- spec/lib/action_subscriber/publisher/async/in_memory_adapter_spec.rb
-- spec/lib/action_subscriber/publisher/async_spec.rb
-- spec/lib/action_subscriber/publisher_spec.rb
 - spec/lib/action_subscriber/router_spec.rb
 - spec/lib/action_subscriber/subscribable_spec.rb
 - spec/lib/action_subscriber/threadpool_spec.rb
@@ -271,12 +279,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.4
+rubygems_version: 2.6.6
 signing_key:
 specification_version: 4
 summary: ActionSubscriber is a DSL that allows a rails app to consume messages from a RabbitMQ broker.
@@ -289,8 +297,8 @@ test_files:
 - spec/integration/custom_actions_spec.rb
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
-- spec/integration/inferred_routes_spec.rb
 - spec/integration/manual_acknowledgement_spec.rb
+- spec/integration/multiple_connections_spec.rb
 - spec/integration/multiple_threadpools_spec.rb
 - spec/lib/action_subscriber/base_spec.rb
 - spec/lib/action_subscriber/configuration_spec.rb
@@ -302,9 +310,6 @@ test_files:
 - spec/lib/action_subscriber/middleware/error_handler_spec.rb
 - spec/lib/action_subscriber/middleware/router_spec.rb
 - spec/lib/action_subscriber/middleware/runner_spec.rb
-- spec/lib/action_subscriber/publisher/async/in_memory_adapter_spec.rb
-- spec/lib/action_subscriber/publisher/async_spec.rb
-- spec/lib/action_subscriber/publisher_spec.rb
 - spec/lib/action_subscriber/router_spec.rb
 - spec/lib/action_subscriber/subscribable_spec.rb
 - spec/lib/action_subscriber/threadpool_spec.rb

data/lib/action_subscriber/publisher.rb

@@ -1,46 +0,0 @@
-module ActionSubscriber
-  module Publisher
-    # Publish a message to RabbitMQ
-    #
-    # @param [String] route The routing key to use for this message.
-    # @param [String] payload The message you are sending. Should already be encoded as a string.
-    # @param [String] exchange The exchange you want to publish to.
-    # @param [Hash] options hash to set message parameters (e.g. headers)
-    def self.publish(route, payload, exchange_name, options = {})
-      with_exchange(exchange_name) do |exchange|
-        exchange.publish(payload, publishing_options(route, options))
-      end
-    end
-
-    def self.with_exchange(exchange_name)
-      connection = RabbitConnection.publisher_connection
-      channel = connection.create_channel
-      begin
-        channel.confirm_select if ActionSubscriber.configuration.publisher_confirms
-        exchange = channel.topic(exchange_name)
-        yield(exchange)
-        channel.wait_for_confirms if ActionSubscriber.configuration.publisher_confirms
-      ensure
-        channel.close rescue nil
-      end
-    end
-
-    def self.publishing_options(route, in_options = {})
-      options = {
-        :mandatory => false,
-        :persistent => false,
-        :routing_key => route,
-      }.merge(in_options)
-
-      if ::RUBY_PLATFORM == "java"
-        java_options = {}
-        java_options[:mandatory]   = options.delete(:mandatory)
-        java_options[:routing_key] = options.delete(:routing_key)
-        java_options[:properties]  = options
-        java_options
-      else
-        options
-      end
-    end
-  end
-end

data/lib/action_subscriber/publisher/async.rb

@@ -1,31 +0,0 @@
-module ActionSubscriber
-  module Publisher
-    # Publish a message asynchronously to RabbitMQ.
-    #
-    # Asynchronous is designed to do two things:
-    # 1. Introduce the idea of a durable retry should the RabbitMQ connection disconnect.
-    # 2. Provide a higher-level pattern for fire-and-forget publishing.
-    #
-    # @param [String] route The routing key to use for this message.
-    # @param [String] payload The message you are sending. Should already be encoded as a string.
-    # @param [String] exchange The exchange you want to publish to.
-    # @param [Hash] options hash to set message parameters (e.g. headers).
-    def self.publish_async(route, payload, exchange_name, options = {})
-      Async.publisher_adapter.publish(route, payload, exchange_name, options)
-    end
-
-    module Async
-      def self.publisher_adapter
-        @publisher_adapter ||= case ::ActionSubscriber.configuration.async_publisher
-                               when /memory/i then
-                                 require "action_subscriber/publisher/async/in_memory_adapter"
-                                 InMemoryAdapter.new
-                               when /redis/i then
-                                 fail "Not yet implemented"
-                               else
-                                 fail "Unknown adapter '#{::ActionSubscriber.configuration.async_publisher}' provided"
-                               end
-      end
-    end
-  end
-end

data/lib/action_subscriber/publisher/async/in_memory_adapter.rb

@@ -1,153 +0,0 @@
-require "thread"
-
-module ActionSubscriber
-  module Publisher
-    module Async
-      class InMemoryAdapter
-        include ::ActionSubscriber::Logging
-
-        attr_reader :async_queue
-
-        def initialize
-          logger.info "Starting in-memory publisher adapter."
-
-          @async_queue = AsyncQueue.new
-        end
-
-        def publish(route, payload, exchange_name, options = {})
-          message = Message.new(route, payload, exchange_name, options)
-          async_queue.push(message)
-          nil
-        end
-
-        def shutdown!
-          max_wait_time = ::ActionSubscriber.configuration.seconds_to_wait_for_graceful_shutdown
-          started_shutting_down_at = ::Time.now
-
-          logger.info "Draining async publisher in-memory adapter queue before shutdown. Current queue size: #{async_queue.size}."
-          while async_queue.size > 0
-            if (::Time.now - started_shutting_down_at) > max_wait_time
-              logger.info "Forcing async publisher adapter shutdown because graceful shutdown period of #{max_wait_time} seconds was exceeded. Current queue size: #{async_queue.size}."
-              break
-            end
-
-            sleep 0.1
-          end
-        end
-
-        class Message
-          attr_reader :route, :payload, :exchange_name, :options
-
-          def initialize(route, payload, exchange_name, options)
-            @route = route
-            @payload = payload
-            @exchange_name = exchange_name
-            @options = options
-          end
-        end
-
-        class UnableToPersistMessageError < ::StandardError
-        end
-
-        class AsyncQueue
-          include ::ActionSubscriber::Logging
-
-          attr_reader :consumer, :queue, :supervisor
-
-          if ::RUBY_PLATFORM == "java"
-            NETWORK_ERRORS = [::MarchHare::Exception, ::Java::ComRabbitmqClient::AlreadyClosedException, ::Java::JavaIo::IOException].freeze
-          else
-            NETWORK_ERRORS = [::Bunny::Exception, ::Timeout::Error, ::IOError].freeze
-          end
-
-          def initialize
-            @queue = ::Queue.new
-            create_and_supervise_consumer!
-          end
-
-          def push(message)
-            # Default of 1_000_000 messages.
-            if queue.size > ::ActionSubscriber.configuration.async_publisher_max_queue_size
-              # Drop Messages if the queue is full and we were configured to do so.
-              return if ::ActionSubscriber.configuration.async_publisher_drop_messages_when_queue_full
-
-              # By default we will raise an error to push the responsibility onto the caller.
-              fail UnableToPersistMessageError, "Queue is full, messages will be dropped."
-            end
-
-            queue.push(message)
-          end
-
-          def size
-            queue.size
-          end
-
-        private
-
-          def await_network_reconnect
-            sleep ::ActionSubscriber::RabbitConnection::NETWORK_RECOVERY_INTERVAL
-          end
-
-          def create_and_supervise_consumer!
-            @consumer = create_consumer
-            @supervisor = ::Thread.new do
-              loop do
-                unless consumer.alive?
-                  # Why might need to requeue the last message.
-                  queue.push(@current_message) if @current_message.present?
-                  consumer.kill
-                  @consumer = create_consumer
-                end
-
-                # Pause before checking the consumer again.
-                sleep supervisor_interval
-              end
-            end
-          end
-
-          def create_consumer
-            ::Thread.new do
-              loop do
-                # Write "current_message" so we can requeue should something happen to the consumer. I don't love this, but it's
-                # better than writing my own `#peek' method.
-                @current_message = message = queue.pop
-
-                begin
-                  ::ActionSubscriber::Publisher.publish(message.route, message.payload, message.exchange_name, message.options)
-
-                  # Reset
-                  @current_message = nil
-                rescue *NETWORK_ERRORS
-                  # Sleep because the connection is down.
-                  await_network_reconnect
-
-                  # Requeue and try again.
-                  queue.push(message)
-                rescue => unknown_error
-                  # Do not requeue the message because something else horrible happened.
-                  @current_message = nil
-
-                  # Log the error.
-                  logger.info unknown_error.class
-                  logger.info unknown_error.message
-                  logger.info unknown_error.backtrace.join("\n")
-
-                  # TODO: Find a way to bubble this out of the thread for logging purposes.
-                  # Reraise the error out of the publisher loop. The Supervisor will restart the consumer.
-                  raise unknown_error
-                end
-              end
-            end
-          end
-
-          def supervisor_interval
-            @supervisor_interval ||= begin
-              interval_in_milliseconds = ::ActionSubscriber.configuration.async_publisher_supervisor_interval
-              interval_in_milliseconds / 1000.0
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/inferred_routes_spec.rb

@@ -1,53 +0,0 @@
-class InferenceSubscriber < ActionSubscriber::Base
-  publisher :kyle
-
-  def yo
-    $messages << payload
-  end
-
-  queue_for :hey, "some_other_queue.hey"
-  routing_key_for :hey, "other_routing_key.hey"
-  def hey
-    $messages << payload
-  end
-end
-
-describe "A Subscriber With Inferred Routes", :integration => true do
-  context "explicit routing with default_routes_for helper" do
-    let(:draw_routes) do
-      ::ActionSubscriber.draw_routes do
-        default_routes_for InferenceSubscriber
-      end
-    end
-
-    it "registers the routes and sets up the queues" do
-      ::ActionSubscriber.auto_subscribe!
-      ::ActionSubscriber::Publisher.publish("kyle.inference.yo", "YO", "events")
-      ::ActionSubscriber::Publisher.publish("other_routing_key.hey", "HEY", "events")
-
-      verify_expectation_within(2.0) do
-        expect($messages).to eq(Set.new(["YO","HEY"]))
-      end
-    end
-  end
-
-  # This is the deprecated behavior we want to keep until version 2.0
-  context "no explicit routes" do
-    before do
-      # TEST HACK: Bust any memoized routes.
-      ::ActionSubscriber.instance_variable_set(:@route_set, nil)
-      ::ActionSubscriber.instance_variable_set(:@draw_routes_block, nil)
-      ::ActionSubscriber.setup_queues!
-    end
-
-    it "registers the routes and sets up the queues" do
-      ::ActionSubscriber.auto_subscribe!
-      ::ActionSubscriber::Publisher.publish("kyle.inference.yo", "YO", "events")
-      ::ActionSubscriber::Publisher.publish("other_routing_key.hey", "HEY", "events")
-
-      verify_expectation_within(2.0) do
-        expect($messages).to eq(Set.new(["YO","HEY"]))
-      end
-    end
-  end
-end

data/spec/lib/action_subscriber/publisher/async/in_memory_adapter_spec.rb

@@ -1,135 +0,0 @@
-describe ::ActionSubscriber::Publisher::Async::InMemoryAdapter do
-  let(:route) { "test" }
-  let(:payload) { "message" }
-  let(:exchange_name) { "place" }
-  let(:options) { { :test => :ok } }
-  let(:message) { described_class::Message.new(route, payload, exchange_name, options) }
-  let(:mock_queue) { double(:push => nil, :size => 0) }
-
-  describe "#publish" do
-    before do
-      allow(described_class::Message).to receive(:new).with(route, payload, exchange_name, options).and_return(message)
-      allow(described_class::AsyncQueue).to receive(:new).and_return(mock_queue)
-    end
-
-    it "can publish a message to the queue" do
-      expect(mock_queue).to receive(:push).with(message)
-      subject.publish(route, payload, exchange_name, options)
-    end
-  end
-
-  describe "#shutdown!" do
-    # This is called when the rspec finishes. I'm sure we can make this a better test.
-  end
-
-  describe "::ActionSubscriber::Publisher::Async::InMemoryAdapter::Message" do
-    specify { expect(message.route).to eq(route) }
-    specify { expect(message.payload).to eq(payload) }
-    specify { expect(message.exchange_name).to eq(exchange_name) }
-    specify { expect(message.options).to eq(options) }
-  end
-
-  describe "::ActionSubscriber::Publisher::Async::InMemoryAdapter::AsyncQueue" do
-    subject { described_class::AsyncQueue.new }
-
-    describe ".initialize" do
-      it "creates a supervisor" do
-        expect_any_instance_of(described_class::AsyncQueue).to receive(:create_and_supervise_consumer!)
-        subject
-      end
-    end
-
-    describe "#create_and_supervise_consumer!" do
-      it "creates a supervisor" do
-        expect_any_instance_of(described_class::AsyncQueue).to receive(:create_consumer)
-        subject
-      end
-
-      it "restarts the consumer when it dies" do
-        consumer = subject.consumer
-        consumer.kill
-
-        verify_expectation_within(0.1) do
-          expect(consumer).to_not be_alive
-        end
-
-        verify_expectation_within(0.3) do
-          expect(subject.consumer).to be_alive
-        end
-      end
-    end
-
-    describe "#create_consumer" do
-      it "can successfully publish a message" do
-        expect(::ActionSubscriber::Publisher).to receive(:publish).with(route, payload, exchange_name, options)
-        subject.push(message)
-        sleep 0.1 # Await results
-      end
-
-      context "when network error occurs" do
-        let(:error) { described_class::AsyncQueue::NETWORK_ERRORS.first }
-        before { allow(::ActionSubscriber::Publisher).to receive(:publish).and_raise(error) }
-
-        it "requeues the message" do
-          consumer = subject.consumer
-          expect(consumer).to be_alive
-          expect(subject).to receive(:await_network_reconnect).at_least(:once)
-          subject.push(message)
-          sleep 0.1 # Await results
-        end
-      end
-
-      context "when an unknown error occurs" do
-        before { allow(::ActionSubscriber::Publisher).to receive(:publish).and_raise(ArgumentError) }
-
-        it "kills the consumer" do
-          consumer = subject.consumer
-          expect(consumer).to be_alive
-          subject.push(message)
-          sleep 0.1 # Await results
-          expect(consumer).to_not be_alive
-        end
-      end
-    end
-
-    describe "#push" do
-      after { ::ActionSubscriber.configuration.async_publisher_max_queue_size = 1000 }
-      after { ::ActionSubscriber.configuration.async_publisher_drop_messages_when_queue_full = false }
-
-      context "when the queue has room" do
-        before { allow(::Queue).to receive(:new).and_return(mock_queue) }
-
-        it "successfully adds to the queue" do
-          expect(mock_queue).to receive(:push).with(message)
-          subject.push(message)
-        end
-      end
-
-      context "when the queue is full" do
-        before { ::ActionSubscriber.configuration.async_publisher_max_queue_size = -1 }
-
-        context "and we're dropping messages" do
-          before { ::ActionSubscriber.configuration.async_publisher_drop_messages_when_queue_full = true }
-
-          it "adding to the queue should not raise an error" do
-            expect { subject.push(message) }.to_not raise_error
-          end
-        end
-
-        context "and we're not dropping messages" do
-          before { ::ActionSubscriber.configuration.async_publisher_drop_messages_when_queue_full = false }
-
-          it "adding to the queue should raise error back to caller" do
-            expect { subject.push(message) }.to raise_error(described_class::UnableToPersistMessageError)
-          end
-        end
-      end
-    end
-
-    describe "#size" do
-      it "can return the size of the queue" do
-        expect(subject.size).to eq(0)
-      end
-    end
-  end
-end