torquebox-messaging 3.2.0-java → 4.0.0.alpha1-java

data/lib/torquebox/messaging/xa_session.rb

@@ -1,51 +0,0 @@
-# Copyright 2008-2013 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
-
-    class XaSession < Session
-      include javax.transaction.Synchronization
-      attr_reader :transaction
-
-      def initialize( jms_session, transaction, connection )
-        super( jms_session )
-        @transaction = transaction
-        @connection = connection
-      end
-
-      def close
-        # eat the close, until tx completes
-      end
-
-      def beforeCompletion
-        # required interface
-      end
-
-      def afterCompletion(status)
-        @connection.deactivate
-        @connection.complete!
-      end
-
-      def xa_resource
-        @jms_session.xa_resource
-      end
-
-    end
-
-  end
-end

data/licenses/cc0-1.0.txt

@@ -1,121 +0,0 @@
-Creative Commons Legal Code
-
-CC0 1.0 Universal
-
-    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
-    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
-    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
-    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
-    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
-    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
-    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
-    HEREUNDER.
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator
-and subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for
-the purpose of contributing to a commons of creative, cultural and
-scientific works ("Commons") that the public can reliably and without fear
-of later claims of infringement build upon, modify, incorporate in other
-works, reuse and redistribute as freely as possible in any form whatsoever
-and for any purposes, including without limitation commercial purposes.
-These owners may contribute to the Commons to promote the ideal of a free
-culture and the further production of creative, cultural and scientific
-works, or to gain reputation or greater distribution for their Work in
-part through the use and efforts of others.
-
-For these and/or other purposes and motivations, and without any
-expectation of additional consideration or compensation, the person
-associating CC0 with a Work (the "Affirmer"), to the extent that he or she
-is an owner of Copyright and Related Rights in the Work, voluntarily
-elects to apply CC0 to the Work and publicly distribute the Work under its
-terms, with knowledge of his or her Copyright and Related Rights in the
-Work and the meaning and intended legal effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not
-limited to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display,
-     communicate, and translate a Work;
- ii. moral rights retained by the original author(s) and/or performer(s);
-iii. publicity and privacy rights pertaining to a person's image or
-     likeness depicted in a Work;
- iv. rights protecting against unfair competition in regards to a Work,
-     subject to the limitations in paragraph 4(a), below;
-  v. rights protecting the extraction, dissemination, use and reuse of data
-     in a Work;
- vi. database rights (such as those arising under Directive 96/9/EC of the
-     European Parliament and of the Council of 11 March 1996 on the legal
-     protection of databases, and under any national implementation
-     thereof, including any amended or successor version of such
-     directive); and
-vii. other similar, equivalent or corresponding rights throughout the
-     world based on applicable law or treaty, and any national
-     implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention
-of, applicable law, Affirmer hereby overtly, fully, permanently,
-irrevocably and unconditionally waives, abandons, and surrenders all of
-Affirmer's Copyright and Related Rights and associated claims and causes
-of action, whether now known or unknown (including existing as well as
-future claims and causes of action), in the Work (i) in all territories
-worldwide, (ii) for the maximum duration provided by applicable law or
-treaty (including future time extensions), (iii) in any current or future
-medium and for any number of copies, and (iv) for any purpose whatsoever,
-including without limitation commercial, advertising or promotional
-purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
-member of the public at large and to the detriment of Affirmer's heirs and
-successors, fully intending that such Waiver shall not be subject to
-revocation, rescission, cancellation, termination, or any other legal or
-equitable action to disrupt the quiet enjoyment of the Work by the public
-as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason
-be judged legally invalid or ineffective under applicable law, then the
-Waiver shall be preserved to the maximum extent permitted taking into
-account Affirmer's express Statement of Purpose. In addition, to the
-extent the Waiver is so judged Affirmer hereby grants to each affected
-person a royalty-free, non transferable, non sublicensable, non exclusive,
-irrevocable and unconditional license to exercise Affirmer's Copyright and
-Related Rights in the Work (i) in all territories worldwide, (ii) for the
-maximum duration provided by applicable law or treaty (including future
-time extensions), (iii) in any current or future medium and for any number
-of copies, and (iv) for any purpose whatsoever, including without
-limitation commercial, advertising or promotional purposes (the
-"License"). The License shall be deemed effective as of the date CC0 was
-applied by Affirmer to the Work. Should any part of the License for any
-reason be judged legally invalid or ineffective under applicable law, such
-partial invalidity or ineffectiveness shall not invalidate the remainder
-of the License, and in such case Affirmer hereby affirms that he or she
-will not (i) exercise any of his or her remaining Copyright and Related
-Rights in the Work or (ii) assert any associated claims and causes of
-action with respect to the Work, in either case contrary to Affirmer's
-express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
-    surrendered, licensed or otherwise affected by this document.
- b. Affirmer offers the Work as-is and makes no representations or
-    warranties of any kind concerning the Work, express, implied,
-    statutory or otherwise, including without limitation warranties of
-    title, merchantability, fitness for a particular purpose, non
-    infringement, or the absence of latent or other defects, accuracy, or
-    the present or absence of errors, whether or not discoverable, all to
-    the greatest extent permissible under applicable law.
- c. Affirmer disclaims responsibility for clearing rights of other persons
-    that may apply to the Work or any use thereof, including without
-    limitation any person's Copyright and Related Rights in the Work.
-    Further, Affirmer disclaims responsibility for obtaining any necessary
-    consents, permissions or other rights required for any use of the
-    Work.
- d. Affirmer understands and acknowledges that Creative Commons is not a
-    party to this document and has no duty or obligation with respect to
-    this CC0 or use of the Work.

data/spec/backgroundable_spec.rb

@@ -1,319 +0,0 @@
-require 'torquebox/messaging/backgroundable'
-require 'pp'
-
-class InstanceMethodTestModel
-  include TorqueBox::Messaging::Backgroundable
-
-  def an_async_action(arg1, arg2)
-    a_sync_action
-  end
-  always_background :an_async_action
-
-  def a_sync_action;  end
-  def foo;  end
-  def bar;  end
-  def optioned; end
-  def redefine_me; end
-end
-
-class ClassMethodTestModel
-  include TorqueBox::Messaging::Backgroundable
-
-  def self.an_async_action(arg1, arg2)
-    a_sync_action
-  end
-  always_background :an_async_action
-
-  def self.a_sync_action;  end
-  def self.foo;  end
-  def self.bar;  end
-  def self.optioned; end
-  def self.redefine_me; end
-
-  def foo; end
-
-  class << self
-    def singleton_class
-      self
-    end
-  end
-end
-
-describe TorqueBox::Messaging::Backgroundable do
-  before(:all) do
-    @util = TorqueBox::Messaging::Backgroundable::Util
-  end
-
-  describe "always_background" do
-    context "for instance methods" do
-      it "should be able to handle multiple methods" do
-        InstanceMethodTestModel.always_background :foo, :bar
-        @util.instance_methods_include?(InstanceMethodTestModel, '__async_foo').should be_true
-        @util.instance_methods_include?(InstanceMethodTestModel, '__async_bar').should be_true
-      end
-
-      it "should handle methods that are defined after the always_background call" do
-        InstanceMethodTestModel.always_background :baz
-        @util.instance_methods_include?(InstanceMethodTestModel, '__async_baz').should_not be_true
-        InstanceMethodTestModel.class_eval('def baz;end')
-        @util.instance_methods_include?(InstanceMethodTestModel, '__async_baz').should be_true
-      end
-
-      it "should handle methods that are redefined after the always_background call" do
-        InstanceMethodTestModel.always_background :redefine_me
-        InstanceMethodTestModel.class_eval('def redefine_me; :xyz; end')
-        InstanceMethodTestModel.new.__sync_redefine_me.should == :xyz
-      end
-
-      it "should work for private methods, maintaining visibility" do
-        InstanceMethodTestModel.class_eval('private; def no_peeking;end')
-        InstanceMethodTestModel.always_background :no_peeking
-        @util.private_instance_methods_include?(InstanceMethodTestModel, 'no_peeking').should be_true
-        @util.private_instance_methods_include?(InstanceMethodTestModel, '__async_no_peeking').should be_true
-        @util.private_instance_methods_include?(InstanceMethodTestModel, '__sync_no_peeking').should be_true
-      end
-
-      it "should work for protected methods, maintaining visibility" do
-        InstanceMethodTestModel.class_eval('protected; def some_peeking;end')
-        InstanceMethodTestModel.always_background :some_peeking
-        @util.protected_instance_methods_include?(InstanceMethodTestModel, 'some_peeking').should be_true
-        @util.protected_instance_methods_include?(InstanceMethodTestModel, '__async_some_peeking').should be_true
-        @util.protected_instance_methods_include?(InstanceMethodTestModel, '__sync_some_peeking').should be_true
-      end
-    end
-
-    context "for class methods" do
-      it "should work when called after the method is defined" do
-        @util.singleton_methods_include?(ClassMethodTestModel, '__async_an_async_action').should be_true
-      end
-
-      it "should be able to handle multiple methods" do
-        ClassMethodTestModel.always_background :foo, :bar
-        @util.singleton_methods_include?(ClassMethodTestModel, '__async_foo').should be_true
-        @util.singleton_methods_include?(ClassMethodTestModel, '__async_bar').should be_true
-      end
-
-      it "class methods should win a tie" do
-        ClassMethodTestModel.always_background :foo
-        @util.singleton_methods_include?(ClassMethodTestModel, '__async_foo').should be_true
-        @util.instance_methods_include?(ClassMethodTestModel, '__async_foo').should_not be_true
-      end
-
-      it "should handle methods that are defined after the always_background call" do
-        ClassMethodTestModel.always_background :baz
-        @util.singleton_methods_include?(ClassMethodTestModel, '__async_baz').should_not be_true
-        ClassMethodTestModel.class_eval('def self.baz;end')
-        @util.singleton_methods_include?(ClassMethodTestModel, '__async_baz').should be_true
-      end
-
-      it "should handle methods that are redefined after the always_background call" do
-        ClassMethodTestModel.always_background :redefine_me
-        ClassMethodTestModel.class_eval('def self.redefine_me; :xyz; end')
-        ClassMethodTestModel.__sync_redefine_me.should == :xyz
-      end
-
-      it "should work for private methods, maintaining visibility" do
-        ClassMethodTestModel.class_eval do
-          class << self
-            private
-            def no_peeking;end
-          end
-        end
-
-        ClassMethodTestModel.always_background :no_peeking
-
-        @util.private_singleton_methods_include?(ClassMethodTestModel,
-                                                 'no_peeking').should be_true
-        @util.private_singleton_methods_include?(ClassMethodTestModel,
-                                                 '__async_no_peeking').should be_true
-        @util.private_singleton_methods_include?(ClassMethodTestModel,
-                                                 '__sync_no_peeking').should be_true
-      end
-
-      it "should work for protected methods, maintaining visibility" do
-        ClassMethodTestModel.class_eval do
-          class << self
-            protected
-            def some_peeking;end
-          end
-        end
-
-        ClassMethodTestModel.always_background :some_peeking
-
-        @util.protected_singleton_methods_include?(ClassMethodTestModel,
-                                                   'some_peeking').should be_true
-        @util.protected_singleton_methods_include?(ClassMethodTestModel,
-                                                   '__async_some_peeking').should be_true
-        @util.protected_singleton_methods_include?(ClassMethodTestModel,
-                                                   '__sync_some_peeking').should be_true
-      end
-    end
-
-  end
-
-  describe "a method handled asynchronously" do
-    before(:each) 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
-      @queue.should_receive(:publish)
-      InstanceMethodTestModel.new.an_async_action(nil, nil)
-    end
-
-    it "should return a future" do
-      result = InstanceMethodTestModel.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 = InstanceMethodTestModel.new
-      @queue.should_receive(:publish).with({
-                                             :receiver => object,
-                                             :future_id => '1234',
-                                             :future_queue => "/queues/torquebox//tasks/torquebox_backgroundable",
-                                             :method => '__sync_an_async_action',
-                                             :future_ttl => nil,
-                                             :args => [:a, :b]
-                                           },
-                                           anything)
-      object.an_async_action(:a, :b)
-    end
-
-    it "should not call the action immediately" do
-      object = InstanceMethodTestModel.new
-      object.should_not_receive(:a_sync_action)
-      object.an_async_action(nil, nil)
-    end
-
-    it "should pass through the options" do
-      InstanceMethodTestModel.always_background :optioned, :priority => :low
-      @queue.should_receive(:publish).with(anything, hash_including(:priority => :low))
-      InstanceMethodTestModel.new.optioned
-    end
-
-  end
-
-  describe 'background' do
-    context "for instance methods" do
-      before(:each) do
-        @queue = mock('queue')
-        @queue.stub(:publish)
-        TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
-        @object = InstanceMethodTestModel.new
-      end
-
-      it "should queue any method called on it" do
-        @queue.should_receive(:publish).with(hash_including(:method => :foo),
-                                             anything)
-        @object.background.foo
-      end
-
-      it "should queue the receiver" do
-        @queue.should_receive(:publish).with(hash_including(:receiver => @object), anything)
-        @object.background.foo
-      end
-
-      it "should queue the args" do
-        @queue.should_receive(:publish).with(hash_including(:args => [1,2]), anything)
-        @object.background.foo(1,2)
-      end
-
-      it "should use default future ttl" do
-        @queue.should_receive(:publish).with(hash_including(:future_ttl => nil), anything)
-        @object.background.foo
-      end
-
-      it "should use custom future ttl" do
-        @queue.should_receive(:publish).with(hash_including(:future_ttl => 100_000), anything)
-        @object.background(:future_ttl => 100_000).foo
-      end
-
-      it "should raise when given a block" do
-        lambda {
-          @object.background.foo { }
-        }.should raise_error(ArgumentError)
-      end
-
-      it "should handle missing methods" do
-        @object.should_receive(:method_missing)
-        @object.background.no_method
-      end
-
-      it "should pass through any options" do
-        @queue.should_receive(:publish).with(anything,
-                                             hash_including(:ttl => 1))
-        @object.background(:ttl => 1).foo
-      end
-
-      it "should always use the :marshal encoding" do
-        @queue.should_receive(:publish).with(anything,
-                                             hash_including(:encoding => :marshal))
-        @object.background.foo
-      end
-
-    end
-
-    context "for class methods" do
-      before(:each) do
-        @queue = mock('queue')
-        @queue.stub(:publish)
-        TorqueBox::Messaging::Queue.stub(:new).and_return(@queue)
-        @object = ClassMethodTestModel
-      end
-
-      it "should queue any method called on it" do
-        @queue.should_receive(:publish).with(hash_including(:method => :foo),
-                                             anything)
-        @object.background.foo
-      end
-
-      it "should queue the receiver" do
-        @queue.should_receive(:publish).with(hash_including(:receiver => @object), anything)
-        @object.background.foo
-      end
-
-      it "should queue the args" do
-        @queue.should_receive(:publish).with(hash_including(:args => [1,2]), anything)
-        @object.background.foo(1,2)
-      end
-
-      it "should use default future ttl" do
-        @queue.should_receive(:publish).with(hash_including(:future_ttl => nil), anything)
-        @object.background.foo
-      end
-
-      it "should use custom future ttl" do
-        @queue.should_receive(:publish).with(hash_including(:future_ttl => 100_000), anything)
-        @object.background(:future_ttl => 100_000).foo
-      end
-
-      it "should raise when given a block" do
-        lambda {
-          @object.background.foo { }
-        }.should raise_error(ArgumentError)
-      end
-
-      it "should handle missing methods" do
-        @object.should_receive(:method_missing)
-        @object.background.no_method
-      end
-
-      it "should pass through any options" do
-        @queue.should_receive(:publish).with(anything,
-                                             hash_including(:ttl => 1))
-        @object.background(:ttl => 1).foo
-      end
-
-      it "should always use the :marshal encoding" do
-        @queue.should_receive(:publish).with(anything,
-                                             hash_including(:encoding => :marshal))
-        @object.background.foo
-      end
-    end
-  end
-
-end