action_subscriber 5.1.4.pre0 → 5.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be413ce9308a022df33f96d787b50b059bd6700911e1a090f98f454777d14a1f
-  data.tar.gz: c09a951d4f0343dc9cb2e23484333656fae3111b5e558668436d3fbdf63d0379
+  metadata.gz: 341fae9698b9a950fe6dcbc2263fcfba9f8f2b87de7156753714a2f5459dc6d0
+  data.tar.gz: 4ee41e85aab759a85339aaa174b499d34ba3967b90220ddfee3e43ada8191282
 SHA512:
-  metadata.gz: c303e23007ddc09b9bb05d09f269d637ce0e7ac8b7ec0c7325412d9afd84fb81f94590e3230716101c82be2799ae9223745ea8e79595e3bd669e932127588351
-  data.tar.gz: 4920a7deec1c46b47c9de7bd467b16ef8e5995050da4c1244c113115bde344fd1b27781e925d72fa1dfa391f2a6adf40ca22c7cd608f5e47ba8cac834c8caa8f
+  metadata.gz: b21075dc61f36ba0b20923178524030f95d4a62be67275ae5fb16db18175e63e27224640f96a9a11e5e624c0a145d37b092d6b627e1f7fa779c07c6b0ea9229d
+  data.tar.gz: ea278d62aee15c5bb1d01832c104e33ff1f305aecf373e547a8ff11929b2771167c51e5a4d029e915065113ffc8bfb1a7d445506abb94e0d0026c8dcd045335d

data/.travis.yml

@@ -1,9 +1,13 @@
 language: ruby
+os:
+  linux
+dist:
+  trusty
 rvm:
- - 2.2.6
- - 2.3.3
- - jruby-9.0.5.0
- - jruby-9.1.7.0
+ - 2.3.8
+ - 2.5.7
+ - jruby-9.1.12.0
+ - jruby-9.2.7.0
  - jruby-head
 services:
  - rabbitmq

data/README.md

@@ -135,6 +135,7 @@ Other configuration options include :
 * config.network_recovery_interval - reconnection interval for TCP connection failures (default 1)
 * config.password - RabbitMQ password (default "guest")
 * config.prefetch - number of messages to hold in the local queue in subscriber mode
+* config.resubscribe_on_consumer_cancellation - resubscribe when the consumer is cancelled (queue deleted or cluster fails, default true)
 * config.seconds_to_wait_for_graceful_shutdown - time to wait before force stopping server after shutdown signal
 * config.threadpool_size - set the number of threads available to action_subscriber
 * config.timeout - how many seconds to allow rabbit to respond before timing out

data/lib/action_subscriber/bunny/subscriber.rb

@@ -26,35 +26,52 @@ module ActionSubscriber
 
       def start_subscribers!
         subscriptions.each do |subscription|
-          route = subscription[:route]
-          queue = subscription[:queue]
-          channel = queue.channel
-          threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
-          channel.prefetch(route.prefetch) if route.acknowledgements?
-          consumer = ::Bunny::Consumer.new(channel, queue, channel.generate_consumer_tag, !route.acknowledgements?)
-          consumer.on_delivery do |delivery_info, properties, encoded_payload|
-            ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
-            properties = {
-              :action => route.action,
-              :channel => queue.channel,
-              :content_type => properties.content_type,
-              :delivery_tag => delivery_info.delivery_tag,
-              :exchange => delivery_info.exchange,
-              :headers => properties.headers,
-              :message_id => properties.message_id,
-              :routing_key => delivery_info.routing_key,
-              :queue => queue.name,
-              :uses_acknowledgements => route.acknowledgements?,
-            }
-            env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            run_env(env, threadpool)
-          end
-          bunny_consumers << consumer
-          queue.subscribe_with(consumer)
+          start_subscriber_for_subscription(subscription)
         end
       end
 
