stomp 1.2.9 → 1.2.10

data/CHANGELOG.rdoc

@@ -1,3 +1,9 @@
+== 1.2.10 20130708
+
+* Issue #57, reconnect delays not honored if erroneous headers
+* Support fail overs when heartbeat send/receive fails
+* Update callback logger example
+
 == 1.2.9 20130328
 
 * Refactoring and documentation updates (glennr)

data/README.rdoc

@@ -10,18 +10,19 @@ An implementation of the Stomp protocol for Ruby. See:
 
 ===New
 
-* Gem version 1.2.9. Miscellaneous fixes and changes. See _CHANGELOG.rdoc_ for details.
-* Gem version 1.2.8. Stomp 1.1+ header codec inversion fix, test refactoring. See _CHANGELOG.rdoc_ for details.
-* Gem version 1.2.7. Stomp 1.2 support and miscellaneous fixes. See _CHANGELOG.rdoc_ for details.
-* Gem version 1.2.6. Miscellaneous fixes and changes. See _CHANGELOG.rdoc_ for details.
-* Gem version 1.2.5. Restructure. Forks with modifcations will be affected. See _CHANGELOG.rdoc_ for details.
+See _CHANGELOG.rdoc_ for details.
+
+* 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.
+* Gem version 1.2.7. Stomp 1.2 support and miscellaneous fixes.
+* Gem version 1.2.6. Miscellaneous fixes and changes.
+* Gem version 1.2.5. Restructure. Forks with modifcations will be affected.
 * Gem version 1.2.4. Stomp 1.1 heartbeat fix, autoflush capability, miscellaneous fixes.
 * Gem version 1.2.3. Miscellaneous fixes, see changelog for details.
 * Gem version 1.2.2. Performance and more SSL enhancements.
-* Full support of SSL certificates is announced as of gem version 1.2.1.
-* Support of Stomp protocol level 1.1 is announced as of gem version 1.2.0.
-
-See _CHANGELOG.rdoc_ for details.
+* Gem version 1.2.1. Full support of SSL certificates.
+* Gem version 1.2.0. Support of Stomp protocol level 1.1.
 
 ===Hash Login Example Usage (this is the recommended login technique)
 
@@ -50,6 +51,8 @@ See _CHANGELOG.rdoc_ for details.
       :hbser => false,                    # raise on heartbeat send exception
       :stompconn => false,                # Use STOMP instead of CONNECT
       :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
     }
 
     # for client

data/examples/slogger.rb

@@ -15,6 +15,14 @@ require 'logger'	# use the standard Ruby logger .....
 #
 # *    on_publish: publish called
 # *    on_subscribe: subscribe called
+# *    on_unsubscribe: unsubscribe called
+#
+# *    on_begin: begin called
+# *    on_ack: ack called
+# *    on_nack: nack called
+# *    on_commit: commit called
+# *    on_abort: abort called
+#
 # *    on_receive: receive called and successful
 #
 # *    on_ssl_connecting: SSL connection starting
@@ -80,7 +88,7 @@ class Slogger
 =begin
     # An example LoggerConnectionError raise
     @log.debug "Connect Fail, will raise"
-    raise Stomp::Error::LoggerConnectionError.new("quit from connect")
+    raise Stomp::Error::LoggerConnectionError.new("quit from connect fail")
 =end
   end
 
@@ -113,6 +121,16 @@ class Slogger
     end
   end
 
+  # Log UnSubscribe
+  def on_unsubscribe(parms, headers)
+    begin
+      @log.debug "UnSubscribe Parms #{info(parms)}"
+      @log.debug "UnSubscribe Headers #{headers}"
+    rescue
+      @log.debug "UnSubscribe oops"
+    end
+  end
+
   # Log Publish
   def on_publish(parms, message, headers)
     begin
@@ -134,11 +152,61 @@ class Slogger
     end
   end
 
+  # Log Begin
+  def on_begin(parms, headers)
+    begin
+      @log.debug "Begin Parms #{info(parms)}"
+      @log.debug "Begin Result #{headers}"
+    rescue
+      @log.debug "Begin oops"
+    end
+  end
+
+  # Log Ack
+  def on_ack(parms, headers)
+    begin
+      @log.debug "Ack Parms #{info(parms)}"
+      @log.debug "Ack Result #{headers}"
+    rescue
+      @log.debug "Ack oops"
+    end
+  end
+
+  # Log NAck
+  def on_nack(parms, headers)
+    begin
+      @log.debug "NAck Parms #{info(parms)}"
+      @log.debug "NAck Result #{headers}"
+    rescue
+      @log.debug "NAck oops"
+    end
+  end
+
+  # Log Commit
+  def on_commit(parms, headers)
+    begin
+      @log.debug "Commit Parms #{info(parms)}"
+      @log.debug "Commit Result #{headers}"
+    rescue
+      @log.debug "Commit oops"
+    end
+  end
+
+  # Log Abort
+  def on_abort(parms, headers)
+    begin
+      @log.debug "Abort Parms #{info(parms)}"
+      @log.debug "Abort Result #{headers}"
+    rescue
+      @log.debug "Abort oops"
+    end
+  end
+
   # Stomp 1.1+ - heart beat read (receive) failed.
   def on_hbread_fail(parms, ticker_data)
     begin
       @log.debug "Hbreadf Parms #{info(parms)}"
-      @log.debug "Hbreadf Result #{ticker_data}"
+      @log.debug "Hbreadf Result #{ticker_data.inspect}"
     rescue
       @log.debug "Hbreadf oops"
     end
@@ -148,7 +216,7 @@ class Slogger
   def on_hbwrite_fail(parms, ticker_data)
     begin
       @log.debug "Hbwritef Parms #{info(parms)}"
-      @log.debug "Hbwritef Result #{ticker_data}"
+      @log.debug "Hbwritef Result #{ticker_data.inspect}"
     rescue
       @log.debug "Hbwritef oops"
     end

data/examples/ssl_uc1_ciphers.rb

@@ -19,8 +19,7 @@ class ExampleSSL1C
   end
   # Run example.
   def run
-    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],
-    ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
+    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
 
     ssl_opts = Stomp::SSLParams.new(:ciphers => ciphers_list)
 
@@ -29,7 +28,8 @@ class ExampleSSL1C
     #
     hash = { :hosts => [
         {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},
-      ]
+      ],
+      :reliable => false, # YMMV, to test this in a sane manner
     }
     #
     puts "Connect starts, SSL Use Case 1"

data/examples/ssl_uc2.rb

@@ -25,8 +25,13 @@ class ExampleSSL2
   # Run example.
   def run
     ts_flist = []
-    ts_flist << "/home/gmallard/sslwork/twocas_tj/serverCA/ServerTJCA.crt"
-    ssl_opts = Stomp::SSLParams.new(:ts_files => ts_flist.join(","))
+
+    # Change the following to the location of your CA's signed certificate.
+    ts_flist << "/home/gmallard/sslwork/2013/TestCA.crt"
+
+    ssl_opts = Stomp::SSLParams.new(:ts_files => ts_flist.join(","), 
+      :fsck => true,
+    )
     #
     hash = { :hosts => [
         {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},

data/examples/ssl_uc2_ciphers.rb

@@ -19,18 +19,24 @@ class ExampleSSL2C
   end
   # Run example.
   def run
-    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],
-    ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
+    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],  ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
     #
     # SSL Use Case 2
     #
     ts_flist = []
-    ts_flist << "/home/gmallard/sslwork/twocas_tj/serverCA/ServerTJCA.crt"
-    ssl_opts = Stomp::SSLParams.new(:ts_files => ts_flist.join(","), :ciphers => ciphers_list)
+
+    # Change the following to the location of your CA's signed certificate.
+    ts_flist << "/home/gmallard/sslwork/2013/TestCA.crt"
+
+    ssl_opts = Stomp::SSLParams.new(:ts_files => ts_flist.join(","), 
+      :ciphers => ciphers_list,
+      :fsck => true
+    )
     #
     hash = { :hosts => [
         {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},
-      ]
+      ],
+      :reliable => false, # YMMV, to test this in a sane manner
     }
     #
     puts "Connect starts, SSL Use Case 2"

data/examples/ssl_uc3.rb

@@ -26,8 +26,14 @@ class ExampleSSL3
   end
   # Run example.
   def run
