torquebox-messaging 1.0.1-java → 1.1-java

data/lib/gem_hook.rb

@@ -20,3 +20,4 @@ require 'torquebox/messaging/task'
 require 'torquebox/messaging/destination'
 require 'torquebox/messaging/message_processor'
 require 'torquebox/messaging/backgroundable'
+require 'torquebox/messaging/web_sockets_processor'

data/lib/torquebox/messaging/backgroundable.rb

@@ -16,12 +16,15 @@
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
 require 'torquebox/messaging/destination'
+require 'torquebox/messaging/future'
+require 'torquebox/messaging/future_status'
 
 module TorqueBox
   module Messaging
     module Backgroundable
       def self.included(base)
         base.extend(ClassMethods)
+        base.send(:include, FutureStatus)
       end
 
       def background(options = { })
@@ -104,7 +107,15 @@ module TorqueBox
 
         class << self
           def publish_message(receiver, method, args, options = { })
-            Queue.new(QUEUE_NAME).publish({:receiver => receiver, :method => method, :args => args}, options)
+            queue = Queue.new(QUEUE_NAME)
+            future = Future.new( queue )
+            queue.publish({:receiver => receiver,
+                            :future_id => future.correlation_id,
+                            :future_queue => QUEUE_NAME,
+                            :method => method,
+                            :args => args}, options)
+
+            future
           rescue javax.naming.NameNotFoundException => ex
             raise RuntimeError.new("The backgroundable queue is not available. Did you disable it by setting its concurrency to 0?")
           end

data/lib/torquebox/messaging/client.rb

@@ -56,6 +56,7 @@ module TorqueBox
         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

data/lib/torquebox/messaging/destination.rb

@@ -1,15 +1,15 @@
 # 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
@@ -25,14 +25,16 @@ module TorqueBox
 
     module Destination
       include Enumerable
-      
-      attr_reader :name
 
+      attr_reader :name
+      attr_reader :connect_options
+      attr_reader :enumerable_options
+      
       PRIORITY_MAP = {
-          :low => 1,
-          :normal => 4,
-          :high => 7,
-          :critical => 9
+        :low => 1,
+        :normal => 4,
+        :high => 7,
+        :critical => 9
       }
 
       def initialize(name, connect_options=nil, enumerable_options=nil)
@@ -91,7 +93,7 @@ module TorqueBox
           end
         end
       end
-      
+
       def to_s
         name
       end
@@ -164,9 +166,19 @@ module TorqueBox
 
     class Topic
       include Destination
+      DEFAULT_SUBSCRIBER_NAME = 'subscriber-1'
+      
       def destination
         @destination ||= Java::org.torquebox.messaging.core::ManagedTopic.new
       end
+
+      def unsubscribe(name = DEFAULT_SUBSCRIBER_NAME, options = {})
+        wait_for_destination(options[:startup_timeout]) {
+          Client.connect(@connect_options) do |session|
+            session.unsubscribe(name)
+          end
+        }
+      end
     end
 
   end

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

@@ -46,7 +46,15 @@ module javax.jms::Session
     timeout = options.fetch(:timeout, 0)
     selector = options.fetch(:selector, nil)
     destination = lookup_destination( destination_name )
-    consumer = createConsumer( destination, selector )
+    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

data/lib/torquebox/messaging/future.rb

@@ -0,0 +1,112 @@
+# 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.
+
+module TorqueBox
+  module Messaging
+    # A Future encapsulates the result of a long running
+    # process, and is used in conjunction with a {FutureResponder}. 
+    class Future
+
+      # Returns the remote error (if any)
+      attr_reader :error
+      attr_reader :correlation_id
+      attr_accessor :default_result_timeout
+
+      # @param [TorqueBox::Messaging::Queue] response_queue The queue
+      #   where response messages are to be received.
+      # @param [Hash] options Additional options
+      # @option options [String] :correlation_id (Future.unique_id) The correlation_id used on
+      #   the messages to uniquely identify the call they are for.
+      # @option options [Integer] :default_result_timeout (30_000) The timeout
+      #   used by default for the receive call. The processing must at
+      #   least start before the timeout expires, and finish before 2x
+      #   this timeout.
+      def initialize(response_queue, options = { })
+        @queue = response_queue
+        @correlation_id = options[:correlation_id] || self.class.unique_id
+        @default_result_timeout = options[:default_result_timeout] || 30_000
+      end
+
+      def started?
+        receive unless @started
+        @started
+      end
+
+      def complete?
+        receive unless @complete || @error
+        @complete
+      end
+
+      def error?
+        receive unless @complete || @error
+        !!@error
+      end
+
+      # Returns the latest response from the remote processor, if
+      # any. Status reporting is optional, and must be handled by the
+      # processed task itself.
+      # @see FutureResponder#status
+      def status
+        receive unless @complete || @error
+        @status
+      end
+      
+      # Attempts to return the remote result.
+      # @param [Integer] timeout The processing must at least start
+      #   before the timeout expires, and finish before 2x this timeout.
+      # @raise [TimeoutException] if the timeout expires when
+      #   receiving the result
+      # @return the remote result
+      def result(timeout = default_result_timeout)
+        receive( timeout ) unless @started
+        raise TimeoutException.new( "timeout expired waiting for processing to start" ) unless @started
+        receive( timeout ) unless @complete || @error
+        raise TimeoutException.new( "timeout expired waiting for processing to finish" ) unless @complete || @error
+        raise @error if @error
+        @result
+      end
+
+      # Delegates to {#result} with the default timeout.
+      def method_missing(method, *args, &block)
+        result.send( method, *args, &block )
+      end
+
+      # @return [String] a unique id useful for correlating a
+      #   result to its call
+      def self.unique_id
+        java.util.UUID.randomUUID.to_s
+      end
+
+      protected
+      def receive(timeout = 1)
+        response = @queue.receive( :timeout => timeout, :selector => "JMSCorrelationID = '#{@correlation_id}'" )
+
+        if response
+          @started = true
+          @status = response[:status] if response.has_key?( :status )
+          @complete = response.has_key?( :result )
+          @result ||= response[:result]
+          @error ||= response[:error]
+        end
+      end
+
+    end
+
+    class TimeoutException < RuntimeError; end
+
+  end
+end

data/lib/torquebox/messaging/future_responder.rb

@@ -0,0 +1,92 @@
+# 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.
+
+module TorqueBox
+  module Messaging
+    # A FutureResponder encapsulates sending the results of a long
+    # running process to a {Future}.
+    class FutureResponder
+
+      # @param [TorqueBox::Messaging::Queue] response_queue The queue
+      #   where response messages are to be published.
+      # @param [String] correlation_id The correlation_id used on
+      #   the messages to uniquely identify the call they are for.
+      # @param [Integer] message_ttl The time-to-live used on messages
+      #   to prevent them from staying in the queue indefinately if
+      #   the result is never accessed.
+      def initialize(response_queue, correlation_id, message_ttl = 600_000)
+        @queue = response_queue
+        @correlation_id = correlation_id
+        @message_ttl = message_ttl
+      end
+
+      # Signal that processing has started.
+      def started
+        publish( :started => true, :priority => :low )
+      end
+
+      # Report the current status back to the client. The status value
+      # is application specific.
+      def status=(status)
+        publish( :status => status )
+      end
+      
+      # Signal that processing has completed.
+      # @param The result of the operation.
+      def result=(result)
+        publish( :result => result, :priority => :high )
+      end
+
+      # Signal that an error occurred during processing.
+      # @param [Exception] The error!
+      def error=(error)
+        publish( :error => error, :priority => :high )
+      end
+      
+      # Handles started/complete/error for you around the given
+      # block. The current responder is avaiable inside the block via
+      # {.current}, which is useful for sending {#status} messages.
+      def respond
+        started
+        Thread.current[:future_responder] = self
+        self.result = yield 
+      rescue Exception => e
+        self.error = e
+        puts "FutureResponder#respond: An error occured: ", e
+        puts e.backtrace.join( "\n" )
+      end
+
+      # Convenience method that returns the thread local
+      # responder. Only valid inside a block passed to {#respond}.
+      def self.current
+        Thread.current[:future_responder]
+      end
+
+      # Convenience method that allows you to send a status message 
+      # via the {.current} responder. Only valid inside a block passed
+      # to {#respond}.
+      def self.status=(status)
+        current.status = status if current
+      end
+      
+      protected
+      def publish(message)
+        @queue.publish( message, :correlation_id => @correlation_id, :ttl => @message_ttl )
+      end
+    end
+  end
+end