-      private
+    private
+
+      def start_subscriber_for_subscription(subscription)
+        route = subscription[:route]
+        queue = subscription[:queue]
+        channel = queue.channel
+        threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
+        channel.prefetch(route.prefetch) if route.acknowledgements?
+        consumer = ::Bunny::Consumer.new(channel, queue, channel.generate_consumer_tag, !route.acknowledgements?)
+
+        if ::ActionSubscriber.configuration.resubscribe_on_consumer_cancellation
+          # Add cancellation callback to rebuild subscriber on cancel.
+          consumer.on_cancellation do
+            ::ActionSubscriber.logger.warn "Cancelation received for queue consumer: #{queue.name}, rebuilding subscription..."
+            bunny_consumers.delete(consumer)
+            channel.close
+            queue = subscription[:queue] = setup_queue(route)
+            start_subscriber_for_subscription(subscription)
+          end
+        end
+
+        consumer.on_delivery do |delivery_info, properties, encoded_payload|
+          ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+          properties = {
+            :action => route.action,
+            :channel => queue.channel,
+            :content_type => properties.content_type,
+            :delivery_tag => delivery_info.delivery_tag,
+            :exchange => delivery_info.exchange,
+            :headers => properties.headers,
+            :message_id => properties.message_id,
+            :routing_key => delivery_info.routing_key,
+            :queue => queue.name,
+            :uses_acknowledgements => route.acknowledgements?,
+          }
+          env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
+          run_env(env, threadpool)
+        end
+
+        bunny_consumers << consumer
+        queue.subscribe_with(consumer)
+      end
 
       def setup_queue(route)
         channel = ::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.create_channel(nil, 1) }

data/lib/action_subscriber/configuration.rb

@@ -16,6 +16,7 @@ module ActionSubscriber
                   :password,
                   :port,
                   :prefetch,
+                  :resubscribe_on_consumer_cancellation,
                   :seconds_to_wait_for_graceful_shutdown,
                   :threadpool_size,
                   :timeout,
@@ -42,6 +43,7 @@ module ActionSubscriber
       :password => "guest",
       :port => 5672,
       :prefetch => 2,
+      :resubscribe_on_consumer_cancellation => true,
       :seconds_to_wait_for_graceful_shutdown => 30,
       :threadpool_size => 8,
       :timeout => 1,
@@ -75,8 +77,8 @@ module ActionSubscriber
           end
 
           ::ActionSubscriber::Configuration::DEFAULTS.each_pair do |key, value|
-            setting = cli_options[key] || yaml_config[key.to_s]
-            ::ActionSubscriber.config.__send__("#{key}=", setting) if setting
+            exists, setting = fetch_config_value(key, cli_options, yaml_config)
+            ::ActionSubscriber.config.__send__("#{key}=", setting) if exists
           end
 
           true
@@ -84,6 +86,15 @@ module ActionSubscriber
       end
     end
 
+    def self.fetch_config_value(key, cli_options, yaml_config)
+      return [true, cli_options[key]] if cli_options.key?(key)
+      return [true, cli_options[key.to_s]] if cli_options.key?(key.to_s)
+      return [true, yaml_config[key]] if yaml_config.key?(key)
+      return [true, yaml_config[key.to_s]] if yaml_config.key?(key.to_s)
+      [false, nil]
+    end
+    private_class_method :fetch_config_value
+
     ##
     # Instance Methods
     #

data/lib/action_subscriber/dsl.rb

@@ -1,5 +1,38 @@
 module ActionSubscriber
   module DSL
+    class Filter
+      attr_accessor :callback_method
+      attr_accessor :included_actions
+      attr_accessor :excluded_actions
+
+      def initialize(callback_method, options)
+        @callback_method = callback_method
+        @included_actions = @excluded_actions = []
+        parse_options(options)
+      end
+
+      def matches(action)
+        unless included_actions.empty?
+          return included_actions.include?(action)
+        end
+
+        unless excluded_actions.empty?
+          return false if excluded_actions.include?(action)
+        end
+
+        true
+      end
+
+    private
+
+      def parse_options(options)
+        return unless options
+
+        @included_actions  = options.fetch(:if, [])
+        @excluded_actions = options.fetch(:unless, [])
+      end
+    end
+
     def at_least_once!
       @_acknowledge_messages = true
       @_at_least_once = true
@@ -22,11 +55,16 @@ module ActionSubscriber
       !!@_acknowledge_messages
     end
 
