hot_bunnies 1.5.0-java → 2.0.0.pre1-java

data/lib/hot_bunnies/channel.rb

@@ -1,19 +1,162 @@
 # encoding: utf-8
 
 module HotBunnies
-  module Channel
-    def queue(name, options={})
-      Queue.new(self, name, options)
+  class Channel
+    attr_reader :session
+
+    def initialize(session, delegate)
+      @connection = session
+      @delegate   = delegate
+
+      # we keep track of consumers 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
+    end
+
+    def client
+      @connection
+    end
+
+    def id
+      @delegate.channel_number
+    end
+
+    def number
+      @delegate.channel_number
+    end
+
+    def channel_number
+      @delegate.channel_number
+    end
+
+    def close(code = 200, reason = "Goodbye")
+      v = @delegate.close(code, reason)
+
+      @consumers.each do |tag, consumer|
+        consumer.gracefully_shut_down
+      end
+
+      @connection.unregister_channel(self)
+
+      v
     end
 
+
+    # @group Exchanges
+
     def exchange(name, options={})
-      exchange = Exchange.new(self, name, options)
-      exchange.declare!
-      exchange
+      Exchange.new(self, name, options).tap do |x|
+        x.declare!
+      end
+    end
+
+    def fanout(name, opts = {})
+      Exchange.new(self, name, opts.merge(:type => "fanout")).tap do |x|
+        x.declare!
+      end
+    end
+
+    def direct(name, opts = {})
+      Exchange.new(self, name, opts.merge(:type => "direct")).tap do |x|
+        x.declare!
+      end
+    end
+
+    def topic(name, opts = {})
+      Exchange.new(self, name, opts.merge(:type => "topic")).tap do |x|
+        x.declare!
+      end
+    end
+
+    def headers(name, opts = {})
+      Exchange.new(self, name, opts.merge(:type => "headers")).tap do |x|
+        x.declare!
+      end
     end
 
     def default_exchange
-      self.exchange("", :durable => true, :auto_delete => false, :type => "direct")
+      @default_exchange ||= self.exchange("", :durable => true, :auto_delete => false, :type => "direct")
+    end
+
+    def exchange_declare(name, type, durable = false, auto_delete = false, arguments = nil)
+      @delegate.exchange_declare(name, type, durable, auto_delete, arguments)
+    end
+
+    # @endgroup
+
+
+    # @group Queues
+
+    def queue(name, options={})
+      Queue.new(self, name, options).tap do |q|
+        q.declare!
+      end
+    end
+
+    def queue_declare(name, durable, exclusive, auto_delete, arguments = {})
+      converting_rjc_exceptions_to_ruby do
+        @delegate.queue_declare(name, durable, exclusive, auto_delete, arguments)
+      end
+    end
+
+    def queue_declare_passive(name)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.queue_declare_passive(name)
+      end
+    end
+
+    def queue_delete(name, if_empty = false, if_unused = false)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.queue_delete(name, if_empty, if_unused)
+      end
+    end
+
+    def queue_bind(queue, exchange, routing_key, arguments = nil)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.queue_bind(queue, exchange, routing_key, arguments)
+      end
+    end
+
+    def queue_unbind(queue, exchange, routing_key, arguments = nil)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.queue_unbind(queue, exchange, routing_key, arguments)
+      end
+    end
+
+    def queue_purge(name)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.queue_purge(name)
+      end
+    end
+
+    # @endgroup
+
+
+    # @group basic.*
+
+    def basic_publish(exchange, routing_key, mandatory, properties, body)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.basic_publish(exchange, routing_key, mandatory, false, BasicPropertiesBuilder.build_properties_from(properties || Hash.new), body)
+      end
+    end
+
+    def basic_get(queue, auto_ack)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.basic_get(queue, auto_ack)
+      end
+    end
+
+    def basic_consume(queue, auto_ack, consumer)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.basic_consume(queue, auto_ack, consumer)
+      end
+    end
+
+    def basic_qos(prefetch_count)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.basic_qos(prefetch_count)
+      end
     end
 
     def qos(options={})
@@ -24,11 +167,146 @@ module HotBunnies
     end
 
     def prefetch=(n)
