jruby-hornetq 0.2.3.alpha → 0.2.5.alpha

data/README.md

@@ -44,6 +44,8 @@ HornetQ
 
 For information on the HornetQ messaging and queuing system, see:
 
+For more documentation on any of the classes, see: http://hornetq.sourceforge.net/docs/hornetq-2.1.0.Final/api/index.html?org/hornetq/api/core/client/package-summary.html
+
 Concepts & Terminology
 ----------------------
 

data/Rakefile

@@ -8,7 +8,7 @@ desc "Build gem"
 task :gem  do |t|
   gemspec = Gem::Specification.new do |s|
     s.name = 'jruby-hornetq'
-    s.version = '0.2.3.alpha'
+    s.version = '0.2.5.alpha'
     s.authors = ['Reid Morrison', 'Brad Pardee']
     s.email = ['rubywmq@gmail.com', 'bpardee@gmail.com']
     s.homepage = 'https://github.com/ClarityServices/jruby-hornetq'

data/examples/advanced/transaction-failover/producer.rb

@@ -14,7 +14,6 @@ constants = config['constants']
 
 # Create a HornetQ session
 HornetQ::Client::Factory.session(config['client']) do |session|
-  session.delete_queue(constants[:queue]) rescue nil
   session.create_queue(constants[:address], constants[:queue], constants[:durable])
   producer = session.create_producer(constants[:address])
   start_time = Time.now

data/examples/client/advanced/batch_client.rb

@@ -25,7 +25,7 @@ request_address = 'jms.queue.ExampleQueue'
 
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
-class BatchClient
+class BatchClientPattern
   def initialize(session, request_address)
     @producer = session.create_producer(request_address)
     reply_queue = "#{request_address}.#{Java::java.util::UUID.randomUUID.toString}"
@@ -62,7 +62,7 @@ class BatchClient
     #print "Sending #{total_count} messages"
     start_time = Time.now
     total_count.times do |i|
-      message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+      message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
       message.reply_to_queue_name = @consumer.queue_name
       message.body = "Request Current Time. #{i}"
       @producer.send(message)
@@ -99,7 +99,7 @@ end
 HornetQ::Client::Factory.session(config) do |session|
   batching_size = total_count if batching_size > total_count
   
-  client = BatchClient.new(session, request_address)
+  client = BatchClientPattern.new(session, request_address)
   
   # Start receive thread
   receive_thread = Thread.new {client.receive}

data/examples/client/resque/hornetq_job.rb

