hot_bunnies 2.0.0.pre9-java → 2.0.0.pre10-java

data/lib/hot_bunnies/channel.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 require "hot_bunnies/shutdown_listener"
+require "hot_bunnies/juc"
 
 module HotBunnies
   # ## Channels in RabbitMQ
@@ -121,10 +122,14 @@ module HotBunnies
       @connection = session
       @delegate   = delegate
 
-      # we keep track of consumers to gracefully shut down their
+      @exchanges      = ConcurrentHashMap.new
+      @queues         = ConcurrentHashMap.new
+      # we keep track of consumers in part to gracefully shut down their
       # executors when the channel is closed. This frees library users
       # from having to worry about this. MK.
-      @consumers  = ConcurrentHashMap.new
+      @consumers      = ConcurrentHashMap.new
+      @shutdown_hooks = ConcurrentSkipListSet.new
+      @recoveries_counter = JavaConcurrent::AtomicInteger.new(0)
 
       on_shutdown do |ch, cause|
         ch.gracefully_shut_down_consumers
@@ -180,11 +185,84 @@ module HotBunnies
 
     def on_shutdown(&block)
       sh = ShutdownListener.new(self, &block)
-      @connection.add_shutdown_listener(sh)
+
+      @shutdown_hooks << sh
+      @delegate.add_shutdown_listener(sh)
 
       sh
     end
 
+    # @private
+    def automatically_recover(session, java_connection)
+      jch = java_connection.create_channel(id)
+
+      self.revive_with(jch)
+      self.recover_shutdown_hooks
+
+      self.recover_prefetch_setting
+      self.recover_exchanges
+      # this includes recovering bindings
+      self.recover_queues
+      self.recover_consumers
+      self.increment_recoveries_counter
+    end
+
+    # @private
+    def revive_with(java_ch)
+      @delegate = java_ch
+    end
+
+    # @private
+    def recover_shutdown_hooks
+      @shutdown_hooks.each do |sh|
+        @delegate.add_shutdown_listener(sh)
+      end
+    end
+
+    # Recovers basic.qos setting. Used by the Automatic Network Failure
+    # Recovery feature.
+    #
+    # @api plugin
+    def recover_prefetch_setting
+      basic_qos(@prefetch_count) if @prefetch_count
+    end
+
+    # Recovers exchanges. Used by the Automatic Network Failure
+    # Recovery feature.
+    #
+    # @api plugin
+    def recover_exchanges
+      @exchanges.values.each do |x|
+        x.recover_from_network_failure
+      end
+    end
+
+    # Recovers queues and bindings. Used by the Automatic Network Failure
+    # Recovery feature.
+    #
+    # @api private
+    def recover_queues
+      @queues.values.each do |q|
+        q.recover_from_network_failure
+      end
+    end
+
+    # Recovers consumers. Used by the Automatic Network Failure
+    # Recovery feature.
+    #
+    # @api private
+    def recover_consumers
+      @consumers.values.each do |c|
+        self.unregister_consumer(c)
+        c.recover_from_network_failure
+      end
+    end
+
+    # @private
+    def increment_recoveries_counter
+      @recoveries_counter.increment
+    end
+
     # @group Exchanges
 
     # Declares a headers exchange or looks it up in the cache of previously
@@ -202,9 +280,11 @@ module HotBunnies
     # @see http://hotbunnies.info/articles/exchanges.html Exchanges and Publishing guide
     # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     def exchange(name, options={})
-      Exchange.new(self, name, options).tap do |x|
+      dx = Exchange.new(self, name, options).tap do |x|
         x.declare!
       end
+
+      self.register_exchange(dx)
     end
 
     # Declares a fanout exchange or looks it up in the cache of previously
@@ -222,9 +302,11 @@ module HotBunnies
     # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def fanout(name, opts = {})
-      Exchange.new(self, name, opts.merge(:type => "fanout")).tap do |x|
+      dx = Exchange.new(self, name, opts.merge(:type => "fanout")).tap do |x|
         x.declare!
       end
+
+      self.register_exchange(dx)
     end
 
     # Declares a direct exchange or looks it up in the cache of previously
@@ -242,9 +324,11 @@ module HotBunnies
     # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def direct(name, opts = {})
-      Exchange.new(self, name, opts.merge(:type => "direct")).tap do |x|
+      dx = Exchange.new(self, name, opts.merge(:type => "direct")).tap do |x|
         x.declare!
       end
+
+      self.register_exchange(dx)
     end
 
     # Declares a topic exchange or looks it up in the cache of previously
@@ -262,9 +346,11 @@ module HotBunnies
     # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def topic(name, opts = {})
-      Exchange.new(self, name, opts.merge(:type => "topic")).tap do |x|
+      dx = Exchange.new(self, name, opts.merge(:type => "topic")).tap do |x|
         x.declare!
       end
+
+      self.register_exchange(dx)
     end
 
     # Declares a headers exchange or looks it up in the cache of previously
@@ -282,9 +368,11 @@ module HotBunnies
     # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions to AMQP 0.9.1 guide
     # @api public
     def headers(name, opts = {})
-      Exchange.new(self, name, opts.merge(:type => "headers")).tap do |x|
+      dx = Exchange.new(self, name, opts.merge(:type => "headers")).tap do |x|
         x.declare!
       end
+
+      self.register_exchange(dx)
     end
 
     # Provides access to the default exchange
@@ -330,9 +418,11 @@ module HotBunnies
     # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions guide
     # @api public
     def queue(name, options={})
-      Queue.new(self, name, options).tap do |q|
+      dq = Queue.new(self, name, options).tap do |q|
         q.declare!
       end
+
+      self.register_queue(dq)
     end
 
     # Declares a queue using queue.declare AMQP 0.9.1 method.
@@ -477,15 +567,22 @@ module HotBunnies
     end
 
     def basic_consume(queue, auto_ack, consumer)
-      converting_rjc_exceptions_to_ruby do
+      consumer.auto_ack = auto_ack
+      tag = converting_rjc_exceptions_to_ruby do
         @delegate.basic_consume(queue, auto_ack, consumer)
       end
+      self.register_consumer(tag, consumer)
+
+      tag
     end
 
     def basic_qos(prefetch_count)
-      converting_rjc_exceptions_to_ruby do
+      r = converting_rjc_exceptions_to_ruby do
         @delegate.basic_qos(prefetch_count)
       end
+      @prefetch_count = prefetch_count
+
+      r
     end
 
     def qos(options={})
@@ -726,6 +823,36 @@ module HotBunnies
       end
     end
 
+    # @private
+    def deregister_queue(queue)
+      @queues.delete(queue.name)
+    end
+
+    # @private
+    def deregister_queue_named(name)
+      @queues.delete(name)
+    end
+
+    # @private
+    def register_queue(queue)
+      @queues[queue.name] = queue
+    end
+
+    # @private
+    def find_queue(name)
+      @queues[name]
+    end
+
+    # @private
+    def deregister_exchange(exchange)
+      @exchanges.delete(exchange.name)
+    end
+
+    # @private
+    def register_exchange(exchange)
+      @exchanges[exchange.name] = exchange
+    end
+
     # @private
     def register_consumer(consumer_tag, consumer)
       @consumers[consumer_tag] = consumer

data/lib/hot_bunnies/consumers/base.rb

@@ -3,10 +3,13 @@ module HotBunnies
 
   class BaseConsumer < DefaultConsumer
     attr_accessor :consumer_tag
+    attr_accessor :auto_ack
 
-    def initialize(channel)
+    def initialize(channel, queue)
       super(channel)
       @channel    = channel
+      @queue      = queue
+      @auto_ack   = true
 
       @cancelling = JavaConcurrent::AtomicBoolean.new
       @cancelled  = JavaConcurrent::AtomicBoolean.new
