action_subscriber 4.5.1 → 5.0.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1256ef323e57f2381a127ec5a92b9a0e58004391
-  data.tar.gz: a4ba006c1307a92285397c36e443aa34a5cdbea9
+  metadata.gz: c7d90f8bf0d2f27b2da875ddec284a9925f91331
+  data.tar.gz: 53b08c262c00deaf0efe1e28ef557201e7e9a469
 SHA512:
-  metadata.gz: bedc36d8710447385bf380a8c19df7327a073d61f02573149772ef455cceb9d51ce67256475e0cb6d56e122310417e8bd21332a75705e4323316966493d99782
-  data.tar.gz: 71c085717ca4b9c9fd9b90dbae6a35bb9895e7b11a435653723f15f2a4248b5f8b775633609de561ec2c9beab59abe32f254119dc27e086075a3cc4c64b27a64
+  metadata.gz: d5e2e940738dc058be7a8566ac12431cd0723143939ee845a6dd1cea9148feeb530155ecbda3a20278f2f6343a130cabe372758cfcb4390c61d4ac33563eb4eb
+  data.tar.gz: 2af092b3486426282771e5f99416836301516047e29809833de223ea00f1d91672878b5d22f6c670864ea0402f9a88afa795d31e9fa35d7c4cac935c84e02ba2

data/lib/action_subscriber/babou.rb

@@ -5,7 +5,7 @@ module ActionSubscriber
     #
     def self.start_subscribers
       reload_active_record
-      ::ActionSubscriber.setup_default_connection!
+      ::ActionSubscriber.setup_default_threadpool!
       ::ActionSubscriber.setup_subscriptions!
       ::ActionSubscriber.print_subscriptions
       ::ActionSubscriber.start_subscribers!
@@ -21,6 +21,7 @@ module ActionSubscriber
       logger.info "Shutting down"
       ::ActionSubscriber::RabbitConnection.subscriber_disconnect!
       logger.info "Shutdown complete"
+      exit(0)
     end
 
     def self.logger

data/lib/action_subscriber/bunny/subscriber.rb

@@ -9,42 +9,8 @@ module ActionSubscriber
 
       def cancel_consumers!
         bunny_consumers.each(&:cancel)
-      end
-
-      def print_subscriptions
-        routes.group_by(&:subscriber).each do |subscriber, routes|
-          logger.info subscriber.name
-          routes.each do |route|
-            logger.info "  -- method: #{route.action}"
-            logger.info "    --  connection: #{route.connection_name}"
-            logger.info "    -- concurrency: #{route.concurrency}"
-            logger.info "    --    exchange: #{route.exchange}"
-            logger.info "    --       queue: #{route.queue}"
-            logger.info "    -- routing_key: #{route.routing_key}"
-            logger.info "    --    prefetch: #{route.prefetch}"
-            logger.error "WARNING having a prefetch lower than your concurrency will prevent your subscriber from fully utilizing its threadpool" if route.prefetch < route.concurrency
-            if route.acknowledgements != subscriber.acknowledge_messages?
-              logger.error "WARNING subscriber has acknowledgements as #{subscriber.acknowledge_messages?} and route has acknowledgements as #{route.acknowledgements}"
-            end
-          end
-        end
-      end
-
-      def print_threadpool_stats
-        logger.info "*DISCLAIMER* the number of running jobs is just a best guess. We don't have a good way to introspect the bunny threadpools so jobs that are sleeping or waiting on IO won't show up as running"
-        subscriptions.group_by{|subscription| subscription[:route].subscriber}.each do |subscriber, subscriptions|
-          logger.info subscriber.name
-          subscriptions.each do |subscription|
-            route = subscription[:route]
-            work_pool = subscription[:queue].channel.work_pool
-            running_threads = work_pool.threads.select{|thread| thread.status == "run"}.count
-            routes.each do |route|
-              logger.info "  -- method: #{route.action}"
-              logger.info "    --  concurrency: #{route.concurrency}"
-              logger.info "    -- running jobs: #{running_threads}"
-              logger.info "    --      backlog: #{work_pool.backlog}"
-            end
-          end
+        ::ActionSubscriber::ThreadPools.threadpools.each do |name, threadpool|
+          threadpool.shutdown
         end
       end
 
