harmoniser 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd51302d5c886af771b66e4528054042a8922071669719ba625aac5d5c0dc503
-  data.tar.gz: 2dd00c5d6699436fca25d6c721cba80518aa8baa967e3bca247af408b829582b
+  metadata.gz: f94dc99fc3550a6ad359ffed69a06652849e74317ef607bedbaadad9c09f44fa
+  data.tar.gz: 489bea79098e457c8391f4fe1949b00e1618818b67fbff1fceb40da89ee48da8
 SHA512:
-  metadata.gz: 6f2f43e8bc13d89db74bc38da9e08b86773aea3582cf5df277c985df22a016aa22bc5f965243b3df451c9f22ff40bc16299aeece5b7d5d15d57b6a43fb8b2233
-  data.tar.gz: e3768b89e31de5b74b27333a990247b416067acc6055e4a1ea15d3ad63560a91780d9f379ced069f0cc9c950907186d2e67cd5daaacfaaf4b4f64b8715804415
+  metadata.gz: 7b78d93705c81e6dc30ddba7dc02733476a40998568299df5b2742ef80c47f2fba6bfb03e1d272f69472030ab19b40276c23beba88505d40fe86c65685855efd
+  data.tar.gz: d0ac0e8502cc760826e22d446ae914eacdca0f8b01faec19dc52350f994cd5c1fb3d663e4d2465bec6c26c5bdbb22e9f9278d8eff60521c08147f8c6cb743425

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.10.0] - 2024-09-16
+
+### Added
+- Add a concurrency option to the CLI. By default, concurrency is unbounded, i.e., each subscriber
+  has its own thread dedicated to processing messages
+- Introduce Harmoniser::Subscriber::Registry for holding references to classes that include
+  Harmoniser::Subscriber
+- Kill the process when an ACK timeout is received through any channel. The process terminates with
+  exit code 138
+- Add a 25-second timeout to shut down the process. This is only applicable to processes using the
+  concurrency option
+
+### Changed
+- Update Bunny to the latest version, i.e., 2.23
+- Cancel subscribers and connection is done within the Launcher context instead of relying on
+  at_exit hook
+- Prevent the connection from being closed after Topology#declare finishes; only the channel used
+  is closed
+
 ## [0.9.0] - 2024-08-09
 
 ### Added

data/harmoniser.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |spec|
   spec.executables = ["harmoniser"]
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "bunny", "~> 2.22"
+  spec.add_runtime_dependency "bunny", "~> 2.23"
 end

data/lib/harmoniser/channelable.rb

@@ -10,22 +10,55 @@ module Harmoniser
         end
       end
 
-      def create_channel
-        channel = Harmoniser.connection.create_channel
-        channel.on_error(&method(:on_error).to_proc)
-        channel.on_uncaught_exception(&method(:on_uncaught_exception).to_proc)
-        channel
+      def create_channel(consumer_pool_size: 1, consumer_pool_shutdown_timeout: 60)
+        connection
+          .create_channel(nil, consumer_pool_size, false, consumer_pool_shutdown_timeout)
+          .tap do |channel|
+            attach_callbacks(channel)
+          end
       end
 
       private
 
+      def connection
+        Harmoniser.connection
+      end
+
+      def attach_callbacks(channel)
+        channel.on_error(&method(:on_error).to_proc)
+        channel.on_uncaught_exception(&method(:on_uncaught_exception).to_proc)
+      end
+
       def on_error(channel, amq_method)
-        Harmoniser.logger.error("Default on_error handler executed for channel: method = `#{amq_method}`, exchanges = `#{channel.exchanges.keys}`, queues = `#{channel.queues.keys}`")
+        attributes = {
+          amq_method: amq_method,
+          exchanges: channel.exchanges.keys,
+          queues: channel.consumers.values.map(&:queue)
+        }
+
+        if amq_method.is_a?(AMQ::Protocol::Channel::Close)
+          attributes[:reply_code] = amq_method.reply_code
+          attributes[:reply_text] = amq_method.reply_text
+        end
+
+        stringified_attributes = attributes.map { |k, v| "#{k} = `#{v}`" }.join(", ")
+        Harmoniser.logger.error("Default on_error handler executed for channel: #{stringified_attributes}")
+        maybe_kill_process(amq_method)
       end
 
       def on_uncaught_exception(error, consumer)
         Harmoniser.logger.error("Default on_uncaught_exception handler executed for channel: error_class = `#{error.class}`, error_message = `#{error.message}`, error_backtrace = `#{error.backtrace&.first(5)}, queue = `#{consumer.queue}`")
       end