-    ssl_opts = Stomp::SSLParams.new(:key_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.key",
-    :cert_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.crt")
+    # Change the following:
+    # * location of your client's signed certificate
+    # * location of tour client's private key.
+    ssl_opts = Stomp::SSLParams.new(
+      :key_file => "/home/gmallard/sslwork/2013/client.key", # the client's private key
+      :cert_file => "/home/gmallard/sslwork/2013/client.crt", # the client's signed certificate
+      :fsck => true # Check that the files exist first
+    )
 
     #
     hash = { :hosts => [

data/examples/ssl_uc3_ciphers.rb

@@ -19,18 +19,24 @@ class ExampleSSL3C
   end
   # Run example.
   def run
-    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],
-    ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
+    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
     #
     # SSL Use Case 3
     #
-    ssl_opts = Stomp::SSLParams.new(:key_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.key",
-    :cert_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.crt", :ciphers => ciphers_list)
-
+    # Change the following:
+    # * location of your client's signed certificate
+    # * location of tour client's private key.
+    ssl_opts = Stomp::SSLParams.new(
+      :key_file => "/home/gmallard/sslwork/2013/client.key", # the client's private key
+      :cert_file => "/home/gmallard/sslwork/2013/client.crt", # the client's signed certificate
+      :fsck => true, # Check that the files exist first
+      :ciphers => ciphers_list
+    )
     #
     hash = { :hosts => [
         {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},
-      ]
+      ],
+      :reliable => false, # YMMV, to test this in a sane manner
     }
     #
     puts "Connect starts, SSL Use Case 3"

data/examples/ssl_uc4.rb

@@ -26,9 +26,16 @@ class ExampleSSL4
   end
   # Run example.
   def run
-    ssl_opts = Stomp::SSLParams.new(:key_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.key",
-    :cert_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.crt",
-    :ts_files => "/home/gmallard/sslwork/twocas_tj/serverCA/ServerTJCA.crt")
+    # Change the following:
+    # * location of the client's private key
+    # * location of the client's signed certificate
+    # * location of the server's CA signed certificate
+    ssl_opts = Stomp::SSLParams.new(
+      :key_file => "/home/gmallard/sslwork/2013/client.key", # The client's private key
+      :cert_file => "/home/gmallard/sslwork/2013/client.crt", # The client's signed certificate
+      :ts_files => "/home/gmallard/sslwork/2013/TestCA.crt", # The CA's signed sertificate
+      :fsck => true # Check that files exist first
+    )
     #
     hash = { :hosts => [
         {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},

data/examples/ssl_uc4_ciphers.rb

@@ -19,19 +19,26 @@ class ExampleSSL4C
   end
   # Run example.
   def run
-    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56],
-    ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
+    ciphers_list = [["DHE-RSA-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["DHE-DSS-AES256-SHA", "TLSv1/SSLv3", 256, 256], ["AES256-SHA", "TLSv1/SSLv3", 256, 256], ["EDH-RSA-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["EDH-DSS-DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DES-CBC3-SHA", "TLSv1/SSLv3", 168, 168], ["DHE-RSA-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["DHE-DSS-AES128-SHA", "TLSv1/SSLv3", 128, 128], ["AES128-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-SHA", "TLSv1/SSLv3", 128, 128], ["RC4-MD5", "TLSv1/SSLv3", 128, 128], ["EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["DES-CBC-SHA", "TLSv1/SSLv3", 56, 56], ["EXP-EDH-RSA-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-EDH-DSS-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-DES-CBC-SHA", "TLSv1/SSLv3", 40, 56], ["EXP-RC2-CBC-MD5", "TLSv1/SSLv3", 40, 128], ["EXP-RC4-MD5", "TLSv1/SSLv3", 40, 128]]
     #
     # SSL Use Case 4
     #
-    ssl_opts = Stomp::SSLParams.new(:key_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.key",
-    :cert_file => "/home/gmallard/sslwork/twocas_tj/clientCA/ClientTJ.crt",
-    :ts_files => "/home/gmallard/sslwork/twocas_tj/serverCA/ServerTJCA.crt",
-    :ciphers => ciphers_list)
+    # Change the following:
+    # * location of the client's private key
+    # * location of the client's signed certificate
+    # * location of the server's CA signed certificate
+    ssl_opts = Stomp::SSLParams.new(
+      :key_file => "/home/gmallard/sslwork/2013/client.key", # The client's private key
+      :cert_file => "/home/gmallard/sslwork/2013/client.crt", # The client's signed certificate
+      :ts_files => "/home/gmallard/sslwork/2013/TestCA.crt", # The CA's signed sertificate
+      :fsck => true, # Check that files exist first
+      :ciphers => ciphers_list
+    )
     #
     hash = { :hosts => [
         {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61612, :ssl => ssl_opts},
-      ]
+      ],
+      :reliable => false, # YMMV, to test this in a sane manner
     }
     #
     puts "Connect starts, SSL Use Case 4"

data/lib/connection/heartbeats.rb

@@ -90,15 +90,17 @@ module Stomp
     # _start_send_ticker starts a thread to send heartbeats when required.
     def _start_send_ticker()
       sleeptime = @hbsend_interval / 1000000.0 # Sleep time secs
+      reconn = false
       @st = Thread.new {
         while true do
           sleep sleeptime
+          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)
           end
           delta = curt - @ls
-          if delta > (@hbsend_interval - (@hbsend_interval/5.0)) / 1000000.0 # Be tolerant (minus)
+          if delta > sleeptime
             if @logger && @logger.respond_to?(:on_hbfire)
               @logger.on_hbfire(log_params, "send_heartbeat", curt)
             end
@@ -106,19 +108,31 @@ module Stomp
             @transmit_semaphore.synchronize do
               begin
                 @socket.puts
-                @ls = curt      # Update last send
-                @hb_sent = true # Reset if necessary
+                @socket.flush       # Do not buffer heartbeats
+                @ls = Time.now.to_f # Update last send
+                @hb_sent = true     # Reset if necessary
                 @hbsend_count += 1
               rescue Exception => sendex
                 @hb_sent = false # Set the warning flag
                 if @logger && @logger.respond_to?(:on_hbwrite_fail)
-                  @logger.on_hbwrite_fail(log_params, {"ticker_interval" => @hbsend_interval,
+                  @logger.on_hbwrite_fail(log_params, {"ticker_interval" => sleeptime,
                   "exception" => sendex})
                 end
                 if @hbser
                   raise # Re-raise if user requested this, otherwise ignore
                 end
+                if @reliable
+                  reconn = true
+                  break # exit the synchronize do
+                end
               end
+            end # of the synchronize
+            if reconn
+              # Attempt a fail over reconnect.  This is 'safe' here because
+              # this thread no longer holds the @transmit_semaphore lock.
+              @rt.kill if @rt   # Kill the receiver thread if one exists
+              _reconn_prep_hb() # Drive reconnection logic
+              Thread.exit       # This sender thread is done
             end
           end
           Thread.pass
@@ -129,44 +143,122 @@ module Stomp
     # _start_receive_ticker starts a thread that receives heartbeats when required.
     def _start_receive_ticker()
       sleeptime = @hbrecv_interval / 1000000.0 # Sleep time secs
+      read_fail_count = 0
+      lock_fail_count = 0
+      fail_hard = false
       @rt = Thread.new {
+
+        #
         while true do
           sleep sleeptime
+          next unless @socket # nil under some circumstances ??
+          rdrdy = @socket.ready? ? true : false
           curt = Time.now.to_f
           if @logger && @logger.respond_to?(:on_hbfire)
             @logger.on_hbfire(log_params, "receive_fire", curt)
           end
-          delta = curt - @lr
-          if delta > ((@hbrecv_interval + (@hbrecv_interval/5.0)) / 1000000.0) # Be tolerant (plus)
-            if @logger && @logger.respond_to?(:on_hbfire)
-              @logger.on_hbfire(log_params, "receive_heartbeat", curt)
-            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
-            if lock
-              last_char = @socket.getc
-              plc = parse_char(last_char)
-              if plc == "\n" # Server Heartbeat
-                @lr = Time.now.to_f
-              else
-                @socket.ungetc(last_char)
+
+          #
+          begin
+            delta = curt - @lr
+            if delta > sleeptime
+              if @logger && @logger.respond_to?(:on_hbfire)
+                @logger.on_hbfire(log_params, "receive_heartbeat", curt)
               end
-              @read_semaphore.unlock
-              @hbrecv_count += 1
-            else
-              # Shrug.  Have not received one.  Just set warning flag.
-              @hb_received = false
-              if @logger && @logger.respond_to?(:on_hbread_fail)
-                @logger.on_hbread_fail(log_params, {"ticker_interval" => @hbrecv_interval})
+
+              # 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
+              if lock
+                lock_fail_count = 0 # clear
+                rdrdy = @socket.ready? ? true : false # This logic will be bad for JRuby I think
+                if rdrdy
+                  read_fail_count = 0 # clear
+                  last_char = @socket.getc
+                  if last_char.nil? # EOF from broker?
+                    fail_hard = true
+                  else
+                    @lr = Time.now.to_f
+                    plc = parse_char(last_char)
+                    if plc == "\n" # Server Heartbeat
+                      @hbrecv_count += 1
+                      @hb_received = true # Reset if necessary
+                    else
+                      @socket.ungetc(last_char)
+                    end
+                  end
+                  @read_semaphore.unlock # Release read lock
+                else # Socket is not ready
+                  @read_semaphore.unlock # Release read lock
+                  @hb_received = false
+                  read_fail_count += 1
+                  if @logger && @logger.respond_to?(:on_hbread_fail)
+                    @logger.on_hbread_fail(log_params, {"ticker_interval" => sleeptime,
+                      "read_fail_count" => read_fail_count, "lock_fail" => false,
+                      "lock_fail_count" => lock_fail_count})
+                  end
+                end
+              else  # try_lock failed
+                # Shrug.  Could not get lock.  Client must be actually be reading.
+                @hb_received = false
+                # But notify caller if possible
+                lock_fail_count += 1
+                if @logger && @logger.respond_to?(:on_hbread_fail)
+                  @logger.on_hbread_fail(log_params, {"ticker_interval" => sleeptime,
+                    "read_fail_count" => read_fail_count, "lock_fail" => true,
+                    "lock_fail_count" => lock_fail_count})
+                end
+              end # of the try_lock
+
+            else # delta <= sleeptime
+              @hb_received = true # Reset if necessary
+              read_fail_count = 0 # reset
+              lock_fail_count = 0 # reset
+            end # of the if delta > sleeptime
+          rescue Exception => recvex
+            if @logger && @logger.respond_to?(:on_hbread_fail)
+              @logger.on_hbread_fail(log_params, {"ticker_interval" => sleeptime,
+                "exception" => recvex, "read_fail_count" => read_fail_count,
+                "lock_fail_count" => lock_fail_count})
+            end
+            fail_hard = true
+          end
+
+          # Do we want to attempt a retry?
+          if @reliable
+            # Retry on hard fail or max read fails
+            if fail_hard ||
+              (@max_hbread_fails > 0 && read_fail_count >= @max_hbread_fails)
+              # This is an attempt at a connection retry.
+              @st.kill if @st   # Kill the sender thread if one exists
+              _reconn_prep_hb() # Drive reconnection logic
+              Thread.exit       # This receiver thread is done            
+            end
+            # Retry on max lock fails.  Different logic in order to avoid a deadlock.
+            if (@max_hbrlck_fails > 0 && lock_fail_count >= @max_hbrlck_fails)
+              # This is an attempt at a connection retry.
+              begin
+                @socket.close # Attempt a forced close
+              rescue
               end
+              @st.kill if @st   # Kill the sender thread if one exists
+              Thread.exit       # This receiver thread is done            
             end
-          else
-            @hb_received = true # Reset if necessary
           end
-          Thread.pass
-        end
-      }
+
+          Thread.pass         # Prior to next receive loop
+        #
+        end # of the "while true"
+      } # end of the Thread.new
+    end
+
+    # _reconn_prep_hb prepares for a reconnect retry
+    def _reconn_prep_hb()
+      if @parameters
+        change_host()
+      end
+      @socket = nil
+      used_socket = socket()
     end
 
   end # class Connection

data/lib/connection/netio.rb

@@ -124,6 +124,8 @@ module Stomp
           else
             $stderr.print errstr
           end
+          # !!! This loop initiates a re-connect !!!
+          _reconn_prep()
         end
       end
     end
@@ -275,6 +277,7 @@ module Stomp
 
         Timeout::timeout(@connect_timeout, Stomp::Error::SocketOpenTimeout) do
           ssl = OpenSSL::SSL::SSLSocket.new(open_tcp_socket, ctx)
+          ssl.sync_close = true # Sync ssl close with underlying TCP socket
           ssl.connect
         end
         def ssl.ready?
@@ -351,7 +354,9 @@ module Stomp
       @disconnect_receipt = nil
       @session = @connection_frame.headers["session"] if @connection_frame
       # replay any subscriptions.
-      @subscriptions.each { |k,v| _transmit(used_socket, Stomp::CMD_SUBSCRIBE, v) }
+      @subscriptions.each {|k,v| 
+        _transmit(used_socket, Stomp::CMD_SUBSCRIBE, v)
+      }
     end
 
   end # class Connection

data/lib/connection/utils.rb

@@ -53,6 +53,7 @@ module Stomp
       lparms[:cur_recondelay] = @reconnect_delay
       lparms[:cur_parseto] = @parse_timeout
       lparms[:cur_conattempts] = @connection_attempts
+      lparms[:cur_failure] = @failure # To assist in debugging
       lparms[:openstat] = open?
       #
       lparms
@@ -122,9 +123,15 @@ module Stomp
           rescue
             @failure = $!
             used_socket = nil
+            @closed = true
+
             raise unless @reliable
             raise if @failure.is_a?(Stomp::Error::LoggerConnectionError)
-            @closed = true
+            # Catch errors which are:
+            # a) emitted from corrupted 1.1+ 'connect' (caller programming error)
+            # b) should never be retried
+            raise if @failure.is_a?(Stomp::Error::ProtocolError11p)
+
             if @logger && @logger.respond_to?(:on_connectfail)
               # on_connectfail may raise
               begin
@@ -172,6 +179,8 @@ module Stomp
         :closed_check => true,
         :hbser => false,
         :stompconn => false,
+        :max_hbread_fails => 0,
+        :max_hbrlck_fails => 0,
       }
 
       res_params = default_params.merge(params)
@@ -229,10 +238,22 @@ module Stomp
           else
             $stderr.print errstr
           end
+          # !!! This initiates a re-connect !!!
+          _reconn_prep()
         end
       end
     end
 
+    # _reconn_prep prepares for a reconnect retry
+    def _reconn_prep()
+      if @parameters
+        change_host()
+      end
+      @st.kill if @st # Kill ticker thread if any
+      @rt.kill if @rt # Kill ticker thread if any
+      @socket = nil
+    end
+
   end # class Connection
 
 end # module Stomp

data/lib/stomp/client.rb

@@ -55,6 +55,8 @@ module Stomp
     #     :hbser => false,
     #     :stompconn => false,
     #     :usecrlf => false,
+    #     :max_hbread_fails => 0,
+    #     :max_hbrlck_fails => 0,
     #   }
     #
     #   e.g. c = Stomp::Client.new(hash)

data/lib/stomp/connection.rb

@@ -65,6 +65,8 @@ module Stomp
     #     :hbser => false,
     #     :stompconn => false,
     #     :usecrlf => false,
+    #     :max_hbread_fails => 0,
+    #     :max_hbrlck_fails => 0,
     #   }
     #
     #   e.g. c = Stomp::Connection.new(hash)
@@ -106,6 +108,8 @@ module Stomp
         @hbser = false        # Raise if heartbeat send exception
         @stompconn = false    # If true, use STOMP rather than CONNECT
         @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
         warn "login looks like a URL, do you have the correct parameters?" if @login =~ /:\/\//
       end
 
@@ -138,6 +142,8 @@ module Stomp
       @hbser = @parameters[:hbser]
       @stompconn = @parameters[:stompconn]
       @usecrlf = @parameters[:usecrlf]
+      @max_hbread_fails = @parameters[:max_hbread_fails]
+      @max_hbrlck_fails = @parameters[:max_hbrlck_fails]
       #sets the first host to connect
       change_host
     end
@@ -163,6 +169,9 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:transaction] = name
       _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_begin)
+        @logger.on_begin(log_params, headers)
+      end
       transmit(Stomp::CMD_BEGIN, headers)
     end
 
@@ -193,6 +202,9 @@ module Stomp
           headers[:'message-id'] = message_id
       end
       _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_ack)
+        @logger.on_ack(log_params, headers)
+      end
       transmit(Stomp::CMD_ACK, headers)
     end
 
@@ -216,6 +228,9 @@ module Stomp
           raise Stomp::Error::SubscriptionRequiredError unless headers[:subscription]
       end
       _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_nack)
+        @logger.on_nack(log_params, headers)
+      end
       transmit(Stomp::CMD_NACK, headers)
     end
 
@@ -225,6 +240,9 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:transaction] = name
       _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_commit)
+        @logger.on_commit(log_params, headers)
+      end
       transmit(Stomp::CMD_COMMIT, headers)
     end
 
@@ -234,6 +252,9 @@ module Stomp
       headers = headers.symbolize_keys
       headers[:transaction] = name
       _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_abort)
+        @logger.on_abort(log_params, headers)
+      end
       transmit(Stomp::CMD_ABORT, headers)
     end
 
@@ -270,8 +291,12 @@ module Stomp
       headers[:destination] = dest
       if @protocol >= Stomp::SPL_11
         raise Stomp::Error::SubscriptionRequiredError if (headers[:id].nil? && subId.nil?)
+        headers[:id] = subId unless headers[:id]
       end
       _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_unsubscribe)
+        @logger.on_unsubscribe(log_params, headers)
+      end
       transmit(Stomp::CMD_UNSUBSCRIBE, headers)
       if @reliable
         subId = dest if subId.nil?
@@ -369,7 +394,7 @@ module Stomp
     # receive returns the next Message off of the wire.
     def receive()
       raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
-      super_result = __old_receive
+      super_result = __old_receive()
       if super_result.nil? && @reliable && !closed?
         errstr = "connection.receive returning EOF as nil - resetting connection.\n"
         if @logger && @logger.respond_to?(:on_miscerr)
@@ -377,8 +402,13 @@ module Stomp
         else
           $stderr.print errstr
         end
-        @socket = nil
-        super_result = __old_receive
+        # !!! This initiates a re-connect !!!
+        # The call to __old_receive() will in turn call socket().  Before
+        # that we should change the target host, otherwise the host that
+        # just failed may be attempted first.
+        _reconn_prep()
+        #
+        super_result = __old_receive()
       end
       #
       if @logger && @logger.respond_to?(:on_receive)

data/lib/stomp/errors.rb

@@ -71,17 +71,24 @@ module Stomp
       end
     end
 
+    # ProtocolError11p - base class of 1.1 CONNECT errors
+    class ProtocolError11p < RuntimeError
+      def message
+        "STOMP 1.1+ CONNECT error"
+      end
+    end
+
     # ProtocolErrorConnect is raised if:
-    # * Incomplete Stomp 1.1 headers are detectd during a connect.
-    class ProtocolErrorConnect < RuntimeError
+    # * Incomplete Stomp 1.1 headers are detected during a connect.
+    class ProtocolErrorConnect < ProtocolError11p
       def message
-        "protocol error on CONNECT"
+        "STOMP 1.1+ CONNECT error, missing/incorrect CONNECT headers"
       end
     end
 
     # UnsupportedProtocolError is raised if:
     # * No supported Stomp protocol levels are detected during a connect.