@@ -0,0 +1,197 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../../lib'
+
+require 'rubygems'
+require 'resque/job_with_status' # in rails you would probably do this in an initializer
+require 'yaml'
+require 'hornetq'
+require 'sync'
+
+# The Batch Client Pattern submits requests to a server following the Server Pattern
+#
+# A good example of when to use the Batch Client Pattern is when processing large
+# batch files. Rather than just flood the queue with every record from a file
+# the Batch Client Pattern can be used to only send out a batch of requests at
+# a time and when sufficient responses have been received, send another batch.
+# 
+# The following additional features can be implemented in this pattern
+# * Stop the batch if say 80% of records fail in the first batch, etc.
+# * Support pause and resume of batch processing
+# * Support restart and recoverability
+# 
+# See the Resque example for implementations of some of the above capabilities
+#
+class BatchClientPattern
+  def initialize(session, request_address)
+    @producer = session.create_producer(request_address)
+    reply_queue = "#{request_address}.#{Java::java.util::UUID.randomUUID.toString}"
+    begin
+      session.create_temporary_queue(reply_queue, reply_queue)
+    rescue NativeException => exc
+      p exc
+    end
+    @consumer = session.create_consumer(reply_queue)
+    @session = session
+    session.start
+    
+    @counter_sync = Sync.new
+    @processed = 0
+  end
+  
+  # Before re-using a batch pattern, reset all internal counters
+  def reset
+    @counter_sync.synchronize(:EX) do
+      @failed    = 0
+      @sucessful = 0
+    end
+  end
+  
+  # Return the current message count
+  def processed
+    @counter_sync.synchronize(:SH) { @sucessful + @processed }
+  end
+  
+  # Increment Successful response counter by supplied count
+  def inc_sucessful(count=1)
+    @counter_sync.synchronize(:EX) { @sucessful += count }
+  end
+
+  # Return the current message count
+  def sucessful
+    @counter_sync.synchronize(:SH) { @sucessful }
+  end
+  
+  # Increment Successful response counter by supplied count
+  def inc_failed(count=1)
+    @counter_sync.synchronize(:EX) { @failed += count }
+  end
+
+  # Return the current message count
+  def failed
+    @counter_sync.synchronize(:SH) { @failed }
+  end
+  
+  # Send x messages
+  def send(total_count)
+    #print "Sending #{total_count} messages"
+    start_time = Time.now
+    total_count.times do |i|
+      message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
+      message.reply_to_queue_name = @consumer.queue_name
+      message.body = "Request Current Time. #{i}"
+      @producer.send(message)
+      print "."
+      #puts "Sent:#{message}"
+    end
+    duration = Time.now - start_time
+    #printf "\nSend %5d msg, %5.2f s, %10.2f msg/s\n", total_count, duration, total_count/duration
+  end
+  
+  # Receive Reply messages calling the supplied block for each message
+  # passing in the message received from the server.
+  # After the block returns, the message is automatically acknowledged
+  def receive(&block)
+    print "Receiving messages"
+    raise "Missing mandatory block" unless block
+    begin
+      while reply = @consumer.receive
+        block.call(reply)
+        reply.acknowledge
+      end
+    rescue Exception => exc
+      p exc
+    end
+  end
+  
+  def close
+    @producer.close
+    @consumer.close
+    @session.delete_queue(@consumer.queue_name)
+  end
+end
+
+# sleeps for _length_ seconds updating the status every second
+#
+#
+# Create a Resque Job with the ability to report status
+#
+class HornetQJob < Resque::JobWithStatus
+  
+  # Set the name of the queue to use for this Job Worker
+  @queue = "hornetq_job"
+
+  # Must be an instance method for Resque::JobWithStatus
+  def perform
+    total_count    = (options['total_count'] || 4000).to_i
+    batching_size  = (options['batching_size'] || 80).to_i
+    address        = options['address'] || 'processor'
+    receive_thread = nil
+    
+    # Create a HornetQ session
+    count = 0
+    HornetQ::Client::Factory.session('hornetq://localhost') do |session|
+      batching_size = total_count if batching_size > total_count
+  
+      client = BatchClient.new(session, address)
+  
+      # Start receive thread
+      receive_thread = Thread.new do
+        client.receive do |message|
+          print '@'
+          client.inc_sucessful
+        end
+      end
+  
+      times = (total_count/batching_size).to_i
+      puts "Performing #{times} loops"
+      times.times do |i|
+        at(count, total_count, "At #{count} of #{total_count}")
+        client.send(batching_size)
+        count += batching_size
+        # Wait for at least 80% of responses
+        loop do
+          #puts "Waiting for receive"
+          sleep 0.1
+          received_count = client.counter
+          #puts "\nReceived #{received_count} messages"
+          if received_count >= 0.8 * count
+            puts ""
+            break 
+          end
+        end
+      end
+  
+      while client.counter < total_count
+        sleep 0.1
+        print "*"
+      end
+      client.close
+    end
+    receive_thread.kill if receive_thread
+    completed('num' => total_count, 'description' => "Completed #{count} of #{total_count}")
+  end
+
+end
+
+# Submit a new request at the command line
+if __FILE__ == $0
+  # Make sure you have a worker running
+  # jruby resque_worker.rb
+  
+  options = {
+    'total_count' => (ARGV[0] || 4000).to_i,
+    'batching_size' => (ARGV[1] || 40).to_i,
+    'address' => 'processor'
+  }
+  # running the job
+  puts "Creating the HornetQJob"
+  job_id = HornetQJob.create(options)
+  puts "Got back #{job_id}"
+  
+  # check the status until its complete
+  while status = Resque::Status.get(job_id) and !status.completed? && !status.failed? &&!status.killed?
+    sleep 1
+    puts status.inspect
+  end
+  puts status.inspect
+end

data/examples/client/resque/processor.rb

@@ -0,0 +1,41 @@
+#
+# Processor:
+#    Process requests submitted by Resque Worker and reply
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+# Let server shutdown on its own after 5 minutes of inactivity. Set to 0 to wait forever
+timeout = (ARGV[0] || 300000).to_i
+
+q_name = 'processor'
+
+HornetQ::Client::Factory.start('hornetq://localhost') do |session|
+  begin
+    # Create durable queue with matching address
+    session.create_queue(q_name, q_name, true)
+  rescue
+    # Ignore when queue already exists
+  end
+  
+  server = session.create_server(q_name, timeout)
+
+  puts "Waiting for Requests..."  
+  server.run do |request_message|
+    print "."
+    
+    # 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, or nil if no reply
+    reply_message
+  end
+
+  # Server will stop after timeout period after no messages received. Set to 0 to wait forever
+  server.close
+end

