march_hare 2.0.0-java

data/lib/march_hare/consumers.rb

@@ -0,0 +1,2 @@
+require "march_hare/consumers/base"
+require "march_hare/consumers/blocking"

data/lib/march_hare/consumers/base.rb

@@ -0,0 +1,121 @@
+require "march_hare/versioned_delivery_tag"
+
+module MarchHare
+  import com.rabbitmq.client.DefaultConsumer
+
+  class BaseConsumer < DefaultConsumer
+    attr_accessor :consumer_tag
+    attr_accessor :auto_ack
+
+    def initialize(channel, queue, opts)
+      super(channel)
+      @channel    = channel
+      @queue      = queue
+      @opts       = opts
+      @auto_ack   = true
+
+      @cancelling = JavaConcurrent::AtomicBoolean.new
+      @cancelled  = JavaConcurrent::AtomicBoolean.new
+
+      @terminated = JavaConcurrent::AtomicBoolean.new
+    end
+
+    def handleDelivery(consumer_tag, envelope, properties, bytes)
+      body    = String.from_java_bytes(bytes)
+      headers = Headers.new(channel, consumer_tag, envelope, properties)
+
+      deliver(headers, body)
+    end
+
+    def handleCancel(consumer_tag)
+      @cancelled.set(true)
+      @channel.unregister_consumer(consumer_tag)
+
+      if f = @opts[:on_cancellation]
+        case f.arity
+        when 0 then
+          f.call
+        when 1 then
+          f.call(self)
+        when 2 then
+          f.call(@channel, self)
+        when 3 then
+          f.call(@channel, self, consumer_tag)
+        else
+          f.call(@channel, self, consumer_tag)
+        end
+      end
+
+      @terminated.set(true)
+    end
+
+    def handleCancelOk(consumer_tag)
+      @cancelled.set(true)
+      @channel.unregister_consumer(consumer_tag)
+
+      @terminated.set(true)
+    end
+
+    def start
+      # no-op
+    end
+
+    def gracefully_shut_down
+      # no-op
+    end
+
+    def deliver(headers, message)
+      raise NotImplementedError, 'To be implemented by a subclass'
+    end
+
+    def cancelled?
+      @cancelling.get || @cancelled.get
+    end
+
+    def active?
+      !terminated?
+    end
+
+    def terminated?
+      @terminated.get
+    end
+
+    # @private
+    def recover_from_network_failure
+      @terminated.set(false)
+      @cancelled.set(false)
+      @consumer_tag = @channel.basic_consume(@queue.name, @auto_ack, self)
+
+      @consumer_tag
+    end
+  end
+
+  class CallbackConsumer < BaseConsumer
+    def initialize(channel, queue, opts, callback)
+      raise ArgumentError, "callback must not be nil!" if callback.nil?
+
+      super(channel, queue, opts)
+      @callback = callback
+      @callback_arity = @callback.arity
+    end
+
+    def deliver(headers, message)
+      if @callback_arity == 2
+        @callback.call(headers, message)
+      else
+        @callback.call(message)
+      end
+    end
+
+    def cancel
+      if @cancelling.get_and_set(true)
+        false
+      else
+        @channel.basic_cancel(@consumer_tag)
+        @cancelled.set(true)
+        @terminated.set(true)
+        true
+      end
+    end
+  end
+end

data/lib/march_hare/consumers/blocking.rb

@@ -0,0 +1,73 @@
+require "march_hare/consumers/base"
+
+module MarchHare
+  class BlockingCallbackConsumer < CallbackConsumer
+    POISON = :__poison__
+
+    def initialize(channel, queue, buffer_size, opts, callback)
+      super(channel, queue, opts, callback)
+      if buffer_size
+        @internal_queue = JavaConcurrent::ArrayBlockingQueue.new(buffer_size)
+      else
+        @internal_queue = JavaConcurrent::LinkedBlockingQueue.new
+      end
+    end
+
+    def cancel
+      if super
+        @internal_queue.offer(POISON)
+      end
+    end
+
+    def start
+      interrupted = false
+      until (@cancelling.get || @cancelled.get) || JavaConcurrent::Thread.current_thread.interrupted?
+        begin
+          pair = @internal_queue.take
+          if pair
+            if pair == POISON
+              @cancelling.set(true)
+            else
+              @callback.call(*pair)
+            end
+          end
+        rescue JavaConcurrent::InterruptedException => e
+          interrupted = true
+        end
+      end
+      while (pair = @internal_queue.poll)
+        if pair
+          if pair == POISON
+            @cancelling.set(true)
+          else
+            @callback.call(*pair)
+          end
+        end
+      end
+      @terminated.set(true)
+      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 JavaConcurrent::InterruptedException => e
+          JavaConcurrent::Thread.current_thread.interrupt
+        end
+      end
+    end
+
+    def gracefully_shut_down
+      @cancelling.set(true)
+      @internal_queue.offer(POISON)
+
+      @terminated.set(true)
+    end
+
+  end
+end

data/lib/march_hare/exceptions.rb

@@ -0,0 +1,174 @@
+module MarchHare
+  class Exception < StandardError
+  end
+
+  class ShutdownSignal < Exception
+    attr_reader :cause
+
+    def initialize(cause)
+      @cause = cause
+    end
+  end
+
+  class NetworkException < Exception
+  end
+
+  class ConnectionRefused < NetworkException
+  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
+
+  # Raised when RabbitMQ closes network connection before
+  # finalizing the connection, typically indicating authentication failure.
+  #
+  # RabbitMQ versions beyond 3.2 use a better defined authentication failure
+  # notifications.
+  class PossibleAuthenticationFailureError < Exception
+    attr_reader :username, :vhost
+
+    def initialize(username, vhost, password_length)
+      @username = username
+      @vhost    = vhost
+
+      super("Authentication with RabbitMQ failed or RabbitMQ version used does not support AMQP 0-9-1. Username: #{username}, vhost: #{vhost}, password length: #{password_length}. Please check your configuration.")
+    end
+  end
+
+  # Raised when RabbitMQ 3.2+ reports authentication
+  # failure before closing TCP connection.
+  class AuthenticationFailureError < PossibleAuthenticationFailureError
+    attr_reader :username, :vhost
+
+    def initialize(username, vhost, password_length)
+      super(username, vhost, password_length)
+    end
+  end
+
+  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
+
+  class ChannelAlreadyClosed < Exception
+  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
+        ChannelAlreadyClosed.new(e.reason)
+      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
+end # MarchHare

