hot_bunnies 1.5.0-java → 2.0.0.pre1-java

data/lib/hot_bunnies/metadata.rb

@@ -0,0 +1,90 @@
+module HotBunnies
+  class Headers
+    attr_reader :channel, :consumer_tag, :envelope, :properties
+
+    def initialize(channel, consumer_tag, envelope, properties)
+      @channel      = channel
+      @consumer_tag = consumer_tag
+      @envelope     = envelope
+      @properties   = properties
+    end
+
+    def ack(options={})
+      @channel.basic_ack(delivery_tag, options.fetch(:multiple, false))
+    end
+
+    def reject(options={})
+      @channel.basic_reject(delivery_tag, options.fetch(:requeue, false))
+    end
+
+    begin :envelope_delegation
+      [
+        :delivery_tag,
+        :routing_key,
+        :redeliver,
+        :exchange
+      ].each do |envelope_property|
+        define_method(envelope_property) { @envelope.__send__(envelope_property) }
+      end
+
+      alias_method :redelivered?, :redeliver
+    end
+
+    begin :message_properties_delegation
+      [
+        :content_encoding,
+        :content_type,
+        :content_encoding,
+        :headers,
+        :delivery_mode,
+        :priority,
+        :correlation_id,
+        :reply_to,
+        :expiration,
+        :message_id,
+        :timestamp,
+        :type,
+        :user_id,
+        :app_id,
+        :cluster_id
+      ].each do |properties_property|
+        define_method(properties_property) { @properties.__send__(properties_property) }
+      end # each
+    end
+
+    def persistent?
+      delivery_mode == 2
+    end
+
+    def redelivered?
+      redeliver
+    end
+
+    def redelivery?
+      redeliver
+    end
+  end # Headers
+
+
+  class BasicPropertiesBuilder
+    def self.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(if props[:expiration] then props[:expiration].to_s end).
+        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 # HotBunnies

data/lib/hot_bunnies/queue.rb

@@ -1,14 +1,8 @@
 # encoding: utf-8
 
-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
+require "hot_bunnies/juc"
+require "hot_bunnies/metadata"
+require "hot_bunnies/consumers"
 
 module HotBunnies
   class Queue
@@ -18,17 +12,20 @@ module HotBunnies
       @channel = channel
       @name = name
       @options = {:durable => false, :exclusive => false, :auto_delete => false, :passive => false, :arguments => Hash.new}.merge(options)
-      declare!
     end
 
     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])
+
+      self
     end
 
     def unbind(exchange, options={})
       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, ''))
+
+      self
     end
 
     def delete
@@ -39,281 +36,71 @@ module HotBunnies
       @channel.queue_purge(@name)
     end
 
-    def get(options={})
+    def get(options = {:block => false})
       response = @channel.basic_get(@name, !options.fetch(:ack, false))
+
       if response
-      then [Headers.new(@channel, nil, response.envelope, response.props), String.from_java_bytes(response.body)]
-      else nil
+        [Headers.new(@channel, nil, response.envelope, response.props), String.from_java_bytes(response.body)]
+      else
+        nil
       end
     end
+    alias pop get
 
-    def subscribe(options={}, &block)
-      subscription = Subscription.new(@channel, @name, options)
-      subscription.each(options, &block) if block
-      subscription
-    end
-
-    def status
-      response = @channel.queue_declare_passive(@name)
-      [response.message_count, response.consumer_count]
-    end
-
-    private
-
-    def declare!
-      response = if @options[:passive]
-                 then @channel.queue_declare_passive(@name)
-                 else @channel.queue_declare(@name, @options[:durable], @options[:exclusive], @options[:auto_delete], @options[:arguments])
+    def subscribe(opts = {}, &block)
+      consumer = if opts[:block] || opts[:blocking]
+                   BlockingCallbackConsumer.new(@channel, opts[:buffer_size], block)
+                 else
+                   AsyncCallbackConsumer.new(@channel, block, opts.fetch(:executor, JavaConcurrent::Executors.new_single_thread_executor))
                  end
-      @name = response.queue
-    end
-
-    class Subscription
-      include JavaConcurrent
 
-      attr_reader :channel, :queue_name, :consumer_tag
+      @consumer_tag     = @channel.basic_consume(@name, !(opts[:ack] || opts[:manual_ack]), consumer)
+      consumer.consumer_tag = @consumer_tag
 
-      def initialize(channel, queue_name, options={})
-        @channel    = channel
-        @queue_name = queue_name
-        @ack        = options.fetch(:ack, false)
+      @default_consumer = consumer
+      @channel.register_consumer(@consumer_tag, consumer)
+      consumer.start
 
