stomp 1.1.3 → 1.1.4

data/CHANGELOG

@@ -1,3 +1,18 @@
+== 1.1.4 2010-21-01
+
+* Added unreceive message method that sends the message back to its queue or to the 
+  dead letter queue, depending on the :max_redeliveries option, similar to a13m one.
+* Added environment variable option for running 'rake test' on any stomp server, using any port with any user.
+* Added suppress_content_length header option for ActiveMQ knowing it is a text message (see: 
+  http://juretta.com/log/2009/05/24/activemq-jms-stomp/)
+* Fixed some bugs with Ruby 1.9 (concatenate string + exception)
+* Major changes on message parsing feature
+* Fixed bug with old socket not being closed when using failover
+* Fixed broken poll method on Connection
+* Fixed broken close method on Client
+* Added connection_frame accessor
+* Added disconnect receipt
+
 == 1.1.3 2009-24-11
 
 * Failover support

data/Rakefile

@@ -44,6 +44,13 @@ Rake::RDocTask.new do |rd|
   rd.options = spec.rdoc_options
 end
 
+desc "Rspec : run all with RCov"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'gems', '--exclude', 'spec']
+end
+
 desc "RSpec : run all"
 Spec::Rake::SpecTask.new('spec') do |t|
   t.spec_files = FileList['spec/**/*.rb']

data/lib/stomp.rb

@@ -13,12 +13,11 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-require 'io/wait'
-require 'socket'
-require 'thread'
-require 'stomp/connection'
-require 'stomp/client'
-require 'stomp/message'
+require File.join(File.dirname(__FILE__), 'stomp', 'ext', 'hash')
+require File.join(File.dirname(__FILE__), 'stomp', 'connection')
+require File.join(File.dirname(__FILE__), 'stomp', 'client')
+require File.join(File.dirname(__FILE__), 'stomp', 'message')
+require File.join(File.dirname(__FILE__), 'stomp', 'errors')
 
 module Stomp
 end

data/lib/stomp/client.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Stomp
 
   # Typical Stomp client class. Uses a listener thread to receive frames
@@ -7,7 +9,7 @@ module Stomp
   # in that thread if you have much message volume.
   class Client
 
-    attr_reader :login, :passcode, :host, :port, :reliable, :running, :parameters
+    attr_reader :login, :passcode, :host, :port, :reliable, :parameters
     alias :obj_send :send
 
     # A new Client object can be initialized using two forms:
@@ -40,7 +42,7 @@ module Stomp
         @login = first_host[:login]
         @passcode = first_host[:passcode]
         @host = first_host[:host]
-        @port = first_host[:port] || default_port(first_host[:ssl])
+        @port = first_host[:port] || Connection::default_port(first_host[:ssl])
         
         @reliable = true
         
@@ -57,7 +59,7 @@ module Stomp
         @login = first_host[:login] = $4 || ""
         @passcode = first_host[:passcode] = $5 || ""
         @host = first_host[:host] = $6
-        @port = first_host[:port] = $7.to_i || default_port(first_host[:ssl])
+        @port = first_host[:port] = $7.to_i || Connection::default_port(first_host[:ssl])
         
         options = $16 || ""
         parts = options.split(/&|=/)
@@ -168,7 +170,13 @@ module Stomp
       end
       @connection.ack message.headers['message-id'], headers
     end
-
+    
+    # Unreceive a message, sending it back to its queue or to the DLQ
+    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
+    #
+    def unreceive(message)
+      @connection.unreceive message
+    end
     # Send message to destination
     #
     # If a block is given a receipt will be requested and passed to the
@@ -181,6 +189,14 @@ module Stomp
       end
       @connection.send(destination, message, headers)
     end
+    
+    def connection_frame
+      @connection.connection_frame
+    end
+
+    def disconnect_receipt
+      @connection.disconnect_receipt
+    end
 
     # Is this client open?
     def open?
@@ -193,9 +209,14 @@ module Stomp
     end
 
     # Close out resources in use by this client