data/lib/torquebox/messaging/future_status.rb

@@ -0,0 +1,37 @@
+# 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/future_responder'
+
+module TorqueBox
+  module Messaging
+    module FutureStatus
+
+      def __future
+        @__future ||= FutureProxy.new
+      end
+      alias_method :future, :__future
+      
+      class FutureProxy
+        def status=(status)
+          FutureResponder.status = status
+        end
+      end
+    end
+  end
+end
+

data/lib/torquebox/messaging/task.rb

@@ -16,27 +16,42 @@
 # 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
 require 'torquebox/messaging/destination'
+require 'torquebox/messaging/future_responder'
+require 'torquebox/messaging/future'
+require 'torquebox/messaging/future_status'
 
 module TorqueBox
   module Messaging
 
     class Task
-
+      include FutureStatus
+      
       def self.queue_name
         suffix = org.torquebox.common.util.StringUtils.underscore(name[0...-4])
         "/queues/torquebox/#{ENV['TORQUEBOX_APP_NAME']}/tasks/#{suffix}"
       end
 
       def self.async(method, payload = {}, options = {})
-        message = {:method => method, :payload => payload}
-        Queue.new(queue_name).publish message, options
+        queue = Queue.new(queue_name)
+        future = Future.new( queue )
+        message = {
+          :method => method,
+          :payload => payload,
+          :future_id => future.correlation_id,
+          :future_queue => queue_name
+        }
+        queue.publish( message, options )
+
+        future
       rescue javax.naming.NameNotFoundException => ex
         raise RuntimeError.new("The queue for #{self.name} is not available. Did you disable it by setting its concurrency to 0?")
       end
 
       def process!(message)
         hash = message.decode
-        self.send hash[:method].to_sym, hash[:payload]
+        FutureResponder.new( Queue.new( hash[:future_queue] ), hash[:future_id] ).respond do
+          self.send hash[:method].to_sym, hash[:payload]
+        end
       end
 
     end

data/lib/torquebox-messaging.rb

@@ -1,6 +1,6 @@
 module TorqueboxMessaging
-  VERSION = '1.0.1'
-  MAVEN_VERSION = '1.0.1'
+  VERSION = '1.1'
+  MAVEN_VERSION = '1.1'
 end
 begin
   require 'java'
@@ -21,7 +21,7 @@ begin
   require File.dirname(__FILE__) + '/activation-1.1.jar'
   require File.dirname(__FILE__) + '/jaxb-api-2.1.9.jar'
   require File.dirname(__FILE__) + '/torquebox-base-spi.jar'
-  require File.dirname(__FILE__) + '/jruby-complete-1.6.2.jar'
+  require File.dirname(__FILE__) + '/jruby-complete-1.6.3.jar'
   require File.dirname(__FILE__) + '/torquebox-base-metadata.jar'
   require File.dirname(__FILE__) + '/torquebox-base-core.jar'
   require File.dirname(__FILE__) + '/picketbox-bare-3.0.0.CR2.jar'

data/spec/backgroundable_spec.rb

@@ -62,6 +62,7 @@ describe TorqueBox::Messaging::Backgroundable do
       @queue = mock('queue')
       @queue.stub(:publish)
       TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
+      TorqueBox::Messaging::Future.stub(:unique_id).and_return('1234')
     end
 
     it "should put a message on the queue" do
@@ -69,9 +70,20 @@ describe TorqueBox::Messaging::Backgroundable do
       MyTestModel.new.an_async_action(nil, nil)
     end
 
-    it "should include the receiver, sync method, and args" do
+    it "should return a future" do
+      result = MyTestModel.new.an_async_action(nil, nil)
+      result.is_a?(TorqueBox::Messaging::Future).should be_true
+    end
+    
+    it "should include the proper options in the message" do
       object = MyTestModel.new
-      @queue.should_receive(:publish).with({:receiver => object, :method => '__sync_an_async_action', :args => [:a, :b]}, { })
+      @queue.should_receive(:publish).with({
+                                             :receiver => object,
+                                             :future_id => '1234',
+                                             :future_queue => "/queues/torquebox//backgroundable",
+                                             :method => '__sync_an_async_action',
+                                             :args => [:a, :b]
+                                           }, { })
       object.an_async_action(:a, :b) 
     end
     
