march_hare 3.1.1-java → 4.3.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 910cb519cfde61ec8390a0c56db3121eb8e5675a3c5b19d662db8ad9a3f7a8d7
-  data.tar.gz: 0be92a42c7ea2102c442184d0cc892fb171a83f59a718fc1411514f51b5c4dae
+  metadata.gz: 006ea49a052e4f2995f87e2739eacfd552945f61135ba8b329cd8dcdf36ede45
+  data.tar.gz: 5ef91217f326fb9cca331378adaae5684a4e98d0b70748b4fd04227c95ccfc74
 SHA512:
-  metadata.gz: 2224b9d612f2419772a19cee956a433243b9e76a3807c372cca723591ee338ab9a2dfa9353e7bbe25601337189b9ab5468ffde8217e7142442baee97b66f082c
-  data.tar.gz: f592e103fcb40342e7162cbb9a10808267eeb435b017438ebf9590745684903018ddd1a5aad6d0f80ca4d59b1a85b6b34bfe18c0fe716b2eb0ef2b12843c4d40
+  metadata.gz: 121e50ac297e48dd61a08f6b08a81e85782bf6dfe402d48320f2654daa4f3cfbbfc3a76c69a61114a7add12ccbe771bcfd7115b4c47cba65fb13cc4bebc32b70
+  data.tar.gz: 2fcaa00100551f6d6a3fd4005722e168684598c612279668f5c82e324848156722d69e2b86a3a7f2efb5cbabeae8de19546ea94ddb5bfa0a9167e594bbaabf2d

data/lib/march_hare/channel.rb

@@ -144,6 +144,11 @@ module MarchHare
     alias client session
     alias connection session
 
+    # @return [::Logger] Logger instance from the connection
+    def logger
+      @connection.logger
+    end
+
     # @return [Integer] Channel id
     def channel_number
       @delegate.channel_number
@@ -187,6 +192,8 @@ module MarchHare
 
     # @private
     def automatically_recover(session, java_connection)
+      logger.debug("channel: begin automatic connection recovery")
+
       jch = java_connection.create_channel(id)
 
       self.revive_with(jch)
@@ -247,10 +254,11 @@ module MarchHare
     def recover_exchanges
       @exchanges.values.each do |x|
         begin
+          logger.debug("channel: recover exchange #{x.name}")
           x.recover_from_network_failure
         rescue Exception => e
-          # TODO: logger
-          $stderr.puts "Caught exception when recovering exchange #{x.name}"
+          logger.error("Caught exception when recovering exchange #{x.name}")
+          logger.error(e)
         end
       end
     end
@@ -260,10 +268,11 @@ module MarchHare
     def recover_queues
       @queues.values.each do |q|
         begin
+          logger.debug("channel: recover queue #{q.name}")
           q.recover_from_network_failure
         rescue Exception => e
-          # TODO: logger
-          $stderr.puts "Caught exception when recovering queue #{q.name}"
+          logger.error("Caught exception when recovering queue #{q.name}")
+          logger.error(e)
         end
       end
     end
@@ -273,11 +282,12 @@ module MarchHare
     def recover_consumers
       @consumers.values.each do |c|
         begin
+          logger.debug("channel: recover consumer #{c.consumer_tag}")
           self.unregister_consumer(c.consumer_tag)
           c.recover_from_network_failure
         rescue Exception => e
-          # TODO: logger
-          $stderr.puts "Caught exception when recovering consumer #{c.consumer_tag}"
+          logger.error("Caught exception when recovering consumer #{c.consumer_tag}")
+          logger.error(e)
         end
       end
     end
@@ -924,6 +934,7 @@ module MarchHare
 
     # @private
     def deregister_queue(queue)
+      logger.debug("channel: deregister queue #{queue.name}")
       @queues.delete(queue.name)
     end
 
@@ -934,6 +945,7 @@ module MarchHare
 
     # @private
     def register_queue(queue)
+      logger.debug("channel: register queue #{queue.name}")
       @queues[queue.name] = queue
     end
 
@@ -944,21 +956,25 @@ module MarchHare
 
     # @private
     def deregister_exchange(exchange)
