jruby-hornetq 0.2.1.alpha → 0.2.3.alpha

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.1.alpha'
+    s.version = '0.2.3.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/README

@@ -0,0 +1,20 @@
+# Window 1:
+# Step 1
+rm -rf data data_backup
+hornetq_server hornetq.yml backup_server
+# Wait for HornetQ Server version ... started
+
+# Window 2:
+# Step 2
+hornetq_server hornetq.yml live_server &
+# Step 5
+# View window 3&4 looking for "1000" signifying that 1000 messages have been produced/consumed
+kill -9 %1 (or whatever the background job id for the server is) (or start in the foreground and just cntl-c)
+
+# Window 3:
+# Step 3
+./producer.rb 10000
+
+# Window 4:
+# Step 4
+./consumer.rb

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env jruby
+#
+# HornetQ Consumer:
+#          Write messages to the queue
+#
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+
+timeout = (ARGV[0] || 3000).to_i
+
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
+constants = config['constants']
+
+# Create a HornetQ session
+HornetQ::Client::Factory.session(config['client']) do |session|
+  consumer = session.create_consumer(constants[:queue])
+  session.start
+
+  i = 0
+  start_time = Time.now
+  while message = consumer.receive(timeout)
+    i += 1
+    message.acknowledge
+    expected_message = "Message ##{i}"
+    if message.body != expected_message
+      puts "Unexpected message: #{message.body} Expected: #{expected_message}"
+      i = $1.to_i if message.body =~ /Message #(\d+)/
+    end
+    puts "#{i}\n" if i%1000 == 0
+  end
+  duration = Time.now - start_time - timeout/1000
+  puts "Received #{i} messages in #{duration} seconds at #{i/duration} messages per second"
+end

data/examples/advanced/transaction-failover/hornetq.yml

@@ -0,0 +1,29 @@
+backup_server:
+  :uri:                 hornetq://localhost:15446
+  :backup:              true
+  :data_directory:      ./data_backup
+  :persistence_enabled: true
+  :security_enabled:    false
+
+live_server:
+  :uri:                 hornetq://localhost:15445,localhost:15446
+  :data_directory:      ./data
+  :persistence_enabled: true
+  :security_enabled:    false
+
+client:
+  :connector:
+    :uri:                            hornetq://localhost:15445,localhost:15446
+    :failover_on_initial_connection: true
+    :failover_on_server_shutdown:    true
+    # 5 Connection attempts takes about 16 seconds before it switches to the backup server
+    :reconnect_attempts:             5
+
+  :session:
+    :username: guest
+    :password: guest
+
+constants:
+  :address: test_address
+  :queue:   test_queue
+  :durable: true

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env jruby
+#
+# HornetQ Producer:
+#          Write messages to the queue
+#
+
+require 'rubygems'
+require 'yaml'
+require 'hornetq'
+
+count = (ARGV[0] || 1).to_i
+config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
+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
+
+  puts "Sending messages"
+  (1..count).each do |i|
+    message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, true)
+    # Set the message body text
+    message.body = "Message ##{i}"
+    message.put_string_property(Java::org.hornetq.api.core.SimpleString.new(HornetQ::Client::Message::HDR_DUPLICATE_DETECTION_ID.to_s), Java::org.hornetq.api.core.SimpleString.new("uniqueid#{i}"))
+    # Send message to the queue
+    begin
+      producer.send(message)
+    rescue Java::org.hornetq.api.core.HornetQException => e
+      puts "Received producer exception: #{e.message} with code=#{e.cause.code}"
+      if e.cause.code == Java::org.hornetq.api.core.HornetQException::UNBLOCKED
+        puts "Retrying the send"
+        retry
+      end
+    end
+    #puts message
+    puts "#{i}\n" if i%1000 == 0
+  end
+
+  duration = Time.now - start_time
+  puts "Delivered #{count} messages in #{duration} seconds at #{count/duration} messages per second"
+end