-    def close
-      @connection.disconnect
-      @running = false
+    def close headers={}
+      @listener_thread.exit
+      @connection.disconnect headers
+    end
+
+    # Check if the thread was created and isn't dead
+    def running
+      @listener_thread && !!@listener_thread.status
     end
 
     private
@@ -210,12 +231,6 @@ module Stomp
         id
       end
       
-      def default_port(ssl)
-        return 61612 if ssl
-        
-        61613
-      end
-      
       def parse_hosts(url)
         hosts = []
         
@@ -257,15 +272,14 @@ module Stomp
       def start_listeners
         @listeners = {}
         @receipt_listeners = {}
-        @running = true
         @replay_messages_by_txn = {}
 
         @listener_thread = Thread.start do
-          while @running
-            message = @connection.receive
+          while true
+            message = @connection.poll
             case
             when message.nil?
-              break
+              sleep 0.1
             when message.command == 'MESSAGE'
               if listener = @listeners[message.headers['destination']]
                 listener.call(message)

data/lib/stomp/connection.rb

@@ -1,10 +1,20 @@
+require 'socket'
+require 'monitor'
+require 'timeout'
+
 module Stomp
 
   # Low level connection which maps commands and supports
   # synchronous receives
   class Connection
-
+    attr_reader :connection_frame
+    attr_reader :disconnect_receipt
     alias :obj_send :send
+
+    def self.default_port(ssl)
+      ssl ? 61612 : 61613
+    end
+    
     # A new Connection object accepts the following parameters:
     #
     #   login             (String,  default : '')
@@ -45,6 +55,8 @@ module Stomp
     #   stomp://user:pass@host.domain.tld:port
     #
     def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
+      @received_messages = []
+
       if login.is_a?(Hash)
         hashed_initialize(login)
       else
@@ -60,8 +72,7 @@ module Stomp
       end
       
       @transmit_semaphore = Mutex.new
-      @read_semaphore = Mutex.new
-      @socket_semaphore = Mutex.new
+      @read_semaphore = Monitor.new
       
       @subscriptions = {}
       @failure = nil
@@ -87,37 +98,28 @@ module Stomp
     end
 
     def socket
-      # Need to look into why the following synchronize does not work.
-      #@read_semaphore.synchronize do
-      
-        s = @socket;
-        
-        s = nil unless connected?
+      @read_semaphore.synchronize do
+        used_socket = @socket
+        used_socket = nil if closed?
         
-        while s.nil? || !@failure.nil?
+        while used_socket.nil? || !@failure.nil?
           @failure = nil
           begin
-            s = open_socket
-            @closed = false
-      
-            headers = @connect_headers.clone
-            headers[:login] = @login
-            headers[:passcode] = @passcode
-            _transmit(s, "CONNECT", headers)
-            @connect = _receive(s)
-            # replay any subscriptions.
-            @subscriptions.each { |k,v| _transmit(s, "SUBSCRIBE", v) }
+            used_socket = open_socket
+            # Open complete
+            
+            connect(used_socket)
             
             @connection_attempts = 0
           rescue
-            @failure = $!;
-            s=nil;
+            @failure = $!
+            used_socket = nil
             raise unless @reliable
-            $stderr.print "connect to #{@host} failed: " + $! +" will retry(##{@connection_attempts}) in #{@reconnect_delay}\n";
+            $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
 
-            raise "Max number of reconnection attempts reached" if max_reconnect_attempts?
+            raise Stomp::Error::MaxReconnectAttempts if max_reconnect_attempts?
 
-            sleep(@reconnect_delay);
+            sleep(@reconnect_delay)
             
             @connection_attempts += 1
             
@@ -127,86 +129,28 @@ module Stomp
             end
           end
         end
-        @socket = s
-        return s;
-      #end
-    end
-    
-    def connected?
-      begin
-        test_socket = TCPSocket.open @host, @port
-        test_socket.close
-        open?
-      rescue
-        false
+        @socket = used_socket
       end
     end
-    
-    def close_socket
-      begin
-        @socket.close
-      rescue
-        #Ignoring if already closed
-      end
-      
-      @closed = true
-    end
-    
-    def open_socket
-      return TCPSocket.open @host, @port unless @ssl
-        
-        ssl_socket
-    end
-  
-    def ssl_socket
-      require 'openssl' unless defined?(OpenSSL)
-      
-      ctx = OpenSSL::SSL::SSLContext.new
-        
-        # For client certificate authentication:
-        # key_path = ENV["STOMP_KEY_PATH"] || "~/stomp_keys"
-        # ctx.cert = OpenSSL::X509::Certificate.new("#{key_path}/client.cer")
-        # ctx.key = OpenSSL::PKey::RSA.new("#{key_path}/client.keystore")
-        
-        # For server certificate authentication:
-        # truststores = OpenSSL::X509::Store.new
-        # truststores.add_file("#{key_path}/client.ts")
-        # ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        # ctx.cert_store = truststores
-        
-        ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE  
-        
-      tcp_socket = TCPSocket.new @host, @port
-      ssl = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx)
-      ssl.connect
-      ssl
-    end
   
     def refine_params(params)
-      params = uncamelized_sym_keys(params)
+      params = params.uncamelize_and_symbolize_keys
       
-      {
+      default_params = {
+        :connect_headers => {},
+        # Failover parameters
         :initial_reconnect_delay => 0.01,
         :max_reconnect_delay => 30.0,
         :use_exponential_back_off => true,
         :back_off_multiplier => 2,
         :max_reconnect_attempts => 0,
         :randomize => false,
-        :connect_headers => {},
         :backup => false,
         :timeout => -1
-      }.merge(params)
-        
-    end
-    
-    def uncamelized_sym_keys(params)
-      uncamelized = {}
-      params.each_pair do |key, value|
-        key = key.to_s.split(/(?=[A-Z])/).join('_').downcase.to_sym
-        uncamelized[key] = value
-      end
+      }
       
-      uncamelized
+      default_params.merge(params)
+        
     end
     
     def change_host
@@ -218,18 +162,12 @@ module Stomp
       
       @ssl = current_host[:ssl]
       @host = current_host[:host]
-      @port = current_host[:port] || default_port(@ssl)
+      @port = current_host[:port] || Connection::default_port(@ssl)
       @login = current_host[:login] || ""
       @passcode = current_host[:passcode] || ""
       
     end
     
-    def default_port(ssl)
-      return 61612 if ssl
-      
-      61613
-    end
-    
     def max_reconnect_attempts?
       !(@parameters.nil? || @parameters[:max_reconnect_attempts].nil?) && @parameters[:max_reconnect_attempts] != 0 && @connection_attempts > @parameters[:max_reconnect_attempts]
     end
@@ -303,16 +241,56 @@ module Stomp
 
     # Send message to destination
     #
+    # To disable content length header ( :suppress_content_length => true )
     # Accepts a transaction header ( :transaction => 'some_transaction_id' )
     def send(destination, message, headers = {})
       headers[:destination] = destination
       transmit("SEND", headers, message)
     end
+    
+    # Send a message back to the source or to the dead letter queue
+    #
+    # Accepts a dead letter queue option ( :dead_letter_queue => "/queue/DLQ" )
+    # Accepts a limit number of redeliveries option ( :max_redeliveries => 6 )
+    def unreceive(message, options = {})
+      options = { :dead_letter_queue => "/queue/DLQ", :max_redeliveries => 6 }.merge options
+      # Lets make sure all keys are symbols
+      message.headers = message.headers.symbolize_keys
+      
+      retry_count = message.headers[:retry_count].to_i || 0
+      message.headers[:retry_count] = retry_count + 1
+      transaction_id = "transaction-#{message.headers[:'message-id']}-#{retry_count}"
+      
+      begin
+        self.begin transaction_id
+        
+        if client_ack?(message)
+          self.ack(message.headers[:'message-id'], :transaction => transaction_id)
+        end
+        
+        if retry_count <= options[:max_redeliveries]
+          self.send(message.headers[:destination], message.body, message.headers.merge(:transaction => transaction_id))
+        else
+          # Poison ack, sending the message to the DLQ
+          self.send(options[:dead_letter_queue], message.body, message.headers.merge(:transaction => transaction_id, :persistent => true))
+        end
+        self.commit transaction_id
+      rescue Exception => exception
+        self.abort transaction_id
+        raise exception
+      end
+    end
+    
+    def client_ack?(message)
+      headers = @subscriptions[message.headers[:destination]]
+      !headers.nil? && headers[:ack] == "client"
+    end
 
     # Close this connection
     def disconnect(headers = {})
       transmit("DISCONNECT", headers)