-        @cancelled  = AtomicBoolean.new(false)
-      end
-
-      def each(options={}, &block)
-        raise 'The subscription already has a message listener' if @consumer
-        start(create_consumer(options, block))
-        nil
-      end
-      alias_method :each_message, :each
-
-      def start(consumer)
-        @consumer = consumer
-        @consumer_tag = @channel.basic_consume(@queue_name, !@ack, @consumer)
-        @consumer.start
-      end
-
-      def cancel
-        raise 'Can\'t cancel: the subscriber haven\'t received an OK yet' if !self.active?
-        @consumer.cancel
-
-        # RabbitMQ Java client won't clear consumer_tag from cancelled consumers,
-        # so we have to do this. Sharing consumers
-        # between threads in general is a can of worms but someone somewhere
-        # will almost certainly do it, so. MK.
-        @cancelled.set(true)
-
-        maybe_shutdown_executor
-      end
-
-      def cancelled?
-        @cancelled.get
-      end
-
-      def active?
-        !@cancelled.get && !@consumer.nil? && !@consumer.consumer_tag.nil?
-      end
-
-      def shutdown!
-        if @executor && @shut_down_executor
-          @executor.shutdown_now
-        end
-      end
-      alias shut_down! shutdown!
-
-      private
-
-      def maybe_shutdown_executor
-        if @executor && @shut_down_executor
-          @executor.shutdown
-          unless @executor.await_termination(1, TimeUnit::SECONDS)
-            @executor.shutdown_now
-          end
-        end
-      end
-
-      def create_consumer(options, callback)
-        if options.fetch(:blocking, true)
-          BlockingCallbackConsumer.new(@channel, options[:buffer_size], callback)
-        else
-          if options[:executor]
-            @shut_down_executor = false
-            @executor = options[:executor]
-          else
-            @shut_down_executor = true
-            @executor = Executors.new_single_thread_executor
-          end
-          AsyncCallbackConsumer.new(@channel, callback, @executor)
-        end
-      end
+      consumer
     end
 
-    public
-
-    class BaseConsumer < DefaultConsumer
-      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 = true
-      end
-
-      def handleCancelOk(consumer_tag)
-        @cancelled = true
-      end
-
-      def start
-      end
-
-      def deliver(headers, message)
-        raise NotImplementedError, 'To be implemented by a subclass'
-      end
-
-      def cancel
-        channel.basic_cancel(consumer_tag)
-        @cancelling = true
-      end
+    def status
+      response = @channel.queue_declare_passive(@name)
+      [response.message_count, response.consumer_count]
     end
 
-    private
-
-    class CallbackConsumer < BaseConsumer
-      def initialize(channel, callback)
-        super(channel)
-        @callback = callback
-        @callback_arity = @callback.arity
-        @cancelled = false
-        @cancelling = false
-      end
-
-      def callback(headers, message)
-        if @callback_arity == 2
-          @callback.call(headers, message)
-        else
-          @callback.call(message)
-        end
-      end
+    def message_count
+      response = @channel.queue_declare_passive(@name)
+      response.message_count
     end
 
-    class AsyncCallbackConsumer < CallbackConsumer
-      def initialize(channel, callback, executor)
-        super(channel, callback)
-        @executor = executor
-        @tasks = []
-      end
-
-      def deliver(headers, message)
-        unless @executor.shutdown?
-          @executor.submit do
-            callback(headers, message)
-          end
-        end
-      end
+    def consumer_count
+      response = @channel.queue_declare_passive(@name)
+      response.consumer_count
     end
 
-    class BlockingCallbackConsumer < CallbackConsumer
-      include JavaConcurrent
+    # Publishes a message to the queue via default exchange. Takes the same arguments
+    # as {Bunny::Exchange#publish}
+    #
+    # @see HotBunnies::Exchange#publish
+    # @see HotBunnies::Channel#default_exchange
+    def publish(payload, opts = {})
+      @channel.default_exchange.publish(payload, opts.merge(:routing_key => @name))
 
-      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 @cancelled || 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 || @cancelled || 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
+      self
     end
 
-    class Headers
-      attr_reader :channel, :consumer_tag, :envelope, :properties
-
-      def initialize(channel, consumer_tag, envelope, properties)
-        @channel = channel
-        @consumer_tag = consumer_tag
-        @envelope = envelope
-        @properties = properties
-      end
-
-      def ack(options={})
-        @channel.basic_ack(delivery_tag, options.fetch(:multiple, false))
-      end
-
-      def reject(options={})
-        @channel.basic_reject(delivery_tag, options.fetch(:requeue, false))
-      end
 
-      begin :envelope_delegation
-        [
-          :delivery_tag,
-          :routing_key,
-          :redeliver,
-          :exchange
-        ].each do |envelope_property|
-          define_method(envelope_property) { @envelope.__send__(envelope_property) }
-        end
+    #
+    # Implementation
+    #
 
-        alias_method :redelivered?, :redeliver
-      end
-
-      begin :message_properties_delegation
-        [
-          :content_encoding,
-          :content_type,
-          :content_encoding,
-          :headers,
-          :delivery_mode,
-          :priority,
-          :correlation_id,
-          :reply_to,
-          :expiration,
-          :message_id,
-          :timestamp,
-          :type,
-          :user_id,
-          :app_id,
-          :cluster_id
-        ].each do |properties_property|
-          define_method(properties_property) { @properties.__send__(properties_property) }
-        end
-
-        def persistent?
-          persistent == 2
-        end
-      end
+    def declare!
+      response = if @options[:passive]
+                 then @channel.queue_declare_passive(@name)
+                 else @channel.queue_declare(@name, @options[:durable], @options[:exclusive], @options[:auto_delete], @options[:arguments])
+                 end
+      @name = response.queue
     end
-  end
-end
+  end # Queue
+end # HotBunnies

data/lib/hot_bunnies/session.rb

@@ -0,0 +1,170 @@
+module HotBunnies
+  java_import com.rabbitmq.client.ConnectionFactory
+  java_import com.rabbitmq.client.Connection
+  java_import java.util.concurrent.ConcurrentHashMap
+
+  class Session
+
+    #
+    # API
+    #
+
+    def self.connect(options={})
+      cf = ConnectionFactory.new
+
+      cf.uri                = options[:uri]          if options[:uri]
+      cf.host               = hostname_from(options) if include_host?(options)
+      cf.port               = options[:port]         if options[:port]
+      cf.virtual_host       = vhost_from(options)    if include_vhost?(options)
+      cf.connection_timeout = timeout_from(options)  if include_timeout?(options)
+      cf.username           = username_from(options) if include_username?(options)
+      cf.password           = password_from(options) if include_password?(options)
+
+      cf.requested_heartbeat = heartbeat_from(options)          if include_heartbeat?(options)
+      cf.connection_timeout  = connection_timeout_from(options) if include_connection_timeout?(options)
+
+      tls = (options[:ssl] || options[:tls])
+      case tls
+      when true then
+        cf.use_ssl_protocol
+      when String then
+        if options[:trust_manager]
+          cf.use_ssl_protocol(tls, options[:trust_manager])
+        else
+          cf.use_ssl_protocol(tls)
+        end
+      end
+
+      new(cf)
+    end
+
+
+    def initialize(connection_factory)
+      @cf         = connection_factory
+      @connection = self.new_connection
+      @channels   = ConcurrentHashMap.new
+    end
+
+    def create_channel(n = nil)
+      jc = if n
+             @connection.create_channel(n)
+           else
+             @connection.create_channel
+           end
+
+      ch = Channel.new(self, jc)
+      register_channel(ch)
+
+      ch
+    end
+
+    def close
+      @channels.select { |_, ch| ch.open? }.each do |_, ch|
+        ch.close
+      end
+
+      @connection.close
+    end
+
+    def flush
+      @connection.flush
+    end
+
+    def heartbeat=(n)
+      @connection.heartbeat = n
+    end
+
+    def method_missing(selector, *args)
+      @connection.__send__(selector, *args)
+    end
+
+
+    #
+    # Implementation
+    #
+
+    def register_channel(ch)
+      @channels[ch.channel_number] = ch
+    end
+
+    def unregister_channel(ch)
+      @channels.delete(ch.channel_number)
+    end
+
+    protected
+
+    def self.hostname_from(options)
+      options[:host] || options[:hostname] || ConnectionFactory.DEFAULT_HOST
+    end
+
+    def self.include_host?(options)
+      !!(options[:host] || options[:hostname])
+    end
+
+    def self.vhost_from(options)
+      options[:virtual_host] || options[:vhost] || ConnectionFactory.DEFAULT_VHOST
+    end
+
+    def self.include_vhost?(options)
+      !!(options[:virtual_host] || options[:vhost])
+    end
+
+    def self.timeout_from(options)
+      options[:connection_timeout] || options[:timeout]
+    end
+
+    def self.include_timeout?(options)
+      !!(options[:connection_timeout] || options[:timeout])
+    end
+
+    def self.username_from(options)
+      options[:username] || options[:user] || ConnectionFactory.DEFAULT_USER
+    end
+
+    def self.heartbeat_from(options)
+      options[:heartbeat_interval] || options[:requested_heartbeat] || ConnectionFactory.DEFAULT_HEARTBEAT
+    end
+
+    def self.connection_timeout_from(options)
+      options[:connection_timeout_interval] || options[:connection_timeout] || ConnectionFactory.DEFAULT_CONNECTION_TIMEOUT
+    end
+
+    def self.include_username?(options)
+      !!(options[:username] || options[:user])
+    end
+
+    def self.password_from(options)
+      options[:password] || options[:pass] || ConnectionFactory.DEFAULT_PASS
+    end
+
+    def self.include_password?(options)
+      !!(options[:password] || options[:pass])
+    end
+
+    def self.include_heartbeat?(options)
+      !!(options[:heartbeat_interval] || options[:requested_heartbeat] || options[:heartbeat])
+    end
+
+    def self.include_connection_timeout?(options)
+      !!(options[:connection_timeout_interval] || options[:connection_timeout])
+    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 com.rabbitmq.client.PossibleAuthenticationFailureException => e
+        raise PossibleAuthenticationFailureError.new(@cf.username, @cf.virtual_host, @cf.password.bytesize)
+      end
+    end
+
+    def new_connection
+      converting_rjc_exceptions_to_ruby do
+        @cf.new_connection
+      end
+    end
+  end
+end

data/lib/hot_bunnies/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module HotBunnies
-  VERSION = '1.5.0'
+  VERSION = '2.0.0.pre1'
 end