-      qos(:prefetch_count => n)
+      basic_qos(n)
+    end
+
+    def ack(delivery_tag, multiple = false)
+      converting_rjc_exceptions_to_ruby do
+        basic_ack(delivery_tag, multiple)
+      end
+    end
+    alias acknowledge ack
+
+    def reject(delivery_tag, requeue = false)
+      converting_rjc_exceptions_to_ruby do
+        basic_reject(delivery_tag, requeue)
+      end
+    end
+
+    def nack(delivery_tag, multiple = false, requeue = false)
+      converting_rjc_exceptions_to_ruby do
+        basic_nack(delivery_tag, multiple, requeue)
+      end
+    end
+
+    def basic_recover(requeue = true)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.basic_recover(requeue)
+      end
+    end
+
+    def basic_recover_async(requeue = true)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.basic_recover_async(requeue)
+      end
+    end
+
+    # @endgroup
+
+
+    def confirm_select
+      converting_rjc_exceptions_to_ruby do
+        @delegate.confirm_select
+      end
+    end
+
+    # Waits until all outstanding publisher confirms arrive.
+    #
+    # Takes an optional timeout in milliseconds. Will raise
+    # an exception in timeout has occured.
+    #
+    # @param [Integer] timeout Timeout in milliseconds
+    # @return [Boolean] true if all confirms were positive,
+    #                        false if some were negative
+    def wait_for_confirms(timeout = nil)
+      if timeout
+        converting_rjc_exceptions_to_ruby do
+          @delegate.wait_for_confirms(timeout)
+        end
+      else
+        @delegate.wait_for_confirms
+      end
+    end
+
+    def next_publisher_seq_no
+      @delegate.next_publisher_seq_no
     end
 
+    def tx_select
+      converting_rjc_exceptions_to_ruby do
+        @delegate.tx_select
+      end
+    end
+
+    def tx_commit
+      converting_rjc_exceptions_to_ruby do
+        @delegate.tx_commit
+      end
+    end
+
+    def tx_rollback
+      converting_rjc_exceptions_to_ruby do
+        @delegate.tx_rollback
+      end
+    end
+
+    def channel_flow(active)
+      converting_rjc_exceptions_to_ruby do
+        @delegate.channel_flow(active)
+      end
+    end
+
+
     def on_return(&block)
-      self.set_return_listener(block)
+      self.add_return_listener(BlockReturnListener.from(block))
+    end
+
+    def method_missing(selector, *args)
+      @delegate.__send__(selector, *args)
+    end
+
+
+    #
+    # Implementation
+    #
+
+    class BlockReturnListener
+      include com.rabbitmq.client.ReturnListener
+
+      def self.from(block)
+        new(block)
+      end
+
+      def initialize(block)
+        @block = block
+      end
+
+      def handleReturn(reply_code, reply_text, exchange, routing_key, basic_properties, payload)
+        # TODO: convert properties to a Ruby hash
+        @block.call(reply_code, reply_text, exchange, routing_key, basic_properties, String.from_java_bytes(payload))
+      end
+    end
+
+    # @private
+    def register_consumer(consumer_tag, consumer)
+      @consumers[consumer_tag] = consumer
+    end
+
+    # @private
+    def unregister_consumer(consumer_tag)
+      @consumers.delete(consumer_tag)
+    end
+
+    # Executes a block, catching Java exceptions RabbitMQ Java client throws and
+    # transforms them to Ruby exceptions that are then re-raised.
+    #
+    # @private
+    def converting_rjc_exceptions_to_ruby(&block)
+      begin
+        block.call
+      rescue Exception, java.lang.Throwable => e
+        Exceptions.convert_and_reraise(e)
+      end
     end
   end
 end

data/lib/hot_bunnies/consumers.rb

@@ -0,0 +1,152 @@
+module HotBunnies
+  import com.rabbitmq.client.DefaultConsumer
+
+  class BaseConsumer < DefaultConsumer
+    attr_accessor :consumer_tag
+
+    def initialize(channel)
+      super(channel)
+      @channel    = channel
+
+      @cancelling = JavaConcurrent::AtomicBoolean.new
+      @cancelled  = JavaConcurrent::AtomicBoolean.new
+    end
+
+    def handleDelivery(consumer_tag, envelope, properties, body)
+      body    = String.from_java_bytes(body)
+      headers = Headers.new(channel, consumer_tag, envelope, properties)
+
+      deliver(headers, body)
+    end
+
+    def handleCancel(consumer_tag)
+      @cancelled.set(true)
+    end
+
+    def handleCancelOk(consumer_tag)
+      @cancelled.set(true)
+      @channel.unregister_consumer(consumer_tag)
+    end
+
+    def start
+    end
+
+    def deliver(headers, message)
+      raise NotImplementedError, 'To be implemented by a subclass'
+    end
+
+    def cancel
+      @cancelling.set(true)
+      response = channel.basic_cancel(consumer_tag)
+      @cancelled.set(true)
+
+      response
+    end
+
+    def cancelled?
+      @cancelling.get || @cancelled.get
+    end
+
+    def active?
+      !cancelled?
+    end
+  end
+
+
+  class CallbackConsumer < BaseConsumer
+    def initialize(channel, callback)
+      super(channel)
+      @callback = callback
+      @callback_arity = @callback.arity
+    end
+
+    def callback(headers, message)
+      if @callback_arity == 2
+        @callback.call(headers, message)
+      else
+        @callback.call(message)
+      end
+    end
+  end
+
+  class AsyncCallbackConsumer < CallbackConsumer
+    def initialize(channel, callback, executor)
+      super(channel, callback)
+      @executor = executor
+    end
+
+    def deliver(headers, message)
+      unless @executor.shutdown?
+        @executor.submit do
+          begin
+            callback(headers, message)
+          rescue Exception => e
+            $stderr.puts "Unhandled exception in consumer #{@consumer_tag}: #{e.message}"
+          end
+        end
+      end
+    end
+
+    def cancel
+      super
+
+      maybe_shut_down_executor
+    end
+
+    def shutdown!
+      @executor.shutdown_now if @executor
+    end
+    alias shut_down! shutdown!
+
+    def gracefully_shut_down
+      unless @executor.await_termination(1, JavaConcurrent::TimeUnit::SECONDS)
+        @executor.shutdown_now
+      end
+    end
+    alias maybe_shut_down_executor gracefully_shut_down
+    alias gracefully_shutdown      gracefully_shut_down
+  end
+
+  class BlockingCallbackConsumer < CallbackConsumer
+    include JavaConcurrent
+
+    def initialize(channel, buffer_size, callback)
+      super(channel, callback)
+      if buffer_size
+        @internal_queue = ArrayBlockingQueue.new(buffer_size)
+      else
+        @internal_queue = LinkedBlockingQueue.new
+      end
+    end
+
+    def start
+      interrupted = false
+      until (@cancelling.get || @cancelled.get) || JavaConcurrent::Thread.current_thread.interrupted?
+        begin
+          pair = @internal_queue.take
+          callback(*pair) if pair
+        rescue InterruptedException => e
+          interrupted = true
+        end
+      end
+      while (pair = @internal_queue.poll)
+        callback(*pair)
+      end
+      if interrupted
+        JavaConcurrent::Thread.current_thread.interrupt
+      end
+    end
+
+    def deliver(*pair)
+      if (@cancelling.get || @cancelled.get) || JavaConcurrent::Thread.current_thread.interrupted?
+        @internal_queue.offer(pair)
+      else
+        begin
+          @internal_queue.put(pair)
+        rescue InterruptedException => e
+          JavaConcurrent::Thread.current_thread.interrupt
+        end
+      end
+    end
+  end
+end

data/lib/hot_bunnies/exceptions.rb

@@ -0,0 +1,151 @@
+module HotBunnies
+  class Exception < ::StandardError
+  end
+
+
+  class ChannelLevelException < Exception
+    attr_reader :channel_close
+
+    def initialize(message, channel_close)
+      super(message)
+
+      @channel_close = channel_close
+    end
+  end
+
+  class ConnectionLevelException < Exception
+    attr_reader :connection_close
+
+    def initialize(message, connection_close)
+      super(message)
+
+      @connection_close = connection_close
+    end
+  end
+
+
+  class PossibleAuthenticationFailureError < Exception
+
+    #
+    # API
+    #
+
+    attr_reader :username, :vhost
+
+    def initialize(username, vhost, password_length)
+      @username = username
+      @vhost    = vhost
+
+      super("RabbitMQ closed TCP connection before authentication succeeded: this usually means authentication failure due to misconfiguration or that RabbitMQ version does not support AMQP 0.9.1. Please check your configuration. Username: #{username}, vhost: #{vhost}, password length: #{password_length}")
+    end # initialize(settings)
+  end # PossibleAuthenticationFailureError
+
+
+  class PreconditionFailed < ChannelLevelException
+  end
+
+  class NotFound < ChannelLevelException
+  end
+
+  class ResourceLocked < ChannelLevelException
+  end
+
+  class AccessRefused < ChannelLevelException
+  end
+
+  class ChannelError < ConnectionLevelException
+  end
+
+  class InvalidCommand < ConnectionLevelException
+  end
+
+  class FrameError < ConnectionLevelException
+  end
+
+  class UnexpectedFrame < ConnectionLevelException
+  end
+
+
+
+  # Converts RabbitMQ Java client exceptions
+  # @private
+  class Exceptions
+    def self.convert(e, unwrap_io_exception = true)
+      case e
+      when java.io.IOException then
+        c = e.cause
+
+        if unwrap_io_exception
+          convert(c, false)
+        else
+          c
+        end
+      when com.rabbitmq.client.AlreadyClosedException then
+        cmd = e.reason
+
+        puts cmd.method.class.inspect
+      when com.rabbitmq.client.ShutdownSignalException then
+        cmd = e.reason
+
+        exception_for_protocol_method(cmd.method)
+      else
+        e
+      end
+    end
+
+    def self.convert_and_reraise(e)
+      raise convert(e)
+    end
+
+    def self.exception_for_protocol_method(m)
+      case m
+      # com.rabbitmq.client.AMQP.Connection.Close does not resolve the inner
+      # class correctly. Looks like a JRuby bug we work around by using Rubyesque
+      # class name. MK.
+      when Java::ComRabbitmqClient::AMQP::Connection::Close then
+        exception_for_connection_close(m)
+      when Java::ComRabbitmqClient::AMQP::Channel::Close then
+        exception_for_channel_close(m)
+      else
+        NotImplementedError.new("Exception convertion for protocol method #{m.inspect} is not implemented!")
+      end
+    end # def self
+
+
+    def self.exception_for_connection_close(m)
+      klass = case m.reply_code
+              when 320 then
+                ConnectionForced
+              when 501 then
+                FrameError
+              when 503 then
+                InvalidCommand
+              when 504 then
+                ChannelError
+              when 505 then
+                UnexpectedFrame
+              else
+                raise "Unknown reply code: #{m.reply_code}, text: #{m.reply_text}"
+              end
+
+      klass.new("Connection-level error: #{m.reply_text}", m)
+    end
+
+    def self.exception_for_channel_close(m)
+      klass = case m.reply_code
+              when 403 then
+                AccessRefused
+              when 404 then
+                NotFound
+              when 405 then
+                ResourceLocked
+              when 406 then
+                PreconditionFailed
+              else
+                ChannelLevelException
+              end
+
+      klass.new(m.reply_text, m)
+    end
+  end # Exceptions
+end # HotBunnies