-    def around_filter(filter_method)
-      around_filters << filter_method unless around_filters.include?(filter_method)
+    def around_filter(callback_method, options = nil)
+      filter = Filter.new(callback_method, options)
+      conditionally_add_filter!(filter)
       around_filters
     end
 
+    def conditionally_add_filter!(filter)
+      around_filters << filter unless around_filters.any? { |f| f.callback_method == filter.callback_method }
+    end
+
     def around_filters
       @_around_filters ||= []
     end
@@ -95,7 +133,11 @@ module ActionSubscriber
       final_block = Proc.new { subscriber_instance.public_send(action) }
 
       first_proc = around_filters.reverse.reduce(final_block) do |block, filter|
-        Proc.new { subscriber_instance.send(filter, &block) }
+        if filter.matches(action)
+          Proc.new { subscriber_instance.send(filter.callback_method, &block) }
+        else
+          block
+        end
       end
       first_proc.call
     end

data/lib/action_subscriber/march_hare/subscriber.rb

@@ -4,7 +4,8 @@ module ActionSubscriber
       include ::ActionSubscriber::Logging
 
       def cancel_consumers!
-        march_hare_consumers.each(&:cancel)
+        # Cancel any non-cancelled consumers.
+        march_hare_consumers.reject(&:cancelled?).each(&:cancel)
         ::ActionSubscriber::ThreadPools.threadpools.each do |name, threadpool|
           threadpool.shutdown
         end
@@ -26,33 +27,50 @@ module ActionSubscriber
 
       def start_subscribers!
         subscriptions.each do |subscription|
-          route = subscription[:route]
-          queue = subscription[:queue]
-          queue.channel.prefetch = route.prefetch if route.acknowledgements?
-          threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
-          consumer = queue.subscribe(route.queue_subscription_options) do |metadata, encoded_payload|
-            ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
-            properties = {
-              :action => route.action,
-              :channel => queue.channel,
-              :content_type => metadata.content_type,
-              :delivery_tag => metadata.delivery_tag,
-              :exchange => metadata.exchange,
-              :headers => _normalized_headers(metadata),
-              :message_id => metadata.message_id,
-              :routing_key => metadata.routing_key,
-              :queue => queue.name,
-              :uses_acknowledgements => route.acknowledgements?,
-            }
-            env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            run_env(env, threadpool)
+          start_subscriber_for_subscription(subscription)
+        end
+      end
+
+    private
+
+      def start_subscriber_for_subscription(subscription)
+        route = subscription[:route]
+        queue = subscription[:queue]
+        queue.channel.prefetch = route.prefetch if route.acknowledgements?
+        threadpool = ::ActionSubscriber::ThreadPools.threadpools.fetch(route.threadpool_name)
+        opts = route.queue_subscription_options
+
+        if ::ActionSubscriber.configuration.resubscribe_on_consumer_cancellation
+          # Add cancellation callback to rebuild subscriber on cancel.
+          opts[:on_cancellation] = lambda do |the_consumer|
+            ::ActionSubscriber.logger.warn "Cancelation received for queue consumer: #{queue.name}, rebuilding subscription..."
+            march_hare_consumers.delete(the_consumer)
+            queue.channel.close
+            queue = subscription[:queue] = setup_queue(route)
+            start_subscriber_for_subscription(subscription)
           end
+        end
 
-          march_hare_consumers << consumer
+        consumer = queue.subscribe(opts) do |metadata, encoded_payload|
+          ::ActiveSupport::Notifications.instrument "received_event.action_subscriber", :payload_size => encoded_payload.bytesize, :queue => queue.name
+          properties = {
+            :action => route.action,
+            :channel => queue.channel,
+            :content_type => metadata.content_type,
+            :delivery_tag => metadata.delivery_tag,
+            :exchange => metadata.exchange,
+            :headers => _normalized_headers(metadata),
+            :message_id => metadata.message_id,
+            :routing_key => metadata.routing_key,
+            :queue => queue.name,
+            :uses_acknowledgements => route.acknowledgements?,
+          }
+          env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
+          run_env(env, threadpool)
         end
-      end
 
-      private
+        march_hare_consumers << consumer
+      end
 
       def setup_queue(route)
         channel = ::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.create_channel }

data/lib/action_subscriber/middleware/env.rb