@@ -14,8 +17,8 @@ module HotBunnies
       @terminated = JavaConcurrent::AtomicBoolean.new
     end
 
-    def handleDelivery(consumer_tag, envelope, properties, body)
-      body    = String.from_java_bytes(body)
+    def handleDelivery(consumer_tag, envelope, properties, bytes)
+      body    = String.from_java_bytes(bytes)
       headers = Headers.new(channel, consumer_tag, envelope, properties)
 
       deliver(headers, body)
@@ -68,5 +71,15 @@ module HotBunnies
     def terminated?
       @terminated.get
     end
+
+    # @private
+    def recover_from_network_failure
+      @consumer_tag = @channel.basic_consume(@queue.name, @auto_ack, self)
+
+      @terminated.set(false)
+      @cancelled.set(false)
+
+      @consumer_tag
+    end
   end
 end

data/lib/hot_bunnies/consumers/blocking.rb

@@ -6,8 +6,8 @@ module HotBunnies
 
     POISON = :__poison__
 
-    def initialize(channel, buffer_size, opts, callback)
-      super(channel, callback)
+    def initialize(channel, queue, buffer_size, opts, callback)
+      super(channel, queue, callback)
       if buffer_size
         @internal_queue = ArrayBlockingQueue.new(buffer_size)
       else

data/lib/hot_bunnies/consumers/non_blocking.rb

@@ -2,10 +2,10 @@ require "hot_bunnies/consumers/base"
 
 module HotBunnies
   class CallbackConsumer < BaseConsumer
-    def initialize(channel, callback)
+    def initialize(channel, queue, callback)
       raise ArgumentError, "callback must not be nil!" if callback.nil?
 
-      super(channel)
+      super(channel, queue)
       @callback = callback
       @callback_arity = @callback.arity
     end
@@ -20,11 +20,20 @@ module HotBunnies
   end
 
   class AsyncCallbackConsumer < CallbackConsumer
-    def initialize(channel, opts, callback, executor)
-      super(channel, callback)
-      @executor = executor
-      @executor_submit = executor.java_method(:submit, [JavaConcurrent::Runnable.java_class])
-      @opts = opts
+    def initialize(channel, queue, opts, callback)
+      super(channel, queue, callback)
+
+      # during connection recovery, the executor may be shut down, e.g. due to
+      # an exception. So we need a way to create a duplicate. Unfortunately, since
+      # the executor can be passed as an argument, we cannot know how it was
+      # instantiated. Instead we require a lambda to produce instance of an executor
+      # as a workaround. MK.
+      @executor_factory = opts.fetch(:executor_factory, Proc.new {
+        JavaConcurrent::Executors.new_single_thread_executor
+      })
+      @executor         = opts.fetch(:executor, @executor_factory.call)
+      @executor_submit  = @executor.java_method(:submit, [JavaConcurrent::Runnable.java_class])
+      @opts             = opts
     end
 
     def deliver(headers, message)
@@ -32,8 +41,9 @@ module HotBunnies
         @executor_submit.call do
           begin
             callback(headers, message)
-          rescue Exception => e
-            $stderr.puts "Unhandled exception in consumer #{@consumer_tag}: #{e.message}"
+          rescue Exception, java.lang.Throwable => e
+            # TODO: logging
+            $stderr.puts "Unhandled exception in consumer #{@consumer_tag}: #{e}"
           end
         end
       end
@@ -69,5 +79,15 @@ module HotBunnies
     end
     alias maybe_shut_down_executor gracefully_shut_down
     alias gracefully_shutdown      gracefully_shut_down
+
+
+    # @private
+    def recover_from_network_failure
+      # ensure we have a functioning executor. MK.
+      @executor        = @executor_factory.call
+      @executor_submit = @executor.java_method(:submit, [JavaConcurrent::Runnable.java_class])
+
+      super
+    end
   end
 end

