stomp 1.2.11 → 1.2.12

data/CHANGELOG.rdoc

@@ -1,3 +1,15 @@
+== 1.2.12 20130728
+
+* Fix infinite loop when max reconn attempts is reached
+* Enhance JRuby support in tests
+* Issue #63, nil message on rapid AMQ restarts
+* Issue #63, fast spurious failovers with JRuby and AMQ
+* Issue #67, SSL SNI support (thanks Hiram)
+* Proper cleanup when not reliable adn EOF from broker
+* Remove extraneous privte declarations
+* Issue #65, allow non-word characters in login and passcode using stomp://
+* Issue #66, allow a single broker in a failover URL
+
 == 1.2.11 20130728
 
 * Issue #60, timeout/hang under JRuby

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.12. Miscellaneous issue fixes and cleanup.
 * 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.
@@ -54,6 +55,9 @@ See _CHANGELOG.rdoc_ for details.
       :usecrlf => false,                  # Use CRLF command and header line ends (1.2+)
       :max_hbread_fails => 0,             # Max HB read fails before retry.  0 => never retry
       :max_hbrlck_fails => 0,             # Max HB read lock obtain fails before retry.  0 => never retry
+      :fast_hbs_adjust => 0.0,            # Fast heartbeat senders sleep adjustment, seconds, needed ...
+                                          # For fast heartbeat senders.  'fast' == YMMV.  If not
+                                          # correct for your environment, expect unnecessary fail overs
     }
 
     # for client

data/examples/slogger.rb

@@ -203,7 +203,7 @@ class Slogger
   end
 
   # Stomp 1.1+ - heart beat read (receive) failed.
-  def on_hbread_fail(parms, ticker_data)
+  def on_hbread_fail(parms, ticker_data = {})
     begin
       @log.debug "Hbreadf Parms #{info(parms)}"
       @log.debug "Hbreadf Result #{ticker_data.inspect}"
@@ -213,7 +213,7 @@ class Slogger
   end
 
   # Stomp 1.1+ - heart beat send (transmit) failed.
-  def on_hbwrite_fail(parms, ticker_data)
+  def on_hbwrite_fail(parms, ticker_data = {})
     begin
       @log.debug "Hbwritef Parms #{info(parms)}"
       @log.debug "Hbwritef Result #{ticker_data.inspect}"
@@ -256,7 +256,7 @@ class Slogger
   end
 
   # Log heart beat fires
-  def on_hbfire(parms, srind, curt)
+  def on_hbfire(parms, srind, firedata = {})
     begin
       @log.debug "HeartBeat Fire Parms #{info(parms)}"
       @log.debug "HeartBeat Fire Send/Receive #{srind}"

data/lib/client/utils.rb

@@ -21,43 +21,43 @@ module Stomp
       @reliable = true
       true
     end
-    private :parse_hash_params
 
     def parse_stomp_url(login)
-      regexp = /^stomp:\/\/#{url_regex}/ # e.g. stomp://login:passcode@host:port or stomp://host:port
+      regexp = /^stomp:\/\/#{URL_REPAT}/
       return false unless login =~ regexp
 
-      @login = $2 || ""
-      @passcode = $3 || ""
-      @host = $4
-      @port = $5.to_i
+      @login = $3 || ""
+      @passcode = $4 || ""
+      @host = $5
+      @port = $6.to_i
+
       @reliable = false
       true
     end
-    private :parse_stomp_url
 
     # e.g. failover://(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)?option1=param
     def parse_failover_url(login)
