stomp 1.2.16 → 1.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDM0Njc0MjJhMzYzOTBjZGQ0NGZiZTM4MDA2MzRlNzgwZmE2M2JmZg==
+    NzAwZGNiZmI2NzJkZWZkNWNlZWY4NDZiZTU3NjFiNzhkNjRmNDkyOA==
   data.tar.gz: !binary |-
-    YmY5YmNlNTFkMTEwMzFlMDRjYWJlNWQ4MmRjZWEwNWJmNjU3YTZjZA==
+    MmUyNDgwOWVmOWYxMmRmMjIxMTZlZDQxMmI3ODcxMTk5ODRlNzQyNA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZmRmZWI0MGUyMDZjNDM2Yjc3YjY5ZmRiODQwZmNhZDIwYmNiOGY0NDczMWI2
-    Nzg2NWNiMWQ4YmY4YWQ5MzRhNjAwOTZlYWUwZDU4ZDhhYWNkMmJmYmI1MDFl
-    ZDFkOWNmMDdjZTgxZmQ3NmZkYTk5YmYzMDk2ZTljYmE4ZjhlOTk=
+    NjA2MDRjODc2MjEwODVjNTFjZDRkYzFmZDdhNGVmN2FiN2NmYjNkOTE2YmIz
+    YzExNWI3OWE1ZjEzMDMwNmJiNDAxYmYxOGFiMjhiYjEzZGY4YWMxMzc5NzI1
+    NTUyNjgwYmQwYjQyNzlkNjlkYmM4M2VkN2QwZjYwZDUyMTU4NWI=
   data.tar.gz: !binary |-
-    MjQ5YWQ3MjYwMjAyYWVkNDRiY2Q1ZGUxYTU0MzFhOTE1NGNlYjU1MGRjN2I3
-    NzU4ZDJkNmZiYTZkNjU3YmQ0MTQxOGUzM2ZhMDIxNmY4NGYwNDhjYTcxNGQ5
-    MWVmNzI5ZjIwMjEwN2E2ZjM0MzBkM2RmZmEwMjk3NTNiNWM2MzM=
+    OTNmMjliOTM4NmI3NmRjOTllNzc0NWE2MDM2YTZlZTg2ZTk1YTBlMDEwMjRk
+    YTk2MGM3ZDFkNzUxZDc3OGI4ZmRkNWI5OWJhZTdjOGVlMzY0MmU3YzljMDU5
+    NWMxZTkwMTk4ZDAwODA2ZDA5YTZiZmQ5N2Q1M2JhMDJkNjZhMmY=

data/CHANGELOG.rdoc

@@ -1,3 +1,13 @@
+== 1.3.0 20130930
+
+* ERROR frames now raise an exception in the Stomp::Client thread(#73, #81)
+* Allow anonymous connections (#75)
+* Fix for subscription id handling in STOMP 1.1 (#78)
+* Added a NullLogger (#77)
+* Added :tcp_nodelay option (disable Nagle's algorithm) (#76)
+* Read receipt ids are now UUIDs
+* Added a :start_timeout parameter
+
 == 1.2.16 20130812
 
 * Stomp::Client's should expose connection's host params

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.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.
 * Gem version 1.2.15. Timeout cleanup, added license info to gemspec.
 * Gem version 1.2.14. Cleanup.
@@ -63,6 +64,7 @@ See _CHANGELOG.rdoc_ for details.
                                           # For fast heartbeat senders.  'fast' == YMMV.  If not
                                           # 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
     }
 
     # for client

data/lib/client/utils.rb

@@ -71,33 +71,22 @@ module Stomp
       end
     end
 
-    # Register a receipt listener.
-    def register_receipt_listener(listener)
-      id = -1
-      @id_mutex.synchronize do
-        id = @ids.to_s
-        @ids = @ids.succ
+    # 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
-      @receipt_listeners[id] = listener
-      id
+      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!()
       first_host = @parameters && @parameters[:hosts] && @parameters[:hosts].first
@@ -131,35 +120,54 @@ end
         set_subscription_id_if_missing(message.headers['destination'], message.headers)
         subscription_id = message.headers[:id]
       end
-      @listeners[subscription_id]
+
+      listener = @listeners[subscription_id]
+      listener.call(message) if listener
     end
 
-    # Start a single listener thread.  Misnamed I think.
-    def start_listeners()
+    # Register a receipt listener.
+    def register_receipt_listener(listener)
+      id = uuid
+      @receipt_listeners[id] = listener
+      id
+    end
+
+    def find_receipt_listener(message)
+      listener = @receipt_listeners[message.headers['receipt-id']]
+      listener.call(message) if listener
+    end
+
+    def create_listener_maps
       @listeners = {}
       @receipt_listeners = {}
       @replay_messages_by_txn = {}
 
+      @listener_map = Hash.new do |message|
+        @logger.on_miscerr(@connection.log_params, "Received unknown frame type: '#{message.command}'\n")
+      end
+
+      @listener_map[Stomp::CMD_MESSAGE] = lambda {|message| find_listener(message) }
+      @listener_map[Stomp::CMD_RECEIPT] = lambda {|message| find_receipt_listener(message) }
+      @listener_map[Stomp::CMD_ERROR]   = @error_listener
+    end
+
+    # Start a single listener thread.  Misnamed I think.
+    def start_listeners()
+      create_listener_maps
+
       @listener_thread = Thread.start do
-        while true
+        loop do
           message = @connection.receive
           # AMQ specific behavior
           if message.nil? && (!@parameters[: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)
-              end
-            end
-          end
-        end # while true
+
+          next unless message # message can be nil on rapid AMQ stop/start sequences
+
+          @listener_map[message.command].call(message)
+        end
+
       end
     end # method start_listeners
 

data/lib/connection/heartbeats.rb

@@ -100,20 +100,17 @@ 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
+          @logger.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
+            @logger.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
@@ -124,10 +121,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
+                @logger.on_hbwrite_fail(log_params, {"ticker_interval" => sleeptime,
+                                                     "exception" => sendex})
                 if @hbser
                   raise # Re-raise if user requested this, otherwise ignore
                 end
@@ -165,16 +160,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
+          @logger.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
+              @logger.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
@@ -201,22 +192,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
+                  @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
               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
+                @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 # of the try_lock
 
             else # delta <= sleeptime
@@ -225,11 +214,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
+            @logger.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?

data/lib/connection/netio.rb

@@ -130,11 +130,8 @@ module Stomp
           @failure = $!
           raise unless @reliable
           errstr = "transmit to #{@host} failed: #{$!}\n"
-          if @logger && @logger.respond_to?(:on_miscerr)
-            @logger.on_miscerr(log_params, "es_trans: " + errstr)
-          else
-            $stderr.print errstr
-          end
+          @logger.on_miscerr(log_params, "es_trans: " + errstr)
+          $stderr.print errstr
           # !!! This loop initiates a re-connect !!!
           _reconn_prep()
         end
@@ -201,9 +198,7 @@ module Stomp
     def open_tcp_socket()
       tcp_socket = nil
 
-      if @logger && @logger.respond_to?(:on_connecting)
-        @logger.on_connecting(log_params)
-      end
+      @logger.on_connecting(log_params)
 
       Timeout::timeout(@connect_timeout, Stomp::Error::SocketOpenTimeout) do
         tcp_socket = TCPSocket.open(@host, @port)
@@ -281,9 +276,7 @@ module Stomp
 
         #
         ssl = nil
-        if @logger && @logger.respond_to?(:on_ssl_connecting)
-          @logger.on_ssl_connecting(log_params)
-        end
+        @logger.on_ssl_connecting(log_params)
 
         Timeout::timeout(@connect_timeout, Stomp::Error::SocketOpenTimeout) do
           tcp_socket = TCPSocket.open(@host, @port)
@@ -304,16 +297,12 @@ module Stomp
           end
           @ssl.peer_cert = ssl.peer_cert
         end
-        if @logger && @logger.respond_to?(:on_ssl_connected)
-          @logger.on_ssl_connected(log_params)
-        end
+        @logger.on_ssl_connected(log_params)
         ssl
       rescue Exception => ex
-        if @logger && @logger.respond_to?(:on_ssl_connectfail)
-          lp = log_params.clone
-          lp[:ssl_exception] = ex
-          @logger.on_ssl_connectfail(lp)
-        end
+        lp = log_params.clone
+        lp[:ssl_exception] = ex
+        @logger.on_ssl_connectfail(lp)
         #
         raise # Reraise
       end
@@ -343,11 +332,15 @@ module Stomp
       @closed = false
       if @parameters # nil in some rspec tests
         unless @reconnect_delay
-          @reconnect_delay = @parameters[:initial_reconnect_delay] ? @parameters[:initial_reconnect_delay] : 0.01
+          @reconnect_delay = @parameters[:initial_reconnect_delay] || 0.01
         end
       end
       # Use keepalive
       used_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+
+      # TCP_NODELAY option (disables Nagle's algorithm)
+      used_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, !!(@parameters && @parameters[:tcp_nodelay]))
+
       used_socket
     end
 
@@ -355,8 +348,8 @@ module Stomp
     def connect(used_socket)
       @connect_headers = {} unless @connect_headers # Caller said nil/false
       headers = @connect_headers.clone
-      headers[:login] = @login
-      headers[:passcode] = @passcode
+      headers[:login] = @login unless @login.to_s.empty?
+      headers[:passcode] = @passcode unless @login.to_s.empty?
       _pre_connect
       if !@hhas10 && @stompconn
         _transmit(used_socket, Stomp::CMD_STOMP, headers)

data/lib/connection/utils.rb

@@ -116,9 +116,7 @@ module Stomp
             used_socket = open_socket() # sets @closed = false if OK
             # Open is complete
             connect(used_socket)
-            if @logger && @logger.respond_to?(:on_connected)
-              @logger.on_connected(log_params)
-            end
+            @logger.on_connected(log_params)
             @connection_attempts = 0
           rescue
             @failure = $!
@@ -132,16 +130,13 @@ module Stomp
             # 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
-                @logger.on_connectfail(log_params)
-              rescue Exception => aex
-                raise if aex.is_a?(Stomp::Error::LoggerConnectionError)
-              end
-            else
-              $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
+            # on_connectfail may raise
+            begin
+              @logger.on_connectfail(log_params)
+            rescue Exception => aex
+              raise if aex.is_a?(Stomp::Error::LoggerConnectionError)
             end
+            $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
             raise Stomp::Error::MaxReconnectAttempts if max_reconnect_attempts?
 
             sleep(@reconnect_delay)
@@ -183,6 +178,7 @@ module Stomp
         :max_hbrlck_fails => 0,
         :fast_hbs_adjust => 0.0,
         :connread_timeout => 0,
+        :tcp_nodelay => true
       }
 
       res_params = default_params.merge(params)
@@ -236,11 +232,9 @@ module Stomp
           @failure = $!
           raise unless @reliable
           errstr = "receive failed: #{$!}"
-          if @logger && @logger.respond_to?(:on_miscerr)
-            @logger.on_miscerr(log_params, "es_oldrecv: " + errstr)
-          else
-            $stderr.print errstr
-          end
+          @logger.on_miscerr(log_params, "es_oldrecv: " + errstr)
+          $stderr.print errstr
+
           # !!! This initiates a re-connect !!!
           _reconn_prep()
         end

data/lib/stomp.rb

@@ -24,6 +24,7 @@ require 'stomp/version'         # Stomp#Version#STRING
 require 'stomp/errors'          # All Stomp# exceptions
 require 'stomp/codec'           # Stomp 1.1 codec
 require 'stomp/sslparams'       # Stomp SSL support
+require 'stomp/null_logger'     # A NullLogger class
 
 # Private methods in #Client
 require 'client/utils'          # private Client Utility methods

data/lib/stomp/client.rb

@@ -2,6 +2,7 @@
 
 require 'thread'
 require 'digest/sha1'
+require 'timeout'
 require 'forwardable'
 
 module Stomp
@@ -80,13 +81,31 @@ module Stomp
 
       check_arguments!()
 
-      @id_mutex = Mutex.new()
-      @ids = 1
+      @logger = @parameters[:logger] ||= Stomp::NullLogger.new
 
-      create_connection(autoflush)
+      @start_timeout = @parameters[:start_timeout] || 10
+      Timeout.timeout(@start_timeout, Stomp::Error::StartTimeoutException.new(@start_timeout)) do
+        create_error_handler
+        create_connection(autoflush)
+        start_listeners()
+      end
+    end
+
+    def create_error_handler
+      client_thread = Thread.current
 
-      start_listeners()
+      @error_listener = lambda do |error|
+        exception = case error.body
+                      when /ResourceAllocationException/i
+                        Stomp::Error::ProducerFlowControlException.new(error)
+                      when /ProtocolException/i
+                        Stomp::Error::ProtocolException.new(error)
+                      else
+                        Stomp::Error::BrokerException.new(error)
+                    end
 
+        client_thread.raise exception
+      end
     end
 
     def create_connection(autoflush)
@@ -119,9 +138,7 @@ module Stomp
       replay_list = @replay_messages_by_txn[name]
       if replay_list
         replay_list.each do |message|
-          if listener = find_listener(message)
-            listener.call(message)
-          end
+          find_listener(message) # find_listener also calls the listener
         end
       end
     end
@@ -159,7 +176,7 @@ module Stomp
     # Acknowledge a message, used when a subscription has specified
     # client acknowledgement ( connection.subscribe("/queue/a",{:ack => 'client'}).
     # Accepts a transaction header ( :transaction => 'some_transaction_id' ).
-    def acknowledge(message, headers = {})
+    def ack(message, headers = {})
       txn_id = headers[:transaction]
       if txn_id
         # lets keep around messages ack'd in this transaction in case we rollback
@@ -175,14 +192,20 @@ module Stomp
       end
       if protocol() == Stomp::SPL_12
         @connection.ack(message.headers['ack'], headers)
+      elsif protocol == Stomp::SPL_11
+        headers.merge!(:subscription => message.headers['subscription'])
+        @connection.ack(message.headers['message-id'], headers)
       else
         @connection.ack(message.headers['message-id'], headers)
       end
     end
 
+    # For posterity, we alias:
+    alias acknowledge ack
+
     # Stomp 1.1+ NACK.
-    def nack(message_id, headers = {})
-      @connection.nack(message_id, headers)
+    def nack(message, headers = {})
+      @connection.nack(message, headers)
     end
 
     # Unreceive a message, sending it back to its queue or to the DLQ.
@@ -240,6 +263,7 @@ module Stomp
 
     # set_logger identifies a new callback logger.
     def set_logger(logger)
+      @logger = logger
       @connection.set_logger(logger)
     end