jruby-hornetq 0.4.0 → 0.5.0.alpha

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'shoulda'
+end
+
+group :develop do
+  gem 'awesome_print'
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.10-java)
+    awesome_print (1.1.0)
+    i18n (0.6.4)
+    minitest (4.7.5)
+    multi_json (1.7.7)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.4)
+    shoulda-matchers (2.2.0)
+      activesupport (>= 3.0.0)
+    thread_safe (0.1.0)
+      atomic
+    tzinfo (0.3.37)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  awesome_print
+  shoulda

data/HISTORY.md

@@ -1,3 +1,9 @@
+## 0.5.0.alpha (2012-07-19)
+
+* Upgrade to HornetQ 2.3
+* HornetQ removed its own built-in logging classes, so corresponding
+  logging classes removed from jruby-hornetq
+
 ## 0.4.0 (2011-04-01)
 
 * Upgrade to HornetQ 2.2.2

data/README.md

@@ -3,11 +3,9 @@ jruby-hornetq
 
 * http://github.com/ClarityServices/jruby-hornetq
 
-Feedback is welcome and appreciated :)
-
 ### Introduction
 
-jruby-hornetq create a Ruby friendly API into the HornetQ Java libraries without 
+jruby-hornetq create a Ruby friendly API into the HornetQ Java libraries without
 compromising performance. It does this by sprinkling "Ruby-goodness" into the
 existing HornetQ Java classes and interfaces, I.e. By adding Ruby methods to
 the existing classes and interfaces. Since jruby-hornetq exposes the HornetQ
@@ -37,7 +35,7 @@ HornetQ
 
 For information on the HornetQ messaging and queuing system, see: http://www.jboss.org/hornetq
 
-For more documentation on any of the classes, see: http://docs.jboss.org/hornetq/2.2.2.Final/api/index.html
+For more documentation on any of the classes, see: http://docs.jboss.org/hornetq/2.3.0.Final/docs/api/hornetq-client/
 
 Concepts & Terminology
 ----------------------
@@ -51,7 +49,7 @@ messages. The consumer does not have to be running in order to receive messages.
 ### Address
 
 In traditional messaging and queuing systems there is only a queue when both
-read and writing messages. With the advent of AMQP and in HornetQ we now have 
+read and writing messages. With the advent of AMQP and in HornetQ we now have
 the concept of an Address which is different from a Queue.
 
 An Address can be thought of the address we would put on an envelope before
@@ -69,7 +67,7 @@ overhead of a disk write every time it is read or written (produced or consumed)
 ### Broker
 
 HornetQ is a broker based architecture which requires the use of one or more
-centralized brokers. A broker is much like the "server" through which all 
+centralized brokers. A broker is much like the "server" through which all
 messages pass through.
 
 An in-vm broker can be used for passing messages around within a Java
@@ -98,7 +96,7 @@ jruby-hornetq is primarily intended to make it easy to use the HornetQ client
 core API. It also supports running the HornetQ broker for scenarios such as
 in-vm messaging.
 
-The examples below address some of the messaging patterns that are used in 
+The examples below address some of the messaging patterns that are used in
 messaging and queuing.
 
 Producer-Consumer
@@ -106,29 +104,29 @@ Producer-Consumer
 
 Producer: Write messages to a queue:
 
+
     require 'rubygems'
     require 'hornetq'
-    
-    HornetQ::Client::Factory.create_session(:connection => {:uri => 'hornetq://localhost'}) do |session|
-      # Create Producer so that we can send messages to the Address 'jms.queue.ExampleQueue'
-      producer = session.create_producer('jms.queue.ExampleQueue')
-      
-      # Create a non-durable message to send
-      message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-      message << "#{Time.now}: ### Hello, World ###"
-      
-      producer.send(message)
-    end
 
+    connection = HornetQ::Client::Connection.new(:uri => 'hornetq://localhost/')
+    session = connection.create_session(:username=>'guest',:password=>'secret')
+
+    producer = session.create_producer('jms.queue.CMDBDataServicesQueue')
+    message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+    message.body_buffer.write_string('Hello World')
+    producer.send(message)
+    session.close
+    connection.close
 
-Consumer: Read message from a queue: 
+
+Consumer: Read message from a queue:
 
     require 'rubygems'
     require 'hornetq'
-    
+
     HornetQ::Client::Factory.start(:connection => {:uri => 'hornetq://localhost'}) do |session|
       consumer = session.create_consumer('jms.queue.ExampleQueue')
-      
+
       # Receive a single message, return immediately if no message available
       if message = consumer.receive_immediate
         puts "Received:[#{message.body}]"
@@ -145,25 +143,25 @@ Server: Receive requests and send back a reply
 
     require 'rubygems'
     require 'hornetq'
-    
+
     # Shutdown Server after 5 minutes of inactivity, set to 0 to wait forever
     timeout = 300000
-    
+
     HornetQ::Client::Factory.start(:connection => {:uri => 'hornetq://localhost'}) do |session|
       server = session.create_server('jms.queue.ExampleQueue', timeout)
-    
-      puts "Waiting for Requests..."  
+
+      puts "Waiting for Requests..."
       server.run do |request_message|
         puts "Received:[#{request_message.body}]"
-        
+
         # Create Reply Message
         reply_message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
         reply_message.body = "Echo [#{request_message.body}]"
-        
+
         # The result of the block is the message to be sent back to the client
         reply_message
       end
-    
+
       # Server will stop after timeout period after no messages received
       server.close
     end
@@ -173,17 +171,17 @@ Client: Send a request and wait for a reply
 
     require 'rubygems'
     require 'hornetq'
-    
+
     # Wait 5 seconds for a reply
     timeout = 5000
-    
+
     HornetQ::Client::Factory.start(:connection => {:uri => 'hornetq://localhost'}) do |session|
       requestor = session.create_requestor('jms.queue.ExampleQueue')
-    
+
       # Create non-durable message
       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
       message.body = "Request Current Time"
-      
+
       # Send message to the queue
       puts "Send request message and wait for Reply"
       if reply = requestor.request(message, timeout)
@@ -192,7 +190,7 @@ Client: Send a request and wait for a reply
       else
         puts "Time out, No reply received after #{timeout/1000} seconds"
       end
-      
+
       requestor.close
     end
 
@@ -228,7 +226,7 @@ The libraries required for the HornetQ Client and to start a simple Core API
 only Broker are included with the Gem.
 
 ### GenePool
- 
+
 GenePool is used to implement session pooling
 
 Running the Broker
@@ -314,4 +312,4 @@ See the License for the specific language governing permissions and
 limitations under the License.
 
 jruby-hornetq includes files from HornetQ, which is also licensed under
-the Apache License, Version 2.0: http://www.jboss.org/hornetq
+the Apache License, Version 2.0: http://www.jboss.org/hornetq

data/Rakefile

@@ -1,23 +1,28 @@
 raise "jruby-hornetq must be built with JRuby: try again with `jruby -S rake'" unless defined?(JRUBY_VERSION)
 
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
 require 'rake/clean'
 require 'rake/testtask'
 require 'date'
 require 'java'
+require 'hornetq/version'
 
 desc "Build gem"
 task :gem  do |t|
   gemspec = Gem::Specification.new do |s|
-    s.name = 'jruby-hornetq'
-    s.version = '0.4.0'
-    s.authors = ['Reid Morrison', 'Brad Pardee']
-    s.email = ['rubywmq@gmail.com', 'bpardee@gmail.com']
-    s.homepage = 'https://github.com/ClarityServices/jruby-hornetq'
-    s.date = Date.today.to_s
+    s.name        = 'jruby-hornetq'
+    s.version     = HornetQ::VERSION
+    s.authors     = ['Reid Morrison', 'Brad Pardee']
+    s.email       = ['reidmo@gmail.com', 'bpardee@gmail.com']
+    s.homepage    = 'https://github.com/ClarityServices/jruby-hornetq'
+    s.date        = Date.today.to_s
     s.description = 'JRuby-HornetQ is a Java and Ruby library that exposes the HornetQ Java API in a ruby friendly way. For JRuby only.'