+
+      def maybe_kill_process(amq_method)
+        Process.kill("USR1", Process.pid) if ack_timed_out?(amq_method) && Harmoniser.server?
+      end
+
+      def ack_timed_out?(amq_method)
+        return false unless amq_method.is_a?(AMQ::Protocol::Channel::Close)
+
+        amq_method.reply_text =~ /delivery acknowledgement on channel \d+ timed out/
+      end
     end
 
     class << self

data/lib/harmoniser/cli.rb

@@ -5,11 +5,13 @@ require "harmoniser/launcher"
 
 module Harmoniser
   class CLI
+    class SigUsr1 < StandardError; end
     include Singleton
 
     SIGNAL_HANDLERS = {
       "INT" => lambda { |cli, signal| raise Interrupt },
-      "TERM" => lambda { |cli, signal| raise Interrupt }
+      "TERM" => lambda { |cli, signal| raise Interrupt },
+      "USR1" => lambda { |cli, signal| raise SigUsr1 }
     }
     SIGNAL_HANDLERS.default = lambda { |cli, signal| cli.logger.info("Default signal handler executed since there is no handler defined: signal = `#{signal}`") }
 
@@ -22,6 +24,7 @@ module Harmoniser
 
     def call
       parse_options
+      @launcher = Launcher.call(configuration: @configuration, logger: @logger)
       run
     end
 
@@ -37,7 +40,7 @@ module Harmoniser
     def define_signals
       @read_io, @write_io = IO.pipe
 
-      ["INT", "TERM"].each do |sig|
+      ["INT", "TERM", "USR1"].each do |sig|
         Signal.trap(sig) do
           @write_io.puts(sig)
         end
@@ -45,9 +48,7 @@ module Harmoniser
     end
 
     def run
-      Launcher
-        .new(configuration: configuration, logger: logger)
-        .start
+      @launcher.start
 
       define_signals
 
@@ -58,7 +59,13 @@ module Harmoniser
     rescue Interrupt
       @write_io.close
       @read_io.close
+      @launcher.stop
       exit(0)
+    rescue SigUsr1
+      @write_io.close
+      @read_io.close
+      @launcher.stop
+      exit(128 + 10)
     end
 
     def handle_signal(signal)

data/lib/harmoniser/configuration.rb

@@ -9,7 +9,7 @@ module Harmoniser
     include Connectable
 
     attr_reader :logger, :options
-    def_delegators :options, :environment, :require, :verbose
+    def_delegators :options, :concurrency, :environment, :require, :verbose, :timeout
 
     def initialize
       @logger = Harmoniser.logger
@@ -33,8 +33,10 @@ module Harmoniser
 
     def default_options
       {
+        concurrency: Float::INFINITY,
         environment: ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", "production")),
         require: ".",
+        timeout: 25,
         verbose: false
       }
     end

data/lib/harmoniser/connectable.rb

@@ -5,7 +5,18 @@ module Harmoniser
     MUTEX = Mutex.new
 
     def connection_opts
-      @connection_opts ||= Connection::DEFAULT_CONNECTION_OPTS.merge({logger: Harmoniser.logger})
+      @connection_opts ||= Connection::DEFAULT_CONNECTION_OPTS
+        .merge({
+          logger: Harmoniser.logger,
+          recovery_attempt_started: proc {
+            stringified_connection = connection.to_s
+            Harmoniser.logger.info("Recovery attempt started: connection = `#{stringified_connection}`")
+          },
+          recovery_completed: proc {
+            stringified_connection = connection.to_s
+            Harmoniser.logger.info("Recovery completed: connection = `#{stringified_connection}`")
+          }
+        })
     end
 
     def connection_opts=(opts)
@@ -16,7 +27,7 @@ module Harmoniser
 
     def connection
       MUTEX.synchronize do
-        @connection ||= create_connection
+        @connection ||= Connection.new(connection_opts)
         @connection.start unless @connection.open? || @connection.recovering_from_network_failure?
         @connection
       end
@@ -25,24 +36,5 @@ module Harmoniser
     def connection?
       !!defined?(@connection)
     end
-
-    private
-
-    def create_connection
-      at_exit(&method(:at_exit_handler).to_proc)
-      Connection.new(connection_opts)
-    end
-
-    def at_exit_handler
-      logger = Harmoniser.logger
-
-      logger.info("Shutting down!")
-      if connection? && @connection.open?
-        logger.info("Connection will be closed: connection = `#{@connection}`")
-        @connection.close
-        logger.info("Connection closed: connection = `#{@connection}`")
-      end
-      logger.info("Bye!")
-    end
   end
 end

data/lib/harmoniser/connection.rb

@@ -7,19 +7,11 @@ module Harmoniser
 
     DEFAULT_CONNECTION_OPTS = {
       connection_name: "harmoniser@#{VERSION}",
-      connection_timout: 5,
+      connection_timeout: 5,
       host: "127.0.0.1",
       password: "guest",
       port: 5672,
       read_timeout: 5,
-      recovery_attempt_started: proc {
-        stringified_connection = Harmoniser.connection.to_s
-        Harmoniser.logger.info("Recovery attempt started: connection = `#{stringified_connection}`")
-      },
-      recovery_completed: proc {
-        stringified_connection = Harmoniser.connection.to_s
-        Harmoniser.logger.info("Recovery completed: connection = `#{stringified_connection}`")
-      },
       tls_silence_warnings: true,
       username: "guest",
       verify_peer: false,
@@ -37,6 +29,7 @@ module Harmoniser
       "<#{self.class.name}>: #{user}@#{host}:#{port}, connection_name = `#{connection_name}`, vhost = `#{vhost}`"
     end
 
+    # TODO Only perform retries when Harmoniser.server?
     def start
       retries = 0
       begin
@@ -79,6 +72,7 @@ module Harmoniser
       @bunny.vhost
     end
 
+    # TODO Use Signal handler defined at Harmoniser::CLI instead of rescuing SignalException?
     def with_signal_handler
       yield if block_given?
     rescue SignalException => e

data/lib/harmoniser/launcher/base.rb

@@ -0,0 +1,75 @@
+require "harmoniser/subscriber"
+require "harmoniser/subscriber/registry"
+require "harmoniser/work_pool_reporter"
+
+module Harmoniser
+  module Launcher
+    class Base
+      attr_reader :subscribers
+
+      def initialize(configuration:, logger:)
+        @configuration = configuration
+        @logger = logger
+        @subscribers = Subscriber.registry
+      end
+
+      def start
+        boot_app
+        start_subscribers
+        @logger.info("Subscribers registered to consume messages from queues: klasses = `#{@subscribers}`")
+      end
+
+      def stop
+        @logger.info("Shutting down!")
+        maybe_close
+        @logger.info("Bye!")
+      end
+
+      private
+
+      def boot_app
+        if File.directory?(@configuration.require)
+          load_rails
+        else
+          load_file
+        end
+      end
+
+      def load_rails
+        filepath = File.expand_path("#{@configuration.require}/config/environment.rb")
+        require filepath
+      rescue LoadError => e
+        @logger.warn("Error while requiring file within directory. No subscribers will run for this process: require = `#{@configuration.require}`, filepath = `#{filepath}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
+      end
+
+      def load_file
+        require @configuration.require
+      rescue LoadError => e
+        @logger.warn("Error while requiring file. No subscribers will run for this process: require = `#{@configuration.require}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
+      end
+
+      def maybe_close
+        return unless @configuration.connection?
+        return unless @configuration.connection.open?
+
+        maybe_cancel_subscribers
+        report_work_pool
+
+        connection = @configuration.connection
+        @logger.info("Connection will be closed: connection = `#{connection}`")
+        connection.close
+        @logger.info("Connection closed: connection = `#{connection}`")
+      end
+
+      def maybe_cancel_subscribers
+        @logger.info("Subscribers will be cancelled from queues: klasses = `#{@subscribers}`")
+        @subscribers.each(&:harmoniser_subscriber_stop)
+        @logger.info("Subscribers cancelled: klasses = `#{@subscribers}`")
+      end
+
+      def report_work_pool
+        @logger.info("Stats about the work pool: work_pool_reporter = `#{WorkPoolReporter.new(consumers: @consumers)}`. Note: A backlog greater than zero means messages could be lost for subscribers configured with no_ack, i.e. automatic ack")
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher/bounded.rb

@@ -0,0 +1,22 @@
+require "harmoniser/channelable"
+require_relative "base"
+
+module Harmoniser
+  module Launcher
+    class Bounded < Base
+      include Channelable
+
+      private
+
+      def start_subscribers
+        @consumers = subscribers.map do |klass|
+          klass.harmoniser_subscriber_start(channel: channel)
+        end
+      end
+
+      def channel
+        @channel ||= self.class.create_channel(consumer_pool_size: @configuration.concurrency, consumer_pool_shutdown_timeout: @configuration.timeout)
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher/unbounded.rb

@@ -0,0 +1,11 @@
+require_relative "base"
+
+module Harmoniser
+  module Launcher
+    class UnBounded < Base
+      def start_subscribers
+        @consumers = subscribers.map(&:harmoniser_subscriber_start)
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher.rb

@@ -1,47 +1,14 @@
-module Harmoniser
-  class Launcher
-    def initialize(configuration:, logger:)
-      @configuration = configuration
-      @logger = logger
-    end
-
-    def start
-      boot_app
-      start_subscribers
-    end
+require_relative "launcher/bounded"
+require_relative "launcher/unbounded"
 
-    private
-
-    def boot_app
-      if File.directory?(@configuration.require)
-        load_rails
-      else
-        load_file
-      end
-    end
+module Harmoniser
+  module Launcher
+    class << self
+      def call(configuration:, logger:)
+        return Bounded.new(configuration:, logger:) unless configuration.options.unbounded_concurrency?
 
-    # TODO - Frameworks like Rails which have autoload for development/test will not start any subscriber unless the files where subscribers are located are required explicitly. Since we premier production and the eager load ensures that every file is loaded, this approach works
-    def start_subscribers
-      klasses = Subscriber.harmoniser_included
-      klasses.each do |klass|
-        klass.harmoniser_subscriber_start
+        UnBounded.new(configuration:, logger:)
       end
-      @logger.info("Subscribers registered to consume messages from queues: klasses = `#{klasses}`")
-    end
-
-    private
-
-    def load_rails
-      filepath = File.expand_path("#{@configuration.require}/config/environment.rb")
-      require filepath
-    rescue LoadError => e
-      @logger.warn("Error while requiring file within directory. No subscribers will run for this process: require = `#{@configuration.require}`, filepath = `#{filepath}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
-    end
-
-    def load_file
-      require @configuration.require
-    rescue LoadError => e
-      @logger.warn("Error while requiring file. No subscribers will run for this process: require = `#{@configuration.require}`, error_class = `#{e.class}`, error_message = `#{e.message}`, error_backtrace = `#{e.backtrace&.first(5)}`")
     end
   end
 end

data/lib/harmoniser/options.rb

@@ -1,9 +1,13 @@
 module Harmoniser
-  Options = Data.define(:environment, :require, :verbose) do
+  Options = Data.define(:concurrency, :environment, :require, :verbose, :timeout) do
     def production?
       environment == "production"
     end
 
+    def unbounded_concurrency?
+      concurrency == Float::INFINITY
+    end
+
     def verbose?
       !!verbose
     end

data/lib/harmoniser/parser.rb

@@ -8,6 +8,9 @@ module Harmoniser
       @options = {}
       @option_parser = OptionParser.new do |opts|
         opts.banner = "harmoniser [options]"
+        opts.on "-c", "--concurrency INT", "Set the number of threads to use" do |arg|
+          @options[:concurrency] = Integer(arg)
+        end
         opts.on "-e", "--environment ENV", "Set the application environment (defaults to inferred environment or 'production')" do |arg|
           @options[:environment] = arg
         end

data/lib/harmoniser/publisher.rb

@@ -44,7 +44,7 @@ module Harmoniser
       end
 
       def raise_missing_exchange_definition
-        raise MissingExchangeDefinition, "Please call the harmoniser_publisher class method at `#{const_get(:HARMONISER_PUBLISHER_CLASS)}` with the exchange_name that will be used for publishing"
+        raise MissingExchangeDefinition, "Please call the harmoniser_publisher class method at `#{name}` with the exchange_name that will be used for publishing"
       end
 
       def handle_return(exchange)
@@ -57,7 +57,7 @@ module Harmoniser
     class << self
       def included(base)
         base.const_set(:HARMONISER_PUBLISHER_MUTEX, Mutex.new)
-        base.const_set(:HARMONISER_PUBLISHER_CLASS, base)
+        base.private_constant(:HARMONISER_PUBLISHER_MUTEX)
         base.extend(ClassMethods)
       end
     end

data/lib/harmoniser/subscriber/registry.rb

@@ -0,0 +1,19 @@
+require "forwardable"
+
+module Harmoniser
+  module Subscriber
+    class Registry
+      extend Forwardable
+
+      def_delegators :@klasses, :<<, :to_a, :each, :map
+
+      def initialize
+        @klasses = Set.new
+      end
+
+      def to_s
+        to_a.map(&:harmoniser_subscriber_to_s).to_s
+      end
+    end
+  end
+end

data/lib/harmoniser/subscriber.rb

@@ -1,12 +1,11 @@
 require "harmoniser/channelable"
 require "harmoniser/definition"
-require "harmoniser/includable"
+require "harmoniser/subscriber/registry"
 
 module Harmoniser
   module Subscriber
     class MissingConsumerDefinition < StandardError; end
     include Channelable
-    include Includable
 
     module ClassMethods
       def harmoniser_subscriber(queue_name:, consumer_tag: nil, no_ack: true, exclusive: false, arguments: {})
@@ -19,22 +18,34 @@ module Harmoniser
         )
       end
 
-      def harmoniser_subscriber_start
+      def harmoniser_subscriber_start(channel: nil)
         const_get(:HARMONISER_SUBSCRIBER_MUTEX).synchronize do
-          @harmoniser_consumer ||= create_consumer
+          @harmoniser_consumer ||= create_consumer(channel)
         end
       end
 
+      def harmoniser_subscriber_stop
+        return unless @harmoniser_consumer
+        return unless @harmoniser_consumer.channel.open?
+
+        @harmoniser_consumer.cancel
+      end
+
+      def harmoniser_subscriber_to_s
+        definition = @harmoniser_consumer_definition
+        "<#{name}>: queue_name = `#{definition.queue_name}`, no_ack = `#{definition.no_ack}`"
+      end
+
       private
 
-      def create_consumer
+      def create_consumer(channel)
         raise_missing_consumer_definition unless @harmoniser_consumer_definition
 
-        channel = Subscriber.create_channel
+        ch = channel || Subscriber.create_channel
         consumer = Bunny::Consumer.new(
-          channel,
+          ch,
           @harmoniser_consumer_definition.queue_name,
-          @harmoniser_consumer_definition.consumer_tag || channel.generate_consumer_tag,
+          @harmoniser_consumer_definition.consumer_tag || ch.generate_consumer_tag,
           @harmoniser_consumer_definition.no_ack,
           @harmoniser_consumer_definition.exclusive,
           @harmoniser_consumer_definition.arguments
@@ -71,16 +82,20 @@ module Harmoniser
       end
 
       def raise_missing_consumer_definition
-        raise MissingConsumerDefinition, "Please call the harmoniser_subscriber class method at `#{const_get(:HARMONISER_SUBSCRIBER_CLASS)}` with the queue_name that will be used for subscribing"
+        raise MissingConsumerDefinition, "Please call the harmoniser_subscriber class method at `#{name}` with the queue_name that will be used for subscribing"
       end
     end
 
     class << self
       def included(base)
         base.const_set(:HARMONISER_SUBSCRIBER_MUTEX, Mutex.new)
-        base.const_set(:HARMONISER_SUBSCRIBER_CLASS, base)
+        base.private_constant(:HARMONISER_SUBSCRIBER_MUTEX)
+        registry << base
         base.extend(ClassMethods)
-        harmoniser_register_included(base)
+      end
+
+      def registry
+        @registry ||= Registry.new
       end
     end
   end

data/lib/harmoniser/topology.rb

@@ -41,11 +41,12 @@ module Harmoniser
     end
 
     def declare
-      channel = self.class.create_channel
-      declare_exchanges(channel)
-      declare_queues(channel)
-      declare_bindings(channel)
-      Harmoniser.connection.close
+      self.class.create_channel.tap do |ch|
+        declare_exchanges(ch)
+        declare_queues(ch)
+        declare_bindings(ch)
+        ch.close
+      end
     end
 
     private

data/lib/harmoniser/version.rb

@@ -1,3 +1,3 @@
 module Harmoniser
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/harmoniser/work_pool_reporter.rb

@@ -0,0 +1,48 @@
+require "delegate"
+
+module Harmoniser
+  class WorkPoolReporter
+    def initialize(consumers:, logger: Harmoniser.logger)
+      @channels = build_channels(consumers)
+      @logger = logger
+    end
+
+    def to_s
+      "<#{self.class.name}>: #{channels_to_s}"
+    end
+
+    private
+
+    def channels_to_s
+      @channels.map do |(channel, queues)|
+        channel_info(channel, queues.to_a)
+      end
+    end
+
+    def channel_info(channel, queues)
+      work_pool = channel.work_pool
+      "<#{channel.id}>: backlog = `#{work_pool.backlog}`, running? = `#{work_pool.running?}`, queues = `#{queues}`"
+    end
+
+    def build_channels(consumers)
+      initial = Hash.new { |hash, key| hash[key] = Set.new }
+      consumers.each_with_object(initial) do |consumer, acc|
+        acc[DecoratedChannel.new(consumer.channel)] << consumer.queue
+      end
+    end
+
+    class DecoratedChannel < SimpleDelegator
+      def id
+        __getobj__.id
+      end
+
+      def hash
+        id.hash
+      end
+
+      def eql?(other)
+        other.is_a?(DecoratedChannel) && id == other.id
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harmoniser
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Jose Lloret
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-09 00:00:00.000000000 Z
+date: 2024-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '2.23'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.22'
+        version: '2.23'
 description: A declarative approach to communication with RabbitMQ that simplifies
   the integration of publishing and consuming messages.
 email:
@@ -49,15 +49,19 @@ files:
 - lib/harmoniser/connectable.rb
 - lib/harmoniser/connection.rb
 - lib/harmoniser/definition.rb
-- lib/harmoniser/includable.rb
 - lib/harmoniser/launcher.rb
+- lib/harmoniser/launcher/base.rb
+- lib/harmoniser/launcher/bounded.rb
+- lib/harmoniser/launcher/unbounded.rb
 - lib/harmoniser/loggable.rb
 - lib/harmoniser/options.rb
 - lib/harmoniser/parser.rb
 - lib/harmoniser/publisher.rb
 - lib/harmoniser/subscriber.rb
+- lib/harmoniser/subscriber/registry.rb
 - lib/harmoniser/topology.rb
 - lib/harmoniser/version.rb
+- lib/harmoniser/work_pool_reporter.rb
 homepage: https://github.com/jollopre/harmoniser
 licenses:
 - MIT

data/lib/harmoniser/includable.rb

@@ -1,25 +0,0 @@
-module Harmoniser
-  module Includable
-    MUTEX = Mutex.new
-    private_constant :MUTEX
-
-    module ClassMethods
-      def harmoniser_register_included(klass)
-        MUTEX.synchronize do
-          @harmoniser_included ||= Set.new
-          @harmoniser_included << klass
-        end
-      end
-
-      def harmoniser_included
-        @harmoniser_included.to_a
-      end
-    end
-
-    class << self
-      def included(base)
-        base.extend(ClassMethods)
-      end
-    end
-  end
-end