torquebox-messaging 1.1.1-java → 2.0.0.beta1-java

data/lib/torquebox/messaging/client.rb

@@ -1,75 +0,0 @@
-# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
-# 
-# This is free software; you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as
-# published by the Free Software Foundation; either version 2.1 of
-# the License, or (at your option) any later version.
-# 
-# This software is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-# 
-# You should have received a copy of the GNU Lesser General Public
-# License along with this software; if not, write to the Free
-# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-
-begin
-  require 'torquebox-messaging'
-rescue LoadError=>e
-  # ignore!
-end
-
-require 'torquebox/naming'
-require 'torquebox/messaging/ext/javax_jms_session'
-
-module TorqueBox
-  module Messaging
-
-    class Client
-
-      AUTO_ACK = javax.jms::Session::AUTO_ACKNOWLEDGE
-      CLIENT_ACK = javax.jms::Session::CLIENT_ACKNOWLEDGE
-      DUPS_OK_ACK = javax.jms::Session::DUPS_OK_ACKNOWLEDGE
-
- 
-      def self.canonical_ack_mode(ack_mode)
-        case ( ack_mode )
-          when Fixnum
-            return ack_mode
-          when :auto
-            return AUTO_ACK
-          when :client
-            return CLIENT_ACK
-          when :dups_ok
-            return DUPS_OK_ACK
-        end
-      end
-
-      def self.connect(options={}, &block)
-        transacted = options.fetch(:transacted, true)
-        ack_mode = options.fetch(:ack_mode, AUTO_ACK)
-        naming_host = options[:naming_host]
-        naming_port = options[:naming_port]
-        connection_factory = nil
-        TorqueBox::Naming.connect( naming_host, naming_port ) do |context|
-          connection_factory = context['/ConnectionFactory']
-          connection = connection_factory.createConnection
-          connection.client_id = options[:client_id]
-          session = connection.createSession( transacted, canonical_ack_mode( ack_mode ) )
-          connection.start
-          session.naming_context = context
-          session.connection = connection
-          return session if ( block.nil? )
-          begin
-            block.call( session )
-          ensure 
-            connection.close()
-          end 
-        end
-      end
-    end
-
-  end
-end

data/lib/torquebox/messaging/ext/javax_jms_session.rb

