harmoniser 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71c030f6ce0d93a7e9bb55a88c3d3cad300f4ab05809944e08442d2bca43cafb
-  data.tar.gz: da8f3f99f2a9846b35b10a8e986f28e53087a81d2a1a6fd149778e3d82222de1
+  metadata.gz: 1d5d92e016161196555365ed7937a455d1e4765c955afa173f59ebde8323a51d
+  data.tar.gz: 735e2b70476779ce10ab83ad2382d70b9ac95598dbdf7d251e90c18ffd025203
 SHA512:
-  metadata.gz: 0774eab4d7682a72e880e764acdb55e05e6e9d10048bbdb3e74ed010293d6dc8c416d9de9d73c3a6752e3c9d1ace45d70dc212a3cc01fb2a33b77d4a494d56d2
-  data.tar.gz: 2eebe48b9779d08b0e516d13daa9f94b358f851de3999d4ca0ee600cab89ae48396bdd351ff583bc9be566e44f113f2fe14c0ef59ce3378d5fe1f35d88802c83
+  metadata.gz: b5e54c2077c6fe92dfb649e3ae6d1407b97db2ef8226cf7ef9baad6d700dd11bb24246388fe883de4eb0e24f989cafe7c88c7d8e4c645bb8f7a44edca0719d34
+  data.tar.gz: 77c5675b22841464d6381e9285b0e1485ab76f0178dd257ec0b8f8463d35b7e5f55a55ab3f9d5333a425bc4de4efac833810a9a2069bb729bb6bdc3b5fe65c89

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.15.0] - 2026-03-03
+
+### Changed
+- Close all channels tracked by `Harmoniser::Connection` before closing the connection. This ensures consumers are cancelled and channels are closed while the connection is still open, preventing `Bunny::ConnectionClosedError` that could occur when a consumer acknowledges a message concurrently during shutdown
+- Introduce `Harmoniser::Channel#close` and `Harmoniser::Channel#open?` to expose channel lifecycle as part of the public interface
+- Inject logger into `Harmoniser::Channel` for consistent logger usage across the codebase
+
+## [0.14.0] - 2025-11-25
+
+### Added
+- Introduce Mock functionality for testing without RabbitMQ dependency. Usage:
+
+```ruby
+require "harmoniser/mock"
+Harmoniser::Mock.mock!
+
+# Your Publisher/Subscriber code works the same but without RabbitMQ
+class TestPublisher
+  include Harmoniser::Publisher
+  harmoniser_publisher exchange_name: "my_exchange"
+end
+
+exchange = TestPublisher.publish("message", routing_key: "test")
+published_messages = exchange.published_messages # Access captured messages
+```
+
+- Add examples for mock publishing and topology under `examples/` folder
+- Create Channel wrapper (`Harmoniser::Channel`) to isolate RabbitMQ dependencies
+
+### Changed
+- Remove explicit dependencies to Bunny classes except for Consumer, enabling better RabbitMQ isolation through a single, well-defined interface
+- Use Channel wrapper everywhere except for subscriptions (which still require actual Channel instance for Bunny::Consumer)
+
+
 ## [0.13.0] - 2025-05-19
 
 ### Added

data/lib/harmoniser/channel.rb