data/lib/hot_bunnies/exchange.rb

@@ -52,5 +52,11 @@ module HotBunnies
         end
       end
     end
+
+    # @private
+    def recover_from_network_failure
+      # puts "Recovering exchange #{@name} from network failure"
+      declare! unless predefined?
+    end
   end
 end

data/lib/hot_bunnies/juc.rb

@@ -7,4 +7,5 @@ module JavaConcurrent
   java_import 'java.util.concurrent.ArrayBlockingQueue'
   java_import 'java.util.concurrent.TimeUnit'
   java_import 'java.util.concurrent.atomic.AtomicBoolean'
+  java_import 'java.util.concurrent.atomic.AtomicInteger'
 end

data/lib/hot_bunnies/queue.rb

@@ -3,33 +3,144 @@
 require "hot_bunnies/juc"
 require "hot_bunnies/metadata"
 require "hot_bunnies/consumers"
+require "set"
 
 module HotBunnies
+  # Represents AMQP 0.9.1 queue.
+  #
+  # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+  # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions guide
   class Queue
-    attr_reader :name, :channel
+    # @return [HotBunnies::Channel] Channel this queue uses
+    attr_reader :channel
+    # @return [String] Queue name
+    attr_reader :name
 
+    # @param [HotBunnies::Channel] channel_or_connection Channel this queue will use.
+    # @param [String] name                          Queue name. Pass an empty string to make RabbitMQ generate a unique one.
+    # @param [Hash] opts                            Queue properties
+    #
+    # @option opts [Boolean] :durable (false)      Should this queue be durable?
+    # @option opts [Boolean] :auto_delete (false)  Should this queue be automatically deleted when the last consumer disconnects?
+    # @option opts [Boolean] :exclusive (false)    Should this queue be exclusive (only can be used by this connection, removed when the connection is closed)?
+    # @option opts [Boolean] :arguments ({})       Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    #
+    # @see HotBunnies::Channel#queue
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    # @see http://hotbunnies.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
     def initialize(channel, name, options={})
       @channel = channel
       @name = name
       @options = {:durable => false, :exclusive => false, :auto_delete => false, :passive => false, :arguments => Hash.new}.merge(options)
+
+      @durable      = @options[:durable]
+      @exclusive    = @options[:exclusive]
+      @server_named = @name.empty?
+      @auto_delete  = @options[:auto_delete]
+      @arguments    = @options[:arguments]
+
+      @bindings     = Set.new
     end
 
+
+    # @return [Boolean] true if this queue was declared as durable (will survive broker restart).
+    # @api public
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    def durable?
+      @durable
+    end # durable?
+
+    # @return [Boolean] true if this queue was declared as exclusive (limited to just one consumer)
+    # @api public
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    def exclusive?
+      @exclusive
+    end # exclusive?
+
+    # @return [Boolean] true if this queue was declared as automatically deleted (deleted as soon as last consumer unbinds).
+    # @api public
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    def auto_delete?
+      @auto_delete
+    end # auto_delete?
+
+    # @return [Boolean] true if this queue was declared as server named.
+    # @api public
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    def server_named?
+      @server_named
+    end # server_named?
+
+    # @return [Hash] Additional optional arguments (typically used by RabbitMQ extensions and plugins)
+    # @api public
+    def arguments
+      @arguments
+    end
+
+
+
+    # Binds queue to an exchange
+    #
+    # @param [HotBunnies::Exchange,String] exchange Exchange to bind to
+    # @param [Hash] options Binding properties
+    #
+    # @option options [String] :routing_key  Routing key
+    # @option options [Hash] :arguments ({}) Additional optional binding arguments
+    #
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    # @see http://hotbunnies.info/articles/bindings.html Bindings guide
+    # @api public
     def bind(exchange, options={})