data/examples/client/resque/readme.md

@@ -0,0 +1,33 @@
+Overview
+
+This example shows how to use Resque to initiate a Job which in turn submits all
+its work to processors.
+
+## Architecture
+
+The architecture for this example uses:
+### Initiator
+
+An _initiator_ which enqueues the job to be completed
+
+### Resque Worker
+
+A _resque worker_ which manages the job itself. The _resque worker_ in turn submits
+requests to the _task worker_.
+
+### Processor
+
+A _processor_ performs the actual work and receives its requests over a
+hornetq queue. It replies back to the _resque worker_ when complete
+
+
+Requirements
+
+Install the following gems
+* resque
+* resque-status
+** https://github.com/quirkey/resque-status
+
+Start the Resque Job worker
+
+Start the Task workers

data/examples/client/resque/resque_conf.rb

@@ -0,0 +1 @@
+require 'resque/status_server'

data/examples/client/resque/resque_worker.rb

@@ -0,0 +1,22 @@
+# Start up a Resque Worker to run the Job Request
+require 'rubygems'
+require 'resque'
+require 'resque/job_with_status'
+require 'sleep_job'
+require 'hornetq_job'
+
+# Number of workers to start (each on its own thread)
+thread_count = (ARGV[0] || 1).to_i
+
+# Configure Redis client connection
+Resque.redis = "localhost:6379"
+
+# How long to keep Job status for in seconds
+Resque::Status.expire_in = (24 * 60 * 60) # 24hrs in seconds
+
+# Start the worker instance(s) in which Jobs are run
+resque_worker = Resque::Worker.new("hornetq_job")
+resque_worker.log "Starting worker #{resque_worker}"
+resque_worker.verbose = true
+resque_worker.very_verbose = true
+resque_worker.work(5) # Redis Poll interval in seconds

data/examples/client/resque/sleep_job.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'resque/job_with_status' # in rails you would probably do this in an initializer
+
+# sleeps for _length_ seconds updating the status every second
+#
+#
+# Create a Resque Job with the ability to report status
+#
+class SleepJob < Resque::JobWithStatus
+  
+  # Set the name of the queue to use for this Job Worker
+  @queue = "sleep_job"
+
+  # Must be an instance method for Resque::JobWithStatus
+  def perform
+    total = options['length'].to_i || 10
+    num = 0
+    while num < total
+      at(num, total, "At #{num} of #{total}")
+      sleep(1)
+      num += 1
+    end
+    completed
+  end
+
+end
+
+# Submit a new request at the command line
+if __FILE__ == $0
+  # Make sure you have a worker running
+  # jruby resque_worker.rb
+  
+  count = (ARGV[0] || 10).to_i
+
+  # running the job
+  puts "Creating the SleepJob"
+  job_id = SleepJob.create :length => count
+  puts "Got back #{job_id}"
+  
+  # check the status until its complete
+  while status = Resque::Status.get(job_id) and !status.completed? && !status.failed?
+    sleep 1
+    puts status.inspect
+  end
+end

data/examples/simple_worker/README

@@ -0,0 +1,14 @@
+# Window 1:
+# Step 1
+hornetq_server hornetq.yml standalone_server
+# Wait for HornetQ Server version ... started
+
+# Window 2:
+# Step 2
+./producer.rb
+
+# Window 3:
+# Step 3
+./worker.rb
+
+#Should be able to cntl-c and restart producer and worker without issues.

data/examples/simple_worker/hornetq.yml

@@ -0,0 +1,34 @@
+standalone_server:
+  :uri:                 hornetq://localhost:15445
+  :data_directory:      ./data
+  :persistence_enabled: true
+  :security_enabled:    false
+
+client:
+  :connector:
+    :uri:   hornetq://localhost:15445
+  :session:
+    :username:          guest
+    :password:          guest
+  :session_pool:
+    :pool_size:         3
+    :pool_warn_timeout: 0.25
+    :username:          guest
+    :password:          guest
+
+  :addresses:
+    address1:
+      :serialize: ruby_marshal
+      :unique:    true
+      :durable:   true
+      :queues:
+        queue1_1:
+        queue1_2:
+
+    address2:
+      :serialize: json
+      :unique:    false
+      :durable:   false
+      :queues:
+        queue2_1:
+        queue2_2: