stomp 1.2.10 → 1.2.11

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+== 1.2.11 20130728
+
+* Issue #60, timeout/hang under JRuby
+* More generally support JRuby use and testing
+* Issue #58, nil message in Client on AMQ shutdown
+* More robust RabbitMQ tests
+
 == 1.2.10 20130708
 
 * Issue #57, reconnect delays not honored if erroneous headers

data/README.rdoc

@@ -12,6 +12,7 @@ An implementation of the Stomp protocol for Ruby. See:
 
 See _CHANGELOG.rdoc_ for details.
 
+* Gem version 1.2.11. JRuby and AMQ support fixes.
 * Gem version 1.2.10. Support failover from heartbeat threads.
 * Gem version 1.2.9. Miscellaneous fixes and changes.
 * Gem version 1.2.8. Stomp 1.1+ header codec inversion fix, test refactoring.

data/lib/client/utils.rb

@@ -157,15 +157,18 @@ module Stomp
       @listener_thread = Thread.start do
         while true
           message = @connection.receive
-          if message # AMQ specific?, nil message on multiple reconnects
-            if message.command == Stomp::CMD_MESSAGE
-              if listener = find_listener(message)
-                listener.call(message)
-              end
-            elsif message.command == Stomp::CMD_RECEIPT
-              if listener = @receipt_listeners[message.headers['receipt-id']]
-                listener.call(message)
-              end
+          # AMQ specific behavior
+          if message.nil? && (!@reliable)
+            raise Stomp::Error::NilMessageError
+          end
+          # OK, we have some real data
+          if message.command == Stomp::CMD_MESSAGE
+            if listener = find_listener(message)
+              listener.call(message)
+            end
+          elsif message.command == Stomp::CMD_RECEIPT
+            if listener = @receipt_listeners[message.headers['receipt-id']]
+              listener.call(message)
             end
           end
         end # while true

data/lib/connection/heartbeats.rb

@@ -152,7 +152,7 @@ module Stomp
         while true do
           sleep sleeptime
           next unless @socket # nil under some circumstances ??
-          rdrdy = @socket.ready? ? true : false
+          rdrdy = _is_ready?(@socket)
           curt = Time.now.to_f
           if @logger && @logger.respond_to?(:on_hbfire)
             @logger.on_hbfire(log_params, "receive_fire", curt)
@@ -171,7 +171,7 @@ module Stomp
               lock = @read_semaphore.try_lock
               if lock
                 lock_fail_count = 0 # clear
-                rdrdy = @socket.ready? ? true : false # This logic will be bad for JRuby I think
+                rdrdy = _is_ready?(@socket)
                 if rdrdy
                   read_fail_count = 0 # clear
                   last_char = @socket.getc

data/lib/connection/netio.rb

@@ -16,7 +16,16 @@ module Stomp
       @read_semaphore.synchronize do
         line = ''
         if @protocol == Stomp::SPL_10 || (@protocol >= Stomp::SPL_11 && !@hbr)
-          line = read_socket.gets # The old way
+          if @jruby
+            # Handle JRuby specific behavior.
+            while true
+              line = read_socket.gets # Data from wire
+              break unless line == "\n"
+              line = ''
+            end
+          else
+            line = read_socket.gets # The old way
+          end
         else # We are >= 1.1 *AND* receiving heartbeats.
           while true
             line = read_socket.gets # Data from wire
@@ -28,7 +37,6 @@ module Stomp
         return nil if line.nil?
         # p [ "wiredatain_01", line ]
         line = _normalize_line_end(line) if @protocol >= Stomp::SPL_12
-
         # If the reading hangs for more than X seconds, abort the parsing process.
         # X defaults to 5.  Override allowed in connection hash parameters.
         Timeout::timeout(@parse_timeout, Stomp::Error::PacketParsingTimeout) do
@@ -58,15 +66,16 @@ module Stomp
 
           # If the buffer isn't empty, reads trailing new lines.
           #
-          # Note: experiments with JRuby seem to show that .ready? never
-          # returns true.  This means that this code to drain trailing new
-          # lines never runs using JRuby.
+          # Note: experiments with JRuby seem to show that socket.ready? never
+          # returns true.  It appears that in cases where Ruby returns true
+          # that JRuby returns a Fixnum.  We attempt to adjust for this
+          # in the _is_ready? method.
           #
           # Note 2: the draining of new lines must be done _after_ a message
           # is read.  Do _not_ leave them on the wire and attempt to drain them
           # at the start of the next read.  Attempting to do that breaks the
           # asynchronous nature of the 'poll' method.
-          while read_socket.ready?
+          while _is_ready?(read_socket)
             last_char = read_socket.getc
             break unless last_char
             if parse_char(last_char) != "\n"
@@ -74,9 +83,6 @@ module Stomp
               break
             end
           end
-          # And so, a JRuby hack.  Remove any new lines at the start of the
-          # next buffer.
-          message_header.gsub!(/^\n?/, "")
 
           if @protocol >= Stomp::SPL_11
             @lr = Time.now.to_f if @hbr
@@ -92,6 +98,15 @@ module Stomp
       end
     end
 
+    # Check if the socket is ready, i.e. there is data to read.
+    def _is_ready?(s)
+      rdy = s.ready?
+      if @jruby
+        rdy = rdy.class == Fixnum ? true : false
+      end
+      rdy
+    end
+
     # Normalize line ends because 1.2+ brokers can send 'mixed mode' headers, i.e.:
     # - Some headers end with '\n'
     # - Other headers end with '\r\n'

data/lib/stomp/client.rb

@@ -233,6 +233,11 @@ module Stomp
       @connection.closed?()
     end
 
+    # jruby? tests if the connection has detcted a JRuby environment
+    def jruby?()
+      @connection.jruby
+    end
+
     # close frees resources in use by this client.  The listener thread is
     # terminated, and disconnect on the connection is called.
     def close(headers={})

data/lib/stomp/connection.rb

@@ -31,6 +31,9 @@ module Stomp
     # Heartbeat send has been successful.
     attr_reader   :hb_sent # Heartbeat sent successfully
 
+    # JRuby detected
+    attr_reader   :jruby
+
     # Autoflush forces a flush on each transmit.  This may be changed
     # dynamically by calling code.
     attr_accessor :autoflush
@@ -87,7 +90,10 @@ module Stomp
       @hb_received = true       # Assumed at first
       @hb_sent = true           # Assumed at first
       @hbs = @hbr = false       # Sending/Receiving heartbeats. Assume no for now.
-
+      @jruby = false            # Assumed at first
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+        @jruby = true
+      end
       if login.is_a?(Hash)
         hashed_initialize(login)
       else

data/lib/stomp/errors.rb

@@ -196,6 +196,15 @@ module Stomp
     class LoggerConnectionError < RuntimeError
     end
 
+    # NilMessageError is raised if:
+    # * Invalid (nil) data is received from the Stomp server in a client's
+    # listener thread, and the connection is not reliable.
+    class NilMessageError < RuntimeError
+      def message
+        "Received message is nil, and connection not reliable"
+      end
+    end
+
   end # module Error
 
 end # module Stomp

data/lib/stomp/version.rb

@@ -6,7 +6,7 @@ module Stomp
   module Version  #:nodoc: all
     MAJOR = 1
     MINOR = 2
-    PATCH = 10
+    PATCH = 11
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

data/stomp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{stomp}
-  s.version = "1.2.10"
+  s.version = "1.2.11"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian McCallister", "Marius Mathiesen", "Thiago Morello", "Guy M. Allard"]
-  s.date = %q{2013-07-08}
+  s.date = %q{2013-07-28}
   s.description = %q{Ruby client for the Stomp messaging protocol.  Note that this gem is no longer supported on rubyforge.}
   s.email = ["brianm@apache.org", "marius@stones.com", "morellon@gmail.com", "allard.guy.m@gmail.com"]
   s.executables = ["catstomp", "stompcat"]

data/test/test_client.rb

@@ -23,7 +23,7 @@ class TestClient < Test::Unit::TestCase
   end
 
   def teardown
-    @client.close if @client.open? # allow tests to close
+    @client.close if @client && @client.open? # allow tests to close
   end
 
   # Test poll works.
@@ -50,7 +50,7 @@ class TestClient < Test::Unit::TestCase
     sleep 0.01 until receipt
     assert_not_nil receipt.headers['receipt-id']
     checkEmsg(@client)
-  end unless ENV['STOMP_RABBIT'] # TODO: why does Rabbit 1.1 fail ?
+  end
 
   # Test Client subscribe
   def test_asynch_subscribe
@@ -160,61 +160,133 @@ class TestClient < Test::Unit::TestCase
   end unless RUBY_ENGINE =~ /jruby/
 
   # Test transaction publish and abort, receive with new client.
-  def test_transaction_ack_rollback_with_new_client
-    @client.publish make_destination, message_text
+  # New client uses ack => client.
+  def test_tran_ack_abrt_newcli_cli
+    @client.close if @client && @client.open? # allow tests to close
+    @client = get_client()
+    q = make_destination
+    data = message_text
+    @client.publish q, data
 
     @client.begin 'tx1'
     message = nil
     sid = nil
     if @client.protocol() == Stomp::SPL_10
-      @client.subscribe(make_destination, :ack => 'client') {|m| message = m}
-    else
+      @client.subscribe(q, :ack => 'client') {|m| message = m}
+    else # 1.1 and 1.2 are the same for this
       sid = @client.uuid()
-      @client.subscribe(make_destination, :ack => 'client', :id => sid) {|m| message = m}
+      @client.subscribe(q, :ack => 'client', :id => sid) {|m| message = m}
     end
     sleep 0.01 until message
-    assert_equal message_text, message.body
+    assert_equal data, message.body
     assert_nothing_raised {
-      if @client.protocol() == Stomp::SPL_10
-        @client.acknowledge message, :transaction => 'tx1'
-      else
-        @client.acknowledge message, :transaction => 'tx1', :subscription => sid
+      case @client.protocol()
+        when Stomp::SPL_10
+          @client.acknowledge message, :transaction => 'tx1'
+          checkEmsg(@client)
+        when Stomp::SPL_11
+          @client.acknowledge message, :transaction => 'tx1', :subscription => message.headers['subscription']
+          checkEmsg(@client)
+        else # 1.2+
+          @client.acknowledge message, :transaction => 'tx1', :id => message.headers['ack']
+          checkEmsg(@client)
       end
-      message = nil
-      @client.abort 'tx1'
+      message = nil # reset
+      @client.abort 'tx1' # now abort
     }
     checkEmsg(@client)
     # lets recreate the connection
-    teardown
-    setup
+    @client.close
+    @client = get_client()
     sid = nil
+    message2 = nil
+    @client.begin 'tx2'
     assert_nothing_raised {
       if @client.protocol() == Stomp::SPL_10
-        @client.subscribe(make_destination, :ack => 'client') {|m| message = m}
-      else
+        @client.subscribe(q, :ack => 'client') {|m| message2 = m}
+      else # 1.1 and 1.2 are the same for this
         sid = @client.uuid()
-        @client.subscribe(make_destination, :ack => 'client', :id => sid) {|m| message = m}
+        @client.subscribe(q, :ack => 'client', :id => sid) {|m| message2 = m}
       end
     }
-    Timeout::timeout(4) do
-      sleep 0.01 until message
-    end
+    sleep 0.01 until message2
     assert_not_nil message
-    assert_equal message_text, message.body
+    assert_equal data, message2.body
     assert_nothing_raised {
-    @client.begin 'tx2'
       case @client.protocol()
         when Stomp::SPL_10
-          @client.acknowledge message, :transaction => 'tx2'
+          @client.acknowledge message2, :transaction => 'tx2'
+          checkEmsg(@client)
         when Stomp::SPL_11
-          @client.acknowledge message, :transaction => 'tx2', :subscription => sid
-        else
-          # Skip 1.2+ for now.  Current 1.2 broker appears to think this is 
-          # already ACK'd.
+          @client.acknowledge message2, :transaction => 'tx2', :subscription => message2.headers['subscription']
+          checkEmsg(@client)
+        else # 1.2+
+          @client.acknowledge message2, :transaction => 'tx2', :id => message2.headers['ack']
+          checkEmsg(@client)
       end
       @client.commit 'tx2'
     }
     checkEmsg(@client)
+    @client.close
+  end
+
+  # Test transaction publish and abort, receive with new client.
+  # New client uses ack => auto.
+  def test_tran_ack_abrt_newcli_auto
+    @client.close if @client && @client.open? # allow tests to close
+    @client = get_client()
+    q = make_destination
+    data = message_text
+    @client.publish q, data
+
+    @client.begin 'tx1'
+    message = nil
+    sid = nil
+    if @client.protocol() == Stomp::SPL_10
+      @client.subscribe(q, :ack => 'client') {|m| message = m}
+    else # 1.1 and 1.2 are the same for this
+      sid = @client.uuid()
+      @client.subscribe(q, :ack => 'client', :id => sid) {|m| message = m}
+    end
+    sleep 0.01 until message
+    assert_equal data, message.body
+    assert_nothing_raised {
+      case @client.protocol()
+        when Stomp::SPL_10
+          @client.acknowledge message, :transaction => 'tx1'
+          checkEmsg(@client)
+        when Stomp::SPL_11
+          @client.acknowledge message, :transaction => 'tx1', :subscription => message.headers['subscription']
+          checkEmsg(@client)
+        else # 1.2+
+          @client.acknowledge message, :transaction => 'tx1', :id => message.headers['ack']
+          checkEmsg(@client)
+      end
+      message = nil # reset
+      @client.abort 'tx1' # now abort
+    }
+    checkEmsg(@client)
+    # lets recreate the connection
+    @client.close
+
+    @client = get_client()
+    sid = nil
+    message2 = nil
+    @client.begin 'tx2'
+    assert_nothing_raised {
+      if @client.protocol() == Stomp::SPL_10
+        @client.subscribe(q, :ack => 'auto') {|m| message2 = m}
+      else # 1.1 and 1.2 are the same for this
+        sid = @client.uuid()
+        @client.subscribe(q, :ack => 'auto', :id => sid) {|m| message2 = m}
+      end
+    }
+    sleep 0.01 until message2
+    assert_not_nil message2
+    assert_equal data, message2.body
+    @client.commit 'tx2'
+    checkEmsg(@client)
+    @client.close
   end
 
   # Test that subscription destinations must be unique for a Client.
@@ -313,50 +385,60 @@ class TestClient < Test::Unit::TestCase
     checkEmsg(@client)
   end unless ENV['STOMP_NOWILD'] || ENV['STOMP_DOTQUEUE']
 
-  # Test transaction with client side redilivery.
-  def test_transaction_with_client_side_redelivery
-    @client.publish make_destination, message_text
+  # Test transaction with client side reacknowledge.
+  def test_transaction_with_client_side_reack
+    @client.close if @client && @client.open? # allow tests to close
+    @client = get_client()
+    q = make_destination
+    data = message_text
+    @client.publish q, data
 
     @client.begin 'tx1'
     message = nil
     sid = nil
     if @client.protocol() == Stomp::SPL_10
-      @client.subscribe(make_destination, :ack => 'client') { |m| message = m }
+      @client.subscribe(q, :ack => 'client') { |m| message = m }
     else
       sid = @client.uuid()
-      @client.subscribe(make_destination, :ack => 'client', :id => sid) { |m| message = m }
+      @client.subscribe(q, :ack => 'client', :id => sid) { |m| message = m }
     end
-
     sleep 0.1 while message.nil?
-
-    assert_equal message_text, message.body
-    if @client.protocol() == Stomp::SPL_10
-      @client.acknowledge message, :transaction => 'tx1'
-    else
-      @client.acknowledge message, :transaction => 'tx1', :subscription => sid
+    assert_equal data, message.body
+    case @client.protocol()
+      when Stomp::SPL_10
+        @client.acknowledge message, :transaction => 'tx1'
+        checkEmsg(@client)
+      when Stomp::SPL_11
+        @client.acknowledge message, :transaction => 'tx1', :subscription => message.headers['subscription']
+        checkEmsg(@client)
+      else # 1.2+
+        @client.acknowledge message, :transaction => 'tx1', :id => message.headers['ack']
+        checkEmsg(@client)
     end
     message = nil
     @client.abort 'tx1'
-
+    # Wait for redlivery (Client logic)
     sleep 0.1 while message.nil?
-
     assert_not_nil message
-    assert_equal message_text, message.body
-
+    assert_equal data, message.body
     assert_nothing_raised {
       @client.begin 'tx2'
       case @client.protocol()
         when Stomp::SPL_10
           @client.acknowledge message, :transaction => 'tx2'
+          checkEmsg(@client)
         when Stomp::SPL_11
-          @client.acknowledge message, :transaction => 'tx2', :subscription => sid
-        else
-          # Skip 1.2+ for now.  Current 1.2 broker appears to think this is 
-          # already ACK'd.
+          @client.acknowledge message, :transaction => 'tx2', :subscription => message.headers['subscription']
+          checkEmsg(@client)
+        else # 1.2+
+          @client.acknowledge message, :transaction => 'tx2', :id => message.headers['ack']
+          checkEmsg(@client)
       end
       @client.commit 'tx2'
     }
     checkEmsg(@client)
+    @client.close
+    @client = nil
   end
 
   # Test that a connection frame is received.
@@ -523,6 +605,15 @@ class TestClient < Test::Unit::TestCase
     end
   end
 
+  # test JRuby detection
+  def test_jruby_presence
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+      assert @client.jruby?
+    else
+      assert !@client.jruby?
+    end
+  end
+
   private
     def message_text
       name = caller_method_name unless name

data/test/test_connection.rb

@@ -115,7 +115,7 @@ class TestConnection < Test::Unit::TestCase
       # matching the message-id for the MESSAGE being acknowledged and 
       # subscription, which MUST be set to match the value of the subscription's 
       # id header.
-      @conn.ack msg.headers['message-id'], :subscription => sid
+      @conn.ack msg.headers['message-id'], :subscription => msg.headers['subscription']
     }
     checkEmsg(@conn)
   end
@@ -509,5 +509,14 @@ class TestConnection < Test::Unit::TestCase
     c.disconnect if c
   end
 
+  # test JRuby detection
+  def test_jruby_presence
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+      assert @conn.jruby
+    else
+      assert !@conn.jruby
+    end
+  end
+
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: stomp
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 1
   - 2
-  - 10
-  version: 1.2.10
+  - 11
+  version: 1.2.11
 platform: ruby
 authors: 
 - Brian McCallister
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-07-08 00:00:00 -04:00
+date: 2013-07-28 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency