Merge lp:~elmo/ubuntu/oneiric/libstomp-ruby/bug-707317 into lp:ubuntu/oneiric/libstomp-ruby

[James Troup]

New upstream version, required for mcollective and also fixes LP
#707317 and Debian #598564.

[Stefano Rivera (stefanor)]

I know little about Debian ruby packaging. But I can spot some issues:
* The version number really should be 1.1.9-0ubuntu1.
* We shouldn't change source format just because we don't have any packages.
* E: libstomp-ruby: ruby-script-but-no-ruby-dep usr/bin/catstomp
  E: libstomp-ruby: ruby-script-but-no-ruby-dep usr/bin/stompcat

review: Needs Fixing

[James Troup (elmo)]

Stefano Rivera <email address hidden> writes:

> * The version number really should be 1.1.9-0ubuntu1.

Even if I NMU it into Debian? ;-)

> * We shouldn't change source format just because we don't have any
> packages.

I assume you mean patches? If so, sorry, but why not? There are no
upstream changes anymore so making it source format 1 makes it easier to
backport to older distributions and AFAICS doesn't have any negative
side effects. What am I missing?

> * E: libstomp-ruby: ruby-script-but-no-ruby-dep usr/bin/catstomp
> E: libstomp-ruby: ruby-script-but-no-ruby-dep usr/bin/stompcat

Well, it has an indirect dependency via libstomp-ruby1.8 |
libstomp-ruby1.9.1. I guess I can make it an explicit dependency, if
you want.

--
James

[Stefano Rivera (stefanor)]

> Even if I NMU it into Debian? ;-)

Then the changelog would say "Non-maintainer upload." :)

> I assume you mean patches? If so, sorry, but why not?

Yeah, that's what I meant. Just because we don't like to deviate unnecessarily from Debian. I wouldn't change source format in an NMU either (but then I guess I'm pretty conservative when touching other people's packages in Debian).

One of the advantages of 3.0 (quilt) is that you don't need to add a patch system to add a patch neatly, it's already there.

IIRC 3.0 (quilt) is supported all the way back to etch, so backporting shouldn't be a big deal either.

The indirect dependency is fine with me (esp. as I prefer not deviating unnecessarily in Ubuntu). The python helpers provide dependencies on python I'd have expected the same for ruby, but as I said I'm completely unfamiliar with it.

[Dave Walker (davewalker)]

Hi James,

I agree that dropping the patch system is a bit of a pain if we need to introduce patches; particularly for SRU's where *adding* a patch system is frowned upon (traditionally favouring directly applying the patches!). I also thought there was a drive to try and get Debian packages to 3.0 ($something).

Anyway, *I* would favour trying to stay with 3.0 (quilt).. However, I don't care that strongly. If you NMU this to Debian then i care even less; as i'll sync whatever you put there making this branch obsolete.

This is currently blocking mcollective installation on Oneiric, so please update on what you want to do; and lets get it done.

Thanks.

review: Needs Information

[Chris Halse Rogers (raof)]

I'm marking this as In Progress to drop it off the sponsorship queue - it sounds like this is going to be resolved by NMUing this package into Debian and then syncing to Ubuntu. If that's the case, this merge request can be deleted.

If that's not the case, then the comments above apply :)

[James Troup (elmo)]

> I know little about Debian ruby packaging. But I can spot some issues:
> * The version number really should be 1.1.9-0ubuntu1.
> * We shouldn't change source format just because we don't have any packages.
> * E: libstomp-ruby: ruby-script-but-no-ruby-dep usr/bin/catstomp
> E: libstomp-ruby: ruby-script-but-no-ruby-dep usr/bin/stompcat

I've pushed r10 which fixes all of the above issues.

review: Needs Resubmitting

[Dave Walker (davewalker)]

Thanks for addressing this, uploading now!

review: Approve

=== added file '.gitignore'
--- .gitignore	1970-01-01 00:00:00 +0000
+++ .gitignore	2011-07-31 16:48:34 +0000
@@ -0,0 +1,5 @@
+pkg/*
+doc/*
+coverage/*
+*.gem
+

=== added directory '.pc'
=== removed directory '.pc'
=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2011-07-31 16:48:34 +0000
@@ -0,0 +1,1 @@
+2

=== removed file '.pc/.version'
--- .pc/.version	2010-09-28 00:25:39 +0000
+++ .pc/.version	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-2

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2010-09-28 00:25:39 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-getc_returns_a_string_1.9.patch
-case_statement_compatible_1.9.2.patch

=== removed directory '.pc/case_statement_compatible_1.9.2.patch'
=== removed directory '.pc/case_statement_compatible_1.9.2.patch/lib'
=== removed file '.pc/case_statement_compatible_1.9.2.patch/lib/stomp.rb'
--- .pc/case_statement_compatible_1.9.2.patch/lib/stomp.rb	2010-09-28 00:25:39 +0000
+++ .pc/case_statement_compatible_1.9.2.patch/lib/stomp.rb	1970-01-01 00:00:00 +0000
@@ -1,422 +0,0 @@
-#   Copyright 2005-2006 Brian McCallister
-#   Copyright 2006 LogicBlaze Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-require 'io/wait'
-require 'socket'
-require 'thread'
-
-module Stomp
-
-  # Low level connection which maps commands and supports
-  # synchronous receives
-  class Connection
-
-    def Connection.open(login = "", passcode = "", host='localhost', port=61613, reliable=FALSE, reconnectDelay=5)
-      Connection.new login, passcode, host, port, reliable, reconnectDelay        
-    end
-
-    # Create a connection, requires a login and passcode.
-    # Can accept a host (default is localhost), and port
-    # (default is 61613) to connect to
-    def initialize(login, passcode, host='localhost', port=61613, reliable=false, reconnectDelay=5)
-      @host = host
-      @port = port
-      @login = login
-      @passcode = passcode
-      @transmit_semaphore = Mutex.new
-      @read_semaphore = Mutex.new
-      @socket_semaphore = Mutex.new
-      @reliable = reliable
-      @reconnectDelay = reconnectDelay
-      @closed = FALSE
-      @subscriptions = {}
-      @failure = NIL
-      socket
-    end
-  
-    def socket
-      # Need to look into why the following synchronize does not work.
-      #@read_semaphore.synchronize do
-        s = @socket;
-        while s == NIL or @failure != NIL
-          @failure = NIL
-          begin
-            s = TCPSocket.open @host, @port
-            _transmit(s, "CONNECT", {:login => @login, :passcode => @passcode})
-            @connect = _receive(s)                        
-            # replay any subscriptions.
-            @subscriptions.each { |k,v| _transmit(s, "SUBSCRIBE", v) }
-          rescue 
-            @failure = $!;
-            s=NIL;
-            raise unless @reliable
-            $stderr.print "connect failed: " + $! +" will retry in #{@reconnectDelay}\n";                
-            sleep(@reconnectDelay);
-          end
-        end
-        @socket = s
-        return s;
-      #end
-    end
-  
-    # Is this connection open?
-    def open?
-      !@closed
-    end
-  
-    # Is this connection closed?
-    def closed?
-      @closed
-    end
-  
-    # Begin a transaction, requires a name for the transaction
-    def begin name, headers={}
-      headers[:transaction] = name
-      transmit "BEGIN", headers
-    end
-  
-    # Acknowledge a message, used then a subscription has specified 
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def ack message_id, headers={}
-      headers['message-id'] = message_id
-      transmit "ACK", headers
-    end
-      
-    # Commit a transaction by name
-    def commit name, headers={}
-      headers[:transaction] = name
-      transmit "COMMIT", headers
-    end
-
-    # Abort a transaction by name
-    def abort name, headers={}
-      headers[:transaction] = name
-      transmit "ABORT", headers
-    end
-  
-    # Subscribe to a destination, must specify a name
-    def subscribe(name, headers = {}, subId=NIL)
-      headers[:destination] = name
-      transmit "SUBSCRIBE", headers
-      
-      # Store the sub so that we can replay if we reconnect.
-      if @reliable
-        subId = name if subId==NIL
-        @subscriptions[subId]=headers
-      end
-    end
-  
-    # Unsubscribe from a destination, must specify a name
-    def unsubscribe(name, headers = {}, subId=NIL)
-      headers[:destination] = name
-      transmit "UNSUBSCRIBE", headers
-      if @reliable
-        subId = name if subId==NIL
-        @subscriptions.delete(subId)
-      end
-    end
-  
-    # Send message to destination
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send(destination, message, headers={})
-      headers[:destination] = destination
-      transmit "SEND", headers, message
-    end
-  
-    # Close this connection
-    def disconnect(headers = {})
-      transmit "DISCONNECT", headers
-    end
-  
-    # Return a pending message if one is available, otherwise
-    # return nil
-    def poll
-      @read_semaphore.synchronize do
-        return nil if @socket==NIL or !@socket.ready?
-        return receive
-      end
-    end
-      
-    # Receive a frame, block until the frame is received
-    def __old_receive
-      # The recive my fail so we may need to retry.
-      while TRUE
-        begin
-          s = socket
-          return _receive(s)
-        rescue 
-          @failure = $!;
-          raise unless @reliable
-          $stderr.print "receive failed: " + $!;
-        end
-      end
-    end
-    
-    def 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()
-      end         
-      return super_result
-    end
-
-    private
-    def _receive( s )
-      line = ' '
-      @read_semaphore.synchronize do
-        line = s.gets while line =~ /^\s*$/
-        return NIL if line == NIL
-        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 (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
-          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
-          end
-          #c = s.getc
-          #raise "Invalid frame termination received" unless c == 10
-        end
-      end
-    end
-
-    private
-    def transmit(command, headers={}, body='')
-      # The transmit my fail so we may need to retry.
-      while TRUE
-        begin
-          s = socket
-          _transmit(s, command, headers, body)
-          return
-        rescue
-          @failure = $!;
-          raise unless @reliable
-          $stderr.print "transmit failed: " + $!+"\n";
-        end
-      end
-    end
-      
-    private
-    def _transmit(s, 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"
-      end
-    end
-  end
-
-  # Container class for frames, misnamed technically
-  class Message
-    attr_accessor :headers, :body, :command
-    
-    def initialize
-      yield(self) if block_given?
-    end
-    
-    def to_s
-      "<Stomp::Message headers=#{headers.inspect} body='#{body}' command='#{command}' >"
-    end
-  end
-
-  # Typical Stomp client class. Uses a listener thread to receive frames
-  # from the server, any thread can send.
-  #
-  # Receives all happen in one thread, so consider not doing much processing
-  # in that thread if you have much message volume.
-  class Client
-
-    # Accepts a username (default ""), password (default ""), 
-    # host (default localhost), and port (default 61613)
-    def initialize user="", pass="", host="localhost", port=61613, reliable=false
-      if user =~ /stomp:\/\/(\w+):(\d+)/
-        user = ""
-        pass = ""
-        host = $1
-        port = $2
-        reliable = false
-      elsif user =~ /stomp:\/\/(\w+):(\w+)@(\w+):(\d+)/
-        user = $1
-        pass = $2
-        host = $3
-        port = $4
-        reliable = false
-      end
-      
-      @id_mutex = Mutex.new
-      @ids = 1
-      @connection = Connection.open user, pass, host, port, reliable
-      @listeners = {}
-      @receipt_listeners = {}
-      @running = true
-      @replay_messages_by_txn = Hash.new
-      @listener_thread = Thread.start do
-        while @running
-          message = @connection.receive
-          case
-          when message == NIL:
-            break
-          when message.command == 'MESSAGE': 
-            if listener = @listeners[message.headers['destination']]
-              listener.call(message)
-            end
-          when message.command == 'RECEIPT':
-            if listener = @receipt_listeners[message.headers['receipt-id']]
-              listener.call(message)
-            end
-          end
-        end
-      end
-    end
-    
-    # Join the listener thread for this client,
-    # generally used to wait for a quit signal
-    def join
-      @listener_thread.join
-    end
-
-    # Accepts a username (default ""), password (default ""), 
-    # host (default localhost), and port (default 61613)
-    def self.open user="", pass="", host="localhost", port=61613, reliable=false
-      Client.new user, pass, host, port, reliable
-    end
-
-    # Begin a transaction by name
-    def begin name, headers={}
-      @connection.begin name, headers
-    end
-
-    # Abort a transaction by name
-    def abort name, headers={}
-      @connection.abort name, headers
-
-      # lets replay any ack'd messages in this transaction      
-      replay_list = @replay_messages_by_txn[name]
-      if replay_list
-        replay_list.each do |message| 
-          if listener = @listeners[message.headers['destination']]
-            listener.call(message)
-          end
-        end
-      end
-    end
-
-    # Commit a transaction by name
-    def commit name, headers={}
-      txn_id = headers[:transaction]
-      @replay_messages_by_txn.delete(txn_id)
-      @connection.commit name, headers
-    end
-    
-    # Subscribe to a destination, must be passed a block 
-    # which will be used as a callback listener
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def subscribe destination, headers={}
-      raise "No listener given" unless block_given?
-      @listeners[destination] = lambda {|msg| yield msg}
-      @connection.subscribe destination, headers
-    end
-
-    # Unsubecribe from a channel
-    def unsubscribe name, headers={}
-      @connection.unsubscribe name, headers
-      @listeners[name] = nil
-    end
-
-    # Acknowledge a message, used then a subscription has specified 
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def acknowledge message, headers={}
-      txn_id = headers[:transaction]
-      if txn_id
-        # lets keep around messages ack'd in this transaction in case we rollback
-        replay_list = @replay_messages_by_txn[txn_id]
-        if replay_list == nil
-          replay_list = []
-          @replay_messages_by_txn[txn_id] = replay_list
-        end
-        replay_list << message
-      end
-      if block_given?
-        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
-      end
-      @connection.ack message.headers['message-id'], headers
-    end
-
-    # Send message to destination
-    #
-    # If a block is given a receipt will be requested and passed to the 
-    # block on receipt
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send destination, message, headers = {}
-      if block_given?
-        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
-      end
-      @connection.send destination, message, headers
-    end
-
-    # Is this client open?
-    def open?
-      @connection.open?
-    end
-    
-    # Close out resources in use by this client
-    def close
-      @connection.disconnect
-      @running = false 
-    end
-
-    private
-    def register_receipt_listener listener
-      id = -1
-      @id_mutex.synchronize do
-        id = @ids.to_s
-        @ids = @ids.succ
-      end
-      @receipt_listeners[id] = listener
-      id
-    end
-        
-  end
-end

=== removed directory '.pc/getc_returns_a_string_1.9.patch'
=== removed directory '.pc/getc_returns_a_string_1.9.patch/lib'
=== removed file '.pc/getc_returns_a_string_1.9.patch/lib/stomp.rb'
--- .pc/getc_returns_a_string_1.9.patch/lib/stomp.rb	2010-09-28 00:25:39 +0000
+++ .pc/getc_returns_a_string_1.9.patch/lib/stomp.rb	1970-01-01 00:00:00 +0000
@@ -1,416 +0,0 @@
-#   Copyright 2005-2006 Brian McCallister
-#   Copyright 2006 LogicBlaze Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-require 'io/wait'
-require 'socket'
-require 'thread'
-
-module Stomp
-
-  # Low level connection which maps commands and supports
-  # synchronous receives
-  class Connection
-
-    def Connection.open(login = "", passcode = "", host='localhost', port=61613, reliable=FALSE, reconnectDelay=5)
-      Connection.new login, passcode, host, port, reliable, reconnectDelay        
-    end
-
-    # Create a connection, requires a login and passcode.
-    # Can accept a host (default is localhost), and port
-    # (default is 61613) to connect to
-    def initialize(login, passcode, host='localhost', port=61613, reliable=false, reconnectDelay=5)
-      @host = host
-      @port = port
-      @login = login
-      @passcode = passcode
-      @transmit_semaphore = Mutex.new
-      @read_semaphore = Mutex.new
-      @socket_semaphore = Mutex.new
-      @reliable = reliable
-      @reconnectDelay = reconnectDelay
-      @closed = FALSE
-      @subscriptions = {}
-      @failure = NIL
-      socket
-    end
-  
-    def socket
-      # Need to look into why the following synchronize does not work.
-      #@read_semaphore.synchronize do
-        s = @socket;
-        while s == NIL or @failure != NIL
-          @failure = NIL
-          begin
-            s = TCPSocket.open @host, @port
-            _transmit(s, "CONNECT", {:login => @login, :passcode => @passcode})
-            @connect = _receive(s)                        
-            # replay any subscriptions.
-            @subscriptions.each { |k,v| _transmit(s, "SUBSCRIBE", v) }
-          rescue 
-            @failure = $!;
-            s=NIL;
-            raise unless @reliable
-            $stderr.print "connect failed: " + $! +" will retry in #{@reconnectDelay}\n";                
-            sleep(@reconnectDelay);
-          end
-        end
-        @socket = s
-        return s;
-      #end
-    end
-  
-    # Is this connection open?
-    def open?
-      !@closed
-    end
-  
-    # Is this connection closed?
-    def closed?
-      @closed
-    end
-  
-    # Begin a transaction, requires a name for the transaction
-    def begin name, headers={}
-      headers[:transaction] = name
-      transmit "BEGIN", headers
-    end
-  
-    # Acknowledge a message, used then a subscription has specified 
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def ack message_id, headers={}
-      headers['message-id'] = message_id
-      transmit "ACK", headers
-    end
-      
-    # Commit a transaction by name
-    def commit name, headers={}
-      headers[:transaction] = name
-      transmit "COMMIT", headers
-    end
-
-    # Abort a transaction by name
-    def abort name, headers={}
-      headers[:transaction] = name
-      transmit "ABORT", headers
-    end
-  
-    # Subscribe to a destination, must specify a name
-    def subscribe(name, headers = {}, subId=NIL)
-      headers[:destination] = name
-      transmit "SUBSCRIBE", headers
-      
-      # Store the sub so that we can replay if we reconnect.
-      if @reliable
-        subId = name if subId==NIL
-        @subscriptions[subId]=headers
-      end
-    end
-  
-    # Unsubscribe from a destination, must specify a name
-    def unsubscribe(name, headers = {}, subId=NIL)
-      headers[:destination] = name
-      transmit "UNSUBSCRIBE", headers
-      if @reliable
-        subId = name if subId==NIL
-        @subscriptions.delete(subId)
-      end
-    end
-  
-    # Send message to destination
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send(destination, message, headers={})
-      headers[:destination] = destination
-      transmit "SEND", headers, message
-    end
-  
-    # Close this connection
-    def disconnect(headers = {})
-      transmit "DISCONNECT", headers
-    end
-  
-    # Return a pending message if one is available, otherwise
-    # return nil
-    def poll
-      @read_semaphore.synchronize do
-        return nil if @socket==NIL or !@socket.ready?
-        return receive
-      end
-    end
-      
-    # Receive a frame, block until the frame is received
-    def __old_receive
-      # The recive my fail so we may need to retry.
-      while TRUE
-        begin
-          s = socket
-          return _receive(s)
-        rescue 
-          @failure = $!;
-          raise unless @reliable
-          $stderr.print "receive failed: " + $!;
-        end
-      end
-    end
-    
-    def 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()
-      end         
-      return super_result
-    end
-
-    private
-    def _receive( s )
-      line = ' '
-      @read_semaphore.synchronize do
-        line = s.gets while line =~ /^\s*$/
-        return NIL if line == NIL
-        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 (m.headers['content-length'])
-            m.body = s.read m.headers['content-length'].to_i
-            c = s.getc
-            raise "Invalid content length received" unless c == 0
-          else
-            m.body = ''
-            until (c = s.getc) == 0
-              m.body << c.chr
-            end
-          end
-          #c = s.getc
-          #raise "Invalid frame termination received" unless c == 10
-        end
-      end
-    end
-
-    private
-    def transmit(command, headers={}, body='')
-      # The transmit my fail so we may need to retry.
-      while TRUE
-        begin
-          s = socket
-          _transmit(s, command, headers, body)
-          return
-        rescue
-          @failure = $!;
-          raise unless @reliable
-          $stderr.print "transmit failed: " + $!+"\n";
-        end
-      end
-    end
-      
-    private
-    def _transmit(s, 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"
-      end
-    end
-  end
-
-  # Container class for frames, misnamed technically
-  class Message
-    attr_accessor :headers, :body, :command
-    
-    def initialize
-      yield(self) if block_given?
-    end
-    
-    def to_s
-      "<Stomp::Message headers=#{headers.inspect} body='#{body}' command='#{command}' >"
-    end
-  end
-
-  # Typical Stomp client class. Uses a listener thread to receive frames
-  # from the server, any thread can send.
-  #
-  # Receives all happen in one thread, so consider not doing much processing
-  # in that thread if you have much message volume.
-  class Client
-
-    # Accepts a username (default ""), password (default ""), 
-    # host (default localhost), and port (default 61613)
-    def initialize user="", pass="", host="localhost", port=61613, reliable=false
-      if user =~ /stomp:\/\/(\w+):(\d+)/
-        user = ""
-        pass = ""
-        host = $1
-        port = $2
-        reliable = false
-      elsif user =~ /stomp:\/\/(\w+):(\w+)@(\w+):(\d+)/
-        user = $1
-        pass = $2
-        host = $3
-        port = $4
-        reliable = false
-      end
-      
-      @id_mutex = Mutex.new
-      @ids = 1
-      @connection = Connection.open user, pass, host, port, reliable
-      @listeners = {}
-      @receipt_listeners = {}
-      @running = true
-      @replay_messages_by_txn = Hash.new
-      @listener_thread = Thread.start do
-        while @running
-          message = @connection.receive
-          case
-          when message == NIL:
-            break
-          when message.command == 'MESSAGE': 
-            if listener = @listeners[message.headers['destination']]
-              listener.call(message)
-            end
-          when message.command == 'RECEIPT':
-            if listener = @receipt_listeners[message.headers['receipt-id']]
-              listener.call(message)
-            end
-          end
-        end
-      end
-    end
-    
-    # Join the listener thread for this client,
-    # generally used to wait for a quit signal
-    def join
-      @listener_thread.join
-    end
-
-    # Accepts a username (default ""), password (default ""), 
-    # host (default localhost), and port (default 61613)
-    def self.open user="", pass="", host="localhost", port=61613, reliable=false
-      Client.new user, pass, host, port, reliable
-    end
-
-    # Begin a transaction by name
-    def begin name, headers={}
-      @connection.begin name, headers
-    end
-
-    # Abort a transaction by name
-    def abort name, headers={}
-      @connection.abort name, headers
-
-      # lets replay any ack'd messages in this transaction      
-      replay_list = @replay_messages_by_txn[name]
-      if replay_list
-        replay_list.each do |message| 
-          if listener = @listeners[message.headers['destination']]
-            listener.call(message)
-          end
-        end
-      end
-    end
-
-    # Commit a transaction by name
-    def commit name, headers={}
-      txn_id = headers[:transaction]
-      @replay_messages_by_txn.delete(txn_id)
-      @connection.commit name, headers
-    end
-    
-    # Subscribe to a destination, must be passed a block 
-    # which will be used as a callback listener
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def subscribe destination, headers={}
-      raise "No listener given" unless block_given?
-      @listeners[destination] = lambda {|msg| yield msg}
-      @connection.subscribe destination, headers
-    end
-
-    # Unsubecribe from a channel
-    def unsubscribe name, headers={}
-      @connection.unsubscribe name, headers
-      @listeners[name] = nil
-    end
-
-    # Acknowledge a message, used then a subscription has specified 
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def acknowledge message, headers={}
-      txn_id = headers[:transaction]
-      if txn_id
-        # lets keep around messages ack'd in this transaction in case we rollback
-        replay_list = @replay_messages_by_txn[txn_id]
-        if replay_list == nil
-          replay_list = []
-          @replay_messages_by_txn[txn_id] = replay_list
-        end
-        replay_list << message
-      end
-      if block_given?
-        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
-      end
-      @connection.ack message.headers['message-id'], headers
-    end
-
-    # Send message to destination
-    #
-    # If a block is given a receipt will be requested and passed to the 
-    # block on receipt
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send destination, message, headers = {}
-      if block_given?
-        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
-      end
-      @connection.send destination, message, headers
-    end
-
-    # Is this client open?
-    def open?
-      @connection.open?
-    end
-    
-    # Close out resources in use by this client
-    def close
-      @connection.disconnect
-      @running = false 
-    end
-
-    private
-    def register_receipt_listener listener
-      id = -1
-      @id_mutex.synchronize do
-        id = @ids.to_s
-        @ids = @ids.succ
-      end
-      @receipt_listeners[id] = listener
-      id
-    end
-        
-  end
-end

=== added file 'CHANGELOG.rdoc'
--- CHANGELOG.rdoc	1970-01-01 00:00:00 +0000
+++ CHANGELOG.rdoc	2011-07-31 16:48:34 +0000
@@ -0,0 +1,84 @@
+== 1.1.9 2011-15-06
+
+* Support wildcard destinations
+* Handle subscribe with string or symbol ID
+* Check for duplicate subscriptions in spec tests
+* Support AMQ and Apollo servers in uinit tests
+* Correct UTF-8 (Unicode) content-length calcualtion in Ruby 1.9
+* Send of a nil body causes exception
+* Add optional callback logging.  See the examples install directory, files logexamp.rb and slogger.rb
+* Correct date stamps in this file
+
+== 1.1.8 2011-16-03
+
+* Set KEEPALIVE on connection socket options
+* Attempt to support JRuby more robustly (poll remains broken)
+* Switch to ruby supplied IO#ready?
+* Test enhancements for suppress_content_length header
+* Miscellaneous small documentation updates
+* Add parse_timeout parameter for use with hashed logins 
+* Allow connection to hosts with a - (dash) in the host name
+* Add limit parameter to thread joins
+
+== 1.1.7 2011-09-01
+
+* Binary parse of raw STOMP frame
+* Fix broken tests on Ruby 1.9.2
+
+== 1.1.6 2010-10-06
+
+* Fixed multi-thread app hanging
+
+== 1.1.5 2010-17-03
+
+* Added publish method (send is now deprecated)
+* Changes on Rake File
+* Added original_destination header to unreceive
+* suppress content length header is send on the message for future handling (like unreceive)
+
+== 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
+* SSL support
+* Stomp::Connection and Stomp::Client accept a hash on their constructor
+
+== 1.1 2009-27-02
+
+* Ruby 1.9 Support
+* Add support for connect_headers, to control the CONNECT command.
+* Refactored lib dir to separate concerns.
+* Better test coverage
+* General code cleanup. 
+
+== 1.0.6 2008-05-08
+
+* Whitespace cleanup
+* Refactored Rakefile and added stomp.gemspec for GitHub friendliness.
+* Added .gitignore file
+* Refactored layout of lib dir to separate concerns
+* Cleanup of initializers, and provide Client accessors for reading values (for testing)
+* Removed test/test_url_* files as they only differed from the test_client.rb in their
+  setup.  Super UnDry.  Added URL tests to cover stomp URL as param.
+* Created initial RSpec specs which stub/mock objects and should not require a running
+  Stomp server instance.
+
+== v1.0.5
+
+SVN rev 86 clone from http://svn.codehaus.org/stomp/ruby/trunk
+
+git-svn-id: http://svn.codehaus.org/stomp/ruby/trunk@86 fd4e7336-3dff-0310-b68a-b6615a75f13b

=== added file 'LICENSE'
--- LICENSE	1970-01-01 00:00:00 +0000
+++ LICENSE	2011-07-31 16:48:34 +0000
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

=== added file 'README.rdoc'
--- README.rdoc	1970-01-01 00:00:00 +0000
+++ README.rdoc	2011-07-31 16:48:34 +0000
@@ -0,0 +1,107 @@
+==README
+
+* (http://gitorious.org/projects/stomp/)
+* (https://github.com/morellon/stomp/)
+* (http://stomp.rubyforge.org/)
+
+===Overview
+
+An implementation of the Stomp protocol for Ruby. See:
+
+* [STOMP 1.0] (http://stomp.codehaus.org/Protocol)
+* [STOMP 1.0 and 1.1 Draft] (http://stomp.github.com/index.html)
+
+
+===Example Usage
+
+    client = Stomp::Client.new("test", "user", "localhost", 61613)
+    client.send("/my/queue", "hello world!")
+    client.subscribe("/my/queue") do |msg|
+      p msg
+    end
+
+===Failover + SSL Example URL Usage
+
+    options = "initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false"
+    
+    #remotehost1 uses SSL, remotehost2 doesn't
+    client = Stomp::Client.new("failover:(stomp+ssl://login1:passcode1@remotehost1:61612,stomp://login2:passcode2@remotehost2:61613)?#{options}")
+    
+    client.send("/my/queue", "hello world!")
+    client.subscribe("/my/queue") do |msg|
+      p msg
+    end
+
+===Hash Login Example Usage
+
+  hash = {
+      :hosts => [
+        {:login => "login1", :passcode => "passcode1", :host => "remotehost1", :port => 61612, :ssl => true},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost2", :port => 61613, :ssl => false},
+        
+      ],
+      # These are the default parameters, don't need to be set
+      :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,
+      :backup => false,
+      :timeout => -1,
+      :connect_headers => {},
+      :parse_timeout => 5,
+      :logger => nil,
+    }
+    
+    # for client
+    client = Stomp::Client.new(hash)
+    
+    # for connection
+    connection = Stomp::Connection.new(hash)
+    
+
+===Contact info 
+
+Up until March 2009 the project was maintained and primarily developed by Brian McCallister. 
+
+The project is now maintained by Johan Sørensen <[e-mail]> and others.
+
+===Source Code
+
+  https://github.com/morellon/stomp/
+  http://gitorious.org/projects/stomp/
+  http://github.com/js/stomp/
+
+===Project urls
+
+Project Home :
+
+  http://gitorious.org/projects/stomp/
+  http://rubyforge.org/projects/stomp/
+
+Stomp Protocol Info :
+
+  http://stomp.github.com/index.html
+  http://stomp.codehaus.org/Protocol
+
+= Contributors
+
+The following people have contributed to Stomp:
+
+* Brian McCaliister
+* Glenn Rempe <[e-mail]>
+* jstrachan 
+* Marius Mathiesen <[e-mail]>
+* Johan S√∏rensen <[e-mail]>
+* Thiago Morello <[e-mail]>
+* Guy M. Allard
+* kookster
+* Tony Garnock-Jones <[e-mail]>
+* chirino
+* Stefan Saasen
+* Neil Wilson
+* Dinesh Majrekar
+* Kiall Mac Innes
+* Rob Skaggs
+

=== added file 'Rakefile'
--- Rakefile	1970-01-01 00:00:00 +0000
+++ Rakefile	2011-07-31 16:48:34 +0000
@@ -0,0 +1,77 @@
+#   Copyright 2005-2006 Brian McCallister
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require "stomp/version"
+
+begin
+  require "hanna/rdoctask"
+rescue LoadError => e
+  require "rdoc/task"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "stomp"
+    gem.version = Stomp::Version::STRING
+    gem.summary = %Q{Ruby client for the Stomp messaging protocol}
+    gem.description = %Q{Ruby client for the Stomp messaging protocol}
+    gem.email = ["[e-mail]", '[e-mail]', '[e-mail]',
+       '[e-mail]' ]
+    gem.homepage = "https://rubygems.org/gems/stomp"
+    gem.authors = ["Brian McCallister", 'Marius Mathiesen', 'Thiago Morello',
+        'Guy M. Allard']
+    gem.add_development_dependency "rspec", '>= 2.3'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+desc 'Run the specs'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ['--colour']
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+desc "Rspec : run all with RCov"
+RSpec::Core::RakeTask.new('spec:rcov') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'gems', '--exclude', 'spec']
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_dir = "doc"
+  rdoc.title = "Stomp"
+  rdoc.options += %w[ --line-numbers --inline-source --charset utf-8 ]
+  rdoc.rdoc_files.include("README.rdoc", "CHANGELOG.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+task :default => :spec
+
+
+

=== added directory 'bin'
=== added file 'bin/catstomp'
--- bin/catstomp	1970-01-01 00:00:00 +0000
+++ bin/catstomp	2011-07-31 16:48:34 +0000
@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+#
+#   Copyright 2006 LogicBlaze Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+begin; require 'rubygems'; rescue; end
+require 'stomp'
+
+#
+# This simple script is inspired by the netcat utility.  It allows you to send
+# input into this process to stomp destination.
+#
+# Usage: catstomp (destination-name)
+#
+# Example: ls | catstomp /topic/foo
+#   Would send the output of the ls command to the stomp destination /topic/foo
+#
+begin
+
+    @port = 61613
+    @host = "localhost"
+    @user = ENV["STOMP_USER"];
+    @password = ENV["STOMP_PASSWORD"]
+
+    @host = ENV["STOMP_HOST"] if ENV["STOMP_HOST"] != nil
+    @port = ENV["STOMP_PORT"] if ENV["STOMP_PORT"] != nil
+
+    @destination = "/topic/default"
+    @destination = $*[0] if $*[0] != nil
+
+    $stderr.print "Connecting to stomp://#{@host}:#{@port} as #{@user}\n"
+    @conn = Stomp::Connection.open(@user, @password, @host, @port, true)
+    $stderr.print "Sending input to #{@destination}\n"
+
+    @headers = {'persistent'=>'false'}
+    @headers['reply-to'] = $*[1] if $*[1] != nil
+
+    STDIN.each_line { |line|
+        @conn.send @destination, line, @headers
+    }
+
+rescue
+end
+

=== added file 'bin/stompcat'
--- bin/stompcat	1970-01-01 00:00:00 +0000
+++ bin/stompcat	2011-07-31 16:48:34 +0000
@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+#
+#   Copyright 2006 LogicBlaze Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+begin; require 'rubygems'; rescue; end
+require 'stomp'
+
+#
+# This simple script is inspired by the netcat utility.  It allows you to receive
+# data from a stomp destination and output it.
+#
+# Usage: stompcat (destination-name)
+#
+# Example: stompcat /topic/foo
+#   Would display output that arrives at the /topic/foo stomp destination
+#
+begin
+
+    @port = 61613
+    @host = "localhost"
+    @user = ENV["STOMP_USER"];
+    @password = ENV["STOMP_PASSWORD"]
+
+    @host = ENV["STOMP_HOST"] if ENV["STOMP_HOST"] != nil
+    @port = ENV["STOMP_PORT"] if ENV["STOMP_PORT"] != nil
+
+    @destination = "/topic/default"
+    @destination = $*[0] if $*[0] != nil
+
+    $stderr.print "Connecting to stomp://#{@host}:#{@port} as #{@user}\n"
+    @conn = Stomp::Connection.open(@user, @password, @host, @port, true)
+    $stderr.print "Getting output from #{@destination}\n"
+
+    @conn.subscribe(@destination, { :ack =>"client" })
+    while true
+        @msg = @conn.receive
+        $stdout.print @msg.body
+        $stdout.flush
+        @conn.ack @msg.headers["message-id"]
+    end
+
+rescue
+end
+

=== modified file 'debian/changelog'
--- debian/changelog	2010-09-28 00:25:39 +0000
+++ debian/changelog	2011-07-31 16:48:34 +0000
@@ -1,3 +1,26 @@
+libstomp-ruby (1.1.9-0ubuntu1) oneiric; urgency=low
+
+  * New upstream release (Closes: #598564, LP: #707317).
+
+  * debian/patches/case_statement_compatible_1.9.2.patch,
+    debian/patches/getc_returns_a_string_1.9.patch: obsolete, removed.
+  * debian/patches/series: update accordingly.
+
+  * debian/rules (common-binary-indep): deal with the catstomp and
+    stompcat binaries by putting them in libstomp-ruby instead of the
+    (ruby-)versioned packages and fixing their hash-bang line to use the
+    generic /usr/bin/ruby binary/symlink.
+
+  * debian/control: have libstomp-ruby depend on libstomp-ruby1.8 or
+    libstomp-ruby1.9.1.  Make libstomp-ruby$ver suggest libstomp-ruby.
+    Update the package description to describe libstomp-ruby's new
+    purpose.
+
+  * debian/control: have libstomp-ruby explicitly depend on ruby for
+    catstomp and stompcat to make lintian happy.
+
+ -- James Troup <[e-mail]>  Sun, 31 Jul 2011 17:14:07 +0100
+
 libstomp-ruby (1.0.4-3) unstable; urgency=low
 
   * Team upload.

=== modified file 'debian/control'
--- debian/control	2010-09-28 00:25:39 +0000
+++ debian/control	2011-07-31 16:48:34 +0000
@@ -12,7 +12,7 @@
 
 Package: libstomp-ruby
 Architecture: all
-Depends: libstomp-ruby1.8, ${misc:Depends}
+Depends: libstomp-ruby1.8 | libstomp-ruby1.9.1, ruby, ${misc:Depends}
 Suggests: libstomp-ruby-doc
 Description: Ruby bindings for the stomp messaging protocol
  Stomp is a text-oriented wire protocol for messaging (MOM/MQ/JMS)
@@ -21,13 +21,12 @@
  implementation, and Stomp::Client, which is designed as a higher
  level convenience API.
  .
- This package is a dependency package, which depends on the package
- containing actual Ruby stomp libraries for the default Ruby version
- (currently 1.8).
+ This package contains the catstomp and stompcat binaries.
 
 Package: libstomp-ruby1.8
 Architecture: all
 Depends: ${shlibs:Depends}, ${misc:Depends}, ruby1.8
+Suggests: libstomp-ruby
 Description: Ruby 1.8 bindings for the stomp messaging protocol
  Stomp is a text-oriented wire protocol for messaging (MOM/MQ/JMS)
  type systems. This library provides two useful interfaces, a low-
@@ -40,6 +39,7 @@
 Package: libstomp-ruby1.9.1
 Architecture: all
 Depends: ${shlibs:Depends}, ${misc:Depends}, ruby1.9.1
+Suggests: libstomp-ruby
 Description: Ruby 1.9.1 bindings for the stomp messaging protocol
  Stomp is a text-oriented wire protocol for messaging (MOM/MQ/JMS)
  type systems. This library provides two useful interfaces, a low-

=== added directory 'debian/patches'
=== removed directory 'debian/patches'
=== removed file 'debian/patches/case_statement_compatible_1.9.2.patch'
--- debian/patches/case_statement_compatible_1.9.2.patch	2010-09-28 00:25:39 +0000
+++ debian/patches/case_statement_compatible_1.9.2.patch	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-From: Marius Mathiesen
-Description: Making 1.9 compatible
-Origin: upstream, http://github.com/js/stomp/commit/a778661ce9c074ae5b415658d17dd2639f5c9c05
-Debian-Bug: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=593079
---- a/lib/stomp.rb
-+++ b/lib/stomp.rb
-@@ -286,13 +286,13 @@ module Stomp
-         while @running
-           message = @connection.receive
-           case
--          when message == NIL:
-+          when message == NIL
-             break
--          when message.command == 'MESSAGE': 
-+          when message.command == 'MESSAGE'
-             if listener = @listeners[message.headers['destination']]
-               listener.call(message)
-             end
--          when message.command == 'RECEIPT':
-+          when message.command == 'RECEIPT'
-             if listener = @receipt_listeners[message.headers['receipt-id']]
-               listener.call(message)
-             end

=== removed file 'debian/patches/getc_returns_a_string_1.9.patch'
--- debian/patches/getc_returns_a_string_1.9.patch	2010-09-28 00:25:39 +0000
+++ debian/patches/getc_returns_a_string_1.9.patch	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-From: Johan Sørensen <[e-mail]>
-Subject: Further Ruby 1.9 support: IO#getc returns a string, instead of a char in 1.9
-Origin: upstream, http://github.com/js/stomp/commit/2971a7922f64052c5b308f2a4a92080d7c8b046b
---- a/lib/stomp.rb
-+++ b/lib/stomp.rb
-@@ -194,12 +194,18 @@ module Stomp
-           
-           if (m.headers['content-length'])
-             m.body = s.read m.headers['content-length'].to_i
--            c = s.getc
-+            c = RUBY_VERSION > '1.9' ? s.getc.ord : s.getc
-             raise "Invalid content length received" unless c == 0
-           else
-             m.body = ''
--            until (c = s.getc) == 0
--              m.body << c.chr
-+            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
-           end
-           #c = s.getc

=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2011-07-31 16:48:34 +0000
@@ -0,0 +1,1 @@
+

=== removed file 'debian/patches/series'
--- debian/patches/series	2010-09-28 00:25:39 +0000
+++ debian/patches/series	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-getc_returns_a_string_1.9.patch
-case_statement_compatible_1.9.2.patch

=== modified file 'debian/rules'
--- debian/rules	2009-01-26 20:38:53 +0000
+++ debian/rules	2011-07-31 16:48:34 +0000
@@ -2,3 +2,15 @@
 
 include /usr/share/cdbs/1/rules/debhelper.mk
 include /usr/share/ruby-pkg-tools/1/class/ruby-setup-rb.mk
+
+common-binary-indep::
+	# Deal with the catstomp and stompcat binaries by putting them
+	# into libstomp-ruby and fixing them to use /usr/bin/ruby
+	install -d -m 755 -o root -g root debian/libstomp-ruby/usr/
+	cp -a debian/$(firstword $(DEB_RUBY_REAL_LIB_PACKAGES))/usr/bin/ debian/libstomp-ruby/usr/bin/
+	for script in `find debian/libstomp-ruby/usr/bin/ -type f`; do \
+		sed -i -e "1s%.*%#! /usr/bin/ruby%" $$script ; \
+	done
+	for pkg in $(DEB_RUBY_REAL_LIB_PACKAGES); do \
+		rm -fr debian/$$pkg/usr/bin/; \
+	done

=== added directory 'debian/source'
=== removed directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2011-07-31 16:48:34 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)

=== removed file 'debian/source/format'
--- debian/source/format	2010-06-12 00:08:49 +0000
+++ debian/source/format	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-3.0 (quilt)

=== added directory 'examples'
=== added file 'examples/consumer.rb'
--- examples/consumer.rb	1970-01-01 00:00:00 +0000
+++ examples/consumer.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'stomp'
+
+
+client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
+puts "Subscribing ronaldo"
+client.subscribe("/queue/ronaldo", {:ack => "client", "activemq.prefetchSize" => 1, "activemq.exclusive" => true }) do |msg|
+  File.open("file", "a") do |f|
+    f.write(msg.body)
+    f.write("\n----------------\n")
+  end
+  
+  client.acknowledge(msg)
+end
+
+loop do
+  sleep(1)
+  puts "."
+end

=== added file 'examples/logexamp.rb'
--- examples/logexamp.rb	1970-01-01 00:00:00 +0000
+++ examples/logexamp.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'stomp'
+require 'logger'  # for the 'local' logger
+#
+$:.unshift(File.dirname(__FILE__))
+#
+require 'slogger'
+#
+# A STOMP client program which uses the callback logging facility.
+#
+llog =        Logger::new(STDOUT)
+llog.level =  Logger::DEBUG
+llog.debug "LE Starting"
+
+# //////////////////////////////////////////////////////////////////////////////
+mylog = Slogger::new  # The client provided STOMP callback logger
+
+# //////////////////////////////////////////////////////////////////////////////
+user =      ENV['STOMP_USER'] ? ENV['STOMP_USER'] : 'guest'
+password =  ENV['STOMP_PASSWORD'] ? ENV['STOMP_PASSWORD'] : 'guestpw'
+host =      ENV['STOMP_HOST'] ? ENV['STOMP_HOST'] : 'localhost'
+port =      ENV['STOMP_PORT'] ? ENV['STOMP_PORT'].to_i : 61613
+# //////////////////////////////////////////////////////////////////////////////
+# A hash type connect *MUST* be used to enable callback logging.
+# //////////////////////////////////////////////////////////////////////////////
+hash = { :hosts => [ 
+          {:login => user, :passcode => password, :host => 'noonehome', :port => 2525},
+          {:login => user, :passcode => password, :host => host, :port => port},
+          ],
+          :logger => mylog,	# This enables callback logging!
+          :max_reconnect_attempts => 5,
+        }
+
+# //////////////////////////////////////////////////////////////////////////////
+# For a Connection:
+conn = Stomp::Connection.new(hash)
+conn.disconnect
+# //////////////////////////////////////////////////////////////////////////////
+llog.debug "LE Connection processing complete"
+
+# //////////////////////////////////////////////////////////////////////////////
+# For a Client:
+conn = Stomp::Client.new(hash)
+conn.close
+# //////////////////////////////////////////////////////////////////////////////
+# llog.debug "LE Client processing complete"
+
+# //////////////////////////////////////////////////////////////////////////////
+llog.debug "LE Ending"
+

=== added file 'examples/publisher.rb'
--- examples/publisher.rb	1970-01-01 00:00:00 +0000
+++ examples/publisher.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'stomp'
+
+#client = Stomp::Client.new("", "", "localhost", 61613)
+
+client = Stomp::Client.new("failover://(stomp://:@localhost:61613,stomp://:@remotehost:61613)?initialReconnectDelay=5000&randomize=false&useExponentialBackOff=false")
+message = "ronaldo #{ARGV[0]}"
+
+for i in (1..300)
+  puts "Sending message"
+  client.send("/queue/ronaldo", "#{i}: #{message}", {:persistent => true})
+  puts "(#{Time.now})Message sent: #{i}"
+  sleep 1
+end
+
+
+

=== added file 'examples/slogger.rb'
--- examples/slogger.rb	1970-01-01 00:00:00 +0000
+++ examples/slogger.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,100 @@
+=begin
+
+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
+
+All methods are optional, at the user's requirements.
+
+If a method is not provided, it is not called (of course.)
+
+IMPORTANT NOTE:  call back logging methods *MUST* not raise exceptions, 
+otherwise the underlying STOMP connection will fail in mysterious ways.
+
+Callback parameters: are a copy of the @parameters instance variable for
+the Stomp::Connection.
+
+=end
+
+require 'logger'	# use the standard Ruby logger .....
+
+class Slogger
+  #
+  def initialize(init_parms = nil)
+    @log = Logger::new(STDOUT)		# User preference
+    @log.level = Logger::DEBUG		# User preference
+    @log.info("Logger initialization complete.")
+  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
+  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
+
+  private
+
+  def info(parms)
+    #
+    # Available in the 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]
+    #
+    "Host: #{parms[:cur_host]}, Port: #{parms[:cur_port]}, Login: Port: #{parms[:cur_login]}, Passcode: #{parms[:cur_passcode]}" 
+  end
+end # of class
+

=== removed file 'lib/._stomp.rb'
Binary files lib/._stomp.rb	2009-01-26 20:38:53 +0000 and lib/._stomp.rb	1970-01-01 00:00:00 +0000 differ
=== added directory 'lib/stomp'
=== modified file 'lib/stomp.rb'
--- lib/stomp.rb	2010-09-28 00:25:39 +0000
+++ lib/stomp.rb	2011-07-31 16:48:34 +0000
@@ -13,410 +13,13 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-require 'io/wait'
-require 'socket'
-require 'thread'
+require 'stomp/ext/hash'
+require 'stomp/connection'
+require 'stomp/client'
+require 'stomp/message'
+require 'stomp/version'
+require 'stomp/errors'
 
 module Stomp
-
-  # Low level connection which maps commands and supports
-  # synchronous receives
-  class Connection
-
-    def Connection.open(login = "", passcode = "", host='localhost', port=61613, reliable=FALSE, reconnectDelay=5)
-      Connection.new login, passcode, host, port, reliable, reconnectDelay        
-    end
-
-    # Create a connection, requires a login and passcode.
-    # Can accept a host (default is localhost), and port
-    # (default is 61613) to connect to
-    def initialize(login, passcode, host='localhost', port=61613, reliable=false, reconnectDelay=5)
-      @host = host
-      @port = port
-      @login = login
-      @passcode = passcode
-      @transmit_semaphore = Mutex.new
-      @read_semaphore = Mutex.new
-      @socket_semaphore = Mutex.new
-      @reliable = reliable
-      @reconnectDelay = reconnectDelay
-      @closed = FALSE
-      @subscriptions = {}
-      @failure = NIL
-      socket
-    end
-  
-    def socket
-      # Need to look into why the following synchronize does not work.
-      #@read_semaphore.synchronize do
-        s = @socket;
-        while s == NIL or @failure != NIL
-          @failure = NIL
-          begin
-            s = TCPSocket.open @host, @port
-            _transmit(s, "CONNECT", {:login => @login, :passcode => @passcode})
-            @connect = _receive(s)                        
-            # replay any subscriptions.
-            @subscriptions.each { |k,v| _transmit(s, "SUBSCRIBE", v) }
-          rescue 
-            @failure = $!;
-            s=NIL;
-            raise unless @reliable
-            $stderr.print "connect failed: " + $! +" will retry in #{@reconnectDelay}\n";                
-            sleep(@reconnectDelay);
-          end
-        end
-        @socket = s
-        return s;
-      #end
-    end
-  
-    # Is this connection open?
-    def open?
-      !@closed
-    end
-  
-    # Is this connection closed?
-    def closed?
-      @closed
-    end
-  
-    # Begin a transaction, requires a name for the transaction
-    def begin name, headers={}
-      headers[:transaction] = name
-      transmit "BEGIN", headers
-    end
-  
-    # Acknowledge a message, used then a subscription has specified 
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def ack message_id, headers={}
-      headers['message-id'] = message_id
-      transmit "ACK", headers
-    end
-      
-    # Commit a transaction by name
-    def commit name, headers={}
-      headers[:transaction] = name
-      transmit "COMMIT", headers
-    end
-
-    # Abort a transaction by name
-    def abort name, headers={}
-      headers[:transaction] = name
-      transmit "ABORT", headers
-    end
-  
-    # Subscribe to a destination, must specify a name
-    def subscribe(name, headers = {}, subId=NIL)
-      headers[:destination] = name
-      transmit "SUBSCRIBE", headers
-      
-      # Store the sub so that we can replay if we reconnect.
-      if @reliable
-        subId = name if subId==NIL
-        @subscriptions[subId]=headers
-      end
-    end
-  
-    # Unsubscribe from a destination, must specify a name
-    def unsubscribe(name, headers = {}, subId=NIL)
-      headers[:destination] = name
-      transmit "UNSUBSCRIBE", headers
-      if @reliable
-        subId = name if subId==NIL
-        @subscriptions.delete(subId)
-      end
-    end
-  
-    # Send message to destination
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send(destination, message, headers={})
-      headers[:destination] = destination
-      transmit "SEND", headers, message
-    end
-  
-    # Close this connection
-    def disconnect(headers = {})
-      transmit "DISCONNECT", headers
-    end
-  
-    # Return a pending message if one is available, otherwise
-    # return nil
-    def poll
-      @read_semaphore.synchronize do
-        return nil if @socket==NIL or !@socket.ready?
-        return receive
-      end
-    end
-      
-    # Receive a frame, block until the frame is received
-    def __old_receive
-      # The recive my fail so we may need to retry.
-      while TRUE
-        begin
-          s = socket
-          return _receive(s)
-        rescue 
-          @failure = $!;
-          raise unless @reliable
-          $stderr.print "receive failed: " + $!;
-        end
-      end
-    end
-    
-    def 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()
-      end         
-      return super_result
-    end
-
-    private
-    def _receive( s )
-      line = ' '
-      @read_semaphore.synchronize do
-        line = s.gets while line =~ /^\s*$/
-        return NIL if line == NIL
-        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 (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
-          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
-          end
-          #c = s.getc
-          #raise "Invalid frame termination received" unless c == 10
-        end
-      end
-    end
-
-    private
-    def transmit(command, headers={}, body='')
-      # The transmit my fail so we may need to retry.
-      while TRUE
-        begin
-          s = socket
-          _transmit(s, command, headers, body)
-          return
-        rescue
-          @failure = $!;
-          raise unless @reliable
-          $stderr.print "transmit failed: " + $!+"\n";
-        end
-      end
-    end
-      
-    private
-    def _transmit(s, 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"
-      end
-    end
-  end
-
-  # Container class for frames, misnamed technically
-  class Message
-    attr_accessor :headers, :body, :command
-    
-    def initialize
-      yield(self) if block_given?
-    end
-    
-    def to_s
-      "<Stomp::Message headers=#{headers.inspect} body='#{body}' command='#{command}' >"
-    end
-  end
-
-  # Typical Stomp client class. Uses a listener thread to receive frames
-  # from the server, any thread can send.
-  #
-  # Receives all happen in one thread, so consider not doing much processing
-  # in that thread if you have much message volume.
-  class Client
-
-    # Accepts a username (default ""), password (default ""), 
-    # host (default localhost), and port (default 61613)
-    def initialize user="", pass="", host="localhost", port=61613, reliable=false
-      if user =~ /stomp:\/\/(\w+):(\d+)/
-        user = ""
-        pass = ""
-        host = $1
-        port = $2
-        reliable = false
-      elsif user =~ /stomp:\/\/(\w+):(\w+)@(\w+):(\d+)/
-        user = $1
-        pass = $2
-        host = $3
-        port = $4
-        reliable = false
-      end
-      
-      @id_mutex = Mutex.new
-      @ids = 1
-      @connection = Connection.open user, pass, host, port, reliable
-      @listeners = {}
-      @receipt_listeners = {}
-      @running = true
-      @replay_messages_by_txn = Hash.new
-      @listener_thread = Thread.start do
-        while @running
-          message = @connection.receive
-          case
-          when message == NIL
-            break
-          when message.command == 'MESSAGE'
-            if listener = @listeners[message.headers['destination']]
-              listener.call(message)
-            end
-          when message.command == 'RECEIPT'
-            if listener = @receipt_listeners[message.headers['receipt-id']]
-              listener.call(message)
-            end
-          end
-        end
-      end
-    end
-    
-    # Join the listener thread for this client,
-    # generally used to wait for a quit signal
-    def join
-      @listener_thread.join
-    end
-
-    # Accepts a username (default ""), password (default ""), 
-    # host (default localhost), and port (default 61613)
-    def self.open user="", pass="", host="localhost", port=61613, reliable=false
-      Client.new user, pass, host, port, reliable
-    end
-
-    # Begin a transaction by name
-    def begin name, headers={}
-      @connection.begin name, headers
-    end
-
-    # Abort a transaction by name
-    def abort name, headers={}
-      @connection.abort name, headers
-
-      # lets replay any ack'd messages in this transaction      
-      replay_list = @replay_messages_by_txn[name]
-      if replay_list
-        replay_list.each do |message| 
-          if listener = @listeners[message.headers['destination']]
-            listener.call(message)
-          end
-        end
-      end
-    end
-
-    # Commit a transaction by name
-    def commit name, headers={}
-      txn_id = headers[:transaction]
-      @replay_messages_by_txn.delete(txn_id)
-      @connection.commit name, headers
-    end
-    
-    # Subscribe to a destination, must be passed a block 
-    # which will be used as a callback listener
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def subscribe destination, headers={}
-      raise "No listener given" unless block_given?
-      @listeners[destination] = lambda {|msg| yield msg}
-      @connection.subscribe destination, headers
-    end
-
-    # Unsubecribe from a channel
-    def unsubscribe name, headers={}
-      @connection.unsubscribe name, headers
-      @listeners[name] = nil
-    end
-
-    # Acknowledge a message, used then a subscription has specified 
-    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def acknowledge message, headers={}
-      txn_id = headers[:transaction]
-      if txn_id
-        # lets keep around messages ack'd in this transaction in case we rollback
-        replay_list = @replay_messages_by_txn[txn_id]
-        if replay_list == nil
-          replay_list = []
-          @replay_messages_by_txn[txn_id] = replay_list
-        end
-        replay_list << message
-      end
-      if block_given?
-        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
-      end
-      @connection.ack message.headers['message-id'], headers
-    end
-
-    # Send message to destination
-    #
-    # If a block is given a receipt will be requested and passed to the 
-    # block on receipt
-    #
-    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
-    def send destination, message, headers = {}
-      if block_given?
-        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
-      end
-      @connection.send destination, message, headers
-    end
-
-    # Is this client open?
-    def open?
-      @connection.open?
-    end
-    
-    # Close out resources in use by this client
-    def close
-      @connection.disconnect
-      @running = false 
-    end
-
-    private
-    def register_receipt_listener listener
-      id = -1
-      @id_mutex.synchronize do
-        id = @ids.to_s
-        @ids = @ids.succ
-      end
-      @receipt_listeners[id] = listener
-      id
-    end
-        
-  end
 end
+

=== added file 'lib/stomp/client.rb'
--- lib/stomp/client.rb	1970-01-01 00:00:00 +0000
+++ lib/stomp/client.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,340 @@
+require 'thread'
+require 'digest/sha1'
+
+module Stomp
+
+  # Typical Stomp client class. Uses a listener thread to receive frames
+  # from the server, any thread can send.
+  #
+  # Receives all happen in one thread, so consider not doing much processing
+  # in that thread if you have much message volume.
+  class Client
+
+    attr_reader :login, :passcode, :host, :port, :reliable, :parameters
+    
+    #alias :obj_send :send
+
+    # A new Client object can be initialized using two forms:
+    #
+    # Standard positional parameters:
+    #   login     (String,  default : '')
+    #   passcode  (String,  default : '')
+    #   host      (String,  default : 'localhost')
+    #   port      (Integer, default : 61613)
+    #   reliable  (Boolean, default : false)
+    #
+    #   e.g. c = Client.new('login', 'passcode', 'localhost', 61613, true)
+    #
+    # Stomp URL :
+    #   A Stomp URL must begin with 'stomp://' and can be in one of the following forms:
+    #
+    #   stomp://host:port
+    #   stomp://host.domain.tld:port
+    #   stomp://login:passcode@host:port
+    #   stomp://login:[e-mail]:port
+    #
+    def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false)
+
+      # Parse stomp:// URL's or set params
+      if login.is_a?(Hash)
+        @parameters = login
+        
+        first_host = @parameters[:hosts][0]
+        
+        @login = first_host[:login]
+        @passcode = first_host[:passcode]
+        @host = first_host[:host]
+        @port = first_host[:port] || Connection::default_port(first_host[:ssl])
+        
+        @reliable = true
+        
+      elsif login =~ /^stomp:\/\/#{url_regex}/ # e.g. stomp://login:passcode@host:port or stomp://host:port
+        @login = $2 || ""
+        @passcode = $3 || ""
+        @host = $4
+        @port = $5.to_i
+        @reliable = false
+      elsif login =~ /^failover:(\/\/)?\(stomp(\+ssl)?:\/\/#{url_regex}(,stomp(\+ssl)?:\/\/#{url_regex}\))+(\?(.*))?$/ # e.g. failover://(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)?option1=param
+
+        first_host = {}
+        first_host[:ssl] = !$2.nil?
+        @login = first_host[:login] = $4 || ""
+        @passcode = first_host[:passcode] = $5 || ""
+        @host = first_host[:host] = $6
+        @port = first_host[:port] = $7.to_i || Connection::default_port(first_host[:ssl])
+        
+        options = $16 || ""
+        parts = options.split(/&|=/)
+        options = Hash[*parts]
+        
+        hosts = [first_host] + parse_hosts(login)
+        
+        @parameters = {}
+        @parameters[:hosts] = hosts
+        
+        @parameters.merge! filter_options(options)
+                
+        @reliable = true
+      else
+        @login = login
+        @passcode = passcode
+        @host = host
+        @port = port.to_i
+        @reliable = reliable
+      end
+
+      check_arguments!
+
+      @id_mutex = Mutex.new
+      @ids = 1
+
+      if @parameters
+        @connection = Connection.new(@parameters)
+      else
+        @connection = Connection.new(@login, @passcode, @host, @port, @reliable)
+      end
+      
+      start_listeners
+
+    end
+    
+    # Syntactic sugar for 'Client.new' See 'initialize' for usage.
+    def self.open(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false)
+      Client.new(login, passcode, host, port, reliable)
+    end
+
+    # Join the listener thread for this client,
+    # generally used to wait for a quit signal
+    def join(limit = nil)
+      @listener_thread.join(limit)
+    end
+
+    # Begin a transaction by name
+    def begin(name, headers = {})
+      @connection.begin(name, headers)
+    end
+
+    # Abort a transaction by name
+    def abort(name, headers = {})
+      @connection.abort(name, headers)
+
+      # lets replay any ack'd messages in this transaction
+      replay_list = @replay_messages_by_txn[name]
+      if replay_list
+        replay_list.each do |message|
+          if listener = find_listener(message)
+            listener.call(message)
+          end
+        end
+      end
+    end
+
+    # Commit a transaction by name
+    def commit(name, headers = {})
+      txn_id = headers[:transaction]
+      @replay_messages_by_txn.delete(txn_id)
+      @connection.commit(name, headers)
+    end
+
+    # Subscribe to a destination, must be passed a block
+    # which will be used as a callback listener
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def subscribe(destination, headers = {})
+      raise "No listener given" unless block_given?
+      # use subscription id to correlate messages to subscription. As described in
+      # the SUBSCRIPTION section of the protocol: http://stomp.codehaus.org/Protocol.
+      # If no subscription id is provided, generate one.
+      set_subscription_id_if_missing(destination, headers)
+      if @listeners[headers[:id]]
+        raise "attempting to subscribe to a queue with a previous subscription"
+      end
+      @listeners[headers[:id]] = lambda {|msg| yield msg}
+      @connection.subscribe(destination, headers)
+    end
+
+    # Unsubecribe from a channel
+    def unsubscribe(name, headers = {})
+      set_subscription_id_if_missing(name, headers)
+      @connection.unsubscribe(name, headers)
+      @listeners[headers[:id]] = nil
+    end
+
+    # Acknowledge a message, used when a subscription has specified
+    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def acknowledge(message, headers = {})
+      txn_id = headers[:transaction]
+      if txn_id
+        # lets keep around messages ack'd in this transaction in case we rollback
+        replay_list = @replay_messages_by_txn[txn_id]
+        if replay_list.nil?
+          replay_list = []
+          @replay_messages_by_txn[txn_id] = replay_list
+        end
+        replay_list << message
+      end
+      if block_given?
+        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
+      end
+      @connection.ack message.headers['message-id'], headers
+    end
+    
+    # Unreceive a message, sending it back to its queue or to the DLQ
+    #
+    def unreceive(message, options = {})
+      @connection.unreceive(message, options)
+    end
+    
+    # Publishes message to destination
+    #
+    # If a block is given a receipt will be requested and passed to the
+    # block on receipt
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def publish(destination, message, headers = {})
+      if block_given?
+        headers['receipt'] = register_receipt_listener lambda {|r| yield r}
+      end
+      @connection.publish(destination, message, headers)
+    end
+    
+    def obj_send(*args)
+      __send__(*args)
+    end
+    
+    def send(*args)
+      warn("This method is deprecated and will be removed on the next release. Use 'publish' instead")
+      publish(*args)
+    end
+    
+    def connection_frame
+      @connection.connection_frame
+    end
+
+    def disconnect_receipt
+      @connection.disconnect_receipt
+    end
+
+    # Is this client open?
+    def open?
+      @connection.open?
+    end
+
+    # Is this client closed?
+    def closed?
+      @connection.closed?
+    end
+
+    # Close out resources in use by this client
+    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
+      # Set a subscription id in the headers hash if one does not already exist.
+      # For simplicities sake, all subscriptions have a subscription ID.
+      # setting an id in the SUBSCRIPTION header is described in the stomp protocol docs:
+      # http://stomp.codehaus.org/Protocol
+      def set_subscription_id_if_missing(destination, headers)
+        headers[:id] = headers[:id] ? headers[:id] : headers['id'] 
+        if headers[:id] == nil
+          headers[:id] = Digest::SHA1.hexdigest(destination)
+        end
+      end
+
+      def register_receipt_listener(listener)
+        id = -1
+        @id_mutex.synchronize do
+          id = @ids.to_s
+          @ids = @ids.succ
+        end
+        @receipt_listeners[id] = listener
+        id
+      end
+      
+       # e.g. login:passcode@host:port or host:port
+      def url_regex
+        '(([\w\.\-]*):(\w*)@)?([\w\.\-]+):(\d+)'
+      end
+      
+      def parse_hosts(url)
+        hosts = []
+        
+        host_match = /stomp(\+ssl)?:\/\/(([\w\.]*):(\w*)@)?([\w\.]+):(\d+)\)/
+        url.scan(host_match).each do |match|
+          host = {}
+          host[:ssl] = !match[0].nil?
+          host[:login] =  match[2] || ""
+          host[:passcode] = match[3] || ""
+          host[:host] = match[4]
+          host[:port] = match[5].to_i
+          
+          hosts << host
+        end
+        
+        hosts
+      end
+      
+      def check_arguments!
+        raise ArgumentError if @host.nil? || @host.empty?
+        raise ArgumentError if @port.nil? || @port == '' || @port < 1 || @port > 65535
+        raise ArgumentError unless @reliable.is_a?(TrueClass) || @reliable.is_a?(FalseClass)
+      end
+      
+      def filter_options(options)
+        new_options = {}
+        new_options[:initial_reconnect_delay] = (options["initialReconnectDelay"] || 10).to_f / 1000 # In ms
+        new_options[:max_reconnect_delay] = (options["maxReconnectDelay"] || 30000 ).to_f / 1000 # In ms
+        new_options[:use_exponential_back_off] = !(options["useExponentialBackOff"] == "false") # Default: true
+        new_options[:back_off_multiplier] = (options["backOffMultiplier"] || 2 ).to_i
+        new_options[:max_reconnect_attempts] = (options["maxReconnectAttempts"] || 0 ).to_i
+        new_options[:randomize] = options["randomize"] == "true" # Default: false
+        new_options[:backup] = false # Not implemented yet: I'm using a master X slave solution
+        new_options[:timeout] = -1 # Not implemented yet: a "timeout(5) do ... end" would do the trick, feel free
+        
+        new_options
+      end
+      
+      def find_listener(message)
+        subscription_id = message.headers['subscription']
+        if subscription_id == nil
+          # For backward compatibility, some messages may already exist with no
+          # subscription id, in which case we can attempt to synthesize one.
+          set_subscription_id_if_missing(message.headers['destination'], message.headers)
+          subscription_id = message.headers['id']
+        end
+        @listeners[subscription_id]
+      end
+
+      def start_listeners
+        @listeners = {}
+        @receipt_listeners = {}
+        @replay_messages_by_txn = {}
+
+        @listener_thread = Thread.start do
+          while true
+            message = @connection.receive
+            if message.command == 'MESSAGE'
+              if listener = find_listener(message)
+                listener.call(message)
+              end
+            elsif message.command == 'RECEIPT'
+              if listener = @receipt_listeners[message.headers['receipt-id']]
+                listener.call(message)
+              end
+            end
+          end
+        end
+        
+      end
+  end
+end
+

=== added file 'lib/stomp/connection.rb'
--- lib/stomp/connection.rb	1970-01-01 00:00:00 +0000
+++ lib/stomp/connection.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,559 @@
+require 'socket'
+require 'timeout'
+require 'io/wait'
+
+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 : '')
+    #   passcode          (String,  default : '')
+    #   host              (String,  default : 'localhost')
+    #   port              (Integer, default : 61613)
+    #   reliable          (Boolean, default : false)
+    #   reconnect_delay   (Integer, default : 5)
+    #
+    #   e.g. c = Connection.new("username", "password", "localhost", 61613, true)
+    #
+    # Hash:
+    #
+    #   hash = {
+    #     :hosts => [
+    #       {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+    #       {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+    #     ],
+    #     :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,
+    #     :backup => false,
+    #     :timeout => -1,
+    #     :connect_headers => {},
+    #     :parse_timeout => 5,
+    #     :logger => nil,
+    #   }
+    #
+    #   e.g. c = Connection.new(hash)
+    #
+    # TODO
+    # Stomp URL :
+    #   A Stomp URL must begin with 'stomp://' and can be in one of the following forms:
+    #
+    #   stomp://host:port
+    #   stomp://host.domain.tld:port
+    #   stomp://user:pass@host:port
+    #   stomp://user:[e-mail]: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
+        @host = host
+        @port = port
+        @login = login
+        @passcode = passcode
+        @reliable = reliable
+        @reconnect_delay = reconnect_delay
+        @connect_headers = connect_headers
+        @ssl = false
+        @parameters = nil
+        @parse_timeout = 5		# To override, use hashed parameters
+        @logger = nil     		# To override, use hashed parameters
+      end
+      
+      # Use Mutexes:  only one lock per each thread
+      # Revert to original implementation attempt
+      @transmit_semaphore = Mutex.new
+      @read_semaphore = Mutex.new
+      @socket_semaphore = Mutex.new
+      
+      @subscriptions = {}
+      @failure = nil
+      @connection_attempts = 0
+      
+      socket
+    end
+    
+    def hashed_initialize(params)
+      
+      @parameters = refine_params(params)
+      @reliable = true
+      @reconnect_delay = @parameters[:initial_reconnect_delay]
+      @connect_headers = @parameters[:connect_headers]
+      @parse_timeout =  @parameters[:parse_timeout]
+      @logger =  @parameters[:logger]
+      #sets the first host to connect
+      change_host
+      if @logger && @logger.respond_to?(:on_connecting)            
+        @logger.on_connecting(log_params)
+      end
+    end
+    
+    # Syntactic sugar for 'Connection.new' See 'initialize' for usage.
+    def Connection.open(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
+      Connection.new(login, passcode, host, port, reliable, reconnect_delay, connect_headers)
+    end
+
+    def socket
+      @socket_semaphore.synchronize do
+        used_socket = @socket
+        used_socket = nil if closed?
+        
+        while used_socket.nil? || !@failure.nil?
+          @failure = nil
+          begin
+            used_socket = open_socket
+            # Open complete
+            
+            connect(used_socket)
+            if @logger && @logger.respond_to?(:on_connected)
+              @logger.on_connected(log_params) 
+            end
+            @connection_attempts = 0
+          rescue
+            @failure = $!
+            used_socket = nil
+            raise unless @reliable
+            if @logger && @logger.respond_to?(:on_connectfail)            
+              @logger.on_connectfail(log_params) 
+            else
+              $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
+            end
+            raise Stomp::Error::MaxReconnectAttempts if max_reconnect_attempts?
+
+            sleep(@reconnect_delay)
+            
+            @connection_attempts += 1
+            
+            if @parameters
+              change_host
+              increase_reconnect_delay
+            end
+          end
+        end
+        @socket = used_socket
+      end
+    end
+  
+    def refine_params(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,
+        :backup => false,
+        :timeout => -1,
+        # Parse Timeout
+        :parse_timeout => 5
+      }
+      
+      default_params.merge(params)
+        
+    end
+    
+    def change_host
+      @parameters[:hosts] = @parameters[:hosts].sort_by { rand } if @parameters[:randomize]
+      
+      # Set first as master and send it to the end of array
+      current_host = @parameters[:hosts].shift
+      @parameters[:hosts] << current_host
+      
+      @ssl = current_host[:ssl]
+      @host = current_host[:host]
+      @port = current_host[:port] || Connection::default_port(@ssl)
+      @login = current_host[:login] || ""
+      @passcode = current_host[:passcode] || ""
+      
+    end
+    
+    def max_reconnect_attempts?
+      !(@parameters.nil? || @parameters[:max_reconnect_attempts].nil?) && @parameters[:max_reconnect_attempts] != 0 && @connection_attempts >= @parameters[:max_reconnect_attempts]
+    end
+    
+    def increase_reconnect_delay
+
+      @reconnect_delay *= @parameters[:back_off_multiplier] if @parameters[:use_exponential_back_off] 
+      @reconnect_delay = @parameters[:max_reconnect_delay] if @reconnect_delay > @parameters[:max_reconnect_delay]
+      
+      @reconnect_delay
+    end
+
+    # Is this connection open?
+    def open?
+      !@closed
+    end
+
+    # Is this connection closed?
+    def closed?
+      @closed
+    end
+
+    # Begin a transaction, requires a name for the transaction
+    def begin(name, headers = {})
+      headers[:transaction] = name
+      transmit("BEGIN", headers)
+    end
+
+    # Acknowledge a message, used when a subscription has specified
+    # client acknowledgement ( connection.subscribe "/queue/a", :ack => 'client'g
+    #
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def ack(message_id, headers = {})
+      headers['message-id'] = message_id
+      transmit("ACK", headers)
+    end
+
+    # Commit a transaction by name
+    def commit(name, headers = {})
+      headers[:transaction] = name
+      transmit("COMMIT", headers)
+    end
+
+    # Abort a transaction by name
+    def abort(name, headers = {})
+      headers[:transaction] = name
+      transmit("ABORT", headers)
+    end
+
+    # Subscribe to a destination, must specify a name
+    def subscribe(name, headers = {}, subId = nil)
+      headers[:destination] = name
+      transmit("SUBSCRIBE", headers)
+
+      # Store the sub so that we can replay if we reconnect.
+      if @reliable
+        subId = name if subId.nil?
+        @subscriptions[subId] = headers
+      end
+    end
+
+    # Unsubscribe from a destination, must specify a name
+    def unsubscribe(name, headers = {}, subId = nil)
+      headers[:destination] = name
+      transmit("UNSUBSCRIBE", headers)
+      if @reliable
+        subId = name if subId.nil?
+        @subscriptions.delete(subId)
+      end
+    end
+
+    # Publish message to destination
+    #
+    # To disable content length header ( :suppress_content_length => true )
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' )
+    def publish(destination, message, headers = {})
+      headers[:destination] = destination
+      transmit("SEND", headers, message)
+    end
+    
+    def obj_send(*args)
+      __send__(*args)
+    end
+    
+    def send(*args)
+      warn("This method is deprecated and will be removed on the next release. Use 'publish' instead")
+      publish(*args)
+    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 )
+    # Accepts a force client acknowledgement option (:force_client_ack => true)
+    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}"
+      message_id = message.headers.delete(:'message-id')
+      
+      begin
+        self.begin transaction_id
+        
+        if client_ack?(message) || options[:force_client_ack]
+          self.ack(message_id, :transaction => transaction_id)
+        end
+        
+        if retry_count <= options[:max_redeliveries]
+          self.publish(message.headers[:destination], message.body, message.headers.merge(:transaction => transaction_id))
+        else
+          # Poison ack, sending the message to the DLQ
+          self.publish(options[:dead_letter_queue], message.body, message.headers.merge(:transaction => transaction_id, :original_destination => message.headers[:destination], :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]
+      if @logger && @logger.respond_to?(:on_disconnect)
+        @logger.on_disconnect(log_params)
+      end
+      close_socket
+    end
+
+    # Return a pending message if one is available, otherwise
+    # return nil
+    def poll
+      # No need for a read lock here.  The receive method eventually fullfills
+      # that requirement.
+      return nil if @socket.nil? || !@socket.ready?
+      receive
+    end
+
+    # Receive a frame, block until the frame is received
+    def __old_receive
+      # The recive my fail so we may need to retry.
+      while TRUE
+        begin
+          used_socket = socket
+          return _receive(used_socket)
+        rescue
+          @failure = $!
+          raise unless @reliable
+          errstr = "receive failed: #{$!}"
+          if @logger && @logger.respond_to?(:on_miscerr)
+            @logger.on_miscerr(log_params, errstr)
+          else
+            $stderr.print errstr
+          end
+        end
+      end
+    end
+
+    def receive
+      super_result = __old_receive
+      if super_result.nil? && @reliable
+        errstr = "connection.receive returning EOF as nil - resetting connection.\n"
+        if @logger && @logger.respond_to?(:on_miscerr)
+          @logger.on_miscerr(log_params, errstr)
+        else
+          $stderr.print errstr
+        end
+        @socket = nil
+        super_result = __old_receive
+      end
+      return super_result
+    end
+
+    private
+
+      def _receive( read_socket )
+        @read_semaphore.synchronize do
+          line = read_socket.gets
+
+          return nil if line.nil?
+
+          # If the reading hangs for more than X seconds, abort the parsing process.
+          # X defaults to 5.  Override allowed in connection hash parameters.
+          Timeout::timeout(@parse_timeout, 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 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
+              message_body += char while (char = parse_char(read_socket.getc)) != "\0"
+            end
+
+            # If the buffer isn't empty, reads trailing new lines.
+            # Note: experiments with JRuby seem to show that .ready? never
+            # returns true.  This means that this code to drain trailing new
+            # lines never runs using JRuby.
+            while read_socket.ready?
+              last_char = read_socket.getc
+              break unless last_char
+              if parse_char(last_char) != "\n"
+                read_socket.ungetc(last_char)
+                break
+              end
+            end
+            # And so, a JRuby hack.  Remove any new lines at the start of the 
+            # next buffer.
+            message_header.gsub!(/^\n?/, "")
+
+            # 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
+            used_socket = socket
+            _transmit(used_socket, command, headers, body)
+            return
+          rescue Stomp::Error::MaxReconnectAttempts => e
+              raise
+          rescue
+            @failure = $!
+            raise unless @reliable
+            errstr = "transmit to #{@host} failed: #{$!}\n"
+            if @logger && @logger.respond_to?(:on_miscerr)
+              @logger.on_miscerr(log_params, errstr)
+            else
+              $stderr.print errstr
+            end
+          end
+        end
+      end
+
+      def _transmit(used_socket, command, headers = {}, body = '')
+        @transmit_semaphore.synchronize do
+          # Handle nil body
+          body = '' if body.nil?
+          # The content-length should be expressed in bytes.
+          # Ruby 1.8: String#length => # of bytes; Ruby 1.9: String#length => # of characters
+          # With Unicode strings, # of bytes != # of characters.  So, use String#bytesize when available.
+          body_length_bytes = body.respond_to?(:bytesize) ? body.bytesize : body.length
+ 
+          # 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/
+          # Lets send this header in the message, so it can maintain state when using unreceive
+          headers['content-length'] = "#{body_length_bytes}" unless headers[: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
+
+        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
+        # Use keepalive
+        used_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        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
+
+      def log_params
+        lparms = @parameters.clone
+        lparms[:cur_host] = @host
+        lparms[:cur_port] = @port
+        lparms[:cur_login] = @login
+        lparms[:cur_passcode] = @passcode
+        lparms[:cur_ssl] = @ssl
+        lparms[:cur_recondelay] = @reconnect_delay
+        lparms[:cur_parseto] = @parse_timeout
+        lparms[:cur_conattempts] = @connection_attempts
+        #
+        lparms
+      end
+  end
+
+end
+

=== added file 'lib/stomp/errors.rb'
--- lib/stomp/errors.rb	1970-01-01 00:00:00 +0000
+++ lib/stomp/errors.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,33 @@
+module Stomp
+  module Error
+    class InvalidFormat < RuntimeError
+      def message
+        "Invalid message - invalid format"
+      end
+    end
+
+    class InvalidServerCommand < RuntimeError
+      def message
+        "Invalid command from server"
+      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

=== added directory 'lib/stomp/ext'
=== added file 'lib/stomp/ext/hash.rb'
--- lib/stomp/ext/hash.rb	1970-01-01 00:00:00 +0000
+++ lib/stomp/ext/hash.rb	2011-07-31 16:48:34 +0000
@@ -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.method_defined?(:symbolize_keys)
+end
\ No newline at end of file

=== added file 'lib/stomp/message.rb'
--- lib/stomp/message.rb	1970-01-01 00:00:00 +0000
+++ lib/stomp/message.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,68 @@
+module Stomp
+
+  # Container class for frames, misnamed technically
+  class Message
+    attr_accessor :command, :headers, :body, :original
+
+		@@allowed_commands = [ 'CONNECTED', 'MESSAGE', 'RECEIPT', 'ERROR' ]
+
+    def initialize(frame)
+			# p frame
+      # Set default empty values
+      self.command = ''
+      self.headers = {}
+      self.body = ''
+      self.original = frame
+      return self if is_blank?(frame)
+			# Figure out where individual parts of the frame begin and end.
+			command_index = frame.index("\n")
+			raise Stomp::Error::InvalidFormat, 'command index' unless command_index
+			#
+			headers_index = frame.index("\n\n", command_index+1)
+			raise Stomp::Error::InvalidFormat, 'headers index' unless headers_index
+			#
+			lastnull_index = frame.rindex("\0")
+			raise Stomp::Error::InvalidFormat, 'lastnull index' unless lastnull_index
+
+			# Extract working copies of each frame part
+			work_command = frame[0..command_index-1]
+			raise Stomp::Error::InvalidServerCommand, "invalid command: #{work_command.inspect}" unless @@allowed_commands.include?(work_command)
+			#
+			work_headers = frame[command_index+1..headers_index-1]
+			raise Stomp::Error::InvalidFormat, 'nil headers' unless work_headers
+			#
+			work_body = frame[headers_index+2..lastnull_index-1]
+			raise Stomp::Error::InvalidFormat, 'nil body' unless work_body
+      # Set the frame values
+      self.command = work_command
+      work_headers.split("\n").map do |value|
+        parsed_value = value.match /^([\w|-]*):(.*)$/
+				raise Stomp::Error::InvalidFormat, 'parsed header value' unless parsed_value
+        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 work_body.length != body_length
+      end
+      self.body = work_body[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
+

=== added file 'lib/stomp/version.rb'
--- lib/stomp/version.rb	1970-01-01 00:00:00 +0000
+++ lib/stomp/version.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,8 @@
+module Stomp
+  module Version  #:nodoc: all
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 9
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

=== added directory 'spec'
=== added file 'spec/client_shared_examples.rb'
--- spec/client_shared_examples.rb	1970-01-01 00:00:00 +0000
+++ spec/client_shared_examples.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+shared_examples_for "standard Client" do
+
+  before(:each) do
+    @destination = "/queue/test/ruby/client"
+    @message_text = "test_client-#{Time.now.to_i}"
+  end
+
+  describe "the closed? method" do
+    it "should be false when the connection is open" do
+      @mock_connection.stub!(:closed?).and_return(false)
+      @client.closed?.should == false
+    end
+
+    it "should be true when the connection is closed" do
+      @mock_connection.stub!(:closed?).and_return(true)
+      @client.closed?.should == true
+    end
+  end
+
+  describe "the open? method" do
+    it "should be true when the connection is open" do
+      @mock_connection.stub!(:open?).and_return(true)
+      @client.open?.should == true
+    end
+
+    it "should be false when the connection is closed" do
+      @mock_connection.stub!(:open?).and_return(false)
+      @client.open?.should == false
+    end
+  end
+
+  describe "the subscribe method" do
+
+    before(:each) do
+      @mock_connection.stub!(:subscribe).and_return(true)
+    end
+
+    it "should raise RuntimeError if not passed a block" do
+      lambda {
+        @client.subscribe(@destination)
+      }.should raise_error
+    end
+
+    it "should not raise an error when passed a block" do
+      lambda {
+        @client.subscribe(@destination) {|msg| received = msg}
+      }.should_not raise_error
+    end
+
+    it "should raise RuntimeError on duplicate subscriptions" do
+      lambda {
+        @client.subscribe(@destination)
+        @client.subscribe(@destination)
+      }.should raise_error
+    end
+
+    it "should raise RuntimeError with duplicate id headers" do
+      lambda {
+        @client.subscribe(@destination, {'id' => 'abcdef'})
+        @client.subscribe(@destination, {'id' => 'abcdef'})
+      }.should raise_error
+    end
+
+  end
+
+end
+

=== added file 'spec/client_spec.rb'
--- spec/client_spec.rb	1970-01-01 00:00:00 +0000
+++ spec/client_spec.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,312 @@
+require 'spec_helper'
+require 'client_shared_examples'
+
+
+describe Stomp::Client do
+
+  before(:each) do
+    @mock_connection = mock('connection')
+    Stomp::Connection.stub!(:new).and_return(@mock_connection)
+  end
+
+  describe "(created with no params)" do
+
+    before(:each) do
+      @client = Stomp::Client.new
+    end
+
+    it "should not return any errors" do
+      lambda {
+        @client = Stomp::Client.new
+      }.should_not raise_error
+    end
+
+    it "should not return any errors when created with the open constructor" do
+      lambda {
+        @client = Stomp::Client.open
+      }.should_not raise_error
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with invalid params)" do
+
+    it "should return ArgumentError if host is nil" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', nil)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if host is empty" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', '')
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is nil" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', nil)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is < 1" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', 0)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is > 65535" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', 65536)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is empty" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', '')
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if reliable is something other than true or false" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', '12345', 'foo')
+      }.should raise_error
+    end
+
+  end
+
+
+  describe "(created with positional params)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('testlogin', 'testpassword', 'localhost', '12345', false)
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpassword')
+      @client.host.should eql('localhost')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://foobar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('foobar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and a host with a '-')" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://foo-bar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('foo-bar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+  
+  describe "(created with authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://test-login:testpasscode@foobar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('test-login')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('foobar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with authenticating stomp:// URL and a host with a '-')" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://test-login:testpasscode@foo-bar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('test-login')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('foo-bar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://host.foobar.com:12345')
+    end
+
+    after(:each) do
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('host.foobar.com')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://testlogin:[e-mail]:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('host.foobar.com')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+  
+  describe "(created with failover URL)" do
+    before(:each) do
+      #default options
+      @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,
+        :backup => false,
+        :timeout => -1
+      }
+    end
+    it "should properly parse a URL with failover://" do
+      url = "failover://(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)"
+
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with failover:" do
+      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost1:61617),stomp://login3:passcode3@remotehost2:61618)"
+      
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost1", :port => 61617, :ssl => false},
+        {:login => "login3", :passcode => "passcode3", :host => "remotehost2", :port => 61618, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL without user and password" do
+      url = "failover:(stomp://localhost:61616,stomp://remotehost:61617)"
+
+      @parameters[:hosts] = [
+        {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "", :passcode => "", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with user and/or password blank" do
+      url = "failover:(stomp://:@localhost:61616,stomp://:@remotehost:61617)"
+      
+      @parameters[:hosts] = [
+        {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "", :passcode => "", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with the options query" do
+      query = "initialReconnectDelay=5000&maxReconnectDelay=60000&useExponentialBackOff=false&backOffMultiplier=3"
+      query += "&maxReconnectAttempts=4&randomize=true&backup=true&timeout=10000"
+      
+      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,
+        :use_exponential_back_off => false,
+        :back_off_multiplier => 3,
+        :max_reconnect_attempts => 4,
+        :randomize => true,
+        :backup => false,
+        :timeout => -1
+      }
+      
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+  end
+
+end

=== added file 'spec/connection_spec.rb'
--- spec/connection_spec.rb	1970-01-01 00:00:00 +0000
+++ spec/connection_spec.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,365 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Stomp::Connection do
+
+  before(:each) do
+    @parameters = {
+      :hosts => [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ],
+      :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,
+      :backup => false,
+      :timeout => -1,
+      :parse_timeout => 5,
+      :connect_headers => {}
+    }
+        
+    #POG:
+    class Stomp::Connection
+      def _receive( s )
+      end
+    end
+    
+    # clone() does a shallow copy, we want a deep one so we can garantee the hosts order
+    normal_parameters = Marshal::load(Marshal::dump(@parameters))
+
+    @tcp_socket = mock(:tcp_socket, :close => nil, :puts => nil, :write => nil, :setsockopt => nil)
+    TCPSocket.stub!(:open).and_return @tcp_socket
+    @connection = Stomp::Connection.new(normal_parameters)
+  end
+  
+  describe "(created using a hash)" do
+    it "should uncamelize and symbolize the main hash keys" do
+      used_hash = {
+        "hosts" => [
+          {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false},
+          {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false}
+        ],
+        "initialReconnectDelay" => 0.01,
+        "maxReconnectDelay" => 30.0,
+        "useExponentialBackOff" => true,
+        "backOffMultiplier" => 2,
+        "maxReconnectAttempts" => 0,
+        "randomize" => false,
+        "backup" => false,
+        "timeout" => -1,
+        "parse_timeout" => 5,
+      }
+      
+      @connection = Stomp::Connection.new(used_hash)
+      @connection.instance_variable_get(:@parameters).should == @parameters
+    end
+    
+    it "should be reliable" do
+      @connection.instance_variable_get(:@reliable).should be_true
+    end
+    it "should start with first host in array" do
+      @connection.instance_variable_get(:@host).should == "localhost"
+    end
+    
+    it "should change host to next one with randomize false" do
+      @connection.change_host
+      @connection.instance_variable_get(:@host).should == "remotehost"
+    end
+    
+    it "should use default port (61613) if none is given" do
+      hash = {:hosts => [{:login => "login2", :passcode => "passcode2", :host => "remotehost", :ssl => false}]}
+      @connection = Stomp::Connection.new hash
+      @connection.instance_variable_get(:@port).should == 61613
+    end
+    
+    context "when dealing with content-length header" do
+      it "should not suppress it when receiving :suppress_content_length => false" do
+        @tcp_socket.should_receive(:puts).with("content-length:7")
+        @connection.publish "/queue", "message", :suppress_content_length => false
+      end
+      
+      it "should not suppress it when :suppress_content_length is nil" do
+        @tcp_socket.should_receive(:puts).with("content-length:7")
+        @connection.publish "/queue", "message"
+      end
+    
+      it "should suppress it when receiving :suppress_content_length => true" do
+        @tcp_socket.should_not_receive(:puts).with("content-length:7")
+        @connection.publish "/queue", "message", :suppress_content_length => true
+      end
+      
+      it "should get the correct byte length when dealing with Unicode characters" do
+        @tcp_socket.should_receive(:puts).with("content-length:18")
+        @connection.publish "/queue", "сообщение"  # 'сообщение' is 'message' in Russian
+      end
+    end
+    
+    describe "when unacknowledging a message" do
+      
+      before :each do
+        @message = Stomp::Message.new(nil)
+        @message.body = "message body"
+        @message.headers = {"destination" => "/queue/original", "message-id" => "ID"}
+        
+        @transaction_id = "transaction-#{@message.headers["message-id"]}-0"
+        
+        @retry_headers = {
+          :destination => @message.headers["destination"],
+          :transaction => @transaction_id,
+          :retry_count => 1
+        }
+      end
+      
+      it "should use a transaction" do
+        @connection.should_receive(:begin).with(@transaction_id).ordered
+        @connection.should_receive(:commit).with(@transaction_id).ordered
+        @connection.unreceive @message
+      end
+    
+      it "should acknowledge the original message if ack mode is client" do
+        @connection.should_receive(:ack).with(@message.headers["message-id"], :transaction => @transaction_id)
+        @connection.subscribe(@message.headers["destination"], :ack => "client")
+        @connection.unreceive @message
+      end
+      
+      it "should acknowledge the original message if forced" do      
+        @connection.subscribe(@message.headers["destination"])
+        @connection.should_receive(:ack)
+        @connection.unreceive(@message, :force_client_ack => true)
+      end
+      
+      it "should not acknowledge the original message if ack mode is not client or it did not subscribe to the queue" do      
+        @connection.subscribe(@message.headers["destination"], :ack => "client")
+        @connection.should_receive(:ack)
+        @connection.unreceive @message
+        
+        # At this time the message headers are symbolized
+        @connection.unsubscribe(@message.headers[:destination])
+        @connection.should_not_receive(:ack)
+        @connection.unreceive @message
+        @connection.subscribe(@message.headers[:destination], :ack => "individual")
+        @connection.unreceive @message
+      end
+      
+      it "should send the message back to the queue it came" do
+        @connection.subscribe(@message.headers["destination"], :ack => "client")
+        @connection.should_receive(:publish).with(@message.headers["destination"], @message.body, @retry_headers)
+        @connection.unreceive @message
+      end
+      
+      it "should increment the retry_count header" do
+        @message.headers["retry_count"] = 4
+        @connection.unreceive @message
+        @message.headers[:retry_count].should == 5
+      end
+      
+      it "should not send the message to the dead letter queue as persistent if redeliveries equal max redeliveries" do
+        max_redeliveries = 5
+        dead_letter_queue = "/queue/Dead"
+        
+        @message.headers["retry_count"] = max_redeliveries
+        transaction_id = "transaction-#{@message.headers["message-id"]}-#{@message.headers["retry_count"]}"
+        @retry_headers = @retry_headers.merge :transaction => transaction_id, :retry_count => @message.headers["retry_count"] + 1
+        @connection.should_receive(:publish).with(@message.headers["destination"], @message.body, @retry_headers)
+        @connection.unreceive @message, :dead_letter_queue => dead_letter_queue, :max_redeliveries => max_redeliveries
+      end
+      
+      it "should send the message to the dead letter queue as persistent if max redeliveries have been reached" do
+        max_redeliveries = 5
+        dead_letter_queue = "/queue/Dead"
+        
+        @message.headers["retry_count"] = max_redeliveries + 1
+        transaction_id = "transaction-#{@message.headers["message-id"]}-#{@message.headers["retry_count"]}"
+        @retry_headers = @retry_headers.merge :persistent => true, :transaction => transaction_id, :retry_count => @message.headers["retry_count"] + 1, :original_destination=> @message.headers["destination"]
+        @connection.should_receive(:publish).with(dead_letter_queue, @message.body, @retry_headers)
+        @connection.unreceive @message, :dead_letter_queue => dead_letter_queue, :max_redeliveries => max_redeliveries
+      end
+      
+      it "should rollback the transaction and raise the exception if happened during transaction" do
+        @connection.should_receive(:publish).and_raise "Error"
+        @connection.should_receive(:abort).with(@transaction_id)
+        lambda {@connection.unreceive @message}.should raise_error("Error")
+      end
+    
+    end
+    
+    describe "when sending a nil message body" do
+      it "should should not raise an error" do
+        @connection = Stomp::Connection.new("niluser", "nilpass", "localhost", 61613)
+        lambda {
+          @connection.publish("/queue/nilq", nil)
+        }.should_not raise_error
+     end
+    end
+
+    describe "when using ssl" do
+
+      # Mocking ruby's openssl extension, so we can test without requiring openssl  
+      module ::OpenSSL
+        module SSL
+          VERIFY_NONE = 0
+          
+          class SSLSocket
+          end
+          
+          class SSLContext
+            attr_accessor :verify_mode
+          end
+        end
+      end
+      
+      before(:each) do
+        ssl_parameters = {:hosts => [{:login => "login2", :passcode => "passcode2", :host => "remotehost", :ssl => true}]}
+        @ssl_socket = mock(:ssl_socket, :puts => nil, :write => nil, :setsockopt => nil)
+        
+        TCPSocket.should_receive(:open).and_return @tcp_socket
+        OpenSSL::SSL::SSLSocket.should_receive(:new).and_return(@ssl_socket)
+        @ssl_socket.should_receive(:connect)
+        
+        @connection = Stomp::Connection.new ssl_parameters
+      end
+    
+      it "should use ssl socket if ssl use is enabled" do
+        @connection.instance_variable_get(:@socket).should == @ssl_socket
+      end
+    
+      it "should use default port for ssl (61612) if none is given" do
+        @connection.instance_variable_get(:@port).should == 61612
+      end
+      
+    end
+
+    describe "when called to increase reconnect delay" do
+      it "should exponentialy increase when use_exponential_back_off is true" do
+        @connection.increase_reconnect_delay.should == 0.02
+        @connection.increase_reconnect_delay.should == 0.04
+        @connection.increase_reconnect_delay.should == 0.08
+      end
+      it "should not increase when use_exponential_back_off is false" do
+        @parameters[:use_exponential_back_off] = false
+        @connection = Stomp::Connection.new(@parameters)
+        @connection.increase_reconnect_delay.should == 0.01
+        @connection.increase_reconnect_delay.should == 0.01
+      end
+      it "should not increase when max_reconnect_delay is reached" do
+        @parameters[:initial_reconnect_delay] = 8.0
+        @connection = Stomp::Connection.new(@parameters)
+        @connection.increase_reconnect_delay.should == 16.0
+        @connection.increase_reconnect_delay.should == 30.0
+      end
+      
+      it "should change to next host on socket error" do
+        @connection.instance_variable_set(:@failure, "some exception")
+        #retries the same host
+        TCPSocket.should_receive(:open).and_raise "exception"
+        #tries the new host
+        TCPSocket.should_receive(:open).and_return @tcp_socket
+
+        @connection.socket
+        @connection.instance_variable_get(:@host).should == "remotehost"
+      end
+      
+      it "should use default options if those where not given" do
+        expected_hash = {
+          :hosts => [
+            {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false},
+            # Once connected the host is sent to the end of array
+            {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false}
+          ],
+          :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,
+          :backup => false,
+          :timeout => -1,
+          :parse_timeout => 5,
+          :connect_headers => {}
+        }
+        
+        used_hash =  {
+          :hosts => [
+            {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+            {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+          ]
+        }
+        
+        @connection = Stomp::Connection.new(used_hash)
+        @connection.instance_variable_get(:@parameters).should == expected_hash
+      end
+      
+      it "should use the given options instead of default ones" do
+        used_hash = {
+          :hosts => [
+            {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false},
+            {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false}
+          ],
+          :initial_reconnect_delay => 5.0,
+          :max_reconnect_delay => 100.0,
+          :use_exponential_back_off => false,
+          :back_off_multiplier => 3,
+          :max_reconnect_attempts => 10,
+          :randomize => true,
+          :backup => false,
+          :timeout => -1,
+          :parse_timeout => 20,
+          :connect_headers => {:lerolero => "ronaldo"},
+          :dead_letter_queue => "queue/Error",
+          :max_redeliveries => 10
+        }
+        
+        @connection = Stomp::Connection.new(used_hash)
+        received_hash = @connection.instance_variable_get(:@parameters)
+        
+        #Using randomize we can't assure the hosts order
+        received_hash.delete(:hosts)
+        used_hash.delete(:hosts)
+        
+        received_hash.should == used_hash
+      end
+      
+    end
+    
+  end
+  
+  describe "when closing a socket" do
+    it "should close the tcp connection" do
+      @tcp_socket.should_receive(:close)
+      @connection.obj_send(:close_socket).should be_true
+    end
+    it "should ignore exceptions" do
+      @tcp_socket.should_receive(:close).and_raise "exception"
+      @connection.obj_send(:close_socket).should be_true
+    end
+  end
+
+  describe "when checking if max reconnect attempts have been reached" do
+    it "should return false if not using failover" do
+      host = @parameters[:hosts][0]
+      @connection = Stomp::Connection.new(host[:login], host[:passcode], host[:host], host[:port], reliable = true, 5, connect_headers = {})
+      @connection.instance_variable_set(:@connection_attempts, 10000)
+      @connection.max_reconnect_attempts?.should be_false
+    end
+    it "should return false if max_reconnect_attempts = 0" do
+      @connection.instance_variable_set(:@connection_attempts, 10000)
+      @connection.max_reconnect_attempts?.should be_false
+    end
+    it "should return true if connection attempts > max_reconnect_attempts" do
+      limit = 10000
+      @parameters[:max_reconnect_attempts] = limit
+      @connection = Stomp::Connection.new(@parameters)
+      
+      @connection.instance_variable_set(:@connection_attempts, limit-1)
+      @connection.max_reconnect_attempts?.should be_false
+      
+      @connection.instance_variable_set(:@connection_attempts, limit)
+      @connection.max_reconnect_attempts?.should be_true
+      
+    end
+  end
+end
+

=== added file 'spec/message_spec.rb'
--- spec/message_spec.rb	1970-01-01 00:00:00 +0000
+++ spec/message_spec.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Stomp::Message do
+
+  context 'when initializing a new message' do
+
+    context 'with invalid parameters' do
+      it 'should return an empty message when receiving an empty string or nil parameter' do
+        message = Stomp::Message.new('')
+        message.should be_empty
+      end
+
+      it 'should raise Stomp::Error::InvalidFormat when receiving a invalid formated message' do
+        lambda{ Stomp::Message.new('any invalid format') }.should raise_error(Stomp::Error::InvalidFormat)
+      end
+    end
+
+    context 'with valid parameters' do
+      subject do
+        @message = ["CONNECTED\n", "session:host_address\n", "\n", "body value\n", "\000\n"]
+        Stomp::Message.new(@message.join)
+      end
+
+      it 'should parse the headers' do
+        subject.headers.should ==  {'session' => 'host_address'}
+      end
+
+      it 'should parse the body' do
+        subject.body.should == @message[3]
+      end
+
+      it 'should parse the command' do
+        subject.command.should == @message[0].chomp
+      end
+    end
+    
+    context 'with multiple line ends on the body' do
+      subject do
+        @message = ["CONNECTED\n", "session:host_address\n", "\n", "body\n\n value\n\n\n", "\000\n"]
+        Stomp::Message.new(@message.join)
+      end
+
+      it 'should parse the headers' do
+        subject.headers.should ==  {'session' => 'host_address'}
+      end
+
+      it 'should parse the body' do
+        subject.body.should == @message[3]
+      end
+
+      it 'should parse the command' do
+        subject.command.should == @message[0].chomp
+      end
+    end
+  end
+end

=== added file 'spec/spec_helper.rb'
--- spec/spec_helper.rb	1970-01-01 00:00:00 +0000
+++ spec/spec_helper.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,6 @@
+require 'rspec'
+dir = File.dirname(__FILE__)
+lib_path = File.expand_path("#{dir}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'stomp'

=== added file 'stomp.gemspec'
--- stomp.gemspec	1970-01-01 00:00:00 +0000
+++ stomp.gemspec	2011-07-31 16:48:34 +0000
@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{stomp}
+  s.version = "1.1.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Brian McCallister}, %q{Marius Mathiesen}, %q{Thiago Morello}, %q{Guy M. Allard}]
+  s.date = %q{2011-06-15}
+  s.description = %q{Ruby client for the Stomp messaging protocol}
+  s.email = [%q{[e-mail]}, %q{[e-mail]}, %q{[e-mail]}, %q{[e-mail]}]
+  s.executables = [%q{catstomp}, %q{stompcat}]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    "CHANGELOG.rdoc",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "bin/catstomp",
+    "bin/stompcat",
+    "examples/consumer.rb",
+    "examples/logexamp.rb",
+    "examples/publisher.rb",
+    "examples/slogger.rb",
+    "lib/stomp.rb",
+    "lib/stomp/client.rb",
+    "lib/stomp/connection.rb",
+    "lib/stomp/errors.rb",
+    "lib/stomp/ext/hash.rb",
+    "lib/stomp/message.rb",
+    "lib/stomp/version.rb",
+    "spec/client_shared_examples.rb",
+    "spec/client_spec.rb",
+    "spec/connection_spec.rb",
+    "spec/message_spec.rb",
+    "spec/spec_helper.rb",
+    "stomp.gemspec",
+    "test/test_client.rb",
+    "test/test_connection.rb",
+    "test/test_helper.rb",
+    "test/test_message.rb"
+  ]
+  s.homepage = %q{https://rubygems.org/gems/stomp}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{Ruby client for the Stomp messaging protocol}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.3"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.3"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.3"])
+  end
+end
+

=== added directory 'test'
=== added file 'test/test_client.rb'
--- test/test_client.rb	1970-01-01 00:00:00 +0000
+++ test/test_client.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,364 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'test_helper'
+
+class TestClient < Test::Unit::TestCase
+  include TestBase
+  
+  def setup
+    @client = Stomp::Client.new(user, passcode, host, port)
+    # Multi_thread test data
+    @max_threads = 20
+    @max_msgs = 50
+  end
+
+  def teardown
+    @client.close if @client # allow tests to close
+  end
+
+  def test_ack_api_works
+    @client.publish destination, message_text, {:suppress_content_length => true}
+
+    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
+
+  def test_asynch_subscribe
+    received = false
+    @client.subscribe(destination) {|msg| received = msg}
+    @client.publish destination, message_text
+    sleep 0.01 until received
+
+    assert_equal message_text, received.body
+  end
+
+  def test_noack
+    @client.publish destination, message_text
+
+    received = nil
+    @client.subscribe(destination, :ack => :client) {|msg| received = msg}
+    sleep 0.01 until received
+    assert_equal message_text, received.body
+    @client.close
+
+    # was never acked so should be resent to next client
+
+    @client = Stomp::Client.new(user, passcode, host, port)
+    received2 = nil
+    @client.subscribe(destination) {|msg| received2 = msg}
+    sleep 0.01 until received2
+
+    assert_equal message_text, received2.body
+    assert_equal received.body, received2.body
+    assert_equal received.headers['message-id'], received2.headers['message-id']
+  end
+
+  def test_receipts
+    receipt = false
+    @client.publish(destination, message_text) {|r| receipt = r}
+    sleep 0.1 until receipt
+
+    message = nil
+    @client.subscribe(destination) {|m| message = m}
+    sleep 0.1 until message
+    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_publish_then_sub
+    @client.publish destination, message_text
+    message = nil
+    @client.subscribe(destination) {|m| message = m}
+    sleep 0.01 until message
+
+    assert_equal message_text, message.body
+  end
+
+  def test_subscribe_requires_block
+    assert_raise(RuntimeError) do
+      @client.subscribe destination
+    end
+  end
+
+  def test_transactional_publish
+    @client.begin 'tx1'
+    @client.publish destination, message_text, :transaction => 'tx1'
+    @client.commit 'tx1'
+
+    message = nil
+    @client.subscribe(destination) {|m| message = m}
+    sleep 0.01 until message
+
+    assert_equal message_text, message.body
+  end
+
+  def test_transaction_publish_then_rollback
+    @client.begin 'tx1'
+    @client.publish destination, "first_message", :transaction => 'tx1'
+    @client.abort 'tx1'
+
+    @client.begin 'tx1'
+    @client.publish destination, "second_message", :transaction => 'tx1'
+    @client.commit 'tx1'
+
+    message = nil
+    @client.subscribe(destination) {|m| message = m}
+    sleep 0.01 until message
+    assert_equal "second_message", message.body
+  end
+
+  def test_transaction_ack_rollback_with_new_client
+    @client.publish destination, message_text
+
+    @client.begin 'tx1'
+    message = nil
+    @client.subscribe(destination, :ack => 'client') {|m| message = m}
+    sleep 0.01 until message
+    assert_equal message_text, message.body
+    @client.acknowledge message, :transaction => 'tx1'
+    message = nil
+    @client.abort 'tx1'
+
+    # lets recreate the connection
+    teardown
+    setup
+    @client.subscribe(destination, :ack => 'client') {|m| message = m}
+
+    Timeout::timeout(4) do
+      sleep 0.01 until message
+    end
+    assert_not_nil message
+    assert_equal message_text, message.body
+
+    @client.begin 'tx2'
+    @client.acknowledge message, :transaction => 'tx2'
+    @client.commit 'tx2'
+  end
+
+  def test_raise_on_multiple_subscriptions_to_same_destination
+    subscribe_dest = destination
+    @client.subscribe(subscribe_dest) {|m| nil }
+    assert_raise(RuntimeError) do
+      @client.subscribe(subscribe_dest) {|m| nil }
+    end
+  end
+
+  def test_raise_on_multiple_subscriptions_to_same_id
+    subscribe_dest = destination
+    @client.subscribe(subscribe_dest, {'id' => 'myid'}) {|m| nil }
+    assert_raise(RuntimeError) do
+      @client.subscribe(subscribe_dest, {'id' => 'myid'}) {|m| nil }
+    end
+  end
+
+  def test_raise_on_multiple_subscriptions_to_same_id_mixed
+    subscribe_dest = destination
+    @client.subscribe(subscribe_dest, {'id' => 'myid'}) {|m| nil }
+    assert_raise(RuntimeError) do
+      @client.subscribe(subscribe_dest, {:id => 'myid'}) {|m| nil }
+    end
+  end
+
+  def  test_asterisk_wildcard_subscribe
+    queue_base_name = destination
+    queue1 = queue_base_name + ".a"
+    queue2 = queue_base_name + ".b"
+    send_message = message_text
+    @client.publish queue1, send_message
+    @client.publish queue2, send_message
+    messages = []
+    @client.subscribe(queue_base_name + ".*", :ack => 'client') do |m|
+      messages << m
+      @client.acknowledge(m)
+    end
+    Timeout::timeout(4) do
+      sleep 0.1 while messages.size < 2
+    end
+
+    messages.each do |message|
+      assert_not_nil message
+      assert_equal send_message, message.body
+    end
+    results = [queue1, queue2].collect do |queue|
+      messages.any? do |message| 
+        message_source = message.headers['destination']
+        message_source == queue
+      end
+    end
+    assert results.all?{|a| a == true }
+
+  end unless ENV['STOMP_NOWILD']
+
+  def test_greater_than_wildcard_subscribe
+    queue_base_name = destination + "."
+    queue1 = queue_base_name + "foo.a"
+    queue2 = queue_base_name + "bar.a"
+    queue3 = queue_base_name + "foo.b"
+    send_message = message_text
+    @client.publish queue1, send_message
+    @client.publish queue2, send_message
+    @client.publish queue3, send_message
+    messages = []
+    # should subscribe to all three queues
+    @client.subscribe(queue_base_name + ">", :ack => 'client') do |m|
+      messages << m
+      @client.acknowledge(m)
+    end
+    Timeout::timeout(4) do
+      sleep 0.1 while messages.size < 3
+    end
+
+    messages.each do |message|
+      assert_not_nil message
+      assert_equal send_message, message.body
+    end
+    # make sure that the messages received came from the expected queues
+    results = [queue1, queue2, queue3].collect do |queue|
+      messages.any? do |message| 
+        message_source = message.headers['destination']
+        message_source == queue
+      end
+    end
+    assert results.all?{|a| a == true }
+  end unless ENV['STOMP_NOWILD'] || ENV['STOMP_APOLLO']
+
+  def test_transaction_with_client_side_redelivery
+    @client.publish destination, message_text
+
+    @client.begin 'tx1'
+    message = nil
+    @client.subscribe(destination, :ack => 'client') { |m| message = m }
+
+    sleep 0.1 while message.nil?
+
+    assert_equal message_text, message.body
+    @client.acknowledge message, :transaction => 'tx1'
+    message = nil
+    @client.abort 'tx1'
+
+    sleep 0.1 while message.nil?
+
+    assert_not_nil message
+    assert_equal message_text, message.body
+
+    @client.begin 'tx2'
+    @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
+    dest = destination
+    to_send = message_text
+    client = Stomp::Client.new(user, passcode, host, port, true)
+    assert_nothing_raised {
+      client.subscribe(dest, :ack => 'client') { |m| message = m }
+      @client.publish dest, to_send
+      Timeout::timeout(4) do
+        sleep 0.01 until message
+      end
+    }
+    assert_equal to_send, message.body, "first body check"
+    assert_nothing_raised {
+      client.unsubscribe dest # was throwing exception on unsub at one point
+      client.close
+    }
+    #  Same message should remain on the queue.  Receive it again with ack=>auto.
+    message_copy = nil
+    client = Stomp::Client.new(user, passcode, host, port, true)
+    assert_nothing_raised {
+      client.subscribe(dest, :ack => 'auto') { |m| message_copy = m }
+      Timeout::timeout(4) do
+        sleep 0.01 until message_copy
+      end
+    }
+    assert_equal to_send, message_copy.body, "second body check"
+    assert_equal message.headers['message-id'], message_copy.headers['message-id'], "header check"
+  end
+
+  def test_thread_one_subscribe
+    msg = nil
+    dest = destination
+    Thread.new(@client) do |acli|
+      assert_nothing_raised {
+        acli.subscribe(dest) { |m| msg = m }
+        Timeout::timeout(4) do
+          sleep 0.01 until msg
+        end
+      }
+    end
+    #
+    @client.publish(dest, message_text)
+    sleep 1
+    assert_not_nil msg
+  end
+
+  def test_thread_multi_subscribe
+    #
+    lock = Mutex.new
+    msg_ctr = 0
+    dest = destination
+    1.upto(@max_threads) do |tnum|
+      # Threads within threads .....
+      Thread.new(@client) do |acli|
+        assert_nothing_raised {
+          acli.subscribe(dest) { |m| 
+            msg = m
+            lock.synchronize do
+              msg_ctr += 1
+            end
+            # Simulate message processing
+            sleep 0.05
+          }
+        }
+      end
+    end
+    #
+    1.upto(@max_msgs) do |mnum|
+      msg = Time.now.to_s + " #{mnum}"
+      @client.publish(dest, message_text)
+    end
+    #
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 30 : 5
+    sleep_incr = 0.10
+    total_slept = 0
+    while true
+      break if @max_msgs == msg_ctr
+      total_slept += sleep_incr
+      break if total_slept > max_sleep
+      sleep sleep_incr
+    end
+    assert_equal @max_msgs, msg_ctr
+  end
+
+  private
+    def message_text
+      name = caller_method_name unless name
+      "test_client#" + name
+    end
+
+    def destination
+      name = caller_method_name unless name
+      qname = ENV['STOMP_APOLLO'] ? "/queue/test.ruby.stomp." + name : "/queue/test/ruby/stomp/" + name
+    end
+end

=== added file 'test/test_connection.rb'
--- test/test_connection.rb	1970-01-01 00:00:00 +0000
+++ test/test_connection.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,278 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'test_helper'
+
+class TestStomp < Test::Unit::TestCase
+  include TestBase
+  
+  def setup
+    @conn = Stomp::Connection.open(user, passcode, host, port)
+    # Data for multi_thread tests
+    @max_threads = 20
+    @max_msgs = 100
+  end
+
+  def teardown
+    @conn.disconnect if @conn # allow tests to disconnect
+  end
+
+  def test_connection_exists
+    assert_not_nil @conn
+  end
+
+  def test_no_length
+    @conn.subscribe make_destination
+    #
+    @conn.publish make_destination, "test_stomp#test_no_length",
+      { :suppress_content_length => true }
+    msg = @conn.receive
+    assert_equal "test_stomp#test_no_length", msg.body
+    #
+    @conn.publish make_destination, "test_stomp#test_\000_length",
+      { :suppress_content_length => true }
+    msg2 = @conn.receive
+    assert_equal "test_stomp#test_", msg2.body
+  end
+
+  def test_explicit_receive
+    @conn.subscribe make_destination
+    @conn.publish make_destination, "test_stomp#test_explicit_receive"
+    msg = @conn.receive
+    assert_equal "test_stomp#test_explicit_receive", msg.body
+  end
+
+  def test_receipt
+    @conn.subscribe make_destination, :receipt => "abc"
+    msg = @conn.receive
+    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.publish make_destination, "test_stomp#test_client_ack_with_symbol"
+    msg = @conn.receive
+    @conn.ack msg.headers['message-id']
+  end
+
+  def test_embedded_null
+    @conn.subscribe make_destination
+    @conn.publish make_destination, "a\0"
+    msg = @conn.receive
+    assert_equal "a\0" , msg.body
+  end
+
+  def test_connection_open?
+    assert_equal true , @conn.open?
+    @conn.disconnect
+    assert_equal false, @conn.open?
+  end
+
+  def test_connection_closed?
+    assert_equal false, @conn.closed?
+    @conn.disconnect
+    assert_equal true, @conn.closed?
+  end
+
+  def test_response_is_instance_of_message_class
+    @conn.subscribe make_destination
+    @conn.publish make_destination, "a\0"
+    msg = @conn.receive
+    assert_instance_of Stomp::Message , msg
+  end
+
+  def test_message_to_s
+    @conn.subscribe make_destination
+    @conn.publish make_destination, "a\0"
+    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.publish make_destination, "a\n\n"
+    @conn.publish 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_publish_two_messages
+    @conn.subscribe make_destination
+    @conn.publish make_destination, "a\0"
+    @conn.publish 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
+
+  def test_thread_hang_one
+    received = nil
+    Thread.new(@conn) do |amq|
+        while true
+            received = amq.receive
+        end
+    end
+    #
+    @conn.subscribe( make_destination )
+    message = Time.now.to_s
+    @conn.publish(make_destination, message)
+    sleep 1
+    assert_not_nil received
+    assert_equal message, received.body
+  end
+
+  def test_thread_poll_one
+    received = nil
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 5 : 1
+    Thread.new(@conn) do |amq|
+        while true
+          received = amq.poll
+          # One message is needed
+          Thread.exit if received
+          sleep max_sleep
+        end
+    end
+    #
+    @conn.subscribe( make_destination )
+    message = Time.now.to_s
+    @conn.publish(make_destination, message)
+    sleep max_sleep+1
+    assert_not_nil received
+    assert_equal message, received.body
+  end
+
+  def test_multi_thread_receive
+    lock = Mutex.new
+    msg_ctr = 0
+    dest = make_destination
+    #
+    1.upto(@max_threads) do |tnum|
+      Thread.new(@conn) do |amq|
+        while true
+          received = amq.receive
+          lock.synchronize do
+            msg_ctr += 1
+          end
+          # Simulate message processing
+          sleep 0.05
+        end
+      end
+    end
+    #
+    @conn.subscribe( dest )
+    1.upto(@max_msgs) do |mnum|
+      msg = Time.now.to_s + " #{mnum}"
+      @conn.publish(dest, msg)
+    end
+    #
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 30 : 5
+    sleep_incr = 0.10
+    total_slept = 0
+    while true
+      break if @max_msgs == msg_ctr
+      total_slept += sleep_incr
+      break if total_slept > max_sleep
+      sleep sleep_incr
+    end
+    assert_equal @max_msgs, msg_ctr
+  end
+
+  def test_multi_thread_poll
+    #
+    lock = Mutex.new
+    msg_ctr = 0
+    dest = make_destination
+    #
+    1.upto(@max_threads) do |tnum|
+      Thread.new(@conn) do |amq|
+        while true
+          received = amq.poll
+          if received
+            lock.synchronize do
+              msg_ctr += 1
+            end
+            # Simulate message processing
+            sleep 0.05
+          else
+            # Wait a bit for more work
+            sleep 0.05
+          end
+        end
+      end
+    end
+    #
+    @conn.subscribe( dest )
+    1.upto(@max_msgs) do |mnum|
+      msg = Time.now.to_s + " #{mnum}"
+      @conn.publish(dest, msg)
+    end
+    #
+    max_sleep = (RUBY_VERSION =~ /1\.8\.6/) ? 30 : 5
+    sleep_incr = 0.10
+    total_slept = 0
+    while true
+      break if @max_msgs == msg_ctr
+      total_slept += sleep_incr
+      break if total_slept > max_sleep
+      sleep sleep_incr
+    end
+    assert_equal @max_msgs, msg_ctr
+  end
+
+  def test_nil_body
+    dest = make_destination
+    assert_nothing_raised {
+      @conn.publish dest, nil
+    }
+    @conn.subscribe dest
+    msg = @conn.receive
+    assert_equal "", msg.body    
+  end
+
+  private
+    def make_destination
+      name = caller_method_name unless name
+      qname = ENV['STOMP_APOLLO'] ? "/queue/test.ruby.stomp." + name : "/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.publish make_destination, "txn message", 'transaction' => "tx1"
+
+      @conn.publish 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
+

=== added file 'test/test_helper.rb'
--- test/test_helper.rb	1970-01-01 00:00:00 +0000
+++ test/test_helper.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,38 @@
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'test/unit'
+require 'timeout'
+require 'stomp'
+
+# 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
+  # Helper for minitest on 1.9
+  def caller_method_name
+    parse_caller(caller(2).first).last
+  end
+  # Helper for minitest on 1.9
+  def parse_caller(at)
+    if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+      file = Regexp.last_match[1]
+      line = Regexp.last_match[2].to_i
+      method = Regexp.last_match[3]
+      method.gsub!(" ","_")
+      [file, line, method]
+    end
+  end
+end
+

=== added file 'test/test_message.rb'
--- test/test_message.rb	1970-01-01 00:00:00 +0000
+++ test/test_message.rb	2011-07-31 16:48:34 +0000
@@ -0,0 +1,118 @@
+$:.unshift(File.dirname(__FILE__))
+#
+# Test Ruby 1.8 with $KCODE='U'
+#
+require 'test_helper'
+#
+class TestMessageKcode < Test::Unit::TestCase
+  include TestBase
+  #
+  def setup
+		$KCODE = 'U' if RUBY_VERSION =~ /1\.8/
+    @conn = Stomp::Connection.open(user, passcode, host, port)
+    # Message body data
+		@messages = [
+			"normal text message",
+			"bad byte: \372",
+			"\004\b{\f:\tbody\"\001\207\004\b{\b:\016statusmsg\"\aOK:\017statuscodei\000:\tdata{\t:\voutput\"3Enabled, not running, last run 693 seconds ago:\frunningi\000:\fenabledi\006:\flastrunl+\aE\021\022M:\rsenderid\"\032xx.xx.xx.xx:\016requestid\"%849d647bbe3e421ea19ac9f947bbdde4:\020senderagent\"\fpuppetd:\016msgtarget\"%/topic/mcollective.puppetd.reply:\thash\"\001\257ZdQqtaDmmdD0jZinnEcpN+YbkxQDn8uuCnwsQdvGHau6d+gxnnfPLUddWRSb\nZNMs+sQUXgJNfcV1eVBn1H+Z8QQmzYXVDMqz7J43jmgloz5PsLVbN9K3PmX/\ngszqV/WpvIyAqm98ennWqSzpwMuiCC4q2Jr3s3Gm6bUJ6UkKXnY=\n:\fmsgtimel+\a\372\023\022M"
+		]
+		#
+  end
+
+  def teardown
+    @conn.disconnect if @conn # allow tests to disconnect
+  end
+
+	# Various message bodies, including the failing test case reported
+  def test_kcode_001