@@ -0,0 +1,75 @@
+require "forwardable"
+
+module Harmoniser
+  class Channel
+    extend Forwardable
+
+    def_delegators :@bunny_channel,
+      :exchange,
+      :open?,
+      :queue,
+      :queue_bind
+
+    attr_reader :bunny_channel
+
+    def initialize(bunny_channel, logger: Harmoniser.logger)
+      @bunny_channel = bunny_channel
+      @logger = logger
+      after_initialize
+    end
+
+    def close
+      @bunny_channel.close
+    rescue => e
+      @logger.warn("Failed to close channel: exception = `#{e.detailed_message}`")
+      false
+    end
+
+    private
+
+    def after_initialize
+      bunny_channel.cancel_consumers_before_closing!
+      attach_callbacks
+    end
+
+    def attach_callbacks
+      bunny_channel.on_error(&method(:on_error_callback).to_proc)
+      bunny_channel.on_uncaught_exception(&method(:on_uncaught_exception_callback).to_proc)
+    end
+
+    def on_error_callback(channel, amq_method)
+      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(", ")
+      @logger.warn("Default on_error handler executed for channel: #{stringified_attributes}")
+      maybe_kill_process(amq_method)
+    end
+
+    def on_uncaught_exception_callback(error, consumer)
+      handle_error(error, {description: "Uncaught exception from consumer", arguments: consumer.arguments, channel_id: consumer.channel.id, consumer_tag: consumer.consumer_tag, exclusive: consumer.exclusive, no_ack: consumer.no_ack, 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
+
+    def handle_error(exception, ctx)
+      Harmoniser.configuration.handle_error(exception, ctx)
+    end
+  end
+end

data/lib/harmoniser/connectable.rb

@@ -1,4 +1,5 @@
 require "harmoniser/connection"
+require "harmoniser/channel"
 
 module Harmoniser
   module Connectable
@@ -20,52 +21,8 @@ module Harmoniser
       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|
-            channel.cancel_consumers_before_closing!
-            attach_callbacks(channel)
-          end
-      end
-
-      private
-
-      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)
-        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.warn("Default on_error handler executed for channel: #{stringified_attributes}")
-        maybe_kill_process(amq_method)
-      end
-
-      def on_uncaught_exception(error, consumer)
-        handle_error(error, {description: "Uncaught exception from consumer", arguments: consumer.arguments, channel_id: consumer.channel.id, consumer_tag: consumer.consumer_tag, exclusive: consumer.exclusive, no_ack: consumer.no_ack, 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
-
-      def handle_error(exception, ctx)
-        Harmoniser.configuration.handle_error(exception, ctx)
+          .yield_self { |bunny_channel| Channel.new(bunny_channel) }
+          .tap { |channel| connection.register_channel(channel) }
       end
     end
 

data/lib/harmoniser/connection.rb

@@ -25,11 +25,16 @@ module Harmoniser
     def initialize(opts, error_handler: ErrorHandler.default, logger: Harmoniser.logger)
       @error_handler = error_handler
       @logger = logger
+      @channels = []
       @bunny = Bunny.new(maybe_dynamic_opts(opts)).tap do |bunny|
         attach_callbacks(bunny)
       end
     end
 
+    def register_channel(channel)
+      @channels << channel
+    end
+
     def to_s
       "<#{self.class.name}>:#{object_id} #{user}@#{host}:#{port}, connection_name = `#{connection_name}`, vhost = `#{vhost}`"
     end
@@ -54,6 +59,7 @@ module Harmoniser
 
     def close
       @logger.info("Connection will be closed: connection = `#{self}`")
+      close_channels
       @bunny.close.tap do
         @logger.info("Connection closed: connection = `#{self}`")
       end
@@ -64,6 +70,10 @@ module Harmoniser
 
     private
 
+    def close_channels
+      @channels.each { |channel| channel.close if channel.open? }
+    end
+
     def attach_callbacks(bunny)
       bunny.on_blocked do |blocked|
         @logger.warn("Connection blocked: connection = `#{self}`, reason = `#{blocked.reason}`")

data/lib/harmoniser/launcher/bounded.rb

@@ -12,7 +12,7 @@ module Harmoniser
       end
 
       def channel
-        @channel ||= Subscriber.create_channel(consumer_pool_size: @configuration.concurrency, consumer_pool_shutdown_timeout: @configuration.timeout)
+        @channel ||= Subscriber.create_channel(consumer_pool_size: @configuration.concurrency, consumer_pool_shutdown_timeout: @configuration.timeout).bunny_channel
       end
     end
   end

data/lib/harmoniser/mock/channel.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Harmoniser
+  module Mock
+    class Channel
+      class MockExchange
+        attr_reader :name, :type, :opts
+
+        def initialize(name, opts = {})
+          @name = name
+          @type = opts[:type]
+          @opts = opts.except(:type)
+          @published_messages = []
+          @return_handler = nil
+        end
+
+        def publish(payload, opts = {})
+          @published_messages << {payload: payload, opts: opts}
+          true
+        end
+
+        def on_return(&block)
+          @return_handler = block
+          self
+        end
+
+        def published_messages
+          @published_messages.dup
+        end
+
+        def reset!
+          @published_messages.clear
+          @return_handler = nil
+        end
+      end
+
+      class MockQueue
+        attr_reader :name, :opts
+
+        def initialize(name, opts = {})
+          @name = name
+          @opts = opts
+        end
+      end
+
+      def initialize
+        @exchanges = {}
+        @queues = {}
+        @bindings = []
+      end
+
+      def exchange(name, opts = {})
+        @exchanges[name] ||= MockExchange.new(name, opts)
+      end
+
+      def queue(name, opts = {})
+        @queues[name] ||= MockQueue.new(name, opts)
+      end
+
+      def queue_bind(destination_name, exchange_name, opts = {})
+        @bindings << {
+          destination_name: destination_name,
+          exchange_name: exchange_name,
+          opts: opts
+        }
+        true
+      end
+
+      def exchanges
+        @exchanges.dup
+      end
+
+      def queues
+        @queues.dup
+      end
+
+      def bindings
+        @bindings.dup
+      end
+
+      def reset!
+        @exchanges.clear
+        @queues.clear
+        @bindings.clear
+      end
+
+      def bunny_channel
+        raise "Cannot access bunny_channel in mock mode. Mock mode is intended for testing only and cannot be used when running Harmoniser as a server process."
+      end
+    end
+  end
+end

data/lib/harmoniser/mock/connection.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "harmoniser/mock/channel"
+
+module Harmoniser
+  module Mock
+    class Connection
+      def initialize(opts = {}, error_handler: nil, logger: nil)
+        @opts = opts
+        @error_handler = error_handler
+        @logger = logger
+        @open = false
+      end
+
+      def create_channel(id = nil, consumer_pool_size = 1, consumer_pool_ack = false, consumer_pool_shutdown_timeout = 60)
+        Channel.new
+      end
+
+      def open?
+        @open
+      end
+
+      def recovering_from_network_failure?
+        false
+      end
+
+      def start
+        @open = true
+        self
+      end
+
+      def close
+        @open = false
+        true
+      end
+    end
+  end
+end

data/lib/harmoniser/mock.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "harmoniser/mock/connection"
+require "harmoniser/mock/channel"
+require "harmoniser/connectable"
+
+module Harmoniser
+  module Mock
+    @mocked = false
+    @prepended = false
+
+    class << self
+      def mock!
+        unless @prepended
+          @prepended = true
+          Harmoniser::Connectable::ClassMethods.prepend(MockConnectableMethods)
+        end
+        @mocked = true
+      end
+
+      def disable!
+        @mocked = false
+      end
+
+      def mocked?
+        @mocked
+      end
+
+      def disabled?
+        !@mocked
+      end
+    end
+
+    module MockConnectableMethods
+      def connection(configuration = Harmoniser.configuration)
+        return super unless Harmoniser::Mock.mocked?
+
+        Harmoniser::Connectable::MUTEX.synchronize do
+          @mock_connection ||= Harmoniser::Mock::Connection.new(configuration.connection_opts, error_handler: configuration.error_handler)
+          @mock_connection.start unless @mock_connection.open? || @mock_connection.recovering_from_network_failure?
+          @mock_connection
+        end
+      end
+
+      def connection?
+        return super unless Harmoniser::Mock.mocked?
+        !!defined?(@mock_connection)
+      end
+
+      def create_channel(consumer_pool_size: 1, consumer_pool_shutdown_timeout: 60)
+        return super unless Harmoniser::Mock.mocked?
+        connection.create_channel(nil, consumer_pool_size, false, consumer_pool_shutdown_timeout)
+      end
+    end
+  end
+end

data/lib/harmoniser/publisher.rb

@@ -33,12 +33,12 @@ module Harmoniser
       end
 
       def create_exchange
-        exchange = Bunny::Exchange.new(
-          Publisher.create_channel,
-          @harmoniser_exchange_definition.type,
-          @harmoniser_exchange_definition.name,
-          @harmoniser_exchange_definition.opts
-        )
+        exchange = Publisher
+          .create_channel
+          .exchange(
+            @harmoniser_exchange_definition.name,
+            {type: @harmoniser_exchange_definition.type}.merge(@harmoniser_exchange_definition.opts)
+          )
         handle_return(exchange)
         exchange
       end

data/lib/harmoniser/subscriber.rb

@@ -41,7 +41,7 @@ module Harmoniser
       def create_consumer(channel)
         raise_missing_consumer_definition unless @harmoniser_consumer_definition
 
-        ch = channel || Subscriber.create_channel
+        ch = channel || Subscriber.create_channel.bunny_channel
         consumer = Bunny::Consumer.new(
           ch,
           @harmoniser_consumer_definition.queue_name,

data/lib/harmoniser/topology.rb

@@ -5,7 +5,7 @@ module Harmoniser
   class Topology
     include Connectable
 
-    attr_reader :bindings, :exchanges, :queues
+    attr_reader :bindings, :exchanges, :queues, :declared_channel
 
     def initialize
       @bindings = Set.new
@@ -41,25 +41,26 @@ module Harmoniser
     end
 
     def declare
-      self.class.create_channel.tap do |ch|
+      @declared_channel = self.class.create_channel.tap do |ch|
         declare_exchanges(ch)
         declare_queues(ch)
         declare_bindings(ch)
-        ch.connection.close
       end
+      self.class.connection.close
+      self
     end
 
     private
 
     def declare_exchanges(channel)
       exchanges.each do |exchange|
-        Bunny::Exchange.new(channel, exchange.type, exchange.name, exchange.opts)
+        channel.exchange(exchange.name, {type: exchange.type}.merge(exchange.opts))
       end
     end
 
     def declare_queues(channel)
       queues.each do |queue|
-        Bunny::Queue.new(channel, queue.name, queue.opts)
+        channel.queue(queue.name, queue.opts)
       end
     end
 

data/lib/harmoniser/version.rb

@@ -1,3 +1,3 @@
 module Harmoniser
-  VERSION = "0.13.0"
+  VERSION = "0.15.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: harmoniser
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Jose Lloret
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-19 00:00:00.000000000 Z
+date: 2026-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -42,6 +42,7 @@ files:
 - bin/setup
 - harmoniser.gemspec
 - lib/harmoniser.rb
+- lib/harmoniser/channel.rb
 - lib/harmoniser/cli.rb
 - lib/harmoniser/configurable.rb
 - lib/harmoniser/configuration.rb
@@ -54,6 +55,9 @@ files:
 - lib/harmoniser/launcher/bounded.rb
 - lib/harmoniser/launcher/unbounded.rb
 - lib/harmoniser/loggable.rb
+- lib/harmoniser/mock.rb
+- lib/harmoniser/mock/channel.rb
+- lib/harmoniser/mock/connection.rb
 - lib/harmoniser/options.rb
 - lib/harmoniser/parser.rb
 - lib/harmoniser/publisher.rb