jruby-hornetq 0.2.0.alpha

data/lib/hornetq/hornet_q_client.rb

@@ -0,0 +1,388 @@
+require 'uri'
+
+module HornetQClient
+
+  # Import Message Constants
+  import Java::org.hornetq.api.core.Message
+
+  # Netty Class name
+  NETTY_CLASS_NAME ='org.hornetq.core.remoting.impl.netty.NettyConnectorFactory'
+  INVM_CLASS_NAME = 'org.hornetq.core.remoting.impl.invm.InVMAcceptorFactory'
+  DEFAULT_NETTY_PORT = 5445
+
+  class Factory
+    # Create a new Factory from which sessions can be created
+    #
+    # Parameters:
+    # * a Hash consisting of one or more of the named parameters
+    # * Summary of parameters and their default values
+    #  HornetQClient::Factory.new(
+    #    :uri                            => 'hornetq://localhost',
+    #    :ack_batch_size                 => ,
+    #    :auto_group                     => ,
+    #    :block_on_acknowledge           => ,
+    #    :block_on_durable_send          => ,
+    #    :block_on_non_durable_send      => ,
+    #    :cache_large_messages_client    => ,
+    #    :call_timeout                   => ,
+    #    :client_failure_check_period    => ,
+    #    :confirmation_window_size       => ,
+    #    :connection_load_balancing_policy_class_name => ,
+    #    :connection_ttl                 => ,
+    #    :consumer_max_rate              => ,
+    #    :consumer_window_size           => ,
+    #    :discovery_address              => ,
+    #    :discovery_initial_wait_timeout => ,
+    #    :discovery_port                 => ,
+    #    :discovery_refresh_timeout      => ,
+    #    :failover_on_initial_connection => true,
+    #    :failover_on_server_shutdown    => true,
+    #    :group_id                       => ,
+    #    :initial_message_packet_size    => ,
+    #    :java_object                    => ,
+    #    :local_bind_address             => ,
+    #    :max_retry_interval             => ,
+    #    :min_large_message_size         => ,
+    #    :pre_acknowledge                => ,
+    #    :producer_max_rate              => ,
+    #    :producer_window_size           => ,
+    #    :reconnect_attempts             => 1,
+    #    :retry_interval                 => ,
+    #    :retry_interval_multiplier      => ,
+    #    :scheduled_thread_pool_max_size => ,
+    #    :static_connectors              => ,
+    #    :thread_pool_max_size           => ,
+    #    :use_global_pools               =>
+    #  )
+    #
+    # Mandatory Parameters
+    # * :uri
+    #   * The hornetq uri as to which server to connect with and which
+    #     transport protocol to use. Format:
+    #       hornetq://server:port,backupserver:port/?protocol=[netty|discover]
+    #   * To use the default netty transport
+    #       hornetq://server:port
+    #   * To use the default netty transport and specify a backup server
+    #       hornetq://server:port,backupserver:port
+    #   * To use auto-discovery
+    #       hornetq://server:port/?protocol=discovery
+    #   * To use HornetQ within the current JVM
+    #       hornetq://invm
+    #
+    # Optional Parameters
+    # * :ack_batch_size
+    # * :auto_group
+    # * :block_on_acknowledge
+    # * :block_on_durable_send
+    # * :block_on_non_durable_send
+    # * :cache_large_messages_client
+    # * :call_timeout
+    # * :client_failure_check_period
+    # * :confirmation_window_size
+    # * :connection_load_balancing_policy_class_name
+    # * :connection_ttl
+    # * :consumer_max_rate
+    # * :consumer_window_size
+    # * :discovery_address
+    # * :discovery_initial_wait_timeout
+    # * :discovery_port
+    # * :discovery_refresh_timeout
+    # * :failover_on_initial_connection
+    # * :failover_on_server_shutdown
+    # * :group_id
+    # * :initial_message_packet_size
+    # * :java_object
+    # * :local_bind_address
+    # * :max_retry_interval
+    # * :min_large_message_size
+    # * :pre_acknowledge
+    # * :producer_max_rate
+    # * :producer_window_size
+    # * :reconnect_attempts
+    # * :retry_interval
+    # * :retry_interval_multiplier
+    # * :scheduled_thread_pool_max_size
+    # * :static_connectors
+    # * :thread_pool_max_size
+    # * :use_global_pools
+
+    def initialize(parms={})
+      raise "Missing :uri under :connector in config" unless uri = parms[:uri]
+      # TODO: Support :uri as an array for cluster configurations
+
+      scheme, userinfo, host, port, registry, path, opaque, query, fragment = URI.split(uri)
+      raise InvalidURIError,"bad URI(only scheme hornetq:// is supported): #{uri}" unless scheme == 'hornetq'
+      backup_host = backup_port = nil
+
+      # Check for multiple server names
+      if registry
+        host, backup_host = registry.split(',')
+        host, port = host.split(':')
+        backup_host, backup_port = backup_host.split(':')
+      end
+
+      # Extract settings passed in query
+      settings = {}
+      if query
+        query.split(';').each do |i|
+          key, value = i.split('=')
+          settings[key] = value
+        end
+      end
+
+      # Determine transport protocol
+      factory = nil
+      # In-VM Transport has no fail-over or additional parameters
+      if host == 'invm'
+        transport = Java::org.hornetq.api.core.TransportConfiguration.new(INVM_CLASS_NAME)
+        factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+      elsif settings[:protocol]
+        # Auto-Discovery just has a host name and port
+        if settings[:protocol] == 'discovery'
+          factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(host, port)
+        elsif settings[:protocol] != 'netty'
+          raise "Unknown HornetQ protocol:#{settings[:protocol]}"
+        end
+      end
+
+      # Unless already created, then the factory will use the netty protocol
+      unless factory
+        # Primary Transport
+        raise "Mandatory hostname missing in :uri" unless host
+        port ||= DEFAULT_NETTY_PORT
+        transport = Java::org.hornetq.api.core.TransportConfiguration.new(NETTY_CLASS_NAME, {'host' => host, 'port' => Java::java.lang.Integer.new(port)})
+
+        # Check for backup server connection information
+        if backup_host
+          backup_port ||= DEFAULT_NETTY_PORT
+          backup_transport = Java::org.hornetq.api.core.TransportConfiguration.new(NETTY_CLASS_NAME, {'host' => backup_host, 'port' => Java::java.lang.Integer.new(backup_port)})
+          factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport, backup_transport)
+        else
+          factory = Java::org.hornetq.api.core.client.HornetQClient.create_client_session_factory(transport)
+        end
+      end
+
+      # If any other options were supplied, apply them to the created Factory instance
+      parms.each_pair do |key, val|
+        next if key == :uri
+        method = key.to_s+'='
+        if factory.respond_to? method
+          factory.send method, val
+          #puts "Debug: #{key} = #{factory.send key}" if factory.respond_to? key.to_sym
+        else
+          puts "Warning: Option:#{key}, with value:#{val} is invalid and being ignored"
+        end
+      end
+
+      @factory = factory
+    end
+
+    # 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:
+    # * The returned session MUST be closed once complete
+    #     factory = HornetQClient::Factory.new(:uri => 'hornetq://localhost/')
+    #     session = factory.create_session
+    #       ...
+    #     session.close
+    #     factory.close
+    # * It is recommended to rather call HornetQClient::Factory.create_session
+    #   so that all resouces are closed automatically
+    #     HornetQClient::Factory.create_session(:uri => 'hornetq://localhost/') do |session|
+    #       ...
+    #     end
+    #
+    # Returns:
+    # * A new HornetQ ClientSession
+    # * See org.hornetq.api.core.client.ClientSession for documentation on returned object
+    #
+    # Throws:
+    # * NativeException
+    # * ...
+    # 
+    # Example:
+    #   require 'hornetq'
+    #
+    #   factory = nil
+    #   begin
+    #     factory = HornetQClient::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(HornetQClient::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 = HornetQClient::Factory.new(:uri => 'hornetq://localhost/')
+    #     session = factory.create_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(HornetQClient::Message::TEXT_TYPE,true)
+    #     message.body_buffer.write_string('Hello World')
+    #
+    #     # Send the message
+    #     producer.send(message)
+    #   ensure
+    #     session.close if session
+    #     factory.close if factory
+    #   end
+    #
+    # Parameters:
+    # * a Hash consisting of one or more of the named parameters
+    # * Summary of parameters and their default values
+    #  factory.create_session(
+    #   :username          => 'my_username',   # Default is no authentication
+    #   :password          => 'password',      # Default is no authentication
+    #   :xa                => false,
+    #   :auto_commit_sends => true,
+    #   :auto_commit_acks  => true,
+    #   :pre_acknowledge   => false,
+    #   :ack_batch_size    => 1
+    #   )
+    #
+    # Mandatory Parameters
+    # * None
+    #
+    # Optional Parameters
+    # * :username
+    #   * The user name. To create an authenticated session
+    #
+    # * :password
+    #   * The user password. To create an authenticated session
+    #
+    # * :xa
+    #   * Whether the session supports XA transaction semantics or not
+    #
+    # * :auto_commit_sends
+    #   * true: automatically commit message sends
+    #   * false: commit manually
+    #
+    # * :auto_commit_acks
+    #   * true: automatically commit message acknowledgement
+    #   * false: commit manually
+    #
+    # * :pre_acknowledge
+    #   * true: to pre-acknowledge messages on the server
+    #   * false: to let the client acknowledge the messages
+    #   * Note: It is possible to pre-acknowledge messages on the server so that the
+    #     client can avoid additional network trip to the server to acknowledge
+    #     messages. While this increases performance, this does not guarantee
+    #     delivery (as messages can be lost after being pre-acknowledged on the
+    #     server). Use with caution if your application design permits it.
+    #
+    #  * :ack_batch_size
+    #    * the batch size of the acknowledgements
+    #
+    def create_session(parms={}, &proc)
+      raise "HornetQClient Factory Already Closed" unless @factory
+      if proc
+        session = nil
+        result = nil
+        begin
+          #session = @factory.create_session(true, true)
+          session = @factory.create_session(
+            parms[:username],
+            parms[:password],
+            parms[:xa] || false,
+            parms[:auto_commit_sends].nil? ? true : parms[:auto_commit_sends],
+            parms[:auto_commit_acks].nil? ? true : parms[:auto_commit_acks],
+            parms[:pre_acknowledge] || false,
+            parms[:ack_batch_size] || 1)
+          result = proc.call(session)
+        ensure
+          session.close if session
+        end
+        result
+      else
+        @factory.create_session(
+          parms[:username],
+          parms[:password],
+          parms[:xa] || false,
+          parms[:auto_commit_sends].nil? ? true : parms[:auto_commit_sends],
+          parms[:auto_commit_acks].nil? ? true : parms[:auto_commit_acks],
+          parms[:pre_acknowledge] || false,
+          parms[:ack_batch_size] || 1)
+      end
+    end
+
+    # Create a Session pool
+    def create_session_pool(parms={})
+      SessionPool.new(self, parms)
+    end
+    
+    # Close Factory connections
+    def close
+      @factory.close if @factory
+      @factory = nil
+    end
+
+    # Create a new Factory and Session
+    # 
+    #  Creates a new factory and session, then passes the session to the supplied
+    #  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(parms={},&proc)
+      raise "Missing mandatory code block" unless proc
+      factory = nil
+      session = nil
+      begin
+        factory = self.new(parms[:connector] || {})
+        session = factory.create_session(parms[:session] || {}, &proc)
+      ensure
+        factory.close if factory
+      end
+    end
+    
+    # Call the supplied code block after creating a factory instance
+    # See initialize for the parameter list
+    # The factory is closed before returning
+    # 
+    # Returns the result of the code block
+    def self.create_factory(parms={}, &proc)
+      raise "Missing mandatory code block" unless proc
+      factory = nil
+      result = nil
+      begin
+        factory=self.new(parms)
+        result = proc.call(factory)
+      ensure
+        factory.close
+      end
+      result
+    end
+
+  end
+  
+end

data/lib/hornetq/org_hornetq_api_core_client_client_session.rb

@@ -0,0 +1,16 @@
+# Add methods to Session Interface
+module Java::org.hornetq.api.core.client::ClientSession
+  
+  # To be consistent create Requestor from Session
+  def create_requestor(request_address)
+    #Java::org.hornetq.api.core.client::ClientRequestor.new(self, request_address);
+    HornetQClient::ClientRequestor.new(self, request_address)
+  end
+  
+  # Create a server handler for receiving requests and responding with
+  # replies to the supplied address
+  def create_server(input_queue, timeout=0)
+    HornetQClient::ClientServer.new(self, input_queue, timeout)
+  end
+end
+

data/lib/hornetq/org_hornetq_core_client_impl_client_message_impl.rb

@@ -0,0 +1,166 @@
+
+# Cannot add to the interface Java::org.hornetq.api.core::Message because these
+# methods access instance variables in the Java object
+class Java::OrgHornetqCoreClientImpl::ClientMessageImpl
+  # Attributes
+  # attr_accessor :address, :type, :durable, :expiration, :priority, :timestamp, :user_id
+  
+  # Is this a request message for which a reply is expected?
+  def request?
+    contains_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME)
+  end
+  
+  # Return the Reply To Queue Name as a string
+  def reply_to_queue_name
+    get_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME)
+  end
+
+  # Set the Reply To Queue Name
+  #  When supplied, the consumer of the message is expected to send a response to the
+  #  specified queue. However, this is by convention, so no response is guaranteed
+  # Note: Rather than set this directly, consider creating a ClientRequestor:
+  #     requestor = session.create_requestor('Request Queue')
+  #
+  def reply_to_queue_name=(name)
+    val = nil
+    if name.is_a? Java::org.hornetq.api.core::SimpleString
+      val = name
+    else
+      val = Java::org.hornetq.api.core::SimpleString.new(name.to_s)
+    end
+
+    put_string_property(Java::OrgHornetqCoreClientImpl::ClientMessageImpl::REPLYTO_HEADER_NAME, val)
+  end
+
+  # Return the size of the encoded message
+  # attr_reader :encode_size
+
+  # Return the body for this message
+  # TODO: Do remaining message Types
+  # 
+  # WARNING: This method can only be called ONCE!
+  # WARNING: Do not call after setting the body otherwise the send will have
+  #          an empty body
+  def body
+    case type
+    when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
+    when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
+    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
+    when Java::org.hornetq.api.core.Message::STREAM_TYPE 	#6
+    when Java::org.hornetq.api.core.Message::TEXT_TYPE 	#3
+      body_buffer.read_nullable_simple_string.to_string
+    else
+      raise "Unknown Message Type, use Message#body_buffer instead"
+    end
+  end
+  
+  # Write data into the message body
+  # 
+  # Data is automatically converted based on the message type
+  # 
+  # TODO Support non-string Types
+  def <<(data)
+    case type
+    when Java::org.hornetq.api.core.Message::BYTES_TYPE  #4
+    when Java::org.hornetq.api.core.Message::DEFAULT_TYPE 	#0
+      raise "Cannot use Message#<< when the Message#type has not been set"
+    when Java::org.hornetq.api.core.Message::MAP_TYPE 	#5
+      if data.class == Java::org.hornetq.utils::TypedProperties
+        body_buffer.reset_writer_index
+        data.encode(body_buffer)
+      elsif data.responds_to? :each_pair
+        properties = Java::org.hornetq.utils::TypedProperties.new
+        properties.from_hash(data)
+        body_buffer.reset_writer_index
+        properties.encode(body_buffer)
+      end
+    when Java::org.hornetq.api.core.Message::OBJECT_TYPE 	#2
+    when Java::org.hornetq.api.core.Message::STREAM_TYPE 	#6
+    when Java::org.hornetq.api.core.Message::TEXT_TYPE 	#3
+      if data.class == 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
+    else
+      raise "Unknown Message Type, use Message#body_buffer instead"
+    end
+  end
+  
+  # Get a property
+  def [](key)
+    getObjectProperty(key.to_s)
+  end
+
+  # Set a property
+  # TODO: Does it need proper translation, otherwise it will be a Ruby object
+  def []=(key,value)
+    putObjectProperty(key, value)
+  end
+
+  # Does this message include the supplied property?
+  def include?(key)
+    # Ensure a Ruby true is returned
+    property_exists(key.to_s) == true
+  end
+
+  # call-seq:
+  #   body_buffer
+  #
+  # Return the message body as a HornetQBuffer
+  #
+
+  # call-seq:
+  #   to_map
+  #
+  # Return the Message as a Map
+  #
+
+  # call-seq:
+  #   remove_property(key)
+  #
+  # Remove a property
+
+  # call-seq:
+  #   contains_property(key)
+  #
+  # Returns true if this message contains a property with the given key
+  # TODO: Symbols?
+
+  # Return TypedProperties
+  def getProperties
+    properties
+  end
+
+  # Iterate over all the properties
+  #
+  def properties_each_pair(&proc)
+    enum = getPropertyNames
+    while enum.has_more_elements
+      key = enum.next_element
+      proc.call key, getObjectProperty(key)
+    end
+  end
+
+  # Return all message Attributes as a hash
+  def attributes
+    {
+      :address => address.nil? ? '' : address.to_string,
+      :type => type,
+      :durable => durable,
+      :expiration => expiration,
+      :priority => priority,
+      :timestamp => timestamp,
+      :user_id => user_id,
+      :encode_size => encode_size
+    }
+  end
+
+  # Does not include the body since it can only read once
+  def inspect
+    "#{self.class.name}:\nAttributes: #{attributes.inspect}\nProperties: #{properties.inspect}"
+  end
+
+end

data/lib/hornetq/org_hornetq_core_client_impl_client_producer_impl.rb

@@ -0,0 +1,5 @@
+# TODO Support send(String)
+# TODO Support send(:data => string, :durable=>true, :address=>'MyAddress')
+#
+class Java::org.hornetq.core.client.impl::ClientProducerImpl
+end

data/lib/hornetq/org_hornetq_utils_typed_properties.rb

@@ -0,0 +1,60 @@
+# Used by HornetQ to move around HashMap messages
+# Ruby methods added to make it behave like a Ruby Hash
+class Java::org.hornetq.utils::TypedProperties 
+  # Get a property
+  def [](key)
+    value = getProperty(key)
+    (value.class == Java::org.hornetq.api.core::SimpleString) ? value.to_s : value
+  end
+
+  # Set a property
+  #   Currently supports Long, Double, Boolean
+  # TODO: Not supported Byte, Bytes, Short, Int, FLoat, Char
+  def []=(key,val)
+    case
+    when val.class == Fixnum # 1
+      putLongProperty(key,val)
+    when val.class == Float #1.1
+      putDoubleProperty(key,val)
+    when val.class == Bignum # 11111111111111111
+      putLongProperty(key,val)
+    when (val.class == TrueClass) || (val.class == FalseClass)
+      putBooleanProperty(key,val)
+    when val.class == NilClass
+      setSimpleStringProperty(key,null)
+    when val.class == Java::org.hornetq.api.core::SimpleString
+      setSimpleStringProperty(key,val)
+    else
+      putSimpleStringProperty(key,val.to_s)
+    end
+  end
+  
+  # Iterate through each key,value pair
+  def each_pair(&proc)
+    it = property_names.iterator
+    while it.has_next
+      key = it.next
+      proc.call(key.to_string, self[key])
+    end
+  end
+  
+  # Convert Properties to a Ruby Hash
+  def to_h
+    h = {}
+    each_pair do |key, value| 
+      h[key] = value
+    end
+    h
+  end
+  
+  # Write Hash values into this TyedProperties instance
+  def from_h(hash)
+    hash.each_pair do |key,value|
+      self[key] = value
+    end
+  end
+  
+  def inspect
+    "#{self.class.name}: #{to_h.inspect}"
+  end
+end