-      
+      headers = headers.symbolize_keys
+      @disconnect_receipt = receive if headers[:receipt]
       close_socket
     end
 
@@ -321,7 +299,7 @@ module Stomp
     def poll
       @read_semaphore.synchronize do
         return nil if @socket.nil? || !@socket.ready?
-        return receive
+        receive
       end
     end
 
@@ -330,93 +308,172 @@ module Stomp
       # The recive my fail so we may need to retry.
       while TRUE
         begin
-          s = socket
-          return _receive(s)
+          used_socket = socket
+          return _receive(used_socket)
         rescue
-          @failure = $!;
+          @failure = $!
           raise unless @reliable
-          $stderr.print "receive failed: " + $!;
+          $stderr.print "receive failed: #{$!}"
         end
       end
     end
 
     def receive
-      super_result = __old_receive()
+      super_result = __old_receive
       if super_result.nil? && @reliable
         $stderr.print "connection.receive returning EOF as nil - resetting connection.\n"
         @socket = nil
-        super_result = __old_receive()
+        super_result = __old_receive
       end
       return super_result
     end
 
     private
 
-      def _receive( s )
-        line = ' '
+      def _receive( read_socket )
         @read_semaphore.synchronize do
-          line = s.gets while line =~ /^\s*$/
+          line = read_socket.gets
           return nil if line.nil?
 
-          message = Message.new do |m|
-            m.command = line.chomp
-            m.headers = {}
-            until (line = s.gets.chomp) == ''
-              k = (line.strip[0, line.strip.index(':')]).strip
-              v = (line.strip[line.strip.index(':') + 1, line.strip.length]).strip
-              m.headers[k] = v
-            end
+          # If the reading hangs for more than 5 seconds, abort the parsing process
+          Timeout::timeout(5, Stomp::Error::PacketParsingTimeout) do
+            # Reads the beginning of the message until it runs into a empty line
+            message_header = ''
+            begin
+              message_header += line
+              line = read_socket.gets
+            end until line =~ /^\s?\n$/
+
+            # Checks if it includes content_length header
+            content_length = message_header.match /content-length\s?:\s?(\d+)\s?\n/
+            message_body = ''
 
-            if (m.headers['content-length'])
-              m.body = s.read m.headers['content-length'].to_i
-              c = RUBY_VERSION > '1.9' ? s.getc.ord : s.getc
-              raise "Invalid content length received" unless c == 0
+            # If it does, reads the specified amount of bytes
+            char = ''
+            if content_length
+              message_body = read_socket.read content_length[1].to_i
+              raise Stomp::Error::InvalidMessageLength unless parse_char(read_socket.getc) == "\0"
+            # Else reads, the rest of the message until the first \0
             else
-              m.body = ''
-              if RUBY_VERSION > '1.9'
-                until (c = s.getc.ord) == 0
-                  m.body << c.chr
-                end
-              else
-                until (c = s.getc) == 0
-                  m.body << c.chr
-                end
-              end
+              message_body += char while read_socket.ready? && (char = parse_char(read_socket.getc)) != "\0"
             end
-            #c = s.getc
-            #raise "Invalid frame termination received" unless c == 10
-          end # message
-          return message
 
+            # If the buffer isn't empty, reads the next char and returns it to the buffer
+            # unless it's a \n
+            if read_socket.ready?
+              last_char = read_socket.getc
+              read_socket.ungetc(last_char) if parse_char(last_char) != "\n"
+            end
+
+            # Adds the excluded \n and \0 and tries to create a new message with it
+            Message.new(message_header + "\n" + message_body + "\0")
+          end
         end
       end
 
+      def parse_char(char)
+        RUBY_VERSION > '1.9' ? char : char.chr
+      end
+
       def transmit(command, headers = {}, body = '')
         # The transmit may fail so we may need to retry.
         while TRUE
           begin
-            s = socket
-            _transmit(s, command, headers, body)
+            used_socket = socket
+            _transmit(used_socket, command, headers, body)
             return
           rescue
-            @failure = $!;
+            @failure = $!
             raise unless @reliable
-            $stderr.print "transmit to #{@host} failed: " + $!+"\n";
+            $stderr.print "transmit to #{@host} failed: #{$!}\n"
           end
         end
       end
 
-      def _transmit(s, command, headers = {}, body = '')
+      def _transmit(used_socket, command, headers = {}, body = '')
         @transmit_semaphore.synchronize do
-          s.puts command
-          headers.each {|k,v| s.puts "#{k}:#{v}" }
-          s.puts "content-length: #{body.length}"
-          s.puts "content-type: text/plain; charset=UTF-8"
-          s.puts
-          s.write body
-          s.write "\0"
+          # ActiveMQ interprets every message as a BinaryMessage 
+          # if content_length header is included. 
+          # Using :suppress_content_length => true will suppress this behaviour
+          # and ActiveMQ will interpret the message as a TextMessage.
+          # For more information refer to http://juretta.com/log/2009/05/24/activemq-jms-stomp/
+          suppress_content_length = headers.delete :suppress_content_length
+          headers['content-length'] = "#{body.length}" unless suppress_content_length
+          
+          used_socket.puts command  
+          headers.each {|k,v| used_socket.puts "#{k}:#{v}" }
+          used_socket.puts "content-type: text/plain; charset=UTF-8"
+          used_socket.puts
+          used_socket.write body
+          used_socket.write "\0"
         end
       end
+      
+      def open_tcp_socket
+        tcp_socket = TCPSocket.open @host, @port
+        def tcp_socket.ready?
+          r,w,e = IO.select([self],nil,nil,0)
+          ! r.nil?
+        end
+
+        tcp_socket
+      end
+
+      def open_ssl_socket
+        require 'openssl' unless defined?(OpenSSL)
+        ctx = OpenSSL::SSL::SSLContext.new
+
+        # For client certificate authentication:
+        # key_path = ENV["STOMP_KEY_PATH"] || "~/stomp_keys"
+        # ctx.cert = OpenSSL::X509::Certificate.new("#{key_path}/client.cer")
+        # ctx.key = OpenSSL::PKey::RSA.new("#{key_path}/client.keystore")
+
+        # For server certificate authentication:
+        # truststores = OpenSSL::X509::Store.new
+        # truststores.add_file("#{key_path}/client.ts")
+        # ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        # ctx.cert_store = truststores
+
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE  
+
+        ssl = OpenSSL::SSL::SSLSocket.new(open_tcp_socket, ctx)
+        def ssl.ready?
+          ! @rbuffer.empty? || @io.ready?
+        end
+        ssl.connect
+        ssl
+      end
+      
+      def close_socket
+        begin
+          @socket.close
+        rescue
+          #Ignoring if already closed
+        end
+
+        @closed = true
+      end
+
+      def open_socket
+        used_socket = @ssl ? open_ssl_socket : open_tcp_socket
+        # try to close the old connection if any
+        close_socket
+        
+        @closed = false
+        
+        used_socket
+      end
+      
+      def connect(used_socket)
+        headers = @connect_headers.clone
+        headers[:login] = @login
+        headers[:passcode] = @passcode
+        _transmit(used_socket, "CONNECT", headers)
+        @connection_frame = _receive(used_socket)
+        @disconnect_receipt = nil
+        # replay any subscriptions.
+        @subscriptions.each { |k,v| _transmit(used_socket, "SUBSCRIBE", v) }
+      end
 
   end
 

data/lib/stomp/errors.rb

@@ -0,0 +1,27 @@
+module Stomp
+  module Error
+    class InvalidFormat < RuntimeError
+      def message
+        "Invalid message - invalid format"
+      end
+    end
+
+    class InvalidMessageLength < RuntimeError
+      def message
+        "Invalid content length received"
+      end
+    end
+
+    class PacketParsingTimeout < RuntimeError
+      def message
+        "Packet parsing timeout"
+      end
+    end
+    
+    class MaxReconnectAttempts < RuntimeError
+      def message
+        "Maximum number of reconnection attempts reached"
+      end
+    end
+  end
+end

data/lib/stomp/ext/hash.rb

@@ -0,0 +1,24 @@
+class ::Hash
+  def uncamelize_and_symbolize_keys
+    self.uncamelize_and_stringify_keys.symbolize_keys
+  end
+
+  def uncamelize_and_stringify_keys
+    uncamelized = {}
+    self.each_pair do |key, value|
+      new_key = key.to_s.split(/(?=[A-Z])/).join('_').downcase
+      uncamelized[new_key] = value
+    end
+
+    uncamelized
+  end
+
+  def symbolize_keys
+    symbolized = {}
+    self.each_pair do |key, value|
+      symbolized[key.to_sym] = value
+    end
+
+    symbolized
+  end unless self.respond_to? :symbolize_keys
+end

data/lib/stomp/message.rb

@@ -2,16 +2,48 @@ module Stomp
 
   # Container class for frames, misnamed technically
   class Message
-    attr_accessor :headers, :body, :command
+    attr_accessor :command, :headers, :body, :original
 
-    def initialize
-      yield(self) if block_given?
+    def initialize(message)
+      # Set default empty values
+      self.command = ''
+      self.headers = {}
+      self.body = ''
+      self.original = message
+      return self if is_blank?(message)
+
+      # Parse the format of the received stomp message
+      parse = message.match /^(CONNECTED|MESSAGE|RECEIPT|ERROR)\n(.*?)\n\n(.*)\0\n?$/m
+      raise Stomp::Error::InvalidFormat if parse.nil?
+
+      # Set the message values
+      self.command = parse[1]
+      self.headers = {}
+      parse[2].split("\n").map do |value|
+        parsed_value = value.match /^([\w|-]*):(.*)$/
+        self.headers[parsed_value[1].strip] = parsed_value[2].strip if parsed_value
+      end
+
+      body_length = -1
+      if self.headers['content-length']
+        body_length = self.headers['content-length'].to_i
+        raise Stomp::Error::InvalidMessageLength if parse[3].length != body_length
+      end
+      self.body = parse[3][0..body_length]
     end
 
     def to_s
       "<Stomp::Message headers=#{headers.inspect} body='#{body}' command='#{command}' >"
     end
+
+    def empty?
+      is_blank?(command) && is_blank?(headers) && is_blank?(body)
+    end
+
+    private
+      def is_blank?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
   end
 
 end
-

data/test/test_client.rb

@@ -1,27 +1,28 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
 class TestClient < Test::Unit::TestCase
-
+  include TestBase
+  
   def setup
-    @client = Stomp::Client.new("test", "user", "localhost", 61613)
+    @client = Stomp::Client.new(user, passcode, host, port)
   end
 
   def teardown
-    @client.close
+    @client.close if @client # allow tests to close
   end
 
-  def message_text
-    "test_client#" + name()
-  end
+  def test_ack_api_works
+    @client.send destination, message_text, {:suppress_content_length => true}
 
-  def destination
-    "/queue/test/ruby/client/" + name()
-  end
+    received = nil
+    @client.subscribe(destination, {:ack => 'client'}) {|msg| received = msg}
+    sleep 0.01 until received
+    assert_equal message_text, received.body
 
-  def test_subscribe_requires_block
-    assert_raise(RuntimeError) do
-      @client.subscribe destination
-    end
+    receipt = nil
+    @client.acknowledge(received) {|r| receipt = r}
+    sleep 0.01 until receipt
+    assert_not_nil receipt.headers['receipt-id']
   end
 
   def test_asynch_subscribe
@@ -33,20 +34,6 @@ class TestClient < Test::Unit::TestCase
     assert_equal message_text, received.body
   end
 
-  def test_ack_api_works
-    @client.send destination, message_text
-
-    received = nil
-    @client.subscribe(destination, :ack => 'client') {|msg| received = msg}
-    sleep 0.01 until received
-    assert_equal message_text, received.body
-
-    receipt = nil
-    @client.acknowledge(received) {|r| receipt = r}
-    sleep 0.01 until receipt
-    assert_not_nil receipt.headers['receipt-id']
-  end
-
   # BROKEN
   def test_noack
     @client.send destination, message_text
@@ -59,7 +46,7 @@ class TestClient < Test::Unit::TestCase
 
     # was never acked so should be resent to next client
 
-    @client = Stomp::Client.new("test", "user", "localhost", 61613)
+    @client = Stomp::Client.new(user, passcode, host, port)
     received = nil
     @client.subscribe(destination) {|msg| received = msg}
     sleep 0.01 until received
@@ -78,6 +65,16 @@ class TestClient < Test::Unit::TestCase
     assert_equal message_text, message.body
   end
 
+  def test_disconnect_receipt
+    @client.close :receipt => "xyz789"
+    assert_nothing_raised {
+      assert_not_nil(@client.disconnect_receipt, "should have a receipt")
+      assert_equal(@client.disconnect_receipt.headers['receipt-id'],
+        "xyz789", "receipt sent and received should match")
+    }
+    @client = nil
+  end
+
   def test_send_then_sub
     @client.send destination, message_text
     message = nil
@@ -87,6 +84,12 @@ class TestClient < Test::Unit::TestCase
     assert_equal message_text, message.body
   end
 
+  def test_subscribe_requires_block
+    assert_raise(RuntimeError) do
+      @client.subscribe destination
+    end
+  end
+
   def test_transactional_send
     @client.begin 'tx1'
     @client.send destination, message_text, :transaction => 'tx1'
@@ -142,18 +145,6 @@ class TestClient < Test::Unit::TestCase
     @client.commit 'tx2'
   end
 
-  def test_unsubscribe
-    message = nil
-    client = Stomp::Client.new("test", "user", "localhost", 61613, true)
-    client.subscribe(destination, :ack => 'client') { |m| message = m }
-    @client.send destination, message_text
-    Timeout::timeout(4) do
-      sleep 0.01 until message
-    end
-    client.unsubscribe destination # was throwing exception on unsub at one point
-
-  end
-
   def test_transaction_with_client_side_redelivery
     @client.send destination, message_text
 
@@ -177,6 +168,29 @@ class TestClient < Test::Unit::TestCase
     @client.acknowledge message, :transaction => 'tx2'
     @client.commit 'tx2'
   end
+  
+  def test_connection_frame
+  	assert_not_nil @client.connection_frame
+  end
 
+  def test_unsubscribe
+    message = nil
+    client = Stomp::Client.new(user, passcode, host, port, true)
+    client.subscribe(destination, :ack => 'client') { |m| message = m }
+    @client.send destination, message_text
+    Timeout::timeout(4) do
+      sleep 0.01 until message
+    end
+    client.unsubscribe destination # was throwing exception on unsub at one point
+
+  end
 
+  private
+    def message_text
+      "test_client#" + name
+    end
+
+    def destination
+      "/queue/test/ruby/client/" + name
+    end
 end

data/test/test_connection.rb

@@ -1,38 +1,14 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
 class TestStomp < Test::Unit::TestCase
-
+  include TestBase
+  
   def setup
-    @conn = Stomp::Connection.open("test", "user", "localhost", 61613)
+    @conn = Stomp::Connection.open(user, passcode, host, port)
   end
 
   def teardown
-    @conn.disconnect
-  end
-
-  def make_destination
-    "/queue/test/ruby/stomp/" + name()
-  end
-
-  def _test_transaction
-    @conn.subscribe make_destination
-
-    # Drain the destination.
-    sleep 0.01 while
-    sleep 0.01 while @conn.poll!=nil
-
-    @conn.begin "tx1"
-    @conn.send make_destination, "txn message", 'transaction' => "tx1"
-
-    @conn.send make_destination, "first message"
-
-    sleep 0.01
-    msg = @conn.receive
-    assert_equal "first message", msg.body
-
-    @conn.commit "tx1"
-    msg = @conn.receive
-    assert_equal "txn message", msg.body
+    @conn.disconnect if @conn # allow tests to disconnect
   end
 
   def test_connection_exists
@@ -52,6 +28,16 @@ class TestStomp < Test::Unit::TestCase
     assert_equal "abc", msg.headers['receipt-id']
   end
 
+  def test_disconnect_receipt
+    @conn.disconnect :receipt => "abc123"
+    assert_nothing_raised {
+      assert_not_nil(@conn.disconnect_receipt, "should have a receipt")
+      assert_equal(@conn.disconnect_receipt.headers['receipt-id'],
+        "abc123", "receipt sent and received should match")
+    }
+    @conn = nil
+  end
+
   def test_client_ack_with_symbol
     @conn.subscribe make_destination, :ack => :client
     @conn.send make_destination, "test_stomp#test_client_ack_with_symbol"
@@ -91,5 +77,57 @@ class TestStomp < Test::Unit::TestCase
     msg = @conn.receive
     assert_match /^<Stomp::Message headers=/ , msg.to_s
   end
+  
+  def test_connection_frame
+  	assert_not_nil @conn.connection_frame
+  end
+  
+  def test_messages_with_multipleLine_ends
+    @conn.subscribe make_destination
+    @conn.send make_destination, "a\n\n"
+    @conn.send make_destination, "b\n\na\n\n"
+    
+    msg_a = @conn.receive
+    msg_b = @conn.receive
+
+    assert_equal "a\n\n", msg_a.body
+    assert_equal "b\n\na\n\n", msg_b.body
+  end
+
+  def test_send_two_messages
+    @conn.subscribe make_destination
+    @conn.send make_destination, "a\0"
+    @conn.send make_destination, "b\0"
+    msg_a = @conn.receive
+    msg_b = @conn.receive
+
+    assert_equal "a\0", msg_a.body
+    assert_equal "b\0", msg_b.body
+  end
+
+  private
+    def make_destination
+      "/queue/test/ruby/stomp/" + name
+    end
+
+    def _test_transaction
+      @conn.subscribe make_destination
+
+      # Drain the destination.
+      sleep 0.01 while
+      sleep 0.01 while @conn.poll!=nil
+
+      @conn.begin "tx1"
+      @conn.send make_destination, "txn message", 'transaction' => "tx1"
+
+      @conn.send make_destination, "first message"
+
+      sleep 0.01
+      msg = @conn.receive
+      assert_equal "first message", msg.body
 
+      @conn.commit "tx1"
+      msg = @conn.receive
+      assert_equal "txn message", msg.body
+    end
 end

data/test/test_helper.rb

@@ -1,5 +1,24 @@
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
 require 'test/unit'
 require 'timeout'
 require 'stomp'
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+# Helper routines
+module TestBase
+  def user
+    ENV['STOMP_USER'] || "test"
+  end
+  def passcode
+    ENV['STOMP_PASSCODE'] || "user"
+  end
+  # Get host
+  def host
+    ENV['STOMP_HOST'] || "localhost"
+  end
+  # Get port
+  def port
+    (ENV['STOMP_PORT'] || 61613).to_i
+  end
+end
 

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: stomp
 version: !ruby/object:Gem::Version 
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors: 
 - Brian McCallister
 - Marius Mathiesen
+- Thiago Morello
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-12-03 00:00:00 -02:00
+date: 2010-02-09 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -18,6 +19,7 @@ description: Ruby client for the Stomp messaging protocol
 email: 
 - brianm@apache.org
 - marius@stones.com
+- morellon@gmail.com
 executables: 
 - catstomp
 - stompcat
@@ -36,6 +38,8 @@ files:
 - lib/stomp/client.rb
 - lib/stomp/connection.rb
 - lib/stomp/message.rb
+- lib/stomp/errors.rb
+- lib/stomp/ext/hash.rb
 - test/test_client.rb
 - test/test_connection.rb
 - test/test_helper.rb