data/lib/hot_bunnies/exchange.rb

@@ -1,18 +1,29 @@
 # encoding: utf-8
 
 module HotBunnies
+  import com.rabbitmq.client.AMQP
+
   class Exchange
     attr_reader :name, :channel
 
-    def initialize(channel, name, options={})
+    def initialize(channel, name, options = {})
+      raise ArgumentError, "exchange channel cannot be nil" if channel.nil?
+      raise ArgumentError, "exchange name cannot be nil" if name.nil?
+      raise ArgumentError, "exchange :type must be specified as an option" if options[:type].nil?
+
       @channel = channel
-      @name = name
+      @name    = name
+      @type    = options[:type]
       @options = {:type => :fanout, :durable => false, :auto_delete => false, :internal => false, :passive => false}.merge(options)
     end
 
-    def publish(body, options={})
-      options = {:routing_key => '', :mandatory => false, :immediate => false}.merge(options)
-      @channel.basic_publish(@name, options[:routing_key], options[:mandatory], options[:immediate], build_properties_from(options.fetch(:properties, Hash.new)), body.to_java_bytes)
+    def publish(body, opts = {})
+      options = {:routing_key => '', :mandatory => false}.merge(opts)
+      @channel.basic_publish(@name,
+                             options[:routing_key],
+                             options[:mandatory],
+                             options.fetch(:properties, Hash.new),
+                             body.to_java_bytes)
     end
 
     def delete(options={})
@@ -28,37 +39,18 @@ module HotBunnies
       @name.empty? || @name.start_with?("amq.")
     end
 
+    #
+    # Implementation
+    #
+
+    # @api private
     def declare!
       unless predefined?
         if @options[:passive]
         then @channel.exchange_declare_passive(@name)
-        else @channel.exchange_declare(@name, @options[:type].to_s, @options[:durable], @options[:auto_delete], @options[:internal], @options[:arguments])
+        else @channel.exchange_declare(@name, @options[:type].to_s, @options[:durable], @options[:auto_delete], @options[:arguments])
         end
       end
     end
-
-
-    protected
-
-    def build_properties_from(props = {})
-      builder = AMQP::BasicProperties::Builder.new
-
-      builder.content_type(props[:content_type]).
-        content_encoding(props[:content_encoding]).
-        headers(props[:headers]).
-        delivery_mode(props[:persistent] ? 2 : 1).
-        priority(props[:priority]).
-        correlation_id(props[:correlation_id]).
-        reply_to(props[:reply_to]).
-        expiration(props[:expiration]).
-        message_id(props[:message_id]).
-        timestamp(props[:timestamp]).
-        type(props[:type]).
-        user_id(props[:user_id]).
-        app_id(props[:app_id]).
-        cluster_id(props[:cluster_id]).
-        build
-    end
-
   end
 end

data/lib/hot_bunnies/juc.rb

@@ -0,0 +1,9 @@
+module JavaConcurrent
+  java_import 'java.lang.Thread'
+  java_import 'java.lang.InterruptedException'
+  java_import 'java.util.concurrent.Executors'
+  java_import 'java.util.concurrent.LinkedBlockingQueue'
+  java_import 'java.util.concurrent.ArrayBlockingQueue'
+  java_import 'java.util.concurrent.TimeUnit'
+  java_import 'java.util.concurrent.atomic.AtomicBoolean'
+end