-      exchange_name = if exchange.respond_to?(:name) then exchange.name else exchange.to_s end
-      @channel.queue_bind(@name, exchange_name, options.fetch(:routing_key, ''), options[:arguments])
+      exchange_name = if exchange.respond_to?(:name) then
+                        exchange.name
+                      else
+                        exchange.to_s
+                      end
+      @channel.queue_bind(@name, exchange_name, (options[:routing_key] || options[:key] || ""), options[:arguments])
+
+      # store bindings for automatic recovery. We need to be very careful to
+      # not cause an infinite rebinding loop here when we recover. MK.
+      binding = { :exchange => exchange_name, :routing_key => (options[:routing_key] || options[:key]), :arguments => options[:arguments] }
+      @bindings << binding unless @bindings.include?(binding)
 
       self
     end
 
+    # Unbinds queue from an exchange
+    #
+    # @param [HotBunnies::Exchange,String] exchange Exchange to unbind from
+    # @param [Hash] options                       Binding properties
+    #
+    # @option options [String] :routing_key  Routing key
+    # @option options [Hash] :arguments ({}) Additional optional binding arguments
+    #
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    # @see http://hotbunnies.info/articles/bindings.html Bindings guide
+    # @api public
     def unbind(exchange, options={})
-      exchange_name = if exchange.respond_to?(:name) then exchange.name else exchange.to_s end
+      exchange_name = if exchange.respond_to?(:name) then
+                        exchange.name
+                      else
+                        exchange.to_s
+                      end
       @channel.queue_unbind(@name, exchange_name, options.fetch(:routing_key, ''))
 
+      binding = { :exchange => exchange_name, :routing_key => (options[:routing_key] || options[:key] || ""), :arguments => options[:arguments] }
+      @bindings.delete(binding) unless @bindings.include?(binding)
+
       self
     end
 
-    def delete
-      @channel.queue_delete(@name)
+    # Deletes the queue
+    #
+    # @option [Boolean] if_unused (false) Should this queue be deleted only if it has no consumers?
+    # @option [Boolean] if_empty (false) Should this queue be deleted only if it has no messages?
+    #
+    # @see http://hotbunnies.info/articles/queues.html Queues and Consumers guide
+    # @api public
+    def delete(if_unused = false, if_empty = false)
+      @channel.queue_delete(@name, if_unused, if_empty)
     end
 
     def purge
@@ -49,9 +160,13 @@ module HotBunnies
 
     def build_consumer(opts, &block)
       if opts[:block] || opts[:blocking]
-        BlockingCallbackConsumer.new(@channel, opts[:buffer_size], opts, block)
+        BlockingCallbackConsumer.new(@channel, self, opts[:buffer_size], opts, block)
       else
-        AsyncCallbackConsumer.new(@channel, opts, block, opts.fetch(:executor, JavaConcurrent::Executors.new_single_thread_executor))
+        esf = opts.fetch(:executor_factory, Proc.new {
+          JavaConcurrent::Executors.new_single_thread_executor
+        })
+        es  = opts.fetch(:executor, esf.call)
+        AsyncCallbackConsumer.new(@channel, self, opts.merge(:executor => es, :executor_factory => esf), block)
       end
     end
 
@@ -117,5 +232,35 @@ module HotBunnies
                  end
       @name = response.queue
     end
+
+    # @private
+    def recover_from_network_failure
+      if self.server_named?
+        old_name = @name.dup
+        @name    = ""
+
+        @channel.deregister_queue_named(old_name)
+      end
+
+      # puts "Recovering queue #{@name}"
+      begin
+        declare!
+
+        @channel.register_queue(self)
+      rescue Exception => e
+        # TODO: use a logger
+        puts "Caught #{e.inspect} while redeclaring and registering #{@name}!"
+      end
+      recover_bindings
+    end
+
+    # @private
+    def recover_bindings
+      @bindings.each do |b|
+        # TODO: use a logger
+        # puts "Recovering binding #{b.inspect}"
+        self.bind(b[:exchange], b)
+      end
+    end
   end # Queue
 end # HotBunnies