@@ -99,21 +111,27 @@ describe TorqueBox::Messaging::Backgroundable do
 
     it "should queue any method called on it" do
       @queue.should_receive(:publish).with({:receiver => anything,
-                                           :method => :foo,
-                                             :args => anything}, { })
+                                             :method => :foo,
+                                             :args => anything,
+                                             :future_id => anything,
+                                             :future_queue => anything}, { })
       @object.background.foo 
     end
 
     it "should queue the receiver" do
       @queue.should_receive(:publish).with({:receiver => @object,
-                                           :method => anything,
-                                             :args => anything}, { })
+                                             :method => anything,
+                                             :args => anything,
+                                             :future_id => anything,
+                                             :future_queue => anything}, { })
       @object.background.foo 
     end
 
     it "should queue the args" do
       @queue.should_receive(:publish).with({:receiver => anything,
-                                           :method => anything,
+                                             :method => anything,
+                                             :future_id => anything,
+                                             :future_queue => anything,
                                              :args => [1,2]}, {})
       @object.background.foo(1,2) 
     end
@@ -131,8 +149,10 @@ describe TorqueBox::Messaging::Backgroundable do
 
     it "should pass through any options" do
       @queue.should_receive(:publish).with({:receiver => anything,
-                                           :method => anything,
-                                             :args => anything},
+                                             :method => anything,
+                                             :args => anything,
+                                             :future_id => anything,
+                                             :future_queue => anything},
                                            {:ttl => 1})
       @object.background(:ttl => 1).foo
     end

data/spec/client_spec.rb

@@ -79,7 +79,7 @@ describe TorqueBox::Messaging::Client do
       received_message.should eql( message )
     end
 
-    it "should identify a non-String message with a text property" do
+    it "should properly decode a non-String message" do
       received_message = nil
       TorqueBox::Messaging::Client.connect() do |session|
         session.publish( '/queues/foo', [] )
@@ -88,10 +88,9 @@ describe TorqueBox::Messaging::Client do
         session.commit
       end
       received_message.decode.should eql( [] )
-      received_message.get_string_property( 'torquebox_encoding' ).should eql( 'base64' )
     end
 
-    it "should not identify a String message with a text property" do
+    it "should properly decode a String message" do
       received_message = nil
       TorqueBox::Messaging::Client.connect() do |session|
         session.publish( '/queues/foo', "foo" )
@@ -99,9 +98,7 @@ describe TorqueBox::Messaging::Client do
         received_message = session.receive( '/queues/foo', :decode => false )
         session.commit
       end
-      received_message.text.should eql( "foo" )
       received_message.decode.should eql( "foo" )
-      received_message.get_string_property( 'torquebox_encoding' ).should be_nil
     end
 
     it "should timeout if asked" do

data/spec/destination_spec.rb

@@ -144,7 +144,7 @@ describe TorqueBox::Messaging::Destination do
       queue = TorqueBox::Messaging::Queue.new "/queues/browseable"
       queue.start
       queue.publish "howdy"
-      queue.first.text.should == 'howdy'
+      queue.first.decode.should == 'howdy'
       queue.destroy
     end
 
@@ -153,8 +153,9 @@ describe TorqueBox::Messaging::Destination do
       queue.start
       queue.publish "howdy", :properties => {:blurple => 5}
       queue.publish "ahoyhoy", :properties => {:blurple => 6}
-      queue.first.text.should == 'ahoyhoy'
-      queue.detect { |m| m.text == 'howdy' }.should be_nil
+      queue.first.decode.should == 'ahoyhoy'
+      queue.detect { |m| m.decode == 'howdy' }.should be_nil
+      queue.detect { |m| m.decode == 'ahoyhoy' }.should_not be_nil
       queue.destroy
       
     end
@@ -183,6 +184,18 @@ describe TorqueBox::Messaging::Destination do
       message.should eql( "howdy" )
     end
 
+    it "should receive a binary file correctly" do
+      queue = TorqueBox::Messaging::Queue.new "/queues/foo"
+      queue.start
+
+      data = File.open("#{File.dirname(__FILE__)}/../src/test/resources/sample.pdf", "r") { |file| file.read }
+      queue.publish data
+      message = queue.receive
+
+      queue.destroy
+      message.should eql( data )
+    end
+
     it "should publish to multiple topic consumers" do
       topic = TorqueBox::Messaging::Topic.new "/topics/foo"
       topic.start
@@ -201,6 +214,56 @@ describe TorqueBox::Messaging::Destination do
       msgs.to_a.should eql( ["howdy"] * count )
     end
 
+    context "durable topics" do
+      describe 'receive' do
+        it "should be durable" do
+          topic = TorqueBox::Messaging::Topic.new "/topics/foo", :client_id => 'blarg'
+          topic.start
+          
+          topic.receive :durable => true, :timeout => 1
+          topic.publish 'biscuit'
+          response = topic.receive :durable => true, :timeout => 10_000
+          response.should == 'biscuit'
+          
+          topic.destroy
+        end
+        
+        it "should raise if client_id is not set" do
+          topic = TorqueBox::Messaging::Topic.new "/topics/foo"
+          topic.start
+          
+          lambda { topic.receive :durable => true, :timeout => 1 }.should raise_error(ArgumentError)
+          
+          topic.destroy
+        end
+      end
+
+      describe 'unsubscribe' do
+        it "should work" do
+          topic = TorqueBox::Messaging::Topic.new "/topics/foo", :client_id => 'blarg'
+          topic.start
+          
+          topic.receive :durable => true, :timeout => 1
+          topic.publish 'biscuit'
+          response = topic.receive :durable => true, :timeout => 10_000
+          response.should == 'biscuit'
+
+          topic.unsubscribe
+
+          topic.publish 'ham'
+          response = topic.receive :durable => true, :timeout => 10
+          response.should be_nil
+          
+          topic.publish 'gravy'
+          response = topic.receive :durable => true, :timeout => 10_000
+          response.should == 'gravy'
+          
+          topic.destroy
+
+        end
+      end
+    end
+    
     context "synchronous messaging" do
       it "should return value of block given to receive_and_publish" do
         queue = TorqueBox::Messaging::Queue.new "/queues/publish_and_receive"

data/spec/future_spec.rb

@@ -0,0 +1,59 @@
+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 )
+    @future = Future.new( @queue )
+  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
+      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
+      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!
+      @future.result.should == :success!
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    it "should delegate to #result" do
+      @result = mock(:result)
+      @future.should_receive(:result).and_return(@result)
+      @result.should_receive(:blah)
+      @future.blah
+    end
+    
+  end
+end

data/spec/task_spec.rb

@@ -1,39 +1,71 @@
-
+require 'torquebox/messaging/future_responder'
+require 'torquebox/messaging/future'
+require 'torquebox/messaging/destination'
 require 'torquebox/messaging/task'
 
-class MyTestTask < TorqueBox::Messaging::Task 
+class MyTestTask < TorqueBox::Messaging::Task
   attr_accessor :payload
+
+  def action(payload={ })
+    future.status = 1
+  end
+end
+
+class TorqueBox::Messaging::FutureResponder
+  def respond
+    yield
+  end
 end
 
 describe TorqueBox::Messaging::Task do
 
-  it "should send payload correctly" do
-    expectation = [{:method => :payload=, :payload => {:foo => 'bar'}}, { }]
-    queue = mock("queue")
-    queue.should_receive(:publish).with(*expectation) 
-    TorqueBox::Messaging::Queue.should_receive(:new).with(MyTestTask.queue_name).and_return(queue)
 
-    MyTestTask.async(:payload=, :foo => 'bar')
-  end
+  describe '#async' do
+    before(:each) do
+      TorqueBox::Messaging::Future.stub(:unique_id).and_return('1234')
+      @send_queue = mock('queue')
+      @send_queue.stub(:publish)
+      TorqueBox::Messaging::Queue.should_receive(:new).with(MyTestTask.queue_name).and_return(@send_queue)
+    end
+
+    it "should send payload correctly" do
+      expectation = [{:method => :payload=, :payload => {:foo => 'bar'}, :future_id => '1234', :future_queue => MyTestTask.queue_name}, { }]
+      @send_queue.should_receive(:publish).with(*expectation)
+      
+      MyTestTask.async(:payload=, :foo => 'bar')
+    end
 
-  it "should process payload correctly" do
-    expectation = {:method => :payload=, :payload => {:foo => 'bar'}}
-    message = mock("message")
-    message.should_receive(:decode).and_return(expectation)
+    it "should handle nil payload as empty hash" do
+      @send_queue.should_receive(:publish).with(hash_including(:payload => {}), {})
 