-    class UnsupportedProtocolError < RuntimeError
+    class UnsupportedProtocolError < ProtocolError11p
       def message
         "unsupported protocol level(s)"
       end
@@ -89,7 +96,7 @@ module Stomp
 
     # InvalidHeartBeatHeaderError is raised if:
     # * A "heart-beat" header is present, but the values are malformed.
-    class InvalidHeartBeatHeaderError < RuntimeError
+    class InvalidHeartBeatHeaderError < ProtocolError11p
       def message
         "heart-beat header value is malformed"
       end

data/lib/stomp/version.rb

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

data/notes/heartbeat_readme.txt

@@ -0,0 +1,103 @@
+Usage notes and comments follow (sorry for the length here, please read carefully).
+
+Write failures:  there is a single type of write failure, and it occurs when 
+an exception of some sort is raised during Heartbeat write.
+This is the only type of write failure that can be detected. 
+If :reliable is true, an exception on heartbeat write will always causes a fail 
+over attempt.
+
+Read failures:  this is actually more complex than originally envisioned. 
+There are really three distinct types of read 'failures':
+
+1) An exception is thrown during Heartbeat read.  If :reliable is true, this 
+   always causes a fail over attempt.
+
+2) Heartbeat reads can not obtain the read_semaphore lock.  This will occur 
+   when the main connection thread has:
+    -- Called Connection#receive
+    -- Only heartbeats but no Stomp frames are on the inbound wire
+    -- Last Heartbeat read time is being maintained by the #receive attempt
+
+3) Heartbeat reads obtain the read_semaphore lock, but the socket shows no 
+   data is available (by IO#ready?).  This will occur when:
+    -- The main thread has not called Connection#receive (the thread is doing other work)
+    -- There is no heartbeat to receive (IO#ready? indicates no input data available)
+
+The requirement to handle cases 2) and 3) results in not one, but two different 
+counters being taken in to consideration.
+
+To handle case 2) add to the connect hash:
+
+:max_hbrlck_fails => x # x is a number strictly greater than 0.  Default is 0, 
+which disables the functionality.
+
+A running count of this failure type is maintained in the HB read thread.  The 
+count is incremented when:
+
+-- Lock obtain fails, *and*
+-- A heartbeat is 'late'
+
+The count is reset to 0 whenever:
+
+-- A heart beat has been received on a timely basis
+
+When the running count *reaches* the value specified in :max_hbrlck_fails, a 
+fail over attempt is initiated.
+
+Advice:  do *not* set this to 1 (in order to avoid fail overs on a transient 
+error).
+
+To handle case 3) add to the connect hash:
+
+:max_hbread_fails => y # y is a number strictly greater than 0.  Default is 0, 
+which disables the functionality.
+
+A running count of this failure type is maintained in the HB read thread.  
+The count is incremented when:
+
+-- Lock obtain succeeds, *and*
+-- IO#ready? indicates no data available
+
+The count is reset to 0 under two conditions:
+
+Condition 1)
+  --  A heartbeat is late, *and*
+  -- Lock obtain succeeds, *and*
+  -- IO#ready? indicates data is available, *and*
+  -- A single character is read from the wire
+
+Condition 2)
+  -- A heartbeat has been received in a timely manner (perhaps by the main thread)
+
+When the running count *reaches* the value specified in :max_hbread_fails, 
+a fail over attempt is initiated.
+
+Advice:  do *not* set this to 1 (in order to avoid fail overs on a transient 
+error).
+
+-----------------------------------------------------------
+
+General notes:
+
+In your real world apps, think about whether one or both of these parameters 
+are appropriate.
+
+Please add the:
+
+-- on_hbread_fail
+-- on_hbwrite_fail
+
+methods to a callback logger.  In those methods show 'ticker_data.inspect' 
+output.  We would want that log output in future problem reports.
+
+We make the comment about not setting these values to 1 because every server 
+we test with is prone to transient (single event) failures, particularly for 
+client HB reads.
+
+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.
+

data/spec/client_spec.rb

@@ -302,7 +302,7 @@ describe Stomp::Client do
       
       url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)?#{query}"
       
-      #backup and timeout are not implemented yet
+      #
       @parameters = {  
         :initial_reconnect_delay => 5.0,
         :max_reconnect_delay => 60.0,

data/spec/connection_spec.rb

@@ -25,7 +25,9 @@ describe Stomp::Connection do
       :hbser => false,
       :stompconn => false,
       :usecrlf => false,
-    }
+      :max_hbread_fails => 0,
+      :max_hbrlck_fails => 0,
+   }
         
     #POG:
     class Stomp::Connection
@@ -90,6 +92,8 @@ describe Stomp::Connection do
         "connect_timeout" => 0,
         "parse_timeout" => 5,
         "usecrlf" => false,
+        :max_hbread_fails => 0,
+        :max_hbrlck_fails => 0,
       }
       
       @connection = Stomp::Connection.new(used_hash)
@@ -338,6 +342,8 @@ describe Stomp::Connection do
           :closed_check => true,
           :hbser => false,
           :stompconn => false,
+          :max_hbread_fails => 0,
+          :max_hbrlck_fails => 0,
         }
         
         used_hash =  {
@@ -363,7 +369,6 @@ describe Stomp::Connection do
           :back_off_multiplier => 3,
           :max_reconnect_attempts => 10,
           :randomize => true,
-          :backup => false,
           :reliable => false,
           :connect_timeout => 0,
           :parse_timeout => 20,
@@ -372,9 +377,11 @@ describe Stomp::Connection do
           :max_redeliveries => 10,
           :dmh => false,
           :closed_check => true,
-          :hbser => false,
-          :stompconn => false,
-          :usecrlf => false,
+          :hbser => true,
+          :stompconn => true,
+          :usecrlf => true,
+          :max_hbread_fails => 123,
+          :max_hbrlck_fails => 456,
         }
         
         @connection = Stomp::Connection.new(used_hash)

data/stomp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{stomp}
-  s.version = "1.2.9"
+  s.version = "1.2.10"
 
   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-03-28}
+  s.date = %q{2013-07-08}
   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"]
@@ -115,6 +115,7 @@ Gem::Specification.new do |s|
     "lib/stomp/message.rb",
     "lib/stomp/sslparams.rb",
     "lib/stomp/version.rb",
+    "notes/heartbeat_readme.txt",
     "spec/client_shared_examples.rb",
     "spec/client_spec.rb",
     "spec/connection_spec.rb",

data/test/test_connection1p.rb

@@ -28,7 +28,7 @@ class TestConnection1P < Test::Unit::TestCase
     assert @conn.open?
   end
 
-  # Test missing connect headers.
+  # Test missing connect headers - part 1.
   def test_conn_1p_0010
     @conn.disconnect
     #
@@ -43,6 +43,33 @@ class TestConnection1P < Test::Unit::TestCase
     end    
   end
 
+  # Test missing connect headers - part 2.
+  def test_conn_1p_0015
+    @conn.disconnect
+    #
+    cha = {:host => "localhost"}
+    hash = { :hosts => [ 
+      {:login => user, :passcode => passcode, :host => host, :port => port, :ssl => nil},
+      ],
+      :reliable => true, # Note, issue #57 discussion
+      :connect_headers => cha,
+      :stompconn => get_stomp_conn(),
+      :usecrlf => get_crlf(),
+      :initial_reconnect_delay => 0.1,
+      :max_reconnect_delay => 30,
+      :use_exponential_back_off => true,
+      :back_off_multiplier => 2,
+      :max_reconnect_attempts => 10,
+    }
+    assert_raise Stomp::Error::ProtocolErrorConnect do
+      conn = Stomp::Connection.open(hash)
+    end
+    hash[:connect_headers] = {"accept-version" => "1.1"}
+    assert_raise Stomp::Error::ProtocolErrorConnect do
+      conn = Stomp::Connection.open(hash)
+    end
+  end
+
   # Test requesting only a 1.0 connection.
   def test_conn_1p_0020
     @conn.disconnect

data/test/tlogger.rb

@@ -6,6 +6,8 @@ require 'logger'	# use the standard Ruby logger .....
 
 Callback logger for Stomp 1.1+ heartbeat tests.
 
+See the examples directory for a more robust logger example.
+
 =end
 class Tlogger
 
@@ -31,7 +33,7 @@ class Tlogger
   def on_hbwrite_fail(parms, ticker_data)
     begin
       @log.debug "Hbwritef Parms #{info(parms)}"
-      @log.debug "Hbwritef Result #{ticker_data}"
+      @log.debug "Hbwritef Result #{ticker_data.inspect}"
     rescue
       @log.debug "Hbwritef oops"
     end
@@ -42,7 +44,7 @@ class Tlogger
   def on_hbread_fail(parms, ticker_data)
     begin
       @log.debug "Hbreadf Parms #{info(parms)}"
-      @log.debug "Hbreadf Result #{ticker_data}"
+      @log.debug "Hbreadf Result #{ticker_data.inspect}"
     rescue
       @log.debug "Hbreadf oops"
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: stomp
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 1
   - 2
-  - 9
-  version: 1.2.9
+  - 10
+  version: 1.2.10
 platform: ruby
 authors: 
 - Brian McCallister
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-03-28 00:00:00 -04:00
+date: 2013-07-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -148,6 +148,7 @@ files:
 - lib/stomp/message.rb
 - lib/stomp/sslparams.rb
 - lib/stomp/version.rb
+- notes/heartbeat_readme.txt
 - spec/client_shared_examples.rb
 - spec/client_spec.rb
 - spec/connection_spec.rb