-    s.summary = 'JRuby interface into HornetQ'
-    s.files = FileList["./**/*"].exclude('*.gem', './nbproject/*').map{|f| f.sub(/^\.\//, '')}
-    s.has_rdoc = true
+    s.summary     = 'JRuby interface into HornetQ'
+    s.files       = FileList["./**/*"].exclude(/.gem$/, /.log$/,/^nbproject/).map{|f| f.sub(/^\.\//, '')}
+    s.license     = "Apache License V2.0"
+    s.has_rdoc    = true
     s.executables = %w(hornetq_server)
     s.add_dependency "gene_pool", "~> 1.1.1"
   end

data/examples/advanced/batch_client.rb

@@ -10,7 +10,7 @@
 # This sample sends a total of 100 requests in batches of 10.
 # One thread sends requests and the other processes replies.
 # Once 80% of the replies are back, it will send the next batch
-#  
+#
 # Before running this sample, start server.rb first
 #
 
@@ -37,23 +37,23 @@ HornetQ::Client::Connection.connection(config[:connection]) do |connection|
   #                number of outstanding requests to have open at any time
   #                Default: 0.8
   #                (:max_outstanding_responses)
-  
+
   pattern_config = {
     :connection     => connection,
     :server_address => server_address,
     :completion_ratio => 0.8
   }
-  
+
   requestor = BatchRequestorPattern.new(connection, server_address) do |message|
     # Display an @ symbol for every reply received
     print '@'
   end
-  
+
   times = (batch_size/window_size).to_i
   puts "Performing #{times} loops"
-  
+
   times.times do |i|
-    
+
     window_size.times do |i|
       message = @session.create_message(true)
       message.type = :text
@@ -61,10 +61,10 @@ HornetQ::Client::Connection.connection(config[:connection]) do |connection|
       requestor.send(message)
       print "."
     end
-    
+
     # Wait for at least 80% of responses before sending more requests
     requestor.wait_for_outstanding_replies
-    
+
   end
   puts "Done sending requests, waiting for remaining replies"
   requestor.wait_for_all_outstanding_replies

data/examples/advanced/batch_requestor_pattern.rb

@@ -16,13 +16,13 @@
 require 'sync'
 
 class BatchRequestorPattern
-  
+
   attr_accessor :batch_size, :window_size, :completion_ratio
   attr_reader :reply_address, :reply_count, :send_count
-  
-  # 
+
+  #
   # Returns a new BatchRequestorPattern
-  # 
+  #
   # Parameters:
   # * connection: The HornetQ connection. Used for creating sessions for the
   #               pattern to run
@@ -31,18 +31,18 @@ class BatchRequestorPattern
   #   It can be used to perform specialized handling such as:
   # ** Aborting a batch process
   # ** Moving the response to another queue for re-queuing later
-  # 
+  #
   # Implementation:
-  # 
+  #
   # Creates a temporary reply to queue for receiving responses from the server
   #   Consists of the server_address following by a '.' and a UUID
-  #   
+  #
   # Uses Connection#on_message to process replies in a separate thread
-  # 
+  #
   # If the connection is started, it will start consuming replies immediately,
   # otherwise it will only start processing replies once the connection has
   # been started.
-  # 
+  #
   # Sending of messages should be done by only one thread at a time since
   # this pattern shares the same session and producer for sending messages
   #
@@ -59,9 +59,9 @@ class BatchRequestorPattern
     connection        = params.delete(:connection)
     server_address    = params.delete(:server_address)
     @completion_ratio = params.delete(:completion_ratio).to_f
-    
+
     raise "Invalid :completion_ratio of #{@completion_ratio}. Must be between 0 and 1 inclusive" unless @completion_ratio.between?(0,1)
-    
+
     @session = connection.create_session
     @producer = @session.create_producer(server_address)
     @reply_address = "#{server_address}.#{Java::java.util::UUID.randomUUID.toString}"
@@ -70,19 +70,19 @@ class BatchRequestorPattern
     @reply_count = 0
     @send_count = 0
     @reply_block = reply_block
-    
+
     # Start consuming replies. The Address and Queue names are the same
     connection.on_message(:queue_name => @reply_address) {|message| process_reply(message) }
   end
-  
+
   # Return the current message count
   def reply_count
     @reply_count_sync.synchronize(:SH) { @reply_count }
   end
-  
+
   # Send a message to the server, setting the reply to address to the temporary
   # address created by this pattern
-  # 
+  #
   # Sending of messages should be done by only one thread at a time since
   # this pattern shares the same session and producer for sending messages
   #
@@ -92,17 +92,17 @@ class BatchRequestorPattern
     @producer.send(message)
     @send_count += 1
   end
-  
-  # Retry Sending a message to the server, setting the reply to address to the 
+
+  # Retry Sending a message to the server, setting the reply to address to the
   # temporary address created by this pattern
-  # 
+  #
   # Only call this method when a reply is received and we want to resend a
   # previous request
-  # 
-  # Note: This method will decrement the number of messages received by 1 
-  #       and will Not increment the number of messages sent, since it is 
+  #
+  # Note: This method will decrement the number of messages received by 1
+  #       and will Not increment the number of messages sent, since it is
   #       considered to have already been sent
-  # 
+  #
   # ReSending and Sending of messages should be done by only one thread at a time since
   # this pattern shares the same session and producer for sending messages
   # #TODO Should we rather just add a Sync around the producer?
@@ -111,53 +111,53 @@ class BatchRequestorPattern
   # Returns the total number of messages sent so far in this batch
   def resend(message)
     message.reply_to_address = @reply_address
-    
+
     # Decrement Reply Message counter
-    @reply_count_sync.synchronize(:EX) { @reply_count -= 1 }  
+    @reply_count_sync.synchronize(:EX) { @reply_count -= 1 }
     @producer.send(message)
   end
-  
+
   # Receive Reply messages, calling the supplied reply handler block to support
   # custom error handling
-  # 
+  #
   # Returns result of reply block supplied to constructor
   def process_reply(message)
     # Increment reply message counter
     @reply_count_sync.synchronize(:EX) { @reply_count += 1 }
-    
+
     result = @reply_block.call(message) if @reply_block
     message.acknowledge
     result
   end
-  
+
   # Release resources used by this pattern
   def close
     @producer.close
     @session.close
   end
-  
+
   # Wait for replies from server until the required number of responses has been
   # received based on the completion ratio
-  # 
+  #
   # For example a completion ration of 0.8 will wait for at least 80% of replies
   # to be received. So if 10 requests were sent this method would only return
   # once 8 or more replies have been received
-  # 
+  #
   # #TODO Need a Timeout here
   def wait_for_outstanding_replies
     while self.reply_count >= self.completion_ratio * self.send_count
       sleep 0.1
     end
   end
-  
+
   # Wait for replies from server until the required number of responses has been
   # received based on the completion ratio
-  # 
+  #
   # #TODO Need a Timeout here
   def wait_for_all_outstanding_replies
     while self.reply_count >= self.send_count
       sleep 0.1
     end
   end
-  
+
 end