-    task = MyTestTask.new
-    task.process! message
-    task.payload[:foo].should == 'bar'
-  end
+      MyTestTask.async(:payload=)
+    end
 
-  it "should handle nil payload as empty hash" do
-    queue = mock("queue")
-    queue.should_receive(:publish).with(hash_including(:payload => {}), {}) 
-    TorqueBox::Messaging::Queue.should_receive(:new).with(MyTestTask.queue_name).and_return(queue)
-    MyTestTask.async(:payload=)
+    it "should return a future" do
+      result = MyTestTask.async(:payload=)
+      result.is_a?(TorqueBox::Messaging::Future).should be_true
+    end
   end
 
+  describe "#process!" do
+    it "should process payload correctly" do
+      expectation = {:method => :payload=, :payload => {:foo => 'bar'}, :future_id => '1234', :future_queue => MyTestTask.queue_name}
+      message = mock("message")
+      message.should_receive(:decode).and_return(expectation)
 
+      task = MyTestTask.new
+      task.process! message
+      task.payload[:foo].should == 'bar'
+    end
+  end
+  
+  describe 'the future proxy' do
+    it "should be available inside a task method" do
+      TorqueBox::Messaging::FutureResponder.should_receive(:status=).with(1)
+      MyTestTask.new.action
+    end
+  end
+  
   describe "queue_name" do
     before(:each) do
       ENV['TORQUEBOX_APP_NAME'] = 'app_name'
@@ -42,11 +74,11 @@ describe TorqueBox::Messaging::Task do
     after(:each) do
       ENV.delete('TORQUEBOX_APP_NAME')
     end
-    
+
     it "should derive the queue name from the class name" do
       MyTestTask.queue_name.should =~ %r{/my_test$}
     end
-    
+
     it "should include the app name in the queue name" do
       MyTestTask.queue_name.should =~ %r{/app_name/}
     end

metadata

@@ -2,15 +2,15 @@
 name: torquebox-messaging
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.0.1
+  version: "1.1"
 platform: java
-authors: []
+authors: ["The TorqueBox Team"]
 
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-05-25 00:00:00 -04:00
+date: 2011-07-13 00:00:00 -04:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -21,7 +21,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: 1.0.1
+            version: "1.1"
     type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: 1.0.1
+            version: "1.1"
     type: :development
     version_requirements: *id002
   - !ruby/object:Gem::Dependency 
@@ -43,7 +43,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: 1.0.1
+            version: "1.1"
     type: :development
     version_requirements: *id003
   - !ruby/object:Gem::Dependency 
@@ -54,7 +54,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: 1.0.1
+            version: "1.1"
     type: :runtime
     version_requirements: *id004
   - !ruby/object:Gem::Dependency 
@@ -96,7 +96,7 @@ files:
   - lib/activation-1.1.jar
   - lib/jaxb-api-2.1.9.jar
   - lib/torquebox-base-spi.jar
-  - lib/jruby-complete-1.6.2.jar
+  - lib/jruby-complete-1.6.3.jar
   - lib/torquebox-base-metadata.jar
   - lib/torquebox-base-core.jar
   - lib/picketbox-bare-3.0.0.CR2.jar
@@ -116,6 +116,9 @@ files:
   - lib/torquebox/messaging/backgroundable.rb
   - lib/torquebox/messaging/client.rb
   - lib/torquebox/messaging/destination.rb
+  - lib/torquebox/messaging/future.rb
+  - lib/torquebox/messaging/future_responder.rb
+  - lib/torquebox/messaging/future_status.rb
   - lib/torquebox/messaging/task.rb
   - lib/torquebox/messaging/ext/javax_jms_queue_browser.rb
   - lib/torquebox/messaging/ext/javax_jms_session.rb
@@ -124,6 +127,7 @@ files:
   - spec/destination_spec.rb
   - spec/dispatcher-queues.yml
   - spec/dispatcher_not_running.rb
+  - spec/future_spec.rb
   - spec/queues.yml
   - spec/task_spec.rb
   - spec/ext/java_jmx_session_spec.rb
@@ -159,5 +163,6 @@ test_files:
   - spec/backgroundable_spec.rb
   - spec/client_spec.rb
   - spec/destination_spec.rb
+  - spec/future_spec.rb
   - spec/task_spec.rb
   - spec/ext/java_jmx_session_spec.rb