stomp 1.3.1 → 1.3.2

data/CHANGELOG.rdoc

@@ -1,3 +1,18 @@
+== 1.3.2 20131208
+
+* Anon tests assigned unique class name.
+* Fix TypeError on connect timeout with 1.8.x, 2.x.
+* Complete revert to previous logger logic.
+* start_timeout and tcp_nodelay parameters
+* SSL Fix, revert not setting default ciphers.
+* Copy hash params at init.
+* Fix ssl => true for Ruby 1.9.x and 2.x.
+* Expanded list of STOMP default SSL ciphers:
+* Do not change caller's :hosts array
+* Issue #78, again.
+* Clean up logger interfacing.
+* Fixes from RSpec testing
+
 == 1.3.1 20131002
 
 * Method calls to the logger object should check for that method first (#83)

data/README.rdoc

@@ -12,6 +12,7 @@ An implementation of the Stomp protocol for Ruby. See:
 
 See _CHANGELOG.rdoc_ for details.
 
+* Gem version 1.3.2. Miscellaneous fixes, see changelog for details.
 * Gem version 1.3.1. Bugfix for logging.
 * Gem version 1.3.0. Added ERROR frame raising as exception, added anonymous connections, miscellaneous other fixes.
 * Gem version 1.2.16. Fixed Stomp::Client to expose its connection's host parameters.
@@ -66,7 +67,7 @@ See _CHANGELOG.rdoc_ for details.
                                           # correct for your environment, expect unnecessary fail overs
       :connread_timeout => 0,             # Timeout during CONNECT for read of CONNECTED/ERROR, secs
       :tcp_nodelay => true,               # Turns on the TCP_NODELAY socket option; disables Nagle's algorithm
-      :start_timeout => 10,               # Timeout around initialization
+      :start_timeout => 10,               # Timeout around Stomp::Client initialization
     }
 
     # for client
@@ -150,4 +151,5 @@ The following people have contributed to Stomp:
 * JP Hastings-Spital
 * Glenn Roberts
 * Ian Smith
+* Orazio Cotroneo
 

data/examples/conn11_hb1.rb

@@ -6,11 +6,11 @@
 #
 if Kernel.respond_to?(:require_relative)
   require_relative("./stomp11_common")
-  require_relative("./slogger")
+  require_relative("./examplogger")
 else
   $LOAD_PATH << File.dirname(__FILE__)
   require "stomp11_common"
-  require "slogger"
+  require "examplogger"
 end
 include Stomp11Common
 

data/examples/examplogger.rb

@@ -0,0 +1,306 @@
+# -*- encoding: utf-8 -*-
+
+require 'logger'	# use the standard Ruby logger .....
+
+# == Example STOMP call back logger class.
+#
+# Optional callback methods:
+#
+# *    on_connecting: connection starting
+# *    on_connected: successful connect
+# *    on_connectfail: unsuccessful connect (will usually be retried)
+# *    on_disconnect: successful disconnect
+#
+# *    on_miscerr: on miscellaneous xmit/recv errors
+#
+# *    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
+# *    on_ssl_connected: successful SSL connect
+# *    on_ssl_connectfail: unsuccessful SSL connect (will usually be retried)
+#
+# *    on_hbread_fail: unsuccessful Heartbeat read
+# *    on_hbwrite_fail: unsuccessful Heartbeat write
+# *    on_hbfire: on any send or receive heartbeat
+#
+# All methods are optional, at the user's requirements.
+#
+# If a method is not provided, it is not called (of course.)
+# 
+# IMPORTANT NOTE:  in general, call back logging methods *SHOULD* not raise exceptions, 
+# otherwise the underlying STOMP connection may fail in mysterious ways.
+#
+# There are two useful exceptions to this rule for:
+#
+# *    on_connectfail
+# *    on_ssl_connectfail
+#
+# These two methods can raise a Stomp::Errors::LoggerConnectionError.  If this
+# exception is raised, it is passed up the chain to the caller.
+#
+# Callback parameters: are a copy of the @parameters instance variable for
+# the Stomp::Connection.
+#
+# A logger class may optionally inherit from the provided NullLogger
+#
+# # class Slogger < Stomp::NullLogger
+#
+class Slogger
+
+  # Initialize a new callback logger instance.
+  def initialize(init_parms = nil)
+    _init
+    @log.info("Logger initialization complete.")
+  end
+
+  def _init
+    @log = Logger::new(STDOUT)		# User preference
+    @log.level = Logger::DEBUG		# User preference
+  end
+
+  def marshal_dump
+    []
+  end
+
+  def marshal_load(array)
+    _init
+  end
+
+  # Log connecting events
+  def on_connecting(parms)
+    begin
+      @log.debug "Connecting: #{info(parms)}"
+    rescue
+      @log.debug "Connecting oops"
+    end
+  end
+
+  # Log connected events
+  def on_connected(parms)
+    begin
+      @log.debug "Connected: #{info(parms)}"
+    rescue
+      @log.debug "Connected oops"
+    end
+  end
+
+  # Log connectfail events
+  def on_connectfail(parms)
+    begin
+      @log.debug "Connect Fail #{info(parms)}"
+    rescue
+      @log.debug "Connect Fail oops"
+    end
+=begin
+    # An example LoggerConnectionError raise
+    @log.debug "Connect Fail, will raise"
+    raise Stomp::Error::LoggerConnectionError.new("quit from connect fail")
+=end
+  end
+
+  # Log disconnect events
+  def on_disconnect(parms)
+    begin
+      @log.debug "Disconnected #{info(parms)}"
+    rescue
+      @log.debug "Disconnected oops"
+    end
+  end
+
+  # Log miscellaneous errors
+  def on_miscerr(parms, errstr)
+    begin
+      @log.debug "Miscellaneous Error #{info(parms)}"
+      @log.debug "Miscellaneous Error String #{errstr}"
+    rescue
+      @log.debug "Miscellaneous Error oops"
+    end
+  end
+
+  # Log Subscribe
+  def on_subscribe(parms, headers)
+    begin
+      @log.debug "Subscribe Parms #{info(parms)}"
+      @log.debug "Subscribe Headers #{headers}"
+    rescue
+      @log.debug "Subscribe oops"
+    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
+      @log.debug "Publish Parms #{info(parms)}"
+      @log.debug "Publish Message #{message}"
+      @log.debug "Publish Headers #{headers}"
+    rescue
+      @log.debug "Publish oops"
+    end
+  end
+
+  # Log Receive
+  def on_receive(parms, result)
+    begin
+      @log.debug "Receive Parms #{info(parms)}"
+      @log.debug "Receive Result #{result}"
+    rescue
+      @log.debug "Receive oops"
+    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.inspect}"
+    rescue
+      @log.debug "Hbreadf oops"
+    end
+  end
+
+  # Stomp 1.1+ - heart beat send (transmit) failed.
+  def on_hbwrite_fail(parms, ticker_data = {})
+    begin
+      @log.debug "Hbwritef Parms #{info(parms)}"
+      @log.debug "Hbwritef Result #{ticker_data.inspect}"
+    rescue
+      @log.debug "Hbwritef oops"
+    end
+  end
+
+  # Log SSL connection start.
+  def on_ssl_connecting(parms)
+    begin
+      @log.debug "SSL Connecting Parms #{info(parms)}"
+    rescue
+      @log.debug "SSL Connecting oops"
+    end
+  end
+
+  # Log a successful SSL connect.
+  def on_ssl_connected(parms)
+    begin
+      @log.debug "SSL Connected Parms #{info(parms)}"
+    rescue
+      @log.debug "SSL Connected oops"
+    end
+  end
+
+  # Log an unsuccessful SSL connect.
+  def on_ssl_connectfail(parms)
+    begin
+      @log.debug "SSL Connect Fail Parms #{info(parms)}"
+      @log.debug "SSL Connect Fail Exception #{parms[:ssl_exception]}, #{parms[:ssl_exception].message}"
+    rescue
+      @log.debug "SSL Connect Fail oops"
+    end
+=begin
+    # An example LoggerConnectionError raise
+    @log.debug "SSL Connect Fail, will raise"
+    raise Stomp::Error::LoggerConnectionError.new("quit from SSL connect")
+=end
+  end
+
+  # Log heart beat fires
+  def on_hbfire(parms, srind, firedata = {})
+    begin
+      @log.debug "HeartBeat Fire Parms #{info(parms)}"
+      @log.debug "HeartBeat Fire Send/Receive #{srind}"
+    rescue
+      @log.debug "HeartBeat Fire oops"
+    end
+  end
+
+  private
+
+  # Example information extract.
+  def info(parms)
+    #
+    # Available in the parms Hash:
+    # parms[:cur_host]
+    # parms[:cur_port]
+    # parms[:cur_login]
+    # parms[:cur_passcode]
+    # parms[:cur_ssl]
+    # parms[:cur_recondelay]
+    # parms[:cur_parseto]
+    # parms[:cur_conattempts]
+    # parms[:openstat]
+    #
+    # For the on_ssl_connectfail callback these are also available:
+    # parms[:ssl_exception]
+    #
+    "Host: #{parms[:cur_host]}, Port: #{parms[:cur_port]}, Login: #{parms[:cur_login]}, Passcode: #{parms[:cur_passcode]}, ssl: #{parms[:cur_ssl]}"
+  end
+end # of class
+

data/examples/logexamp.rb

@@ -5,10 +5,10 @@ require 'stomp'
 require 'logger'  # for the 'local' logger
 #
 if Kernel.respond_to?(:require_relative)
-  require_relative("./slogger")
+  require_relative("./examplogger")
 else
   $LOAD_PATH << File.dirname(__FILE__)
-  require "slogger"
+  require "examplogger"
 end
 #
 # == A STOMP::Connection program which uses the callback logging facility.

data/examples/logexamp_ssl.rb

@@ -5,10 +5,10 @@ require 'stomp'
 require 'logger'  # for the 'local' logger
 #
 if Kernel.respond_to?(:require_relative)
-  require_relative("./slogger")
+  require_relative("./examplogger")
 else
   $LOAD_PATH << File.dirname(__FILE__)
-  require "slogger"
+  require "examplogger"
 end
 #
 # == A STOMP::Connection program which uses the callback logging facility.

data/lib/client/utils.rb

@@ -143,7 +143,9 @@ module Stomp
       @replay_messages_by_txn = {}
 
       @listener_map = Hash.new do |message|
-        @logger.on_miscerr(@connection.log_params, "Received unknown frame type: '#{message.command}'\n")
+        unless @connection.slog(:on_miscerr, @connection.log_params, "Received unknown frame type: '#{message.command}'\n")
+          warn "Received unknown frame type: '#{message.command}'\n"
+        end
       end
 
       @listener_map[Stomp::CMD_MESSAGE] = lambda {|message| find_listener(message) }

data/lib/connection/heartbeats.rb

@@ -100,22 +100,16 @@ module Stomp
           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 => curt, :last_sleep => slt)
-          end
-
+          slog(:on_hbfire, log_params, "send_fire", :curt => curt, :last_sleep => slt)
           delta = curt - @ls
           # 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", :last_sleep => slt,
-                                :curt => curt, :last_send => @ls, :delta => delta,
-                                :compval => compval)
-            end
+            slog(:on_hbfire, log_params, "send_heartbeat", :last_sleep => slt,
+                    :curt => curt, :last_send => @ls, :delta => delta,
+                    :compval => compval)
             # Send a heartbeat
             @transmit_semaphore.synchronize do
               begin
@@ -126,10 +120,8 @@ module Stomp
                 @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" => sleeptime,
-                                                       "exception" => sendex})
-                end
+                slog(:on_hbwrite_fail, log_params, {"ticker_interval" => sleeptime,
+                  "exception" => sendex})
                 if @hbser
                   raise # Re-raise if user requested this, otherwise ignore
                 end
@@ -167,16 +159,12 @@ module Stomp
           next unless @socket # nil under some circumstances ??
           rdrdy = _is_ready?(@socket)
           curt = Time.now.to_f
-          if @logger && @logger.respond_to?(:on_hbfire)
-            @logger.on_hbfire(log_params, "receive_fire", :curt => curt)
-          end
+          slog(:on_hbfire, log_params, "receive_fire", :curt => curt)
           #
           begin
             delta = curt - @lr
             if delta > sleeptime
-              if @logger && @logger.respond_to?(:on_hbfire)
-                @logger.on_hbfire(log_params, "receive_heartbeat", {})
-              end
+              slog(:on_hbfire, log_params, "receive_heartbeat", {})
               # 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
@@ -203,24 +191,20 @@ module Stomp
                   @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
+                  slog(:on_hbread_fail, log_params, {"ticker_interval" => sleeptime,
+                    "read_fail_count" => read_fail_count,
+                    "lock_fail" => false,
+                    "lock_fail_count" => lock_fail_count})
                 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
+                slog(:on_hbread_fail, log_params, {"ticker_interval" => sleeptime,
+                  "read_fail_count" => read_fail_count,
+                  "lock_fail" => true,
+                  "lock_fail_count" => lock_fail_count})
               end # of the try_lock
 
             else # delta <= sleeptime
@@ -229,12 +213,10 @@ module Stomp
               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
+            slog(:on_hbread_fail, log_params, {"ticker_interval" => sleeptime,
+              "exception" => recvex,
+              "read_fail_count" => read_fail_count,
+              "lock_fail_count" => lock_fail_count})
             fail_hard = true
           end
           # Do we want to attempt a retry?