data/lib/march_hare/exchange.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+module MarchHare
+  import com.rabbitmq.client.AMQP
+
+  # Represents AMQP 0.9.1 exchanges.
+  #
+  # @see http://rubymarchhare.info/articles/exchanges.html Exchanges and Publishing guide
+  # @see http://rubymarchhare.info/articles/extensions.html RabbitMQ Extensions guide
+  # @see Queue#bind
+  class Exchange
+    # @return [String] Exchange name
+    attr_reader :name
+    # @return [MarchHare::Channel] Channel this exchange object uses
+    attr_reader :channel
+
+    # Type of this exchange (one of: :direct, :fanout, :topic, :headers).
+    # @return [Symbol]
+    attr_reader :type
+
+    # Instantiates a new exchange.
+    #
+    # @param [Channel] channel Channel to declare exchange on
+    # @params [String] name Exchange name
+    # @params [Hash] options ({}) Exchange and declaration attributes
+    #
+    # @options opts :type [Symbol, String] Exchange type
+    # @options opts :durable [Boolean] (false) Will the exchange be durable?
+    # @options opts :auto_delete [Boolean] (false) Will the exchange be auto-deleted?
+    # @options opts :passive [Boolean] (false) Should passive declaration be used?
+    #
+    # @see MarchHare::Channel#default_exchange
+    # @see MarchHare::Channel#fanout
+    # @see MarchHare::Channel#topic
+    # @see MarchHare::Channel#direct
+    # @see MarchHare::Channel#headers
+    # @see MarchHare::Channel#exchange
+    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
+      @type    = options[:type]
+      @options = {:type => :fanout, :durable => false, :auto_delete => false, :internal => false, :passive => false}.merge(options)
+    end
+
+    # Publishes a message
+    #
+    # @param [String] payload Message payload. It will never be modified by MarchHare or RabbitMQ in any way.
+    # @param [Hash] opts Message properties (metadata) and delivery settings
+    #
+    # @option opts [String] :routing_key Routing key
+    # @option opts [Boolean] :persistent Should the message be persisted to disk?
+    # @option opts [Boolean] :mandatory Should the message be returned if it cannot be routed to any queue?
+    # @option opts [Hash] :properties Messages and delivery properties
+    #
+    #  * :timestamp (Integer) A timestamp associated with this message
+    #  * :expiration (Integer) Expiration time after which the message will be deleted
+    #  * :type (String) Message type, e.g. what type of event or command this message represents. Can be any string
+    #  * :reply_to (String) Queue name other apps should send the response to
+    #  * :content_type (String) Message content type (e.g. application/json)
+    #  * :content_encoding (String) Message content encoding (e.g. gzip)
+    #  * :correlation_id (String) Message correlated to this one, e.g. what request this message is a reply for
+    #  * :priority (Integer) Message priority, 0 to 9. Not used by RabbitMQ, only applications
+    #  * :message_id (String) Any message identifier
+    #  * :user_id (String) Optional user ID. Verified by RabbitMQ against the actual connection username
+    #  * :app_id (String) Optional application ID
+    #
+    # @return [MarchHare::Exchange] Self
+    # @see http://rubymarchhare.info/articles/exchanges.html Exchanges and Publishing guide
+    # @api public
+    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
+
+    # Deletes the exchange unless it is predefined
+    #
+    # @param [Hash] options Options
+    #
+    # @option opts [Boolean] if_unused (false) Should this exchange be deleted only if it is no longer used
+    #
+    # @see http://rubymarchhare.info/articles/exchanges.html Exchanges and Publishing guide
+    # @api public
+    def delete(options={})
+      @channel.deregister_exchange(self)
+      @channel.exchange_delete(@name, options.fetch(:if_unused, false)) unless predefined?
+    end
+
+    # Binds an exchange to another (source) exchange using exchange.bind AMQP 0.9.1 extension
+    # that RabbitMQ provides.
+    #
+    # @param [String] exchange Source exchange name
+    # @param [Hash] options Options
+    #
+    # @option opts [String] routing_key (nil) Routing key used for binding
+    # @option opts [Hash] arguments ({}) Optional arguments
+    #
+    # @return [MarchHare::Exchange] Self
+    # @see http://rubymarchhare.info/articles/exchanges.html Exchanges and Publishing guide
+    # @see http://rubymarchhare.info/articles/bindings.html Bindings guide
+    # @see http://rubymarchhare.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def bind(exchange, options={})
+      exchange_name = if exchange.respond_to?(:name) then exchange.name else exchange.to_s end
+      @channel.exchange_bind(@name, exchange_name, options.fetch(:routing_key, ''))
+    end
+
+    # Unbinds an exchange from another (source) exchange using exchange.unbind AMQP 0.9.1 extension
+    # that RabbitMQ provides.
+    #
+    # @param [String] source Source exchange name
+    # @param [Hash] opts Options
+    #
+    # @option opts [String] routing_key (nil) Routing key used for binding
+    # @option opts [Hash] arguments ({}) Optional arguments
+    #
+    # @return [Bunny::Exchange] Self
+    # @see http://rubymarchhare.info/articles/exchanges.html Exchanges and Publishing guide
+    # @see http://rubymarchhare.info/articles/bindings.html Bindings guide
+    # @see http://rubymarchhare.info/articles/extensions.html RabbitMQ Extensions guide
+    # @api public
+    def unbind(exchange, opts = {})
+      exchange_name = if exchange.respond_to?(:name) then exchange.name else exchange.to_s end
+      @channel.exchange_unbind(@name, exchange_name, opts.fetch(:routing_key, ''), opts[:arguments])
+    end
+
+    # @return [Boolean] true if this exchange is a pre-defined one (amq.direct, amq.fanout, amq.match and so on)
+    def predefined?
+      @name.empty? || @name.start_with?("amq.")
+    end
+
+    # Waits until all outstanding publisher confirms on the channel
+    # arrive.
+    #
+    # This is a convenience method that delegates to {Channel#wait_for_confirms}
+    #
+    # @api public
+    def wait_for_confirms
+      @channel.wait_for_confirms
+    end
+
+
+    #
+    # Implementation
+    #
+
+    # @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[:arguments])
+        end
+      end
+    end
+
+    # @private
+    def recover_from_network_failure
+      # puts "Recovering exchange #{@name} from network failure"
+      unless predefined?
+        begin
+          declare!
+
+          @channel.register_exchange(self)
+        rescue Exception => e
+          # TODO: use a logger
+          puts "Caught #{e.inspect} while redeclaring and registering exchange #{@name}!"
+        end
+      end
+    end
+  end
+end