-      regexp = /^failover:(\/\/)?\(stomp(\+ssl)?:\/\/#{url_regex}(,stomp(\+ssl)?:\/\/#{url_regex}\))+(\?(.*))?$/
-      return false unless login =~ regexp
-
-      first_host = {}
-      first_host[:ssl] = !$2.nil?
-      @login = first_host[:login] = $4 || ""
-      @passcode = first_host[:passcode] = $5 || ""
-      @host = first_host[:host] = $6
-      @port = first_host[:port] = $7.to_i || Connection::default_port(first_host[:ssl])
-      options = $16 || ""
-      parts = options.split(/&|=/)
-      options = Hash[*parts]
-      hosts = [first_host] + parse_hosts(login)
-      @parameters = {}
-      @parameters[:hosts] = hosts
-      @parameters.merge! filter_options(options)
-      @reliable = true
-      true
+      rval = nil
+      if md = FAILOVER_REGEX.match(login)
+        finhosts = parse_hosts(login)
+        #
+        @login = finhosts[0][:login] || ""
+        @passcode = finhosts[0][:passcode] || ""
+        @host = finhosts[0][:host] || ""
+        @port = finhosts[0][:port] || ""
+        #
+        options = {}
+        if md_last = md[md.size-1]
+          parts = md_last.split(/&|=/)
+          raise Stomp::Error::MalformedFailoverOptionsError unless (parts.size % 2 ) == 0
+          options = Hash[*parts]
+        end
+        @parameters = {:hosts => finhosts}.merge! filter_options(options)
+        @reliable = true
+        rval = true
+      end
+      rval
     end
-    private :parse_failover_url
 
     def parse_positional_params(login, passcode, host, port, reliable)
       @login = login
@@ -67,7 +67,6 @@ module Stomp
       @reliable = reliable
       true
     end
-    private :parse_positional_params
 
     # Set a subscription id in the headers hash if one does not already exist.
     # For simplicities sake, all subscriptions have a subscription ID.
@@ -91,29 +90,21 @@ module Stomp
       id
     end
 
-    # url_regex defines a regex for e.g. login:passcode@host:port or host:port
-    def url_regex
-      '(([\w\.\-]*):(\w*)@)?([\w\.\-]+):(\d+)'
-    end
-
-    # Parse a stomp URL.
-    def parse_hosts(url)
-      hosts = []
-
-      host_match = /stomp(\+ssl)?:\/\/(([\w\.]*):(\w*)@)?([\w\.]+):(\d+)\)/
-      url.scan(host_match).each do |match|
-        host = {}
-        host[:ssl] = !match[0].nil?
-        host[:login] =  match[2] || ""
-        host[:passcode] = match[3] || ""
-        host[:host] = match[4]
-        host[:port] = match[5].to_i
-
-        hosts << host
-      end
-
-      hosts
-    end
+# Parse a stomp URL.
+def parse_hosts(url)
+  hosts = []
+  host_match = /stomp(\+ssl)?:\/\/#{URL_REPAT}/
+  url.scan(host_match).each do |match|
+    host = {}
+    host[:ssl] = match[0] == "+ssl" ? true : false
+    host[:login] =  match[3] || ""
+    host[:passcode] = match[4] || ""
+    host[:host] = match[5]
+    host[:port] = match[6].to_i
+    hosts << host
+  end
+  hosts
+end
 
     # A very basic check of required arguments.
     def check_arguments!()
@@ -161,14 +152,16 @@ module Stomp
           if message.nil? && (!@reliable)
             raise Stomp::Error::NilMessageError
           end
+          if message # message can be nil on rapid AMQ stop / start sequences
           # 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)
+            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
         end # while true

data/lib/connection/heartbeats.rb

@@ -91,18 +91,28 @@ module Stomp
     def _start_send_ticker()
       sleeptime = @hbsend_interval / 1000000.0 # Sleep time secs
       reconn = false
+      adjust = 0.0
       @st = Thread.new {
+        first_time = true
         while true do
-          sleep sleeptime
+          #
+          slt = sleeptime - adjust - @fast_hbs_adjust
+          sleep(slt)
           next unless @socket # nil under some circumstances ??
           curt = Time.now.to_f
           if @logger && @logger.respond_to?(:on_hbfire)
-            @logger.on_hbfire(log_params, "send_fire", curt)
+            @logger.on_hbfire(log_params, "send_fire", :curt => curt, :last_sleep => slt)
           end
           delta = curt - @ls
-          if delta > sleeptime
+          # Be tolerant (minus), and always do this the first time through.
+          # Reintroduce logic removed in d922fa.
+          compval = (@hbsend_interval - (@hbsend_interval/5.0)) / 1000000.0
+          if delta > compval || first_time
+            first_time = false
             if @logger && @logger.respond_to?(:on_hbfire)
-              @logger.on_hbfire(log_params, "send_heartbeat", curt)
+              @logger.on_hbfire(log_params, "send_heartbeat", :last_sleep => slt,
+                :curt => curt, :last_send => @ls, :delta => delta,
+                :compval => compval)
             end
             # Send a heartbeat
             @transmit_semaphore.synchronize do
@@ -135,6 +145,7 @@ module Stomp
               Thread.exit       # This sender thread is done
             end
           end
+          adjust = Time.now.to_f - curt
           Thread.pass
         end
       }
@@ -155,17 +166,15 @@ module Stomp
           rdrdy = _is_ready?(@socket)
           curt = Time.now.to_f
           if @logger && @logger.respond_to?(:on_hbfire)
-            @logger.on_hbfire(log_params, "receive_fire", curt)
+            @logger.on_hbfire(log_params, "receive_fire", :curt => curt)
           end
-
           #
           begin
             delta = curt - @lr
             if delta > sleeptime
               if @logger && @logger.respond_to?(:on_hbfire)
-                @logger.on_hbfire(log_params, "receive_heartbeat", curt)
+                @logger.on_hbfire(log_params, "receive_heartbeat", {})
               end
-
               # Client code could be off doing something else (that is, no reading of
               # the socket has been requested by the caller).  Try to  handle that case.
               lock = @read_semaphore.try_lock
@@ -223,7 +232,6 @@ module Stomp
             end
             fail_hard = true
           end
-
           # Do we want to attempt a retry?
           if @reliable
             # Retry on hard fail or max read fails
@@ -245,7 +253,6 @@ module Stomp
               Thread.exit       # This receiver thread is done            
             end
           end
-
           Thread.pass         # Prior to next receive loop
         #
         end # of the "while true"

data/lib/connection/netio.rb

@@ -279,7 +279,6 @@ module Stomp
             if @ssl.ciphers # User ciphers list?
               ctx.ciphers = @ssl.ciphers # Accept user supplied ciphers
             else
-              ctx.ciphers = Stomp::DEFAULT_CIPHERS # Just use Stomp defaults
             end
           end
         end
@@ -292,6 +291,7 @@ module Stomp
 
         Timeout::timeout(@connect_timeout, Stomp::Error::SocketOpenTimeout) do
           ssl = OpenSSL::SSL::SSLSocket.new(open_tcp_socket, ctx)
+          ssl.hostname = @host if ssl.respond_to? :hostname=
           ssl.sync_close = true # Sync ssl close with underlying TCP socket
           ssl.connect
         end

data/lib/connection/utils.rb

@@ -181,6 +181,7 @@ module Stomp
         :stompconn => false,
         :max_hbread_fails => 0,
         :max_hbrlck_fails => 0,
+        :fast_hbs_adjust => 0.0,
       }
 
       res_params = default_params.merge(params)
@@ -229,6 +230,8 @@ module Stomp
         begin
           used_socket = socket()
           return _receive(used_socket)
+        rescue Stomp::Error::MaxReconnectAttempts
+          raise
         rescue
           @failure = $!
           raise unless @reliable

data/lib/stomp/client.rb

@@ -57,6 +57,7 @@ module Stomp
     #     :usecrlf => false,
     #     :max_hbread_fails => 0,
     #     :max_hbrlck_fails => 0,
+    #     :fast_hbs_adjust => 0.0,
     #   }
     #
     #   e.g. c = Stomp::Client.new(hash)

data/lib/stomp/connection.rb

@@ -70,6 +70,7 @@ module Stomp
     #     :usecrlf => false,
     #     :max_hbread_fails => 0,
     #     :max_hbrlck_fails => 0,
+    #     :fast_hbs_adjust => 0.0,
     #   }
     #
     #   e.g. c = Stomp::Connection.new(hash)
@@ -116,6 +117,7 @@ module Stomp
         @usecrlf = false      # If true, use \r\n as line ends (1.2 only)
         @max_hbread_fails = 0 # 0 means never retry for HB read failures
         @max_hbrlck_fails = 0 # 0 means never retry for HB read lock failures
+        @fast_hbs_adjust = 0.0 # Fast heartbeat senders sleep adjustment 
         warn "login looks like a URL, do you have the correct parameters?" if @login =~ /:\/\//
       end
 
@@ -150,6 +152,7 @@ module Stomp
       @usecrlf = @parameters[:usecrlf]
       @max_hbread_fails = @parameters[:max_hbread_fails]
       @max_hbrlck_fails = @parameters[:max_hbrlck_fails]
+      @fast_hbs_adjust = @parameters[:fast_hbs_adjust]
       #sets the first host to connect
       change_host
     end
@@ -397,7 +400,10 @@ module Stomp
       receive()
     end
 
-    # receive returns the next Message off of the wire.
+    # receive returns the next Message off of the wire.  this can return nil
+    # in cases where:
+    # * the broker has closed the connection
+    # * the connection is not reliable
     def receive()
       raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
       super_result = __old_receive()
@@ -417,6 +423,13 @@ module Stomp
         super_result = __old_receive()
       end
       #
+      if super_result.nil? && !@reliable
+        @st.kill if @st # Kill ticker thread if any
+        @rt.kill if @rt # Kill ticker thread if any
+        close_socket()
+        @closed = true
+        warn 'warning: broker sent EOF, and connection not reliable' unless defined?(Test)
+      end
       if @logger && @logger.respond_to?(:on_receive)
         @logger.on_receive(log_params, super_result)
       end

data/lib/stomp/constants.rb

@@ -111,4 +111,11 @@ module Stomp
     ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128],
   ]
 
+  # stomp URL regex pattern, for e.g. login:passcode@host:port or host:port
+  URL_REPAT = '((([\w~!@#$%^&*()\-+=.?:<>,.]*\w):([\w~!@#$%^&*()\-+=.?:<>,.]*))?@)?([\w\.\-]+):(\d+)'
+
+  # Failover URL regex, for e.g.
+  #failover:(stomp+ssl://login1:passcode1@remotehost1:61612,stomp://login2:passcode2@remotehost2:61613)
+  FAILOVER_REGEX = /^failover:(\/\/)?\(stomp(\+ssl)?:\/\/#{URL_REPAT}(,stomp(\+ssl)?:\/\/#{URL_REPAT})*\)(\?(.*))?$/
+
 end # Module Stomp

data/lib/stomp/errors.rb

@@ -205,6 +205,14 @@ module Stomp
       end
     end
 
+    # MalformedFailoverOptionsError is raised if failover URL
+    # options can not be parsed
+    class MalformedFailoverOptionsError < RuntimeError
+      def message
+        "failover options are malformed"
+      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 = 11
+    PATCH = 12
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

data/notes/heartbeat_readme.txt

@@ -77,6 +77,18 @@ error).
 
 -----------------------------------------------------------
 
+General advice:
+
+Set your heartbeat intervals to the maximum possible to obtain your desired
+behavior.  Do *not* set them at extremely low values even if the broker allows
+that.  An absurd example:
+
+heart-beat:1,1
+
+which will likely not work well.
+
+-----------------------------------------------------------
+
 General notes:
 
 In your real world apps, think about whether one or both of these parameters 
@@ -98,6 +110,60 @@ We have done a variety of informal tests here, using both server kill and
 packet drop strategies as appropriate.  We believe more real world testing is
 required.
 
-We already know that the use of IO#ready? will diminish (probably break) JRuby 
-functionality.
+-----------------------------------------------------------
+
+08/07/2013
+
+Issue #63 related, specifically fast send heart beats are being used and 
+spurious fail overs occur in rapid succession.
+
+Background:
+
+Fail over from heartbeat failures was introduced in gem version 1.2.10.
+
+Subsequently:
+
+This issue has been observed and documented in the following environment:
+
+-- JRuby engine 1.7.4 *and*
+-- ActiveMQ 5.8.0 *and*
+-- 'fast' client send heartbeats
+
+Heartbeat sends were at 2000ms.
+
+At this point in time, fast send heart beats and spurious fail overs have 
+*not* been observed using:
+
+-- Any native RUBY_ENGINE and ActiveMQ
+-- Any native RUBY_ENGINE and Apollo (client send rates are limited by default)
+-- Any native RUBY_ENGINE and RabbitMQ
+-- JRuby and Apollo (client send rates are limited by default)
+-- JRuby and RabbitMQ
+
+Note that 'fast' will depend on your use case for heartbeats.  Observations
+are that sending heartbeat times less than 5000ms might be considered 'fast'
+in the targeted environment.
+
+The solution / bypass being put in place as of the above date was developed
+through experimentation and is as follows:
+
+- Add 'adjustment' logic to the heartbeat sender (thanks to ppaul for this idea).
+- Re-introduce tolerance logic removed in d922fa.
+- Add a new connection hash parameter to adjust heartbeat sends.
+
+The newly introduced connection hash parameter is:
+
+:fast_hbs_adjust => 0.0 # The default, no adjustment to sender sleep times (sec)
+
+Recommendation for gem users that:
+
+- Use fast send heartbeats
+- Actually notice spurious fail overs
+
+is to provide a very sender sleep time adjustment when connecting.  Examples:
+
+:fast_hbs_adjust => 0.05 # 50 milliseconds
+:fast_hbs_adjust => 0.10 # 100 milliseconds
+
+As usual, YMMV.
 

data/spec/client_spec.rb

@@ -254,7 +254,7 @@ describe Stomp::Client do
     end
     
     it "should properly parse a URL with failover:" do
-      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost1:61617),stomp://login3:passcode3@remotehost2:61618)"
+      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost1:61617,stomp://login3:passcode3@remotehost2:61618)"
       
       @parameters[:hosts] = [
         {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
@@ -283,7 +283,7 @@ describe Stomp::Client do
     end
     
     it "should properly parse a URL with user and/or password blank" do
-      url = "failover:(stomp://:@localhost:61616,stomp://:@remotehost:61617)"
+      url = "failover:(stomp://@localhost:61616,stomp://@remotehost:61617)"
       
       @parameters[:hosts] = [
         {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},

data/spec/connection_spec.rb

@@ -27,6 +27,7 @@ describe Stomp::Connection do
       :usecrlf => false,
       :max_hbread_fails => 0,
       :max_hbrlck_fails => 0,
+      :fast_hbs_adjust => 0.0,
    }
         
     #POG:
@@ -89,11 +90,12 @@ describe Stomp::Connection do
         "backOffMultiplier" => 2,
         "maxReconnectAttempts" => 0,
         "randomize" => false,
-        "connect_timeout" => 0,
-        "parse_timeout" => 5,
+        "connectTimeout" => 0,
+        "parseTimeout" => 5,
         "usecrlf" => false,
-        :max_hbread_fails => 0,
-        :max_hbrlck_fails => 0,
+        :maxHbreadFails => 0,
+        :maxHbrlckFails => 0,
+        :fastHbsAdjust => 0.0,
       }
       
       @connection = Stomp::Connection.new(used_hash)
@@ -272,7 +274,9 @@ describe Stomp::Connection do
       
       before(:each) do
         ssl_parameters = {:hosts => [{:login => "login2", :passcode => "passcode2", :host => "remotehost", :ssl => true}]}
-        @ssl_socket = mock(:ssl_socket, :puts => nil, :write => nil, :setsockopt => nil, :flush => true)
+        @ssl_socket = mock(:ssl_socket, :puts => nil, :write => nil, 
+          :setsockopt => nil, :flush => true)
+        @ssl_socket.stub!(:sync_close=)
         
         TCPSocket.should_receive(:open).and_return @tcp_socket
         OpenSSL::SSL::SSLSocket.should_receive(:new).and_return(@ssl_socket)
@@ -344,6 +348,7 @@ describe Stomp::Connection do
           :stompconn => false,
           :max_hbread_fails => 0,
           :max_hbrlck_fails => 0,
+          :fast_hbs_adjust => 0.0,
         }
         
         used_hash =  {
@@ -382,6 +387,7 @@ describe Stomp::Connection do
           :usecrlf => true,
           :max_hbread_fails => 123,
           :max_hbrlck_fails => 456,
+          :fast_hbs_adjust => 0.2,
         }
         
         @connection = Stomp::Connection.new(used_hash)
@@ -430,7 +436,14 @@ describe Stomp::Connection do
       
       @connection.instance_variable_set(:@connection_attempts, limit)
       @connection.send(:max_reconnect_attempts?).should be_true
+    end
+
+    # These should be raised for the user to deal with
+    it "should not rescue MaxReconnectAttempts" do
+      @connection = Stomp::Connection.new(@parameters)
+      @connection.stub(:socket).and_raise(Stomp::Error::MaxReconnectAttempts)
       
+      expect { @connection.receive() }.to raise_error
     end
   end
 

data/stomp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{stomp}
-  s.version = "1.2.11"
+  s.version = "1.2.12"
 
   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-28}
+  s.date = %q{2013-08-11}
   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"]
@@ -65,6 +65,7 @@ Gem::Specification.new do |s|
     "test/test_helper.rb",
     "test/test_message.rb",
     "test/test_ssl.rb",
+    "test/test_urlogin.rb",
     "test/tlogger.rb"
   ]
   s.files = [
@@ -129,6 +130,7 @@ Gem::Specification.new do |s|
     "test/test_helper.rb",
     "test/test_message.rb",
     "test/test_ssl.rb",
+    "test/test_urlogin.rb",
     "test/tlogger.rb"
   ]
   s.homepage = %q{https://github.com/stompgem/stomp}

data/test/test_connection.rb

@@ -484,10 +484,11 @@ class TestConnection < Test::Unit::TestCase
   def test_conn10_simple
     @conn.disconnect
     #
+    vhost = ENV['STOMP_RABBIT'] ? "/" : host
     hash = { :hosts => [ 
       {:login => user, :passcode => passcode, :host => host, :port => port, :ssl => false},
       ],
-      :connect_headers => {"accept-version" => "1.0", "host" => host},
+      :connect_headers => {"accept-version" => "1.0", "host" => vhost},
       :reliable => false,
     }
     c = nil
@@ -499,7 +500,7 @@ class TestConnection < Test::Unit::TestCase
     hash = { :hosts => [ 
       {:login => user, :passcode => passcode, :host => host, :port => port, :ssl => false},
       ],
-      :connect_headers => {"accept-version" => "3.14159,1.0,12.0", "host" => host},
+      :connect_headers => {"accept-version" => "3.14159,1.0,12.0", "host" => vhost},
       :reliable => false,
     }
     c = nil

data/test/test_helper.rb

@@ -84,7 +84,7 @@ module TestBase
   # Get a Stomp SSL Connection.
   def get_ssl_connection()
     ch = get_conn_headers()
-    ssl_params = Stomp::SSLParams.new # S/B safe for all Ruby versions tested
+    ssl_params = Stomp::SSLParams.new(:use_ruby_ciphers => jruby?())
     hash = { :hosts => [ 
       {:login => user, :passcode => passcode, :host => host, :port => ssl_port, :ssl => ssl_params},
       ],
@@ -164,5 +164,10 @@ module TestBase
     end
   end
 
+  # Check for JRuby before a connection exists
+  def jruby?()
+    jr = defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/ ? true : false
+  end
+
 end
 

data/test/test_urlogin.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+if Kernel.respond_to?(:require_relative)
+  require_relative("test_helper")
+else
+  $:.unshift(File.dirname(__FILE__))
+  require 'test_helper'
+end
+
+=begin
+
+  Main class for testing Stomp::Client URL based Logins.
+
+=end
+class TestURLLogins < Test::Unit::TestCase
+  include TestBase
+  
+  def setup
+    hostname = host()
+    portnum = port()
+    sslpn = ssl_port()
+    @tdstomp = [ 
+          "stomp://guestl:guestp@#{hostname}:#{portnum}",
+          "stomp://#{hostname}:#{portnum}",
+          "stomp://@#{hostname}:#{portnum}",
+          "stomp://f@#$$%^&*()_+=o.o:@#{hostname}:#{portnum}",
+          'stomp://f@#$$%^&*()_+=o.o::b~!@#$%^&*()+-_=?:<>,.@@' + hostname + ":#{portnum}",
+    ]
+    @tdfailover = [
+      "failover://(stomp://#{hostname}:#{portnum})",
+      "failover://(stomp+ssl://#{hostname}:#{sslpn})",
+      "failover://(stomp://#{hostname}:#{portnum})",
+      "failover://(stomp://#{hostname}:#{portnum})?whatup=doc&coyote=kaboom",
+      "failover://(stomp://#{hostname}:#{portnum})?whatup=doc",
+      "failover://(stomp://#{hostname}:#{portnum})?whatup=doc&coyote=kaboom&randomize=true",
+      'failover://(stomp://f@#$$%^&*()_+=o.o::b~!@#$%^&*()+-_=?:<>,.@@' + "localhost" + ":#{portnum}" + ")",
+      'failover://(stomp://f@#$$%^&*()_+=o.o::b~!@#$%^&*()+-_=:<>,.@@' + "localhost" + ":#{portnum}" + ")",
+      'failover://(stomp://f@#$$%^&*()_+=o.o::b~!@#$%^&*()+-_=?:<>,.@@' + "localhost" + ":#{portnum}" + ")?a=b",
+      'failover://(stomp://f@#$$%^&*()_+=o.o::b~!@#$%^&*()+-_=:<>,.@@' + "localhost" + ":#{portnum}" + ")?c=d&e=f",
+      "failover://(stomp://usera:passa@#{hostname}:#{portnum})",
+      "failover://(stomp+ssl://usera:passa@#{hostname}:#{sslpn})",
+      "failover://(stomp://usera:@#{hostname}:#{portnum})",
+      "failover://(stomp://#{hostname}:#{portnum},stomp://#{hostname}:#{portnum})",
+      "failover://(stomp://usera:passa@#{hostname}:#{portnum},stomp://#{hostname}:#{portnum})",
+      "failover://(stomp://usera:@#{hostname}:#{portnum},stomp://#{hostname}:#{portnum})",
+      "failover://(stomp://usera:@#{hostname}:#{portnum},stomp+ssl://#{hostname}:#{sslpn})",
+      "failover://(stomp://#{hostname}:#{portnum},stomp://#{hostname}:#{portnum})?a=b&c=d",
+      "failover://(stomp://#{hostname}:#{portnum},stomp://#{hostname}:#{portnum})?a=b&c=d&connect_timeout=2020",
+    ]
+
+    @badparms = "failover://(stomp://#{hostname}:#{portnum})?a=b&noequal"
+  end
+
+  def teardown
+    @client.close if @client && @client.open? # allow tests to close
+  end
+
+  # test stomp:// URLs
+  def test_0010_stomp_urls()
+    @tdstomp.each_with_index do |url, ndx|
+      c = Stomp::Client.new(url)
+      assert !c.nil?, url
+      assert c.open?, url
+      c.close
+    end
+  end
+
+  # test failover:// urls
+  def test_0020_failover_urls()
+    @tdfailover.each_with_index do |url, ndx|
+      c = Stomp::Client.new(url)
+      assert !c.nil?, url
+      assert c.open?, url
+      c.close
+    end
+  end
+
+  # test failover:// with bad parameters
+  def test_0020_failover_badparms()
+    assert_raise(Stomp::Error::MalformedFailoverOptionsError) {
+      c = Stomp::Client.new(@badparms)
+    }
+  end
+
+end unless ENV['STOMP_RABBIT']
+

data/test/tlogger.rb

@@ -51,11 +51,11 @@ class Tlogger
   end
 
   # Stomp 1.1+ - heart beat thread fires
-  def on_hbfire(parms, type, time)
+  def on_hbfire(parms, type, firedata)
     begin
       @log.debug "HBfire #{type} " + "=" * 30
       @log.debug "HBfire #{type} Parms #{info(parms)}"
-      @log.debug "HBfire #{type} Time #{time}"
+      @log.debug "HBfire #{type} Firedata #{firedata.inspect}"
     rescue
       @log.debug "HBfire #{type} oops"
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: stomp
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 7
   prerelease: false
   segments: 
   - 1
   - 2
-  - 11
-  version: 1.2.11
+  - 12
+  version: 1.2.12
 platform: ruby
 authors: 
 - Brian McCallister
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-07-28 00:00:00 -04:00
+date: 2013-08-11 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -99,6 +99,7 @@ extra_rdoc_files:
 - test/test_helper.rb
 - test/test_message.rb
 - test/test_ssl.rb
+- test/test_urlogin.rb
 - test/tlogger.rb
 files: 
 - CHANGELOG.rdoc
@@ -162,6 +163,7 @@ files:
 - test/test_helper.rb
 - test/test_message.rb
 - test/test_ssl.rb
+- test/test_urlogin.rb
 - test/tlogger.rb
 has_rdoc: true
 homepage: https://github.com/stompgem/stomp