data/examples/client/advanced/batch_client.rb

@@ -64,7 +64,7 @@ class BatchClient
     total_count.times do |i|
       message = @session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
       message.reply_to_queue_name = @consumer.queue_name
-      message << "Request Current Time. #{i}"
+      message.body = "Request Current Time. #{i}"
       @producer.send(message)
       print "."
       #puts "Sent:#{message}"
@@ -96,7 +96,7 @@ class BatchClient
 end
 
 # Create a HornetQ session
-HornetQ::Client::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.session(config) do |session|
   batching_size = total_count if batching_size > total_count
   
   client = BatchClient.new(session, request_address)

data/examples/client/advanced/bytes_producer.rb

@@ -0,0 +1,21 @@
+#
+# HornetQ Producer:
+#          Write messages to the queue
+#
+
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../../lib'
+
+require 'rubygems'
+require 'hornetq'
+
+HornetQ::Client::Factory.session('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::BYTES_TYPE,false)
+  message.body = "#{Time.now}: ### Hello, World ###"
+  
+  producer.send(message)
+end

data/examples/client/advanced/client.rb

@@ -16,7 +16,7 @@ timeout = (ARGV[1] || 30000).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQ::Client::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.session(config) do |session|
   #session.create_queue('Example', 'Example', true)
   requestor = session.create_requestor('jms.queue.ExampleQueue')
   session.start
@@ -26,7 +26,7 @@ HornetQ::Client::Factory.create_session(config) do |session|
   (1..count).each do |i|
     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
     # Set the message body text
-    message << "Request Current Time"
+    message.body = "Request Current Time"
     # Set the user managed message id
     message.user_id = Java::org.hornetq.utils::UUIDGenerator.getInstance.generateUUID
     # Send request message and wait for reply

data/examples/client/advanced/consumer.rb

@@ -15,7 +15,7 @@ timeout = (ARGV[0] || 1000).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQ::Client::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.session(config) do |session|
   consumer = session.create_consumer('jms.queue.ExampleQueue')
   session.start
   

data/examples/client/advanced/multi_client.rb

@@ -26,7 +26,7 @@ def worker_thread(id, session_pool)
     # Obtain a session from the pool and return when complete
     session_pool.requestor('jms.queue.ExampleQueue') do |session, requestor|
       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-      message << "Request Current Time"
+      message.body = "Request Current Time"
     
       # Send message to the queue
       puts "Thread[#{id}]: Sending Request"

data/examples/client/advanced/producer.rb

@@ -14,7 +14,7 @@ count = (ARGV[0] || 1).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQ::Client::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.session(config) do |session|
   producer = session.create_producer('jms.queue.ExampleQueue')
   start_time = Time.now
 
@@ -22,7 +22,7 @@ HornetQ::Client::Factory.create_session(config) do |session|
   (1..count).each do |i|
     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
     # Set the message body text
-    message << "#{Time.now}: ### Hello, World ###"
+    message.body = "#{Time.now}: ### Hello, World ###"
     # Send message to the queue
     producer.send(message)
     #puts message

data/examples/client/advanced/server.rb

@@ -15,7 +15,7 @@ timeout = (ARGV[0] || 60000).to_i
 config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
 
 # Create a HornetQ session
-HornetQ::Client::Factory.create_session(config) do |session|
+HornetQ::Client::Factory.session(config) do |session|
   server = session.create_server('jms.queue.ExampleQueue', timeout)
   session.start
   
@@ -28,7 +28,7 @@ HornetQ::Client::Factory.create_session(config) do |session|
     puts "#{count}" if count%1000 == 0
     puts "Durable" if request_message.durable
     reply_message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, false)
-    reply_message << "Test Response"
+    reply_message.body = "Test Response"
     reply_message
   end
   

data/examples/client/invm.rb

@@ -22,7 +22,7 @@ HornetQ::Server::Factory.start('hornetq://invm') do |server|
   
     # Create a non-durable message to send
     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-    message << "#{Time.now}: ### Hello, World ###"
+    message.body = "#{Time.now}: ### Hello, World ###"
   
     producer.send(message)
   

data/examples/client/producer.rb

@@ -9,13 +9,13 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
 require 'rubygems'
 require 'hornetq'
 
-HornetQ::Client::Factory.create_session(:connector=> {:uri => 'hornetq://localhost'}) do |session|
+HornetQ::Client::Factory.session('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 ###"
+  message.body = "#{Time.now}: ### Hello, World ###"
   
   producer.send(message)
 end

data/lib/hornetq/client/factory.rb

@@ -155,12 +155,8 @@ module HornetQ::Client
 
     # Create a new HornetQ session
     # 
-    # If a block is passed in the block will be passed the session as a parameter
-    # and this method will return the result of the block. The session is
-    # always closed once the proc completes
-    # 
-    # If no block is passed, a new session is returned and it is the responsibility
-    # of the caller to close the session
+    # Note: Remember to close the session once it is no longer used.
+    #       Recommend using #session with a block over this method where possible
     #
     # Note:
     # * The returned session MUST be closed once complete
@@ -169,11 +165,6 @@ module HornetQ::Client
     #       ...
     #     session.close
     #     factory.close
-    # * It is recommended to rather call HornetQ::Client::Factory.create_session
-    #   so that all resouces are closed automatically
-    #     HornetQ::Client::Factory.create_session(:uri => 'hornetq://localhost/') do |session|
-    #       ...
-    #     end
     #
     # Returns:
     # * A new HornetQ ClientSession
@@ -187,31 +178,6 @@ module HornetQ::Client
     #   require 'hornetq'
     #
     #   factory = nil
-    #   begin
-    #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
-    #     factory.create_session do |session|
-    #
-    #       # Create a new queue
-    #       session.create_queue('Example', 'Example', true)
-    #
-    #       # Create a producer to send messages
-    #       producer = session.create_producer('Example')
-    #
-    #       # Create a Text Message
-    #       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
-    #       message << 'Hello World'
-    #
-    #       # Send the message
-    #       producer.send(message)
-    #     end
-    #   ensure
-    #     factory.close if factory
-    #   end
-    #
-    # Example:
-    #   require 'hornetq'
-    #
-    #   factory = nil
     #   session = nil
     #   begin
     #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
@@ -280,37 +246,64 @@ module HornetQ::Client
     #  * :ack_batch_size
     #    * the batch size of the acknowledgements
     #
-    def create_session(params={}, &proc)
+    def create_session(params={})
       raise "HornetQ::Client::Factory Already Closed" unless @factory
-      if proc
-        session = nil
-        result = nil
-        begin
-          session = @factory.create_session(
-            params[:username],
-            params[:password],
-            params[:xa] || false,
-            params[:auto_commit_sends].nil? ? true : params[:auto_commit_sends],
-            params[:auto_commit_acks].nil? ? true : params[:auto_commit_acks],
-            params[:pre_acknowledge] || false,
-            params[:ack_batch_size] || 1)
-          result = proc.call(session)
-        ensure
-          session.close if session
-        end
-        result
-      else
-        @factory.create_session(
-          params[:username],
-          params[:password],
-          params[:xa] || false,
-          params[:auto_commit_sends].nil? ? true : params[:auto_commit_sends],
-          params[:auto_commit_acks].nil? ? true : params[:auto_commit_acks],
-          params[:pre_acknowledge] || false,
-          params[:ack_batch_size] || 1)
-      end
+      @factory.create_session(
+        params[:username],
+        params[:password],
+        params[:xa] || false,
+        params[:auto_commit_sends].nil? ? true : params[:auto_commit_sends],
+        params[:auto_commit_acks].nil? ? true : params[:auto_commit_acks],
+        params[:pre_acknowledge] || false,
+        params[:ack_batch_size] || 1)
     end
 
+    # Create a session, call the supplied block and once it completes
+    # close the session.
+    # See session_create for the Parameters
+    # 
+    # Returns the result of the block
+    # 
+    # Example
+    #     HornetQ::Client::Factory.create_session(:uri => 'hornetq://localhost/') do |session|
+    #       session.create_queue("Address", "Queue")
+    #     end    
+    #
+    # Example:
+    #   require 'hornetq'
+    #
+    #   factory = nil
+    #   begin
+    #     factory = HornetQ::Client::Factory.new(:uri => 'hornetq://localhost/')
+    #     factory.create_session do |session|
+    #
+    #       # Create a new queue
+    #       session.create_queue('Example', 'Example', true)
+    #
+    #       # Create a producer to send messages
+    #       producer = session.create_producer('Example')
+    #
+    #       # Create a Text Message
+    #       message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,true)
+    #       message.body = 'Hello World'
+    #
+    #       # Send the message
+    #       producer.send(message)
+    #     end
+    #   ensure
+    #     factory.close if factory
+    #   end
+    def session(params={}, &proc)
+      raise "HornetQ::Client::session mandatory block missing" unless proc
+      session = nil
+      begin
+        session = create_session(params)
+        proc.call(session)
+      ensure
+        session.close if session
+      end
+    end
+    
     # Create a Session pool
     # TODO Raise an exception when gene_pool is not available
     def create_session_pool(params={})
@@ -330,7 +323,7 @@ module HornetQ::Client
     #  block. Upon completion the session and factory are both closed
     # See Factory::initialize and Factory::create_session for the list
     #  of parameters
-    def self.create_session(params={},&proc)
+    def self.session(params={},&proc)
       raise "Missing mandatory code block" unless proc
       factory = nil
       session = nil
@@ -338,10 +331,10 @@ module HornetQ::Client
         if params.kind_of?(String)
           # TODO: Support passing username and password from URI to Session
           factory = self.new(params)
-          session = factory.create_session({}, &proc)
+          session = factory.session({}, &proc)
         else
           factory = self.new(params[:connector] || {})
-          session = factory.create_session(params[:session] || {}, &proc)
+          session = factory.session(params[:session] || {}, &proc)
         end
       ensure
         session.close if session
@@ -356,7 +349,7 @@ module HornetQ::Client
     # See Factory::initialize and Factory::create_session for the list
     #  of parameters
     def self.start(params={},&proc)
-      create_session(params) do |session|
+      session(params) do |session|
         session.start
         proc.call(session)
       end

data/lib/hornetq/client/org_hornetq_core_client_impl_client_message_impl.rb

@@ -48,12 +48,35 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
     case type
     when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
       buf = body_buffer
-      String.new(buf.read_bytes(buf.readable_bytes))
+      buf.reset_reader_index
+      available = body_size
+      result = ""      
+      bytes_size = 1024
+      bytes = Java::byte[bytes_size].new
+      
+      while (n = available < bytes_size ? available : bytes_size) > 0
+        buf.read_bytes(bytes, 0, n)
+        if n == bytes_size
+          result << String.from_java_bytes(bytes)
+        else
+          result << String.from_java_bytes(bytes)[0..n-1]
+        end
+        available -= n
+      end
+      result
+      
     when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
+      #TODO Default Type?
+      
     when Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
       Java::org.hornetq.utils::TypedProperties.new.decode(body_buffer)
+      
     when Java::org.hornetq.api.core.Message::OBJECT_TYPE 	#2
+      # TODO Java Object Type
+      
     when Java::org.hornetq.api.core.Message::STREAM_TYPE 	#6
+      #TODO Stream Type
+      
     when Java::org.hornetq.api.core.Message::TEXT_TYPE 	#3
       body_buffer.read_nullable_simple_string.to_string
     else
@@ -63,89 +86,52 @@ class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
   
   # Write data into the message body
   # 
+  # Note: The message type Must be set before calling this method
+  # 
   # Data is automatically converted based on the message type
   # 
-  # DEPRECATED
-  def <<(data)
+  def body=(data)
+    body_buffer.reset_writer_index
     case type
+      
     when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
-      body_buffer.write_bytes(data)
-    when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
-      raise "Cannot use Message#<< when the Message#type has not been set"
+      body_buffer.write_bytes(data.respond_to?(:to_java_bytes) ? data.to_java_bytes : data)
+      
     when Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
-      if data.class == Java::org.hornetq.utils::TypedProperties
-        body_buffer.reset_writer_index
+      if data.kind_of? Java::org.hornetq.utils::TypedProperties
         data.encode(body_buffer)
       elsif data.responds_to? :each_pair
+        # Ruby Hash, or anything that responds to :each_pair
+        # TODO What about Hash inside of Hash?
         properties = Java::org.hornetq.utils::TypedProperties.new
-        properties.from_hash(data)
-        body_buffer.reset_writer_index
+        data.each_pair do |key, val|
+          properties[key.to_s] = val
+        end
         properties.encode(body_buffer)
+      else
+        raise "Unrecognized data type #{data.class.name} being set when the message type is MAP"
       end
+      
     when Java::org.hornetq.api.core.Message::OBJECT_TYPE 	#2
+      # Serialize Java Object
+      # TODO Should we do the serialize here?
+      body_buffer.write_bytes(data)
+      
     when Java::org.hornetq.api.core.Message::STREAM_TYPE 	#6
+      # TODO Stream Type
+      
     when Java::org.hornetq.api.core.Message::TEXT_TYPE 	#3
-      if data.class == Java::org.hornetq.api.core::SimpleString
+      if data.kind_of? Java::org.hornetq.api.core::SimpleString
         body_buffer.writeNullableSimpleString(data)
       else
         body_buffer.writeNullableSimpleString(Java::org.hornetq.api.core::SimpleString.new(data.to_s))
       end
+      
+    when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
+      raise "The Message#type must be set before attempting to set the message body"
+      
     else
-      raise "Unknown Message Type, use Message#body_buffer instead"
-    end
-  end
-  
-  # Set the body of the message
-  # The type of the message is automatically set based on the type passed in.
-  # The following types are automatically supported in order of priority
-  #   String                                   => :text
-  #   Java::org.hornetq.api.core::SimpleString => :text
-  #   Java::org.hornetq.utils::TypedProperties => :map
-  #   Hash (actually any object responding to  => :map
-  def body=(data)
-    body_buffer.reset_writer_index
-    if data.is_a? String
-      # Ruby String
-      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE
-      body_buffer.writeNullableSimpleString(Java::org.hornetq.api.core::SimpleString.new(data))
-    elsif data.is_a? Java::org.hornetq.api.core::SimpleString
-      # SimpleString instance
-      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE
-      body_buffer.writeNullableSimpleString(data)
-    elsif data.is_a? Java::org.hornetq.utils::TypedProperties
-      # TypedProperties
-      self.type = Java::org.hornetq.api.core.Message::MAP_TYPE
-      data.encode(body_buffer)
-    elsif data.responds_to? :each_pair
-      # Ruby Hash, or anything that responds to :each_pair
-      # TODO What about Hash inside of Hash?
-      self.type = Java::org.hornetq.api.core.Message::MAP_TYPE
-      properties = Java::org.hornetq.utils::TypedProperties.new
-      data.each_pair do |key, val|
-        properties[key.to_s] = val
-      end
-      properties.encode(body_buffer)
-    elsif data.responds_to? :to_s
-      # Can be converted to a Ruby String
-      self.type = Java::org.hornetq.api.core.Message::TEXT_TYPE
-      body_buffer.writeNullableSimpleString(Java::org.hornetq.api.core::SimpleString.new(data.to_s))
-    else
-      # Otherwise Serialize Ruby object
-      self.type = Java::org.hornetq.api.core.Message::BYTES_TYPE
-      self['encoding', 'jruby']
-      # If BYTES type is not working we could use Base64.encode64
-      self << Marshal.dump(data)
-      self.text = encoded
-    end
-  end
-  
-  # Serialize JRuby object and base64 encode
-  def decode
-    if self.get_string_property( 'torquebox_encoding' ) == 'base64'
-      serialized = Base64.decode64( self.text )
-      Marshal.restore( serialized )
-    else
-      self.text
+      raise "Unknown Message Type, use Message#body_buffer directly"
     end
   end
   

data/lib/hornetq/client/session_pool.rb

@@ -95,7 +95,7 @@ module HornetQ::Client
       # Example
       #   session_pool.producer('MyAddress') do |session, producer|
       #     message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-      #     message << "#{Time.now}: ### Hello, World ###"
+      #     message.body = "#{Time.now}: ### Hello, World ###"
       #     producer.send(message)
       #   end
       def producer(address, &block)

data/lib/hornetq/server/factory.rb

@@ -20,25 +20,10 @@ module HornetQ::Server
       config.journal_directory = "#{data_directory}/journal"
       config.large_messages_directory = "#{data_directory}/large-messages"
 
-      parms.each_pair do |key, val|
-        method = key.to_s+'='
-        if config.respond_to? method
-          config.send method, val
-          #puts "Debug: #{key} = #{config.send key}" if config.respond_to? key.to_sym
-        else
-          puts "Warning: Option:#{key} class=#{key.class} with value:#{val} is invalid and being ignored"
-        end
-      end
-
-      if Java::org.hornetq.core.journal.impl.AIOSequentialFileFactory.isSupported
-        config.journal_type = Java::org.hornetq.core.server.JournalType::ASYNCIO
-      else
-        puts("AIO wasn't located on this platform, it will fall back to using pure Java NIO. If your platform is Linux, install LibAIO to enable the AIO journal");
-        config.journal_type = Java::org.hornetq.core.server.JournalType::NIO
-      end
-
       if uri.host == 'invm'
         acceptor = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::INVM_ACCEPTOR_CLASS_NAME)
+        config.persistence_enabled = false
+        config.security_enabled    = false
       else
         acceptor = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_ACCEPTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
         connector = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.host, 'port' => uri.port })
@@ -50,6 +35,12 @@ module HornetQ::Server
       acceptor_conf_set.add(acceptor)
       config.acceptor_configurations = acceptor_conf_set
 
+      if Java::org.hornetq.core.journal.impl.AIOSequentialFileFactory.isSupported
+        config.journal_type = Java::org.hornetq.core.server.JournalType::ASYNCIO
+      else
+        puts("AIO wasn't located on this platform, it will fall back to using pure Java NIO. If your platform is Linux, install LibAIO to enable the AIO journal");
+        config.journal_type = Java::org.hornetq.core.server.JournalType::NIO
+      end
 
       if parms[:backup]
         puts "backup"
@@ -67,6 +58,16 @@ module HornetQ::Server
         puts 'standalone'
       end
 
+      parms.each_pair do |key, val|
+        method = key.to_s+'='
+        if config.respond_to? method
+          config.send method, val
+          #puts "Debug: #{key} = #{config.send key}" if config.respond_to? key.to_sym
+        else
+          puts "Warning: Option:#{key} class=#{key.class} with value:#{val} is invalid and being ignored"
+        end
+      end
+
       return Java::org.hornetq.core.server.HornetQServers.newHornetQServer(config)
     end
     

data/test/server_factory_test.rb

@@ -45,20 +45,20 @@ class ServerFactoryTest < Test::Unit::TestCase
       }
 
       # Create a HornetQ session
-      HornetQ::Client::Factory.create_session(config) do |session|
+      HornetQ::Client::Factory.session(config) do |session|
         session.create_queue(queue_name, queue_name, true)
         producer = session.create_producer(queue_name)
         (1..count).each do |i|
           message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
           message.durable = true
           # Set the message body text
-          message << "Message ##{i}"
+          message.body = "Message ##{i}"
           # Send message to the queue
           producer.send(message)
         end
       end
 
-      HornetQ::Client::Factory.create_session(config) do |session|
+      HornetQ::Client::Factory.session(config) do |session|
         consumer = session.create_consumer(queue_name)
         session.start
 
@@ -124,14 +124,13 @@ class ServerFactoryTest < Test::Unit::TestCase
 
       @producer_thread = MyThread.new('producer') do
         # Create a HornetQ session
-        HornetQ::Client::Factory.create_session(@config) do |session|
+        HornetQ::Client::Factory.session(@config) do |session|
           session.create_queue(@queue_name, @queue_name, true)
           producer = session.create_producer(@queue_name)
           (1..@count).each do |i|
-            message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-            message.durable = true
+            message = session.create_message(HornetQ::Client::Message::TEXT_TYPE, true)
             # Set the message body text
-            message << "Message ##{i}"
+            message.body = "Message ##{i}"
             # Send message to the queue
             begin
               puts "Producing message: #{message.body}"
@@ -163,7 +162,7 @@ class ServerFactoryTest < Test::Unit::TestCase
     should 'failover to backup server w/o message loss' do
       # Let the producer create the queue
       sleep 2
-      HornetQ::Client::Factory.create_session(@config) do |session|
+      HornetQ::Client::Factory.session(@config) do |session|
         consumer = session.create_consumer(@queue_name)
         session.start
 

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: jruby-hornetq
 version: !ruby/object:Gem::Version 
-  prerelease: true
-  segments: 
-    - 0
-    - 2
-    - 1
-    - alpha
-  version: 0.2.1.alpha
+  prerelease: 6
+  version: 0.2.3.alpha
 platform: ruby
 authors: 
   - Reid Morrison
@@ -16,20 +11,17 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-26 00:00:00 -05:00
+date: 2011-01-27 00:00:00 -05:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: gene_pool
     prerelease: false
     requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
       requirements: 
         - - ~>
           - !ruby/object:Gem::Version 
-            segments: 
-              - 1
-              - 1
-              - 1
             version: 1.1.1
     type: :runtime
     version_requirements: *id001
@@ -49,12 +41,17 @@ files:
   - Rakefile
   - README.md
   - bin/hornetq_server
+  - examples/advanced/transaction-failover/consumer.rb
+  - examples/advanced/transaction-failover/hornetq.yml
+  - examples/advanced/transaction-failover/producer.rb
+  - examples/advanced/transaction-failover/README
   - examples/client/client.rb
   - examples/client/consumer.rb
   - examples/client/invm.rb
   - examples/client/producer.rb
   - examples/client/server.rb
   - examples/client/advanced/batch_client.rb
+  - examples/client/advanced/bytes_producer.rb
   - examples/client/advanced/client.rb
   - examples/client/advanced/consumer.rb
   - examples/client/advanced/hornetq.yml
@@ -62,6 +59,10 @@ files:
   - examples/client/advanced/multi_consumer.rb
   - examples/client/advanced/producer.rb
   - examples/client/advanced/server.rb
+  - examples/client/data/bindings/hornetq-bindings-1.bindings
+  - examples/client/data/bindings/hornetq-bindings-2.bindings
+  - examples/client/data/journal/hornetq-data-1.hq
+  - examples/client/data/journal/hornetq-data-2.hq
   - examples/server/backup_server.yml
   - examples/server/live_server.yml
   - examples/server/standalone_server.yml
@@ -96,25 +97,21 @@ rdoc_options: []
 require_paths: 
   - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-          - 0
         version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
     - - ">"
       - !ruby/object:Gem::Version 
-        segments: 
-          - 1
-          - 3
-          - 1
         version: 1.3.1
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: JRuby interface into HornetQ