@@ -42,7 +42,7 @@ module ActionSubscriber
         @has_been_nacked = false
         @has_been_rejected = false
         @headers = properties.fetch(:headers, {})
-        @message_id = properties.fetch(:message_id, ::SecureRandom.hex(3))
+        @message_id = properties[:message_id].presence || ::SecureRandom.hex(3)
         @queue = properties.fetch(:queue)
         @routing_key = properties.fetch(:routing_key)
         @subscriber = subscriber

data/lib/action_subscriber/rabbit_connection.rb

@@ -30,9 +30,22 @@ module ActionSubscriber
           ::MarchHare::ThreadPools.fixed_of_size(options[:threadpool_size])
         end
         connection = ::MarchHare.connect(options)
+        connection.on_blocked do |reason|
+          on_blocked(reason)
+        end
+        connection.on_unblocked do
+          on_unblocked
+        end
+        connection
       else
         connection = ::Bunny.new(options)
         connection.start
+        connection.on_blocked do |blocked_message|
+          on_blocked(blocked_message.reason)
+        end
+        connection.on_unblocked do
+          on_unblocked
+        end
         connection
       end
     end
@@ -59,5 +72,15 @@ module ActionSubscriber
       }
     end
     private_class_method :connection_options
+
+    def self.on_blocked(reason)
+      ::ActiveSupport::Notifications.instrument("connection_blocked.action_subscriber", :reason => reason)
+    end
+    private_class_method :on_blocked
+
+    def self.on_unblocked
+      ::ActiveSupport::Notifications.instrument("connection_unblocked.action_subscriber")
+    end
+    private_class_method :on_unblocked
   end
 end

data/lib/action_subscriber/version.rb

@@ -1,3 +1,3 @@
 module ActionSubscriber
-  VERSION = "5.1.4.pre0"
+  VERSION = "5.2.2"
 end

data/spec/integration/around_filters_spec.rb

@@ -33,7 +33,7 @@ describe "subscriber filters", :integration => true do
   let(:subscriber) { InstaSubscriber }
 
   it "does not allow an around filter to be pushed on twice" do
-    expect(InstaSubscriber.around_filters).to eq([:whisper, :yell])
+    expect(InstaSubscriber.around_filters.map(&:callback_method)).to eq([:whisper, :yell])
   end
 
   it "runs multiple around filters" do
@@ -46,3 +46,89 @@ describe "subscriber filters", :integration => true do
     end
   end
 end
+
+class OptionsSubscriber < ActionSubscriber::Base
+  around_filter :whisper, :if => [:primero, :segundo]
+  around_filter :yell, :if => [:primero]
+  around_filter :gossip, :unless => [:private_action]
+  around_filter :everybody
+
+  def primero
+    $messages << payload
+  end
+
+  def private_action
+    $messages << payload
+  end
+
+  def segundo
+    $messages << payload
+  end
+
+  private
+
+  def everybody
+    $messages << :everybody_before
+    yield
+    $messages << :everybody_after
+  end
+
+  def gossip
+    $messages << :gossip_before
+    yield
+    $messages << :gossip_after
+  end
+
+  def whisper
+    $messages << :whisper_before
+    yield
+    $messages << :whisper_after
+  end
+
+  def yell
+    $messages << :yell_before
+    yield
+    $messages << :yell_after
+  end
+end
+
+describe "subscriber filters with conditions", :integration => true do
+  let(:draw_routes) do
+    ::ActionSubscriber.draw_routes do
+      default_routes_for OptionsSubscriber
+    end
+  end
+  let(:subscriber) { OptionsSubscriber }
+
+  context "honors conditions" do
+    it "runs yell" do
+      $messages = []
+      ::ActionSubscriber.start_subscribers!
+      ::ActivePublisher.publish("options.primero", "Howdy!", "events")
+
+      verify_expectation_within(1.0) do
+        expect($messages).to eq [:whisper_before, :yell_before, :gossip_before, :everybody_before, "Howdy!", :everybody_after, :gossip_after, :yell_after, :whisper_after]
+      end
+    end
+
+    it "doesn't yell" do
+      $messages = []
+      ::ActionSubscriber.start_subscribers!
+      ::ActivePublisher.publish("options.segundo", "Howdy!", "events")
+
+      verify_expectation_within(1.0) do
+        expect($messages).to eq [:whisper_before, :gossip_before, :everybody_before, "Howdy!", :everybody_after, :gossip_after, :whisper_after]
+      end
+    end
+
+    it "doesn't gossip" do
+      $messages = []
+      ::ActionSubscriber.start_subscribers!
+      ::ActivePublisher.publish("options.private_action", "Howdy!", "events")
+
+      verify_expectation_within(1.0) do
+        expect($messages).to eq [:everybody_before, "Howdy!", :everybody_after]
+      end
+    end
+  end
+end

data/spec/integration/consumer_cancellation_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+require "rabbitmq/http/client"
+
+class YoloSubscriber < ActionSubscriber::Base
+  def created
+    $messages << payload
+  end
+end
+
+describe "Automatically handles consumer cancellation", :integration => true, :slow => true do
+ let(:draw_routes) do
+   ::ActionSubscriber.draw_routes do
+     default_routes_for ::YoloSubscriber
+   end
+ end
+ let(:http_client) { ::RabbitMQ::HTTP::Client.new("http://127.0.0.1:15672") }
+ let(:subscriber) { ::YoloSubscriber }
+
+ it "resubscribes on cancellation" do
+   ::ActionSubscriber::start_subscribers!
+   ::ActivePublisher.publish("yolo.created", "First", "events")
+   verify_expectation_within(5.0) do
+     expect($messages).to eq(::Set.new(["First"]))
+   end
+
+   consumers = rabbit_consumers.dup
+
+   # Signal a cancellation event to all subscribers.
+   delete_all_queues!
+
+   # Give consumers a chance to restart.
+   sleep 2.0
+
+   expect(rabbit_consumers).to_not eq(consumers)
+
+   ::ActivePublisher.publish("yolo.created", "Second", "events")
+   verify_expectation_within(5.0) do
+     expect($messages).to eq(Set.new(["First", "Second"]))
+   end
+ end
+
+ context "when resubscribe on consumer cancellation is disabled" do
+   before do
+     allow(::ActionSubscriber.configuration).to receive(:resubscribe_on_consumer_cancellation).and_return(false)
+   end
+
+   it "does not resubscribe on cancellation" do
+     ::ActionSubscriber::start_subscribers!
+     ::ActivePublisher.publish("yolo.created", "First", "events")
+     verify_expectation_within(5.0) do
+       expect($messages).to eq(::Set.new(["First"]))
+     end
+
+     consumers = rabbit_consumers.dup
+
+     # Signal a cancellation event to all subscribers.
+     delete_all_queues!
+
+     # Give consumers a chance to restart.
+     sleep 2.0
+
+     # Verify the consumers did not change.
+     expect(rabbit_consumers).to eq(consumers)
+
+     ::ActivePublisher.publish("yolo.created", "Second", "events")
+
+     # Force sleep 2 seconds to ensure a resubscribe did not happen and messages were not processed.
+     sleep 2.0
+     expect($messages).to eq(Set.new(["First"]))
+   end
+ end
+
+ def rabbit_consumers
+   route_set = ::ActionSubscriber.send(:route_set)
+   route_set.try(:bunny_consumers) || route_set.try(:march_hare_consumers)
+ end
+
+ def delete_all_queues!
+   http_client.list_queues.each do |queue|
+     http_client.delete_queue(queue.vhost, queue.name)
+   end
+ end
+end

data/spec/lib/action_subscriber/configuration_spec.rb

@@ -24,6 +24,13 @@ describe ::ActionSubscriber::Configuration do
         ::ActionSubscriber::Configuration.configure_from_yaml_and_cli({}, true)
       end
     end
+
+    it "can override a true value with a false value" do
+      expect(::ActionSubscriber.configuration.verify_peer).to eq(true)
+      expect(::ActionSubscriber.configuration).to receive(:verify_peer=).with(false).and_call_original
+      ::ActionSubscriber::Configuration.configure_from_yaml_and_cli({"verify_peer" => false}, true)
+      expect(::ActionSubscriber.configuration.verify_peer).to eq(false)
+    end
   end
 
   describe "add_decoder" do

data/spec/lib/action_subscriber/rabbit_connection_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe ::ActionSubscriber::RabbitConnection do
+  let(:reason) { "low on disk" }
+
+  before { ActionSubscriber.draw_routes {} }
+
+  context "on_block" do
+    if ::RUBY_PLATFORM == "java"
+      def trigger_mocked_blocking_event(connection, reason)
+        amqp_message = ::Java::ComRabbitmqClient::AMQP::Connection::Blocked::Builder.new.
+          reason(reason).build
+        amq_command = ::Java::ComRabbitmqClientImpl::AMQCommand.new(amqp_message)
+
+        connection.send(:processControlCommand, amq_command)
+      end
+    else
+      def trigger_mocked_blocking_event(connection, reason)
+        connection.send(:handle_frame, 0, ::AMQ::Protocol::Connection::Blocked.new(reason))
+      end
+    end
+
+    it "can deliver an on_blocked message" do
+      expect(::ActiveSupport::Notifications).to receive(:instrument).
+        with("connection_blocked.action_subscriber", :reason => reason)
+
+      described_class.with_connection do |connection|
+        # NOTE: Trigger the receiving of a blocked message from the broker.
+        # It's a bit of a hack but it is a more realistic test without changing
+        # memory alarms.
+        trigger_mocked_blocking_event(connection, reason)
+      end
+    end
+  end
+
+  context "on_unblocked" do
+    if ::RUBY_PLATFORM == "java"
+      def trigger_mocked_unblocked_event(connection, reason)
+        amqp_message = ::Java::ComRabbitmqClient::AMQP::Connection::Unblocked::Builder.new.
+          build
+        amq_command = ::Java::ComRabbitmqClientImpl::AMQCommand.new(amqp_message)
+
+        connection.send(:processControlCommand, amq_command)
+      end
+    else
+      def trigger_mocked_unblocked_event(connection, reason)
+        connection.send(:handle_frame, 0, ::AMQ::Protocol::Connection::Unblocked.new)
+      end
+    end
+
+    it "can deliver an on_unblocked message" do
+      expect(::ActiveSupport::Notifications).to receive(:instrument).
+        with("connection_unblocked.action_subscriber")
+
+      described_class.with_connection do |connection|
+        # NOTE: Trigger the receiving of an unblocked message from the broker.
+        # It's a bit of a hack but it is a more realistic test without changing
+        # memory alarms.
+        trigger_mocked_unblocked_event(connection, reason)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_subscriber
 version: !ruby/object:Gem::Version
-  version: 5.1.4.pre0
+  version: 5.2.2
 platform: ruby
 authors:
 - Brian Stien
@@ -9,10 +9,10 @@ authors:
 - Brandon Dewitt
 - Devin Christensen
 - Michael Ries
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-11-30 00:00:00.000000000 Z
+date: 2020-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -258,6 +258,7 @@ files:
 - spec/integration/at_most_once_spec.rb
 - spec/integration/automatic_reconnect_spec.rb
 - spec/integration/basic_subscriber_spec.rb
+- spec/integration/consumer_cancellation_spec.rb
 - spec/integration/custom_actions_spec.rb
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
@@ -272,6 +273,7 @@ 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/rabbit_connection_spec.rb
 - spec/lib/action_subscriber/router_spec.rb
 - spec/lib/action_subscriber/subscribable_spec.rb
 - spec/spec_helper.rb
@@ -281,7 +283,7 @@ homepage: https://github.com/mxenabled/action_subscriber
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -292,13 +294,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.7.6
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: ActionSubscriber is a DSL that allows a rails app to consume messages from
   a RabbitMQ broker.
@@ -308,6 +309,7 @@ test_files:
 - spec/integration/at_most_once_spec.rb
 - spec/integration/automatic_reconnect_spec.rb
 - spec/integration/basic_subscriber_spec.rb
+- spec/integration/consumer_cancellation_spec.rb
 - spec/integration/custom_actions_spec.rb
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
@@ -322,6 +324,7 @@ 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/rabbit_connection_spec.rb
 - spec/lib/action_subscriber/router_spec.rb
 - spec/lib/action_subscriber/subscribable_spec.rb
 - spec/spec_helper.rb