data/lib/hot_bunnies/session.rb

@@ -1,10 +1,12 @@
 # encoding: utf-8
 require "hot_bunnies/shutdown_listener"
+require "set"
 
 module HotBunnies
   java_import com.rabbitmq.client.ConnectionFactory
   java_import com.rabbitmq.client.Connection
   java_import java.util.concurrent.ConcurrentHashMap
+  java_import java.util.concurrent.ConcurrentSkipListSet
 
   # Connection to a RabbitMQ node.
   #
@@ -22,6 +24,9 @@ module HotBunnies
     # API
     #
 
+    # Default reconnection interval for TCP connection failures
+    DEFAULT_NETWORK_RECOVERY_INTERVAL = 5.0
+
     # Connects to a RabbitMQ node.
     #
     # @param [Hash] options Connection options
@@ -65,7 +70,7 @@ module HotBunnies
       end
 
 
-      new(cf)
+      new(cf, options)
     end
 
     # @private
@@ -75,14 +80,26 @@ module HotBunnies
 
 
     # @private
-    def initialize(connection_factory)
+    def initialize(connection_factory, opts = {})
       @cf         = connection_factory
       @connection = converting_rjc_exceptions_to_ruby do
         self.new_connection
       end
       @channels   = ConcurrentHashMap.new
-
       @thread     = Thread.current
+
+      # should automatic recovery from network failures be used?
+      @automatically_recover = if opts[:automatically_recover].nil? && opts[:automatic_recovery].nil?
+                                 true
+                               else
+                                 opts[:automatically_recover] || opts[:automatic_recovery]
+                               end
+      @network_recovery_interval = opts.fetch(:network_recovery_interval, DEFAULT_NETWORK_RECOVERY_INTERVAL)
+      @shutdown_hooks            = ConcurrentSkipListSet.new
+
+      if @automatically_recover
+        self.add_automatic_recovery_hook
+      end
     end
 
     # Opens a new channel.
@@ -115,13 +132,57 @@ module HotBunnies
       @connection.close
     end
 
+    def open?
+      @connection.open?
+    end
+    alias connected? open?
+
     def on_shutdown(&block)
       sh = ShutdownListener.new(self, &block)
+      @shutdown_hooks << sh
+
       @connection.add_shutdown_listener(sh)
 
       sh
     end
 
+    # @private
+    def add_automatic_recovery_hook
+      fn = Proc.new do |_, signal|
+        if !signal.initiated_by_application
+          self.automatically_recover
+        end
+      end
+
+      @automatic_recovery_hook = self.on_shutdown(&fn)
+    end
+
+    # @private
+    def disable_automatic_recovery
+      @connetion.remove_shutdown_listener(@automatic_recovery_hook) if @automatic_recovery_hook
+    end
+
+    def automatically_recover
+      # recovering immediately makes little sense. Wait a bit first. MK.
+      java.lang.Thread.sleep(@network_recovery_interval * 1000)
+
+      @connection = converting_rjc_exceptions_to_ruby do
+        self.new_connection
+      end
+      self.recover_shutdown_hooks
+
+      @channels.each do |id, ch|
+        ch.automatically_recover(self, @connection)
+      end
+    end
+
+    # @private
+    def recover_shutdown_hooks
+      @shutdown_hooks.each do |sh|
+        @connection.add_shutdown_listener(sh)
+      end
+    end
+
     # Flushes the socket used by this connection.
     def flush
       @connection.flush

data/lib/hot_bunnies/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module HotBunnies
-  VERSION = "2.0.0.pre9"
+  VERSION = "2.0.0.pre10"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hot_bunnies
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre9
+  version: 2.0.0.pre10
   prerelease: 6
 platform: java
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-08-11 00:00:00.000000000 Z
 dependencies: []
 description: RabbitMQ client for JRuby built around the official RabbitMQ Java client
 email: