jruby-hornetq 0.2.5.alpha → 0.3.0.alpha

data/examples/client/advanced/multi_consumer.rb

@@ -1,54 +0,0 @@
-#
-# HornetQ Consumer:
-#          Multi-threaded Consumer
-#
-
-# Allow examples to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../../lib'
-
-require 'rubygems'
-require 'yaml'
-require 'hornetq'
-
-# Arguments: 'number of threads' 'timeout'
-$thread_count = (ARGV[0] || 3).to_i
-$timeout = (ARGV[1] || 1000).to_i
-
-config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
-
-def worker(id, session)
-  begin
-    consumer = session.create_consumer('jms.queue.ExampleQueue')
-    session.start
-  
-    count = 0
-    start_time = Time.now
-    while message = consumer.receive($timeout)
-      count = count + 1
-      message.acknowledge
-      #puts "=================================="
-      #text = message.body
-      #p text
-      #p message
-      puts "Durable" if message.durable
-      print "#{id}."
-    end
-    duration = Time.now - start_time - $timeout/1000
-    puts "\nReceived #{count} messages in #{duration} seconds at #{count/duration} messages per second"
-  rescue Exception => exc
-    puts "Thread #{id} Terminating"
-    p exc
-  ensure
-    session.close
-  end
-end
-
-# Create a HornetQ session
-HornetQ::Client::Factory.create_factory(config[:connector]) do |factory|
-  threads = []
-  $thread_count.times do |i|
-    session = factory.create_session(config[:session])
-    threads << Thread.new { worker(i, session) }
-  end
-  threads.each {|t| t.join}
-end

data/examples/client/advanced/producer.rb

@@ -1,35 +0,0 @@
-#
-# 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 'yaml'
-require 'hornetq'
-
-count = (ARGV[0] || 1).to_i
-config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
-
-# Create a HornetQ session
-HornetQ::Client::Factory.session(config) do |session|
-  producer = session.create_producer('jms.queue.ExampleQueue')
-  start_time = Time.now
-
-  puts "Sending messages"
-  (1..count).each do |i|
-    message = session.create_message(HornetQ::Client::Message::TEXT_TYPE,false)
-    # Set the message body text
-    message.body = "#{Time.now}: ### Hello, World ###"
-    # Send message to the queue
-    producer.send(message)
-    #puts message
-    puts "#{i}\n" if i%1000 == 0
-    puts "Durable" if message.durable
-  end
-
-  duration = Time.now - start_time
-  puts "Delivered #{count} messages in #{duration} seconds at #{count/duration} messages per second"
-end

data/examples/client/advanced/server.rb

@@ -1,39 +0,0 @@
-#
-# HornetQ Consumer:
-#      Reply to a request
-#
-
-# Allow examples to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../../lib'
-
-require 'rubygems'
-require 'yaml'
-require 'hornetq'
-
-timeout = (ARGV[0] || 60000).to_i
-
-config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')['development']
-
-# Create a HornetQ session
-HornetQ::Client::Factory.session(config) do |session|
-  server = session.create_server('jms.queue.ExampleQueue', timeout)
-  session.start
-  
-  count = 0
-  start_time = Time.now
-  puts "Server started and waiting for requests ..."
-  server.run do |request_message|
-    count += 1
-    print '.'
-    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.body = "Test Response"
-    reply_message
-  end
-  
-  duration = Time.now - start_time - timeout/1000
-  puts "\nReceived #{count} requests in #{duration} seconds at #{count/duration} messages per second"
-  
-  server.close
-end

data/examples/client/client.rb

@@ -1,31 +0,0 @@
-#
-# HornetQ Requestor:
-#      Submit a request and wait for a reply
-#
-
-# Allow examples to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
-
-require 'rubygems'
-require 'hornetq'
-
-timeout = (ARGV[0] || 5000).to_i
-
-HornetQ::Client::Factory.start(:connector=> {: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)
-    puts "Received Response: #{reply.inspect}"
-    puts "  Message: #{reply.body.inspect}"
-  else
-    puts "Time out, No reply received after #{timeout/1000} seconds"
-  end
-  
-  requestor.close
-end

data/examples/client/consumer.rb

@@ -1,22 +0,0 @@
-#
-# HornetQ Consumer:
-#          Write a single message 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.start(:connector=> {: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}]"
-    message.acknowledge
-  else
-    puts "No message found"
-  end
-end

data/examples/client/producer.rb

@@ -1,21 +0,0 @@
-#
-# 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::TEXT_TYPE,false)
-  message.body = "#{Time.now}: ### Hello, World ###"
-  
-  producer.send(message)
-end

data/examples/client/server.rb

@@ -1,31 +0,0 @@
-#
-# HornetQ Consumer:
-#      Reply to a request
-#
-
-# Allow examples to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
-
-require 'rubygems'
-require 'hornetq'
-
-timeout = (ARGV[0] || 60000).to_i
-
-HornetQ::Client::Factory.start(:connector=> {:uri => 'hornetq://localhost'}) do |session|
-  server = session.create_server('jms.queue.ExampleQueue', timeout)
-
-  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
-    reply_message
-  end
-
-  # Server will stop after timeout period after no messages received. Set to 0 to wait foreve
-  server.close
-end

data/examples/simple_worker/hornetq.yml

@@ -1,34 +0,0 @@
-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:

data/examples/simple_worker/producer.rb

@@ -1,54 +0,0 @@
-#!/usr/bin/env jruby
-#
-# HornetQ Producer:
-#          Write messages to the queue
-#
-
-require 'rubygems'
-require 'yaml'
-require 'hornetq'
-require 'logger'
-require 'test_object'
-
-config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
-client = config['client']
-
-# Create a HornetQ session
-logger = Logger.new($stdout)
-factory = HornetQ::Client::Factory.new(client[:connector])
-session_pool = factory.create_session_pool(client[:session_pool])
-producer_manager = HornetQ::Client::ProducerManager.new(session_pool, client[:addresses], true)
-
-['HUP', 'INT', 'TERM'].each do |signal_name|
-  Signal.trap(signal_name) do
-    puts "caught #{signal_name}"
-    $stopped = true
-  end
-end
-
-$stopped = false
-threads = []
-(1..5).each do |i|
-  threads << Thread.new(i) do |thread_count|
-    msg_count = 0
-    while !$stopped
-      msg_count += 1
-      obj = TestObject.new("Message ##{thread_count}-#{msg_count}")
-      producer_manager.send('address1', obj)
-      sleep 1
-    end
-  end
-end
-(6..10).each do |i|
-  threads << Thread.new(i) do |thread_count|
-    msg_count = 0
-    while !$stopped
-      msg_count += 1
-      obj = {:thread => thread_count, :message => msg_count}
-      producer_manager.send('address2', obj)
-      sleep 2
-    end
-  end
-end
-
-threads.each { |thread| thread.join }

data/examples/simple_worker/worker.rb

@@ -1,49 +0,0 @@
-#!/usr/bin/env jruby
-#
-# HornetQ Consumer:
-#          Write messages to the queue
-#
-
-require 'rubygems'
-require 'yaml'
-require 'hornetq'
-require 'test_object'
-
-$config = YAML.load_file(File.dirname(__FILE__) + '/hornetq.yml')
-$client = $config['client']
-factory = HornetQ::Client::Factory.new($client[:connector])
-$consumer_manager = HornetQ::Client::ConsumerManager.new(factory, $client[:session], $client[:addresses])
-
-['HUP', 'INT', 'TERM'].each do |signal_name|
-  Signal.trap(signal_name) do
-    puts "caught #{signal_name}"
-    consumer_manager.close
-  end
-end
-
-$threads = []
-def create_workers(address, queue, count, sleep_time)
-  address_config = $client[:addresses][address]
-  queue_config = address_config[:queues][queue]
-  (1..count).each do |i|
-    $threads << Thread.new(i) do |thread_count|
-      prefix = "#{address}-#{queue}-#{thread_count}"
-      begin
-        $consumer_manager.each(address,queue) do |obj|
-          puts "#{prefix} read #{obj.inspect}"
-          sleep sleep_time
-        end
-        puts "#{prefix} end of thread"
-      rescue Exception => e
-        puts "#{prefix} Exception: #{e.message}\n#{e.backtrace.join("\n")}"
-      end
-    end
-  end
-end
-
-create_workers('address1', 'queue1_1', 5, 1)
-create_workers('address1', 'queue1_2', 5, 2)
-create_workers('address2', 'queue2_1', 5, 2)
-create_workers('address2', 'queue2_2', 5, 1)
-
-$threads.each { |thread| thread.join }

data/lib/hornetq/server/factory.rb

@@ -1,87 +0,0 @@
-module HornetQ::Server
-
-  class Factory
-    def self.create_server(parms={})
-      HornetQ::Server.load_requirements
-
-      if parms.kind_of?(String)
-        uri = HornetQ::URI.new(parms)
-        parms = uri.params
-      else
-        raise "Missing :uri param in HornetQ::Server.create_server" unless parms[:uri]
-        uri = HornetQ::URI.new(parms.delete(:uri))
-        # parms override uri params
-        parms = uri.params.merge(parms)
-      end
-      config = Java::org.hornetq.core.config.impl.ConfigurationImpl.new
-      data_directory = parms.delete(:data_directory) || HornetQ::DEFAULT_DATA_DIRECTORY
-      config.paging_directory = "#{data_directory}/paging"
-      config.bindings_directory = "#{data_directory}/bindings"
-      config.journal_directory = "#{data_directory}/journal"
-      config.large_messages_directory = "#{data_directory}/large-messages"
-
-      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 })
-        connector_conf_map = java.util.HashMap.new
-        connector_conf_map.put('netty-connector', connector)
-        config.connector_configurations = connector_conf_map
-      end
-      acceptor_conf_set = java.util.HashSet.new
-      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"
-        config.backup = true
-        config.shared_store = false
-      elsif uri.backup_host
-        puts "live"
-        #backup_params.put('reconnectAttempts', -1)
-        backup_connector = Java::org.hornetq.api.core.TransportConfiguration.new(HornetQ::NETTY_CONNECTOR_CLASS_NAME, {'host' => uri.backup_host, 'port' => uri.backup_port })
-        connector_conf_map.put('backup-connector', backup_connector)
-        config.backup_connector_name = 'backup-connector'
-      elsif uri.host == 'invm'
-        puts 'invm'
-      else
-        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
-    
-    # Start a new server instance and stop it once the supplied block completes
-    def self.start(params={}, &block)
-      server = nil
-      begin
-        server = self.create_server(params)
-        server.start
-        block.call(server)
-      ensure
-        server.stop if server
-      end
-    end
-    
-  end
-end