@@ -63,6 +29,7 @@ module ActionSubscriber
           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|
@@ -79,26 +46,17 @@ module ActionSubscriber
               :queue => queue.name,
             }
             env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            run_env(env)
+            run_env(env, threadpool)
           end
           bunny_consumers << consumer
           queue.subscribe_with(consumer)
         end
       end
 
-      def wait_to_finish_with_timeout(timeout)
-        puts <<-MSG
-          Currently bunny doesn't have any sort of a graceful shutdown or
-          the ability to check on the status of its ConsumerWorkPool objects.
-          For now we just wait for #{timeout}sec to let the worker pools drain.
-        MSG
-        sleep(timeout)
-      end
-
       private
 
       def setup_queue(route)
-        channel = ::ActionSubscriber::RabbitConnection.with_connection(route.connection_name){ |connection| connection.create_channel(nil, route.concurrency) }
+        channel = ::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.create_channel(nil, 1) }
         exchange = channel.topic(route.exchange)
         queue = channel.queue(route.queue, :durable => route.durable)
         queue.bind(exchange, :routing_key => route.routing_key)

data/lib/action_subscriber/march_hare/subscriber.rb

@@ -5,49 +5,22 @@ module ActionSubscriber
 
       def cancel_consumers!
         march_hare_consumers.each(&:cancel)
+        ::ActionSubscriber::ThreadPools.threadpools.each do |name, threadpool|
+          threadpool.shutdown
+        end
       end
 
       def march_hare_consumers
         @march_hare_consumers ||= []
       end
 
-      def print_subscriptions
-        routes.group_by(&:subscriber).each do |subscriber, routes|
-          logger.info subscriber.name
-          routes.each do |route|
-            executor = ::ActionSubscriber::RabbitConnection.connection_threadpools[route.connection_name]
-            logger.info "  -- method: #{route.action}"
-            logger.info "    --  connection: #{route.connection_name} (#{executor.get_maximum_pool_size} threads)"
-            logger.info "    -- concurrency: #{route.concurrency}"
-            logger.info "    --    exchange: #{route.exchange}"
-            logger.info "    --       queue: #{route.queue}"
-            logger.info "    -- routing_key: #{route.routing_key}"
-            logger.info "    --    prefetch: #{route.prefetch} per consumer (#{route.prefetch * route.concurrency} total)"
-            if route.acknowledgements != subscriber.acknowledge_messages?
-              logger.error "WARNING subscriber has acknowledgements as #{subscriber.acknowledge_messages?} and route has acknowledgements as #{route.acknowledgements}"
-            end
-          end
-        end
-      end
-
-      def print_threadpool_stats
-        ::ActionSubscriber::RabbitConnection.connection_threadpools.each do |name, executor|
-          logger.info "Connection #{name}"
-          logger.info "  -- available threads: #{executor.get_maximum_pool_size}"
-          logger.info "  --    running thread: #{executor.get_active_count}"
-          logger.info "  --           backlog: #{executor.get_queue.size}"
-        end
-      end
-
       def setup_subscriptions!
         fail ::RuntimeError, "you cannot setup queues multiple times, this should only happen once at startup" unless subscriptions.empty?
         routes.each do |route|
-          route.concurrency.times do
-            subscriptions << {
-              :route => route,
-              :queue => setup_queue(route),
-            }
-          end
+          subscriptions << {
+            :route => route,
+            :queue => setup_queue(route),
+          }
         end
       end
 
@@ -56,6 +29,7 @@ module ActionSubscriber
           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 = {
@@ -70,37 +44,17 @@ module ActionSubscriber
               :queue => queue.name,
             }
             env = ::ActionSubscriber::Middleware::Env.new(route.subscriber, encoded_payload, properties)
-            run_env(env)
+            run_env(env, threadpool)
           end
 
           march_hare_consumers << consumer
         end
       end
 
-      def wait_to_finish_with_timeout(timeout)
-        wait_loops = 0
-        loop do
-          wait_loops = wait_loops + 1
-          any_threadpools_busy = false
-          ::ActionSubscriber::RabbitConnection.connection_threadpools.each do |name, executor|
-            next if executor.get_active_count <= 0
-            logger.info "  -- Connection #{name} (active: #{executor.get_active_count}, queued: #{executor.get_queue.size})"
-            any_threadpools_busy = true
-          end
-          if !any_threadpools_busy
-            logger.info "Connection threadpools empty"
-            break
-          end
-          break if wait_loops >= timeout
-          Thread.pass
-          sleep 1
-        end
-      end
-
       private
 
       def setup_queue(route)
-        channel = ::ActionSubscriber::RabbitConnection.with_connection(route.connection_name){ |connection| connection.create_channel }
+        channel = ::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.create_channel }
         exchange = channel.topic(route.exchange)
         queue = channel.queue(route.queue, :durable => route.durable)
         queue.bind(exchange, :routing_key => route.routing_key)

data/lib/action_subscriber/message_retry.rb

@@ -46,7 +46,7 @@ module ActionSubscriber
     end
 
     def self.with_exchange(env, ttl, retry_queue_name)
-      channel = RabbitConnection.with_connection(:default){|connection| connection.create_channel}
+      channel = RabbitConnection.with_connection{|connection| connection.create_channel}
       begin
         channel.confirm_select
         # an empty string is the default exchange [see bunny docs](http://rubybunny.info/articles/exchanges.html#default_exchange)

data/lib/action_subscriber/rabbit_connection.rb

@@ -5,46 +5,27 @@ module ActionSubscriber
     SUBSCRIBER_CONNECTION_MUTEX = ::Mutex.new
     NETWORK_RECOVERY_INTERVAL = 1.freeze
 
-    def self.connection_threadpools
-      if ::RUBY_PLATFORM == "java"
-        subscriber_connections.each_with_object({}) do |(name, connection), hash|
-          hash[name] = connection.instance_variable_get("@executor")
-        end
-      else
-        [] # TODO can I get a hold of the thredpool that bunny uses?
-      end
-    end
-
-    def self.setup_connection(name, settings)
-      SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        fail ArgumentError, "a #{name} connection already exists" if subscriber_connections[name]
-        subscriber_connections[name] = create_connection(settings)
-      end
-    end
-
     def self.subscriber_connected?
-      SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        subscriber_connections.all?{|_name, connection| connection.connected?}
-      end
+      with_connection{|connection| connection.connected? }
     end
 
     def self.subscriber_disconnect!
       SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        subscriber_connections.each{|_name, connection| connection.close}
-        @subscriber_connections = {}
+        @subscriber_connection.close if @subscriber_connection
+        @subscriber_connection = nil
       end
     end
 
-    def self.with_connection(name)
+    def self.with_connection
       SUBSCRIBER_CONNECTION_MUTEX.synchronize do
-        fail ArgumentError, "there is no connection named #{name}" unless subscriber_connections[name]
-        yield(subscriber_connections[name])
+        @subscriber_connection ||= create_connection
+        yield(@subscriber_connection)
       end
     end
 
     # Private API
-    def self.create_connection(settings)
-      options = connection_options.merge(settings)
+    def self.create_connection
+      options = connection_options
       if ::RUBY_PLATFORM == "java"
         options[:executor_factory] = ::Proc.new do
           ::MarchHare::ThreadPools.fixed_of_size(options[:threadpool_size])
@@ -79,10 +60,5 @@ module ActionSubscriber
       }
     end
     private_class_method :connection_options
-
-    def self.subscriber_connections
-      @subscriber_connections ||= {}
-    end
-    private_class_method :subscriber_connections
   end
 end

data/lib/action_subscriber/route.rb

@@ -2,27 +2,29 @@ module ActionSubscriber
   class Route
     attr_reader :acknowledgements,
                 :action,
-                :concurrency,
-                :connection_name,
                 :durable,
                 :exchange,
                 :prefetch,
                 :queue,
                 :routing_key,
                 :subscriber,
