hot_bunnies 1.1.2-java

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use jruby-1.6.2@hot_bunnies

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+gemspec
+
+gem 'jruby-openssl'
+gem 'rake'

data/Rakefile

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'bundler'
+
+
+Bundler::GemHelper.install_tasks

data/examples/blocking_subscription.rb

@@ -0,0 +1,36 @@
+$: << 'lib'
+
+require 'hot_bunnies'
+
+
+connection = HotBunnies.connect(:host => 'localhost')
+channel = connection.create_channel
+channel.prefetch = 10
+
+exchange = channel.exchange('test', :type => :direct)
+
+queue = channel.queue('hello.world')
+queue.bind(exchange, :routing_key => 'xyz')
+queue.purge
+
+100.times do |i|
+  exchange.publish("hello world! #{i}", :routing_key => 'xyz')
+end
+
+exchange.publish("POISON!", :routing_key => 'xyz')
+
+subscription = queue.subscribe(:ack => true)
+subscription.each(:blocking => true) do |headers, msg|
+  puts msg
+  headers.ack
+  if msg == "POISON!"
+    :cancel
+  end
+end
+
+puts "ALL DONE!"
+
+at_exit do
+  channel.close
+  connection.close
+end

data/examples/non_blocking_subscription.rb

@@ -0,0 +1,32 @@
+$: << 'lib'
+
+require 'hot_bunnies'
+
+
+connection = HotBunnies.connect(:host => 'localhost')
+channel = connection.create_channel
+channel.prefetch = 10
+
+exchange = channel.exchange('test', :type => :direct)
+
+queue = channel.queue('hello.world')
+queue.bind(exchange, :routing_key => 'xyz')
+queue.purge
+
+subscription = queue.subscribe(:ack => true, :blocking => false) do |headers, msg|
+  puts msg
+  headers.ack
+end
+
+100.times do |i|
+  exchange.publish("hello world! #{i}", :routing_key => 'xyz')
+end
+
+subscription.cancel
+
+puts "ALMOST ALL DONE!"
+
+at_exit do
+  channel.close
+  connection.close
+end

data/examples/non_blocking_subscription_with_executor.rb

@@ -0,0 +1,38 @@
+$: << 'lib'
+
+require 'hot_bunnies'
+
+import java.util.concurrent.Executors
+
+
+connection = HotBunnies.connect(:host => 'localhost')
+channel = connection.create_channel
+channel.prefetch = 10
+
+exchange = channel.exchange('test', :type => :direct)
+
+queue = channel.queue('hello.world')
+queue.bind(exchange, :routing_key => 'xyz')
+queue.purge
+
+thread_pool = Executors.new_fixed_thread_pool(3)
+
+subscription = queue.subscribe(:ack => true)
+subscription.each(:blocking => false, :executor => thread_pool) do |headers, msg|
+  puts msg
+  headers.ack
+end
+
+100.times do |i|
+  exchange.publish("hello world! #{i}", :routing_key => 'xyz')
+end
+
+thread_pool.shutdown_now
+subscription.cancel
+
+puts "ALMOST ALL DONE!"
+
+at_exit do
+  channel.close
+  connection.close
+end

data/hot_bunnies.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+$: << File.expand_path('../lib', __FILE__)
+
+require 'hot_bunnies/version'
+
+
+Gem::Specification.new do |s|
+  s.name        = 'hot_bunnies'
+  s.version     = HotBunnies::VERSION
+  s.platform    = 'java'
+  s.authors     = ['Theo Hultberg']
+  s.email       = ['theo@burtcorp.com']
+  s.homepage    = 'http://github.com/iconara/hot_bunnies'
+  s.summary     = %q{Ruby wrapper for the RabbitMQ Java driver}
+  s.description = %q{A object oriented interface to RabbitMQ that uses the Java driver under the hood}
+
+  s.rubyforge_project = 'hot_bunnies'
+
+  s.files         = `git ls-files`.split("\n")
+# s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+# s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+end

data/lib/hot_bunnies/channel.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module HotBunnies
+  module Channel
+    def queue(name, options={})
+      Queue.new(self, name, options)
+    end
+    
+    def exchange(name, options={})
+      Exchange.new(self, name, options)
+    end
+    
+    def qos(options={})
+      if options.size == 1 && options[:prefetch_count]
+      then basic_qos(options[:prefetch_count])
+      else basic_qos(options.fetch(:prefetch_size, 0), options.fetch(:prefetch_count, 0), options.fetch(:global, false))
+      end
+    end
+    
+    def prefetch=(n)
+      qos(:prefetch_count => n)
+    end
+  end
+end

data/lib/hot_bunnies/exchange.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module HotBunnies
+  class Exchange
+    attr_reader :name, :channel
+    
+    def initialize(channel, name, options={})
+      @channel = channel
+      @name = name
+      @options = {:type => :fanout, :durable => false, :auto_delete => false, :internal => false, :passive => false}.merge(options)
+      declare!
+    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], nil, body.to_java_bytes)
+    end
+    
+    def delete(options={})
+      @channel.exchange_delete(@name, options.fetch(:if_unused, false))
+    end
+    
+  private
+  
+    def declare!
+      unless @name == ''
+        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], nil)
+        end
+      end
+    end
+  end
+end

data/lib/hot_bunnies/queue.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+
+module HotBunnies
+  class Queue
+    attr_reader :name, :channel
+    
+    def initialize(channel, name, options={})
+      @channel = channel
+      @name = name
+      @options = {:durable => false, :exclusive => false, :auto_delete => false, :passive => false}.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, ''))
+    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, ''))
+    end
+    
+    def delete
+      @channel.queue_delete(@name)
+    end
+    
+    def purge
+      @channel.queue_purge(@name)
+    end
+    
+    def get(options={})
+      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
+      end
+    end
+    
+    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], nil)
+      end
+      @name = response.queue
+    end
+    
+    class Subscription
+      def initialize(channel, queue_name, options={})
+        @channel = channel
+        @queue_name = queue_name
+        @ack = options.fetch(:ack, false)
+      end
+      
+      def each(options={}, &block)
+        raise 'The subscription already has a message listener' if @subscriber
+        if options.fetch(:blocking, true)
+          run(&block)
+        else
+          if options[:executor]
+            @shut_down_executor = false
+            @executor = options[:executor]
+          else
+            @shut_down_executor = true
+            @executor = java.util.concurrent.Executors.new_single_thread_executor
+          end
+          @executor.submit { run(&block) }
+        end
+      end
+
+      def cancel
+        raise 'Can\'t cancel: the subscriber haven\'t received an OK yet' if !@subscriber || !@subscriber.consumer_tag
+        @channel.basic_cancel(@subscriber.consumer_tag)
+        @executor.shutdown_now if @executor && @shut_down_executor
+      end
+      
+    private
+    
+      def run(&block)
+        @subscriber = BlockingSubscriber.new(@channel, self)
+        @channel.basic_consume(@queue_name, !@ack, @subscriber.consumer)
+        @subscriber.on_message(&block)
+      end
+    end
+  
+    class Headers
+      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_ack(delivery_tag, options.fetch(:requeue, false))
+      end
+      
+      def delivery_tag
+        @envelope.delivery_tag
+      end
+    end
+  
+    module Subscriber
+      def start
+        # to be implemented by the host class
+      end
+      
+      def on_message(&block)
+        raise ArgumentError, 'Message listener already registered for this subscriber' if @subscriber
+        @subscriber = block
+        start
+      end
+      
+      def handle_message(consumer_tag, envelope, properties, body_bytes)
+        body = String.from_java_bytes(body_bytes)
+        case @subscriber.arity
+        when 2 then @subscriber.call(Headers.new(@channel, consumer_tag, envelope, properties), body)
+        when 1 then @subscriber.call(body)
+        else raise ArgumentError, 'Consumer callback wants no arguments'
+        end
+      end
+    end
+  
+    class BlockingSubscriber
+      include Subscriber
+      
+      attr_reader :consumer
+      
+      def initialize(channel, subscription)
+        @channel = channel
+        @subscription = subscription
+        @consumer = QueueingConsumer.new(@channel)
+      end
+      
+      def consumer_tag
+        @consumer.consumer_tag
+      end
+      
+      def start
+        super
+        while delivery = @consumer.next_delivery
+          result = handle_message(@consumer.consumer_tag, delivery.envelope, delivery.properties, delivery.body)
+          if result == :cancel
+            @subscription.cancel
+            while delivery = @consumer.next_delivery(0)
+              handle_message(@consumer.consumer_tag, delivery.envelope, delivery.properties, delivery.body)
+            end
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hot_bunnies/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module HotBunnies
+  VERSION = '1.1.2'
+end

data/lib/hot_bunnies.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'java'
+require 'ext/commons-io'
+require 'ext/rabbitmq-client'
+
+
+module HotBunnies
+  import com.rabbitmq.client.ConnectionFactory
+  import com.rabbitmq.client.Connection
+  import com.rabbitmq.client.Channel
+  import com.rabbitmq.client.DefaultConsumer
+  import com.rabbitmq.client.QueueingConsumer
+
+  CONNECTION_PROPERTIES = [:host, :port, :virtual_host, :connection_timeout, :username, :password]
+  
+  def self.connect(options={})
+    cf = ConnectionFactory.new
+    CONNECTION_PROPERTIES.each do |property|
+      if options[property]
+        cf.send("#{property}=".to_sym, options[property]) 
+      end
+    end
+    cf.new_connection
+  end
+end
+
+require 'hot_bunnies/channel'
+require 'hot_bunnies/queue'
+require 'hot_bunnies/exchange'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: hot_bunnies
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.1.2
+platform: java
+authors: 
+- Theo Hultberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-13 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: A object oriented interface to RabbitMQ that uses the Java driver under the hood
+email: 
+- theo@burtcorp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Rakefile
+- examples/blocking_subscription.rb
+- examples/non_blocking_subscription.rb
+- examples/non_blocking_subscription_with_executor.rb
+- hot_bunnies.gemspec
+- lib/ext/commons-io.jar
+- lib/ext/rabbitmq-client.jar
+- lib/hot_bunnies.rb
+- lib/hot_bunnies/channel.rb
+- lib/hot_bunnies/exchange.rb
+- lib/hot_bunnies/queue.rb
+- lib/hot_bunnies/version.rb
+has_rdoc: true
+homepage: http://github.com/iconara/hot_bunnies
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: hot_bunnies
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for the RabbitMQ Java driver
+test_files: []
+