+      logger.debug("channel: deregister exchange #{exchange.name}")
       @exchanges.delete(exchange.name)
     end
 
     # @private
     def register_exchange(exchange)
+      logger.debug("channel: register exchange #{exchange.name}")
       @exchanges[exchange.name] = exchange
     end
 
     # @private
     def register_consumer(consumer_tag, consumer)
+      logger.debug("channel: register consumer #{consumer_tag}")
       @consumers[consumer_tag] = consumer
     end
 
     # @private
     def unregister_consumer(consumer_tag)
+      logger.debug("channel: unregister consumer #{consumer_tag}")
       @consumers.delete(consumer_tag)
     end
 

data/lib/march_hare/exception_handler.rb

@@ -0,0 +1,17 @@
+module MarchHare
+  class ExceptionHandler < com.rabbitmq.client.impl.ForgivingExceptionHandler
+    def initialize(logger)
+      super()
+      @logger = logger
+    end
+
+    def log(msg, error)
+      logger.error(msg)
+      logger.error(error)
+    end
+
+    private
+
+    attr_reader :logger
+  end
+end

data/lib/march_hare/exceptions.rb

@@ -16,6 +16,12 @@ module MarchHare
   class ConnectionRefused < NetworkException
   end
 
+  class ConnectionClosedException < Exception
+    def initialize(message='')
+      super("Connection was explicitly closed and cannot be reopened. Create a new Connection instead. #{message}")
+    end
+  end
+
   class ChannelLevelException < Exception
     attr_reader :channel_close
 
@@ -99,14 +105,14 @@ module MarchHare
     def self.convert(e, unwrap_io_exception = true)
       case e
       when java.net.SocketException then
-        IOError.new
+        IOError.new(e.message)
       when java.io.IOException then
         c = e.cause
 
         if c && unwrap_io_exception
           convert(c, false)
         else
-          IOError.new
+          IOError.new(e.message)
         end
       when com.rabbitmq.client.AlreadyClosedException then
         ChannelAlreadyClosed.new(e.reason)

data/lib/march_hare/exchange.rb

@@ -193,8 +193,8 @@ module MarchHare
 
           @channel.register_exchange(self)
         rescue Exception => e
-          # TODO: use a logger
-          puts "Caught #{e.inspect} while redeclaring and registering exchange #{@name}!"
+          @channel.logger.error("Caught Exception while redeclaring and registering exchange #{@name}!")
+          @channel.logger.error(e)
         end
       end
     end

data/lib/march_hare/queue.rb

@@ -168,7 +168,6 @@ module MarchHare
     #
     # @option opts [Boolean] :manual_ack (false) Will this consumer use manual acknowledgements?
     # @option opts [Boolean] :exclusive (false) Should this consumer be exclusive for this queue?
-    # @option opts [Boolean] :block (false) Should the call block calling thread?
     # @option opts [#call] :on_cancellation Block to execute when this consumer is cancelled remotely (e.g. via the RabbitMQ Management plugin)
     # @option opts [String] :consumer_tag Unique consumer identifier. It is usually recommended to let MarchHare generate it for you.
     # @option opts [Hash] :arguments ({}) Additional (optional) arguments, typically used by RabbitMQ extensions
@@ -233,6 +232,7 @@ module MarchHare
 
     # @private
     def declare!
+      @channel.logger.debug("queue: declare! #{@name}")
       response = if @options[:passive]
                  then @channel.queue_declare_passive(@name)
                  else @channel.queue_declare(@name, @options[:durable], @options[:exclusive], @options[:auto_delete], @options[:arguments])
@@ -258,8 +258,7 @@ module MarchHare
     # @private
     def recover_bindings
       @bindings.each do |b|
-        # TODO: use a logger
-        # puts "Recovering binding #{b.inspect}"
+        @channel.logger.debug("Recovering binding #{b.inspect}")
         self.bind(b[:exchange], b)
       end
     end

data/lib/march_hare/session.rb

@@ -2,13 +2,15 @@
 require "march_hare/shutdown_listener"
 require "set"
 require "march_hare/thread_pools"
+require "march_hare/exception_handler"
 require "java"
+require "logger"
 
 module MarchHare
   java_import com.rabbitmq.client.ConnectionFactory
   java_import com.rabbitmq.client.Connection
   java_import com.rabbitmq.client.BlockedListener
-  java_import com.rabbitmq.client.NullTrustManager
+  java_import com.rabbitmq.client.TrustEverythingTrustManager
   java_import com.rabbitmq.client.MissedHeartbeatException
   java_import com.rabbitmq.client.Address
 
@@ -52,6 +54,9 @@ module MarchHare
     #                                   This will switch port to 5671 by default.
     # @option options [String] :tls_certificate_path Path to a PKCS12 certificate.
     # @option options [java.util.concurrent.ThreadFactory] :thread_factory Thread factory RabbitMQ Java client will use (useful in restricted PaaS platforms such as GAE)
+    # @option options [Logger] :logger The logger.  If missing, one is created using :log_file and :log_level.
+    # @option options [IO, String] :log_file The file or path to use when creating a logger.  Defaults to STDOUT.
+    # @option options [Integer] :log_level The log level to use when creating a logger.  Defaults to LOGGER::WARN
     #
     # @see http://rubymarchhare.info/articles/connecting.html Connecting to RabbitMQ guide
     def self.connect(options = {})
@@ -77,17 +82,16 @@ module MarchHare
       cf.connection_timeout  = connection_timeout_from(options) if include_connection_timeout?(options)
 
       cf.thread_factory      = thread_factory_from(options)    if include_thread_factory?(options)
-      cf.exception_handler   = exception_handler_from(options) if include_exception_handler?(options)
 
       tls = (options[:ssl] || options[:tls])
       case tls
       when true then
         cf.use_ssl_protocol
-        when String then
-        # TODO: logging
-        $stdout.puts "Using TLS/SSL version #{tls}"
-        # Note: `options[:trust_manager] = com.rabbitmq.client.NullTrustManager.new` can be set to disable TLS verification.
-       if (cert_path = tls_certificate_path_from(options)) && (password = tls_certificate_password_from(options))
+      when String then
+        options[:logger].info("Using TLS/SSL version #{tls}") if options[:logger]
+        # Note: `options[:trust_manager] = com.rabbitmq.client.TrustEverythingTrustManager.new`
+        # can be set to effectively disable TLS verification.
+        if (cert_path = tls_certificate_path_from(options)) && (password = tls_certificate_password_from(options))
           ctx = SSLContext.get_instance(tls)
           pwd = password.to_java.to_char_array
           begin
@@ -99,7 +103,7 @@ module MarchHare
             kmf.init(ks, pwd)
 
             if options[:trust_manager]
-              ctx.init(kmf.get_key_managers, [options[:trust_manager]], nil)
+              ctx.init(kmf.get_key_managers, Array(options[:trust_manager]), nil)
             else
               # use the key store as the trust store
               tmf = TrustManagerFactory.get_instance(TrustManagerFactory.getDefaultAlgorithm());
@@ -107,6 +111,7 @@ module MarchHare
               ctx.init(kmf.get_key_managers, tmf.getTrustManagers(), nil)
             end
 
+            cf.set_sasl_config(options[:sasl_config]) if options[:sasl_config]
             cf.use_ssl_protocol(ctx)
           rescue Java::JavaLang::Throwable => e
             message = e.message
@@ -134,11 +139,19 @@ module MarchHare
     # @return [Array<MarchHare::Channel>] Channels opened on this connection
     attr_reader :channels
 
+    # @return [::Logger] Logger instance
+    attr_reader :logger
+
 
     # @private
     def initialize(connection_factory, opts = {})
       @cf               = connection_factory
 
+      log_file                   = opts[:log_file] || STDOUT
+      log_level                  = opts[:log_level] || ENV["MARCH_HARE_LOG_LEVEL"] || Logger::WARN
+      @logger                    = opts.fetch(:logger, init_default_logger(log_file, log_level))
+      @cf.exception_handler      = opts.fetch(:exception_handler, init_default_exception_handler(@logger))
+
       # March Hare uses its own connection recovery implementation and
       # as of Java client 4.x automatic recovery is enabled by
       # default. MK.
@@ -153,7 +166,7 @@ module MarchHare
       # we expect this option to be specified in seconds
       @executor_shutdown_timeout = opts.fetch(:executor_shutdown_timeout, 30.0)
 
-      @addresses        = self.class.adresses_from(opts)
+      @addresses        = self.class.addresses_from(opts)
       @connection       = build_new_connection
       @channels         = JavaConcurrent::ConcurrentHashMap.new
 
@@ -165,6 +178,9 @@ module MarchHare
                                end
       @network_recovery_interval = opts.fetch(:network_recovery_interval, DEFAULT_NETWORK_RECOVERY_INTERVAL)
       @shutdown_hooks            = Array.new
+      @blocked_connection_hooks  = Array.new
+      @connection_recovery_hooks = Array.new
+      @was_explicitly_closed     = false
 
       if @automatically_recover
         self.add_automatic_recovery_hook
@@ -210,8 +226,16 @@ module MarchHare
         ch.close
       end
 
+      @was_explicitly_closed = true
       maybe_shut_down_executor
       @connection.close
+    rescue com.rabbitmq.client.AlreadyClosedException
+      @logger.debug("close: connection already closed")
+    end
+
+    def reopen
+      @was_explicitly_closed = false
+      automatically_recover
     end
 
     # @return [Boolean] true if connection is open, false otherwise
@@ -239,19 +263,45 @@ module MarchHare
 
     # Defines a connection.blocked handler
     def on_blocked(&block)
-      self.add_blocked_listener(BlockBlockedUnblockedListener.for_blocked(block))
+      listener = BlockBlockedUnblockedListener.for_blocked(block)
+      @blocked_connection_hooks << listener
+
+      self.add_blocked_listener(listener)
     end
 
     # Defines a connection.unblocked handler
     def on_unblocked(&block)
-      self.add_blocked_listener(BlockBlockedUnblockedListener.for_unblocked(block))
+      listener = BlockBlockedUnblockedListener.for_unblocked(block)
+      @blocked_connection_hooks << listener
+
+      self.add_blocked_listener(listener)
+    end
+
+    def add_blocked_listener(listener)
+      @connection.add_blocked_listener(listener)
     end
 
     # Clears all callbacks defined with #on_blocked and #on_unblocked.
     def clear_blocked_connection_callbacks
+      @blocked_connection_hooks.clear
+
       @connection.clear_blocked_listeners
     end
 
+    def on_recovery_start(&block)
+      listener = RecoveryListener.for_start(block)
+      @connection_recovery_hooks << listener
+    end
+
+    def on_recovery(&block)
+      listener = RecoveryListener.for_finish(block)
+      @connection_recovery_hooks << listener
+    end
+
+    # Clears all callbacks defined with #on_recovery_started and #on_recovery
+    def clear_connection_recovery_callbacks
+      @connection_recovery_hooks.clear
+    end
 
     # @private
     def add_automatic_recovery_hook
@@ -277,6 +327,11 @@ module MarchHare
     # Begins automatic connection recovery (typically only used internally
     # to recover from network failures)
     def automatically_recover
+      raise ConnectionClosedException if @was_explicitly_closed
+      @logger.debug("session: begin automatic connection recovery #{Thread.current.inspect}")
+
+      fire_recovery_start_hooks
+
       ms = @network_recovery_interval * 1000
       # recovering immediately makes little sense. Wait a bit first. MK.
       java.lang.Thread.sleep(ms)
@@ -285,6 +340,7 @@ module MarchHare
         reconnecting_on_network_failures(ms) { build_new_connection }
       end
       self.recover_shutdown_hooks(new_connection)
+      self.recover_connection_block_hooks(new_connection)
 
       # sorting channels by id means that the cases like the following:
       #
@@ -302,21 +358,33 @@ module MarchHare
         begin
           ch.automatically_recover(self, new_connection)
         rescue Exception, java.io.IOException => e
-          # TODO: logging
-          $stderr.puts e
+          @logger.error(e)
         end
       end
 
       @connection = new_connection
+
+      fire_recovery_hooks
+
+      @connection
     end
 
     # @private
     def recover_shutdown_hooks(connection)
+      @logger.debug("session: recover_shutdown_hooks")
       @shutdown_hooks.each do |sh|
         connection.add_shutdown_listener(sh)
       end
     end
 
+    # @private
+    def recover_connection_block_hooks(connection)
+      @logger.debug("session: recover_connection_block_hooks")
+      @blocked_connection_hooks.each do |listener|
+        connection.add_blocked_listener(listener)
+      end
+    end
+
     # Flushes the socket used by this connection.
     def flush
       @connection.flush
@@ -401,7 +469,7 @@ module MarchHare
     end
 
     # @private
-    def self.adresses_from(options)
+    def self.addresses_from(options)
       options[:addresses] || options[:hosts] || [address_with_port_from(options)]
     end
 
@@ -485,13 +553,16 @@ module MarchHare
     end
 
     # @private
-    def self.exception_handler_from(opts)
-      opts[:exception_handler]
-    end
-
-    # @private
-    def self.include_exception_handler?(opts)
-      !!opts[:exception_handler]
+    def endpoint_info_from(cf)
+      if @uses_uri
+        uri_without_credentials = URI.parse(@uri).tap do |u|
+          u.password = "REDACTED"
+          u.to_s
+        end
+        "Target URI: #{uri_without_credentials}"
+      else
+        "Target host list: #{@addresses.join(', ')}, target virtual host: #{cf.virtual_host}, username: #{cf.username}"
+      end
     end
 
     # Executes a block, catching Java exceptions RabbitMQ Java client throws and
@@ -501,28 +572,30 @@ module MarchHare
     def converting_rjc_exceptions_to_ruby(&block)
       begin
         block.call
-      rescue java.net.ConnectException => e
-        raise ConnectionRefused.new("Connection to #{@cf.host}:#{@cf.port} refused")
-      rescue java.net.NoRouteToHostException => e
-        raise ConnectionRefused.new("Connection to #{@cf.host}:#{@cf.port} failed: no route to host")
-      rescue java.net.UnknownHostException => e
-        raise ConnectionRefused.new("Connection to #{@cf.host}:#{@cf.port} refused: host unknown")
-      rescue java.net.SocketException => e
-        raise ConnectionRefused.new("Connection to #{@cf.host}:#{@cf.port} failed")
-      rescue java.util.concurrent.TimeoutException => e
-        raise ConnectionRefused.new("Connection to #{@cf.host}:#{@cf.port} failed: timeout")
-      rescue com.rabbitmq.client.AuthenticationFailureException => e
+      rescue java.net.ConnectException
+        raise ConnectionRefused.new("Connection was refused. #{endpoint_info_from(@cf)}")
+      rescue java.net.NoRouteToHostException
+        raise ConnectionRefused.new("Connection failed: no route to target host. #{endpoint_info_from(@cf)}")
+      rescue java.net.UnknownHostException
+        raise ConnectionRefused.new("Connection refused: target host unknown (cannot be resolved). #{endpoint_info_from(@cf)}")
+      rescue java.net.SocketException
+        raise ConnectionRefused.new("Connection failed due to a socket exception. #{endpoint_info_from(@cf)}")
+      rescue java.util.concurrent.TimeoutException
+        raise ConnectionRefused.new("Connection timed out. #{endpoint_info_from(@cf)}")
+      rescue com.rabbitmq.client.AuthenticationFailureException
         raise AuthenticationFailureError.new(@cf.username, @cf.virtual_host, @cf.password.bytesize)
-      rescue com.rabbitmq.client.PossibleAuthenticationFailureException => e
+      rescue com.rabbitmq.client.PossibleAuthenticationFailureException
         raise PossibleAuthenticationFailureError.new(@cf.username, @cf.virtual_host, @cf.password.bytesize)
       end
     end
 
     # @private
     def reconnecting_on_network_failures(interval_in_ms, &fn)
+      @logger.debug("session: reconnecting_on_network_failures")
       begin
+        return if @was_explicitly_closed
         fn.call
-      rescue IOError, MarchHare::ConnectionRefused, java.io.IOException, java.util.concurrent.TimeoutException => e
+      rescue IOError, MarchHare::ConnectionRefused, java.io.IOException, java.util.concurrent.TimeoutException
         java.lang.Thread.sleep(interval_in_ms)
 
         retry
@@ -531,7 +604,13 @@ module MarchHare
 
     # @private
     def build_new_connection
-      @uses_uri ? new_uri_connection_impl(@uri) : new_connection_impl(@addresses)
+      if @uses_uri
+        @logger.debug("session: instantiating a new connection using a URI")
+        new_uri_connection_impl(@uri)
+      else
+        @logger.debug("session: instantiating a new connection using a set of addresses: #{@addresses.join(',')}")
+        new_connection_impl(@addresses)
+      end
     end
 
     # @private
@@ -608,6 +687,48 @@ module MarchHare
       self.class.tls_certificate_password_from(opts)
     end
 
+    # @private
+    def init_default_exception_handler(logger)
+      ExceptionHandler.new(logger)
+    end
+
+    # @private
+    def init_default_logger(logfile, level)
+      lgr = ::Logger.new(logfile)
+      lgr.level    = normalize_log_level(level)
+      lgr.progname = self.to_s
+      lgr
+    end
+
+    # @private
+    def normalize_log_level(level)
+      case level
+      when :debug, Logger::DEBUG, "debug" then Logger::DEBUG
+      when :info,  Logger::INFO,  "info"  then Logger::INFO
+      when :warn,  Logger::WARN,  "warn"  then Logger::WARN
+      when :error, Logger::ERROR, "error" then Logger::ERROR
+      when :fatal, Logger::FATAL, "fatal" then Logger::FATAL
+      else
+        Logger::WARN
+      end
+    end
+
+    # @private
+    def fire_recovery_start_hooks
+      @logger.debug "Have #{@connection_recovery_hooks.size} recovery start hooks to run"
+      @connection_recovery_hooks.each do |recovery_listener|
+        recovery_listener.handle_recovery_started(self)
+      end
+    end
+
+    # @private
+    def fire_recovery_hooks
+      @logger.debug "Have #{@connection_recovery_hooks.size} recovery completion hooks to run"
+      @connection_recovery_hooks.each do |recovery_listener|
+        recovery_listener.handle_recovery(self)
+      end
+    end
+
     # Ruby blocks-based BlockedListener that handles
     # connection.blocked and connection.unblocked.
     # @private
@@ -646,5 +767,32 @@ module MarchHare
       end
     end
 
+    # Ruby blocks-based RecoveryListener that handles
+    # connection recovery_started and recovery
+    class RecoveryListener
+      NOOP_FN1 = Proc.new { |_| }
+      private_constant :NOOP_FN1
+
+      def self.for_start(block)
+        new(block, NOOP_FN1)
+      end
+
+      def self.for_finish(block)
+        new(NOOP_FN1, block)
+      end
+
+      def initialize(before_recovery, after_recovery)
+        @recovery_start_hook = before_recovery
+        @recovery_hook = after_recovery
+      end
+
+      def handle_recovery_started(recoverable)
+        @recovery_start_hook.call(recoverable)
+      end
+
+      def handle_recovery(recoverable)
+        @recovery_hook.call(recoverable)
+      end
+    end
   end
 end

data/lib/march_hare/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module MarchHare
-  VERSION = "3.1.1"
+  VERSION = "4.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: march_hare
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 4.3.0
 platform: java
 authors:
 - Theo Hultberg
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-03-01 00:00:00.000000000 Z
+date: 2020-09-30 00:00:00.000000000 Z
 dependencies: []
 description: RabbitMQ client for JRuby built around the official RabbitMQ Java client
 email:
@@ -27,6 +27,7 @@ files:
 - lib/march_hare/consumers.rb
 - lib/march_hare/consumers/base.rb
 - lib/march_hare/consumers/blocking.rb
+- lib/march_hare/exception_handler.rb
 - lib/march_hare/exceptions.rb
 - lib/march_hare/exchange.rb
 - lib/march_hare/juc.rb
@@ -55,8 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: march_hare
-rubygems_version: 2.6.13
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: RabbitMQ client for JRuby built around the official RabbitMQ Java client