-                :threadpool
+                :threadpool_name
 
     def initialize(attributes)
       @acknowledgements = attributes.fetch(:acknowledgements)
       @action = attributes.fetch(:action)
-      @concurrency = attributes.fetch(:concurrency, 1)
-      @connection_name = attributes.fetch(:connection_name)
       @durable = attributes.fetch(:durable)
       @exchange = attributes.fetch(:exchange).to_s
       @prefetch = attributes.fetch(:prefetch) { ::ActionSubscriber.config.prefetch }
       @queue = attributes.fetch(:queue)
       @routing_key = attributes.fetch(:routing_key)
       @subscriber = attributes.fetch(:subscriber)
+      @threadpool_name = attributes.fetch(:threadpool_name)
+      if attributes.has_key?(:concurrency)
+        concurrency = attributes[:concurrency]
+        ::ActionSubscriber.print_deprecation_warning("setting prefetch for #{@queue} to #{concurrency}")
+        @prefetch = concurrency
+      end
     end
 
     def acknowledgements?

data/lib/action_subscriber/route_set.rb

@@ -12,16 +12,56 @@ module ActionSubscriber
       @routes = routes
     end
 
+    def print_subscriptions
+      routes.group_by(&:subscriber).each do |subscriber, routes|
+        logger.info subscriber.name
+        routes.each do |route|
+          threadpool = ::ActionSubscriber::ThreadPools.threadpools[route.threadpool_name]
+          logger.info "  -- method: #{route.action}"
+          logger.info "    --  threadpool: #{route.threadpool_name} (#{threadpool.max_length} threads)"
+          logger.info "    --    exchange: #{route.exchange}"
+          logger.info "    --       queue: #{route.queue}"
+          logger.info "    -- routing_key: #{route.routing_key}"
+          logger.info "    --    prefetch: #{route.prefetch}"
+          if route.acknowledgements != subscriber.acknowledge_messages?
+            logger.error "WARNING subscriber has acknowledgements as #{subscriber.acknowledge_messages?} and route has acknowledgements as #{route.acknowledgements}"
+          end
+        end
+      end
+    end
+
+    def print_threadpool_stats
+      ::ActionSubscriber::ThreadPools.threadpools.each do |name, threadpool|
+        logger.info "Threadpool #{name}"
+        logger.info "  -- available threads: #{threadpool.length}"
+        logger.info "  --           backlog: #{threadpool.queue_length}"
+      end
+    end
+
+    def wait_to_finish_with_timeout(timeout)
+      ::ActionSubscriber::ThreadPools.threadpools.map do |name, threadpool|
+        logger.info "  -- Threadpool #{name} (queued: #{threadpool.queue_length})"
+        ::Thread.new do
+          completed = threadpool.wait_for_termination(timeout)
+          unless completed
+            logger.error "  -- FAILED #{name} did not finish shutting down within #{timeout}sec"
+          end
+        end
+      end.each(&:join)
+    end
+
   private
 
     def subscriptions
       @subscriptions ||= []
     end
 
-    def run_env(env)
+    def run_env(env, threadpool)
       logger.info "RECEIVED #{env.message_id} from #{env.queue}"
       ::ActiveSupport::Notifications.instrument "process_event.action_subscriber", :subscriber => env.subscriber.to_s, :routing_key => env.routing_key, :queue => env.queue do
-        ::ActionSubscriber.config.middleware.call(env)
+        threadpool << lambda do
+          ::ActionSubscriber.config.middleware.call(env)
+        end
       end
     end
   end

data/lib/action_subscriber/router.rb

@@ -13,14 +13,19 @@ module ActionSubscriber
     }.freeze
 
     def initialize
-      @current_connection_name = :default
+      @current_threadpool_name = :default
     end
 
-    def connection(name, settings)
-      ::ActionSubscriber::RabbitConnection.setup_connection(name, settings)
-      @current_connection_name = name
+    def connection(name, settings, &block)
+      ::ActionSubscriber.print_deprecation_warning("setting up a threadpool for #{name} instead of a new connection")
+      threadpool(name, settings, &block)
+    end
+
+    def threadpool(name, settings)
+      ::ActionSubscriber::ThreadPools.setup_threadpool(name, settings)
+      @current_threadpool_name = name
       yield
-      @current_connection_name = :default
+      @current_threadpool_name = :default
     end
 
     def default_routing_key_for(route_settings)
@@ -41,7 +46,7 @@ module ActionSubscriber
     end
 
     def default_routes_for(subscriber, options = {})
-      options = options.merge({:connection_name => @current_connection_name})
+      options = options.merge({:threadpool_name => @current_threadpool_name})
       subscriber.routes(options).each do |route|
         routes << route
       end
@@ -66,7 +71,7 @@ module ActionSubscriber
     end
 
     def route(subscriber, action, options = {})
-      route_settings = DEFAULT_SETTINGS.merge(:connection_name => @current_connection_name).merge(options).merge(:subscriber => subscriber, :action => action)
+      route_settings = DEFAULT_SETTINGS.merge(:threadpool_name => @current_threadpool_name).merge(options).merge(:subscriber => subscriber, :action => action)
       route_settings[:routing_key] ||= default_routing_key_for(route_settings)
       route_settings[:queue] ||= default_queue_for(route_settings)
       routes << Route.new(route_settings)

data/lib/action_subscriber/thread_pools.rb

@@ -0,0 +1,34 @@
+require "concurrent"
+require "thread"
+
+module ActionSubscriber
+  module ThreadPools
+    MUTEX = ::Mutex.new
+    THREADPOOL_DEFAULTS = {
+      :auto_terminate => true,
+      :fallback_policy => :caller_runs,
+      :max_queue => 10_000,
+    }.freeze
+
+    def self.threadpools
+      MUTEX.synchronize do
+        @threadpools ||= {}
+      end
+    end
+
+    def self.setup_threadpool(name, settings)
+      MUTEX.synchronize do
+        @threadpools ||= {}
+        fail ArgumentError, "a #{name} threadpool already exists" if @threadpools.has_key?(name)
+        @threadpools[name] = create_threadpool(settings)
+      end
+    end
+
+    def self.create_threadpool(settings)
+      settings = THREADPOOL_DEFAULTS.merge(settings)
+      num_threads = settings.delete(:threadpool_size) || ::ActionSubscriber.configuration.threadpool_size
+      ::Concurrent::FixedThreadPool.new(num_threads, settings)
+    end
+    private_class_method :create_threadpool
+  end
+end

data/lib/action_subscriber/version.rb

@@ -1,3 +1,3 @@
 module ActionSubscriber
-  VERSION = "4.5.1"
+  VERSION = "5.0.0.pre0"
 end

data/lib/action_subscriber.rb

@@ -21,6 +21,7 @@ require "action_subscriber/message_retry"
 require "action_subscriber/middleware"
 require "action_subscriber/rabbit_connection"
 require "action_subscriber/subscribable"
+require "action_subscriber/thread_pools"
 require "action_subscriber/bunny/subscriber"
 require "action_subscriber/march_hare/subscriber"
 require "action_subscriber/babou"
@@ -47,6 +48,16 @@ module ActionSubscriber
     @draw_routes_block = block
   end
 
+  def self.print_deprecation_warning(specific_warning)
+    logger.info ("#"*50)
+    logger.info ("# DEPRECATION NOTICE ")
+    logger.info ("# #{specific_warning}")
+    logger.info ("# The usage of multiple connections and the :concurrency setting have been deprecated in favor of using threadpools")
+    logger.info ("# Please see https://github.com/mxenabled/action_subscriber#connections-deprecated for details")
+    logger.info ("# If this change is a problem for your usage of action_subscriber please let us know here: https://github.com/mxenabled/action_subscriber/issues/92")
+    logger.info ("#"*50)
+  end
+
   def self.print_subscriptions
     logger.info configuration.inspect
     route_set.print_subscriptions
@@ -56,8 +67,8 @@ module ActionSubscriber
     route_set.print_threadpool_stats
   end
 
-  def self.setup_default_connection!
-    ::ActionSubscriber::RabbitConnection.setup_connection(:default, {})
+  def self.setup_default_threadpool!
+    ::ActionSubscriber::ThreadPools.setup_threadpool(:default, {})
   end
 
   def self.setup_subscriptions!

data/spec/integration/automatic_reconnect_spec.rb

@@ -25,7 +25,7 @@ describe "Automatically reconnect on connection failure", :integration => true,
    close_all_connections!
    sleep 5.0
    verify_expectation_within(5.0) do
-     expect(::ActionSubscriber::RabbitConnection.with_connection(:default){|connection| connection.open?}).to eq(true)
+     expect(::ActionSubscriber::RabbitConnection.with_connection{|connection| connection.open?}).to eq(true)
    end
 
    ::ActivePublisher.publish("gus.spoke", "Second", "events")

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ require 'action_subscriber/rspec'
 # Silence the Logger
 $TESTING = true
 ::ActionSubscriber::Logging.initialize_logger(nil)
-::ActionSubscriber.setup_default_connection!
+::ActionSubscriber.setup_default_threadpool!
 
 RSpec.configure do |config|
   config.mock_with :rspec do |mocks|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: action_subscriber
 version: !ruby/object:Gem::Version
-  version: 4.5.1
+  version: 5.0.0.pre0
 platform: ruby
 authors:
 - Brian Stien
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-24 00:00:00.000000000 Z
+date: 2017-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -235,6 +235,7 @@ files:
 - lib/action_subscriber/router.rb
 - lib/action_subscriber/rspec.rb
 - lib/action_subscriber/subscribable.rb
+- lib/action_subscriber/thread_pools.rb
 - lib/action_subscriber/uri.rb
 - lib/action_subscriber/version.rb
 - routing.md
@@ -247,7 +248,6 @@ files:
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
 - spec/integration/manual_acknowledgement_spec.rb
-- spec/integration/multiple_connections_spec.rb
 - spec/lib/action_subscriber/base_spec.rb
 - spec/lib/action_subscriber/configuration_spec.rb
 - spec/lib/action_subscriber/dsl_spec.rb
@@ -278,9 +278,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.13
@@ -298,7 +298,6 @@ test_files:
 - spec/integration/custom_headers_spec.rb
 - spec/integration/decoding_payloads_spec.rb
 - spec/integration/manual_acknowledgement_spec.rb
-- spec/integration/multiple_connections_spec.rb
 - spec/lib/action_subscriber/base_spec.rb
 - spec/lib/action_subscriber/configuration_spec.rb
 - spec/lib/action_subscriber/dsl_spec.rb

data/spec/integration/multiple_connections_spec.rb

@@ -1,36 +0,0 @@
-class MultipleConnectionsSubscriber < ::ActionSubscriber::Base
-  MUTEX = ::Mutex.new
-  at_least_once!
-
-  def burp
-    MUTEX.synchronize do
-      $messages << payload
-    end
-  end
-end
-
-describe "Separate connections to get multiple threadpools", :integration => true do
-  let(:draw_routes) do
-    ::ActionSubscriber.draw_routes do
-      connection(:background_work, :thread_pool_size => 20) do
-        route MultipleConnectionsSubscriber, :burp,
-          :acknowledgements => true,
-          :concurrency => 20
-      end
-      route MultipleConnectionsSubscriber, :burp,
-          :acknowledgements => true,
-          :concurrency => 8 # match the default threadpool size
-    end
-  end
-
-  it "spreads the load across multiple threadpools and consumer" do
-    ::ActionSubscriber.start_subscribers!
-    1.upto(10).each do |i|
-      ::ActivePublisher.publish("multiple_connections.burp", "belch#{i}", "events")
-    end
-
-    verify_expectation_within(5.0) do
-      expect($messages).to eq(Set.new(["belch1", "belch2", "belch3", "belch4", "belch5", "belch6", "belch7", "belch8", "belch9", "belch10"]))
-    end
-  end
-end