torquebox-messaging 1.1-java → 1.1.1-java

data/lib/torquebox-messaging.rb

@@ -1,6 +1,6 @@
 module TorqueboxMessaging
-  VERSION = '1.1'
-  MAVEN_VERSION = '1.1'
+  VERSION = '1.1.1'
+  MAVEN_VERSION = '1.1.1'
 end
 begin
   require 'java'

data/lib/torquebox/messaging/future.rb

@@ -20,12 +20,17 @@ module TorqueBox
     # A Future encapsulates the result of a long running
     # process, and is used in conjunction with a {FutureResponder}. 
     class Future
-
+      # We can't really do no timeout - 1ms is as close as we can get.
+      NO_TIMEOUT = 1
+      
       # Returns the remote error (if any)
       attr_reader :error
       attr_reader :correlation_id
       attr_accessor :default_result_timeout
-
+      
+      # Returns all of the statuses seen by this future as an array.
+      attr_reader :all_statuses
+      
       # @param [TorqueBox::Messaging::Queue] response_queue The queue
       #   where response messages are to be received.
       # @param [Hash] options Additional options
@@ -39,6 +44,7 @@ module TorqueBox
         @queue = response_queue
         @correlation_id = options[:correlation_id] || self.class.unique_id
         @default_result_timeout = options[:default_result_timeout] || 30_000
+        @all_statuses = []
       end
 
       def started?
@@ -61,8 +67,13 @@ module TorqueBox
       # processed task itself.
       # @see FutureResponder#status
       def status
-        receive unless @complete || @error
-        @status
+        @prior_status = retrieve_status
+      end
+      
+      # Returns true if the status has changed since the last call to
+      # {#status}. 
+      def status_changed?
+        @prior_status != retrieve_status
       end
       
       # Attempts to return the remote result.
@@ -92,12 +103,20 @@ module TorqueBox
       end
 
       protected
-      def receive(timeout = 1)
+      def retrieve_status
+        receive unless @complete || @error
+        @status
+      end
+      
+      def receive(timeout = NO_TIMEOUT)
         response = @queue.receive( :timeout => timeout, :selector => "JMSCorrelationID = '#{@correlation_id}'" )
 
         if response
           @started = true
-          @status = response[:status] if response.has_key?( :status )
+          if response.has_key?( :status )
+            @status = response[:status]
+            @all_statuses << @status
+          end
           @complete = response.has_key?( :result )
           @result ||= response[:result]
           @error ||= response[:error]

data/lib/torquebox/messaging/future_responder.rb

@@ -36,25 +36,30 @@ module TorqueBox
 
       # Signal that processing has started.
       def started
-        publish( :started => true, :priority => :low )
+        send_response(:low)
       end
 
       # Report the current status back to the client. The status value
       # is application specific.
       def status=(status)
-        publish( :status => status )
+        @status_set = true
+        @status = status
+        send_response
       end
       
       # Signal that processing has completed.
       # @param The result of the operation.
       def result=(result)
-        publish( :result => result, :priority => :high )
+        @result_set = true
+        @result = result
+        send_response :high 
       end
 
       # Signal that an error occurred during processing.
       # @param [Exception] The error!
       def error=(error)
-        publish( :error => error, :priority => :high )
+        @error = error
+        send_response :high 
       end
       
       # Handles started/complete/error for you around the given
@@ -84,8 +89,17 @@ module TorqueBox
       end
       
       protected
-      def publish(message)
-        @queue.publish( message, :correlation_id => @correlation_id, :ttl => @message_ttl )
+      def send_response(priority = :normal)
+        message = {}
+        message[:status] = @status if @status_set
+        message[:error] = @error if @error
+        message[:result] = @result if @result_set
+        @queue.publish( message,
+                        {
+                          :correlation_id => @correlation_id,
+                          :ttl => @message_ttl,
+                          :priority => priority
+                        } )
       end
     end
   end

data/spec/destination_spec.rb

@@ -110,15 +110,15 @@ describe TorqueBox::Messaging::Destination do
       @container.stop
     end
 
-    {
-      true => 'prop = true',
-      true => 'prop <> false',
-      5 => 'prop = 5',
-      5 => 'prop > 4',
-      5.5 => 'prop = 5.5',
-      5.5 => 'prop < 6',
-      'string' => "prop = 'string'"
-    }.each do |value, selector|
+    [
+      [true, 'prop = true'],
+      [true, 'prop <> false'],
+      [5, 'prop = 5'],
+      [5, 'prop > 4'],
+      [5.5, 'prop = 5.5'],
+      [5.5, 'prop < 6'],
+      ['string', "prop = 'string'"]
+    ].each do |value, selector|
       it "should be able to select with property set to #{value} using selector '#{selector}'" do
         @queue.publish value.to_s, :properties => { :prop => value }
         message = @queue.receive(:timeout => 1000, :selector => selector)
@@ -270,9 +270,9 @@ describe TorqueBox::Messaging::Destination do
         queue.start
 
         response_thread = Thread.new {
-          queue.receive_and_publish( :timeout => 10000 ) { |msg| msg.upcase }
+          queue.receive_and_publish( :timeout => 120_000 ) { |msg| msg.upcase }
         }
-        message = queue.publish_and_receive "ping", :timeout => 10000
+        message = queue.publish_and_receive "ping", :timeout => 120_000
         response_thread.join
 
         queue.destroy
@@ -284,9 +284,9 @@ describe TorqueBox::Messaging::Destination do
         queue.start
 
         response_thread = Thread.new {
-          queue.receive_and_publish( :timeout => 10000 )
+          queue.receive_and_publish( :timeout => 120_000 )
         }
-        message = queue.publish_and_receive "ping", :timeout => 10000
+        message = queue.publish_and_receive "ping", :timeout => 120_000
         response_thread.join
 
         queue.destroy
@@ -300,14 +300,14 @@ describe TorqueBox::Messaging::Destination do
         thread_count = 3
         response_threads = (1..thread_count).map do
           Thread.new {
-            queue.receive_and_publish( :timeout => 10000 ) { |msg| msg.upcase }
+            queue.receive_and_publish( :timeout => 120_000 ) { |msg| msg.upcase }
           }
         end
 
-        message = queue.publish_and_receive "ping", :timeout => 10000
+        message = queue.publish_and_receive "ping", :timeout => 120_000
         # Send extra messages to trigger all remaining response threads
         (thread_count - 1).times do
-          queue.publish_and_receive "ping", :timeout => 10000
+          queue.publish_and_receive "ping", :timeout => 120_000
         end
         response_threads.each { |thread| thread.join }
 
@@ -320,7 +320,7 @@ describe TorqueBox::Messaging::Destination do
         queue.start
 
         response_thread = Thread.new {
-          queue.receive_and_publish( :timeout => 10000,
+          queue.receive_and_publish( :timeout => 120_000,
                                      :selector => "age > 60 or tan = true" )
         }
 
@@ -332,7 +332,7 @@ describe TorqueBox::Messaging::Destination do
                                    :properties => { :age => 25 } )
         # Publish a synchronous message that should match selector
         message = queue.publish_and_receive( "wrinkled",
-                                             :timeout => 10000,
+                                             :timeout => 120_000,
                                              :properties => { :age => 65, :tan => true } )
         message.should eql( "wrinkled" )
         response_thread.join

data/spec/future_responder_spec.rb

@@ -0,0 +1,81 @@
+require 'torquebox/messaging/future_responder'
+
+include TorqueBox::Messaging
+
+describe TorqueBox::Messaging::FutureResponder do
+  def self.it_should_publish(message, priority=nil, &block)
+    it "should publish with #{message.inspect}#{priority ? ' and priority :' + priority.to_s : ''}" do
+      opts = { :correlation_id => 'ham-biscuit', :ttl => 1234 }
+      opts[:priority] = priority if priority
+      queue = mock('queue')
+      responder = FutureResponder.new(queue, 'ham-biscuit', 1234)
+      queue.should_receive( :publish ).with( hash_including(message), hash_including( opts ) )
+      block.call( responder )
+    end
+  end
+    
+  before(:each) do
+    @queue = mock('queue')
+    @queue.stub(:publish)
+    @responder = FutureResponder.new(@queue, 'correlation-id')
+  end
+
+  describe '#started' do
+    it_should_publish({}, :low) do |responder|
+      responder.started
+    end
+  end
+
+  describe '#status=' do
+    it "should set the status" do
+      @responder.status = 'biscuit'
+      @responder.instance_variable_get('@status').should == 'biscuit'
+    end
+
+    it_should_publish({:status => 'biscuit'}, :normal) do |responder|
+      responder.status = 'biscuit'
+    end
+  end
+
+  describe '#result=' do
+    it "should set the result" do
+      @responder.result = 'biscuit'
+      @responder.instance_variable_get('@result').should == 'biscuit'
+    end
+
+    it_should_publish({:result => 'biscuit'}, :high) do |responder|
+      responder.result = 'biscuit'
+    end
+
+    it "should include the last status with the result" do
+      queue = mock('queue')
+      responder = FutureResponder.new(queue, 'ham-biscuit')
+      queue.should_receive( :publish )
+      responder.status = 'crepe'
+      queue.should_receive( :publish ).with( hash_including({:result => 'biscuit', :status => 'crepe'}), anything )
+      responder.result = 'biscuit'
+    end
+  end
+
+  describe '#error=' do
+    it "should set the error" do
+      @responder.error = 'biscuit'
+      @responder.instance_variable_get('@error').should == 'biscuit'
+    end
+
+    it_should_publish({:error => 'biscuit'}, :high) do |responder|
+      responder.error = 'biscuit'
+    end
+
+    it "should include the last status with the error" do
+      queue = mock('queue')
+      responder = FutureResponder.new(queue, 'ham-biscuit')
+      queue.should_receive( :publish )
+      responder.status = 'crepe'
+      queue.should_receive( :publish ).with( hash_including({:error => 'biscuit', :status => 'crepe'}), anything )
+      responder.error = 'biscuit'
+    end
+
+  end
+
+end

data/spec/future_spec.rb

@@ -2,45 +2,147 @@ require 'torquebox/messaging/future'
 
 include TorqueBox::Messaging
 
-class Future
-  attr_writer :started
-  attr_writer :complete
-  attr_writer :error
-  attr_writer :result
-end
-
 describe TorqueBox::Messaging::Future do
   
   before(:each) do
     @queue = mock( Queue )
+    @response = nil
+    @queue.stub( :receive ).and_return { @response }
     @future = Future.new( @queue )
   end
 
+  describe "#started?" do
+    it "should be false if the remote side hasn't started" do
+      @future.should_not be_started
+    end
+
+    it "should be true if the remote side has started" do
+      @response = { }
+      @future.should be_started
+    end
+
+    it "should be true if an error occurs" do
+      @response = { :error => 'foo' }
+      @future.should be_started
+    end
+
+    it "should be true if an processing is complete" do
+      @response = { :result => 'foo' }
+      @future.should be_started
+    end
+  end
+
+  describe "#complete?" do
+    it "should be false if the remote side hasn't started" do
+      @future.should_not be_complete
+    end
+
+    it "should be false if the remote side hasn't completed" do
+      @response = { }
+      @future.should_not be_complete
+    end
+
+    it "should be false if an error occurs" do
+      @response = { :error => 'foo' }
+      @future.should_not be_complete
+    end
+
+    it "should be true if an processing is complete" do
+      @response = { :result => 'foo' }
+      @future.should be_complete
+    end
+  end
+  
+  describe "#error?" do
+    it "should be false if the remote side hasn't started" do
+      @future.should_not be_error
+    end
+
+    it "should be false if the remote side hasn't completed" do
+      @response = { }
+      @future.should_not be_error
+    end
+
+    it "should be true if an error occurs" do
+      @response = { :error => 'foo' }
+      @future.should be_error
+    end
+
+    it "should be false if an processing is complete" do
+      @response = { :result => 'foo' }
+      @future.should_not be_error
+    end
+  end
+
+  describe '#status' do
+    it "should return nil if no status set" do
+      @future.status.should be_nil
+    end
+
+    it "should return the remote status" do
+      @response = { :status => 'biscuit' }
+      @future.status.should == 'biscuit'
+    end
+
+    it "should remember the last status" do
+      @response = { :status => 'biscuit' }
+      @future.status.should == 'biscuit'
+      @response = { }
+      @future.status.should == 'biscuit'
+    end
+  end
+
+  describe "#all_statuses" do
+    it "should be an emtpy array if no status has been received" do
+      @future.all_statuses.should == []
+    end
+
+    it "should be an have all the seen statuses" do
+      @response = { :status => :ham }
+      @future.status
+      @response = { :status => :biscuit }
+      @future.status
+      @future.all_statuses.should == [:ham, :biscuit]
+    end
+  end
+  
+  describe "#status_changed?" do
+    it "should return false if no status has been sent" do
+      @future.should_not be_status_changed
+    end
+
+    it "should be true for the first status" do
+      @response = { :status => :ham }
+      @future.should be_status_changed
+    end
+    
+    it "should return true if the status doesn't match the last" do
+      @response = { :status => :ham }
+      @future.status
+      @future.should_not be_status_changed
+      @response = { :status => :biscuit }
+      @future.should be_status_changed
+    end
+  end
+  
   describe "#result" do
 
     it "should raise if it fails to start before timeout" do
-      @future.stub(:receive)
       lambda { @future.result( 1 ) }.should raise_error( TimeoutException )
     end
 
     it "should raise if it fails to complete before timeout" do
-      @future.stub(:receive)
-      @future.started = true
+      @response = { }
       lambda { @future.result( 1 ) }.should raise_error( TimeoutException )
     end
 
     it "should raise if a remote error occurs" do
-      @future.stub(:receive)
-      @future.started = true
-      @future.error = ArgumentError.new
+      @response = { :error => ArgumentError.new }
       lambda { @future.result( 1 ) }.should raise_error( ArgumentError )
     end
 
     it "should return the result if complete" do
-      @future.stub(:receive)
-      @future.started = true
-      @future.complete = true
-      @future.result = :success!
+      @response = { :result => :success! }
       @future.result.should == :success!
     end
 
@@ -50,10 +152,12 @@ describe TorqueBox::Messaging::Future do
 
     it "should delegate to #result" do
       @result = mock(:result)
-      @future.should_receive(:result).and_return(@result)
       @result.should_receive(:blah)
+      @response = { :result => @result }
       @future.blah
     end
     
   end
+
+
 end

metadata

@@ -2,15 +2,15 @@
 name: torquebox-messaging
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: "1.1"
+  version: 1.1.1
 platform: java
-authors: ["The TorqueBox Team"]
-
+authors: 
+  - The TorqueBox Team
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-07-13 00:00:00 -04:00
+date: 2011-08-09 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -21,7 +21,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: "1.1"
+            version: 1.1.1
     type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: "1.1"
+            version: 1.1.1
     type: :development
     version_requirements: *id002
   - !ruby/object:Gem::Dependency 
@@ -43,7 +43,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: "1.1"
+            version: 1.1.1
     type: :development
     version_requirements: *id003
   - !ruby/object:Gem::Dependency 
@@ -54,7 +54,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: "1.1"
+            version: 1.1.1
     type: :runtime
     version_requirements: *id004
   - !ruby/object:Gem::Dependency 
@@ -70,6 +70,7 @@ dependencies:
     version_requirements: *id005
 description: ""
 email: 
+  - torquebox-dev@torquebox.org
 executables: []
 
 extensions: []
@@ -127,6 +128,7 @@ files:
   - spec/destination_spec.rb
   - spec/dispatcher-queues.yml
   - spec/dispatcher_not_running.rb
+  - spec/future_responder_spec.rb
   - spec/future_spec.rb
   - spec/queues.yml
   - spec/task_spec.rb
@@ -163,6 +165,7 @@ test_files:
   - spec/backgroundable_spec.rb
   - spec/client_spec.rb
   - spec/destination_spec.rb
+  - spec/future_responder_spec.rb
   - spec/future_spec.rb
   - spec/task_spec.rb
   - spec/ext/java_jmx_session_spec.rb