@@ -1,153 +0,0 @@
-# Copyright 2008-2011 Red Hat, Inc, and individual contributors.
-# 
-# This is free software; you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as
-# published by the Free Software Foundation; either version 2.1 of
-# the License, or (at your option) any later version.
-# 
-# This software is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-# 
-# You should have received a copy of the GNU Lesser General Public
-# License along with this software; if not, write to the Free
-# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-
-require 'torquebox/messaging/javax_jms_text_message'
-
-module javax.jms::Session
-
-  attr_accessor :connection
-  attr_accessor :naming_context
-
-  def publish(destination, message, options = {})
-    destination = lookup_destination( destination ) unless destination.is_a?( Java::javax.jms.Destination )
-    producer = createProducer( destination )
-    jms_message = create_text_message
-    populate_message_headers(jms_message, options)
-    populate_message_properties(jms_message, options[:properties])
-    jms_message.encode message
-    producer.send( jms_message,
-                   options.fetch(:delivery_mode, producer.delivery_mode),
-                   options.fetch(:priority, producer.priority),
-                   options.fetch(:ttl, producer.time_to_live) )
-    jms_message
-  ensure
-    producer.close unless producer.nil?
-  end
-
-  # Returns decoded message, by default.  Pass :decode=>false to
-  # return the original JMS TextMessage.  Pass :timeout to give up
-  # after a number of milliseconds
-  def receive(destination_name, options={})
-    decode = options.fetch(:decode, true)
-    timeout = options.fetch(:timeout, 0)
-    selector = options.fetch(:selector, nil)
-    destination = lookup_destination( destination_name )
-    if options[:durable] && destination.class.name =~ /Topic/
-      raise ArgumentError.new( "You must set the :client_id via Topic.new's connect_options to use :durable" ) unless connection.client_id
-      consumer = createDurableSubscriber( destination,
-                                          options.fetch(:subscriber_name, TorqueBox::Messaging::Topic::DEFAULT_SUBSCRIBER_NAME),
-                                          selector,
-                                          false )
-    else
-      consumer = createConsumer( destination, selector )      
-    end
-    jms_message = consumer.receive( timeout )
-    if jms_message
-      decode ? jms_message.decode : jms_message
-    end
-  ensure
-    consumer.close unless consumer.nil?
-  end
-
-  # Implement the request-response pattern. Sends a message to the
-  # request destination and waits for a reply on the response
-  # destination.
-  #
-  # Options:
-  #
-  # :timeout - specifies the time in miliseconds to wait for answer,
-  #            default: 10000 (10s)
-  # :decode  - pass false to return the original JMS TextMessage,
-  #            default: true
-  #
-  def publish_and_receive(destination, message, options = {})
-    options[:timeout] ||= 10000 # 10s
-    decode = options.fetch(:decode, false)
-    options[:properties] ||= {}
-    options[:properties]["synchronous"] = "true"
-    wrapped_message = { :timeout => options[:timeout], :message => message }
-    jms_message = publish(destination, wrapped_message, options)
-    commit if transacted?
-
-    options[:selector] = "JMSCorrelationID='#{jms_message.jms_message_id}'"
-    response = receive(destination, options)
-    commit if transacted?
-
-    if response
-      decode ? response.decode : response
-    end
-  end
-
-  # Receiving end of the request-response pattern. The return value of
-  # the block passed to this method is the response sent back to the
-  # client. If no block is given then request is returned as the
-  # response.
-  def receive_and_publish(destination, options = {})
-    selector = "synchronous = 'true'"
-    selector = "#{selector} and (#{options[:selector]})" if options[:selector]
-    receive_options = options.merge(:decode => false,
-                                    :selector => selector)
-
-    request = receive(destination, receive_options)
-    unless request.nil?
-      decoded_request = request.decode
-      request_message = decoded_request[:message]
-      # Base the response ttl off the original request timeout
-      request_timeout = decoded_request[:timeout]
-      options[:ttl] ||= request_timeout
-
-      response = block_given? ? yield(request_message) : request_message
-
-      options[:correlation_id] = request.jms_message_id
-      publish(destination, response, options)
-    end
-    commit if transacted?
-  end
-
-  def lookup_destination(destination_name)
-    @naming_context[ destination_name ]
-  end
-
-  def populate_message_headers(jms_message, options)
-    return if options.nil?
-    options.each do |key, value|
-      case key.to_s
-      when 'correlation_id' then jms_message.setJMSCorrelationID(value)
-      when 'reply_to' then jms_message.setJMSReplyTo(value)
-      when 'type' then jms_message.setJMSType(value)
-      end
-    end
-  end
-
-  def populate_message_properties(jms_message, properties)
-    return if properties.nil?
-    properties.each do |key, value|
-      case value
-      when Integer
-        jms_message.set_long_property(key.to_s, value)
-      when Float
-        jms_message.set_double_property(key.to_s, value)
-      when TrueClass, FalseClass
-        jms_message.set_boolean_property(key.to_s, value)
-      else
-        jms_message.set_string_property(key.to_s, value.to_s)
-      end
-    end
-  end
-
-end
-

data/spec/client_spec.rb

@@ -1,116 +0,0 @@
-
-
-require 'torquebox-messaging-container'
-require 'torquebox-naming-container'
-require 'torquebox-container-foundation'
-
-require 'torquebox/messaging/client'
-
-describe TorqueBox::Messaging::Client do
-
-  describe "sending and receiving" do
-    before(:each) do
-      @container = TorqueBox::Container::Foundation.new
-      @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=false}
-      @container.enable( TorqueBox::Messaging::MessageBroker ) 
-      @container.start
-
-      @queues_yml = @container.deploy( File.join( File.dirname(__FILE__), 'queues.yml' ) )
-      @container.process_deployments(true)
-    end
-  
-    after(:each) do
-      @container.undeploy( @queues_yml )
-      @container.stop
-    end
-
-    it "should be able to send to a queue from two threads/two sessions" do
-  
-      received_message = nil
-
-      consumer_thread = Thread.new {
-        TorqueBox::Messaging::Client.connect() do |session|
-          received_message = session.receive( '/queues/foo' )
-          session.commit
-        end
-      }
-
-      producer_thread = Thread.new {
-        TorqueBox::Messaging::Client.connect() do |session|
-          session.publish( '/queues/foo', "howdy" )
-          session.commit
-        end
-      }
-
-      consumer_thread.join
-
-      received_message.should_not be_nil
-      received_message.should eql( "howdy" )
-    end
-
-
-    it "should be able to send to a queue from one thread/one session" do
-
-      received_message = nil
-
-      TorqueBox::Messaging::Client.connect() do |session|
-        session.publish( '/queues/foo', "howdy" )
-        session.commit
-        received_message = session.receive( '/queues/foo' )
-        session.commit
-      end
-
-      received_message.should_not be_nil
-      received_message.should eql( "howdy" )
-    end
-
-    it "should be able to send and receive a non-String message" do
-      message = {:string => "a string", :symbol => :a_symbol, :hash => {}, :array => []}
-      received_message = nil
-
-      TorqueBox::Messaging::Client.connect() do |session|
-        session.publish( '/queues/foo', message )
-        session.commit
-        received_message = session.receive( '/queues/foo' )
-        session.commit
-      end
-
-      received_message.should_not be_nil
-      received_message.should eql( message )
-    end
-
-    it "should properly decode a non-String message" do
-      received_message = nil
-      TorqueBox::Messaging::Client.connect() do |session|
-        session.publish( '/queues/foo', [] )
-        session.commit
-        received_message = session.receive( '/queues/foo', :decode => false )
-        session.commit
-      end
-      received_message.decode.should eql( [] )
-    end
-
-    it "should properly decode a String message" do
-      received_message = nil
-      TorqueBox::Messaging::Client.connect() do |session|
-        session.publish( '/queues/foo', "foo" )
-        session.commit
-        received_message = session.receive( '/queues/foo', :decode => false )
-        session.commit
-      end
-      received_message.decode.should eql( "foo" )
-    end
-
-    it "should timeout if asked" do
-      received_message = nil
-      TorqueBox::Messaging::Client.connect() do |session|
-        received_message = session.receive( '/queues/foo', :timeout => 1 )
-      end
-      received_message.should be_nil
-    end
-    
-  end
-
-end
-
-

data/spec/dispatcher-queues.yml

@@ -1,4 +0,0 @@
-
-/queues/questions:
-
-/queues/answers:

data/spec/dispatcher_not_running.rb

@@ -1,54 +0,0 @@
-#require 'spec_helper'
-
-require 'rubygems'
-require 'torquebox-naming'
-require 'torquebox-naming-container'
-require 'torquebox-messaging-container'
-require 'torquebox/messaging/message_processor'
-require 'torquebox/messaging/destination'
-
-QUEUE_QUESTIONS = TorqueBox::Messaging::Queue.new("/queues/questions")
-QUEUE_ANSWERS   = TorqueBox::Messaging::Queue.new("/queues/answers")
-
-TESTING_ON_WINDOWS = ( java.lang::System.getProperty( "os.name" ) =~ /.*windows*/i )
-
-class Upcaser < TorqueBox::Messaging::MessageProcessor
-  def on_message(body)
-    QUEUE_ANSWERS.publish( body.upcase )
-  end
-end
-
-describe "dispatcher test" do
-  before(:each) do
-    @container = TorqueBox::Container::Foundation.new
-    @container.enable( TorqueBox::Naming::NamingService ) {|config| config.export=true}
-    @container.enable( TorqueBox::Messaging::MessageBroker ) 
-    @container.start
-
-    @queues_yml = @container.deploy( File.join( File.dirname(__FILE__), 'dispatcher-queues.yml' ) )
-    @container.process_deployments(true)
-    puts "Deployed queues"
-  end
-  
-  after(:each) do
-    puts "UNDEPLOY queues"
-    @container.undeploy( @queues_yml )
-    puts "UNDEPLOYED queues"
-    puts "STOP container"
-    @container.stop
-    puts "STOPPED container"
-  end
-
-  unless TESTING_ON_WINDOWS
-    it "should associate a processor with a queue" do
-      dispatcher = TorqueBox::Messaging::Dispatcher.new( :skip_naming=>true ) do
-        map Upcaser, QUEUE_QUESTIONS
-      end
-      dispatcher.start
-      QUEUE_QUESTIONS.publish "lkjsdf"
-      QUEUE_ANSWERS.receive(:timeout => 2000).should == "LKJSDF"
-      dispatcher.stop
-    end
-  end
-
-end