torquebox-console 0.2.3 → 0.2.4

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/lib/stomp.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+#   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 'stomp/constants'       # Constants first
+require 'stomp/ext/hash'        # #Hash additions
+require 'stomp/connection'      # Main Stomp#Connection
+require 'stomp/client'          # Main Stomp#Client
+require 'stomp/message'         # Stomp#Message
+require 'stomp/version'         # Stomp#Version#STRING
+require 'stomp/errors'          # All Stomp# exceptions
+require 'stomp/codec'           # Stomp 1.1 codec
+require 'stomp/sslparams'       # Stomp SSL support
+
+# Private methods in #Client
+require 'client/utils'          # private Client Utility methods
+
+# Private methods in #Connection
+require 'connection/utils'      # private Connection Utility methods
+require 'connection/netio'      # private Network io methods
+require 'connection/heartbeats' # private 1.1+ heartbeat related methods
+require 'connection/utf8'       # private 1.1+ UTF8 related methods
+
+module Stomp
+end
+

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/lib/stomp/client.rb

@@ -0,0 +1,350 @@
+# -*- encoding: utf-8 -*-
+
+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
+
+    public
+
+    # The login ID used by the client.
+    attr_reader :login
+
+    # The login credentials used by the client.
+    attr_reader :passcode
+
+    # The Stomp host specified by the client.
+    attr_reader :host
+
+    # The Stomp host's listening port.
+    attr_reader :port
+
+    # Is this connection reliable?
+    attr_reader :reliable
+
+    # Parameters Hash, possibly nil for a non-hashed connect.
+    attr_reader :parameters
+
+    # A new Client object can be initialized using three forms:
+    #
+    # Hash (this is the recommended Client initialization method):
+    #
+    #   hash = {
+    #     :hosts => [
+    #       {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+    #       {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+    #     ],
+    #     :reliable => true,
+    #     :initial_reconnect_delay => 0.01,
+    #     :max_reconnect_delay => 30.0,
+    #     :use_exponential_back_off => true,
+    #     :back_off_multiplier => 2,
+    #     :max_reconnect_attempts => 0,
+    #     :randomize => false,
+    #     :connect_timeout => 0,
+    #     :connect_headers => {},
+    #     :parse_timeout => 5,
+    #     :logger => nil,
+    #     :dmh => false,
+    #     :closed_check => true,
+    #     :hbser => false,
+    #     :stompconn => false,
+    #     :usecrlf => false,
+    #   }
+    #
+    #   e.g. c = Stomp::Client.new(hash)
+    #
+    # Positional parameters:
+    #   login     (String,  default : '')
+    #   passcode  (String,  default : '')
+    #   host      (String,  default : 'localhost')
+    #   port      (Integer, default : 61613)
+    #   reliable  (Boolean, default : false)
+    #
+    #   e.g. c = Stomp::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:passcode@host.domain.tld:port
+    #
+    #   e.g. c = Stomp::Client.new(urlstring)
+    #
+    def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, autoflush = 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)
+        @connection.autoflush = autoflush
+      end
+
+      start_listeners()
+
+    end
+
+    # open is 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 starts work in a a transaction by name.
+    def begin(name, headers = {})
+      @connection.begin(name, headers)
+    end
+
+    # Abort aborts work in a transaction by name.
+    def abort(name, headers = {})
+      @connection.abort(name, headers)
+
+      # 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 commits work in 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.github.com/.
+      # 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
+
+    # Unsubscribe from a subscription by name.
+    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'}).
+    # 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
+      if protocol() == Stomp::SPL_12
+        @connection.ack(message.headers['ack'], headers)
+      else
+        @connection.ack(message.headers['message-id'], headers)
+      end
+    end
+
+    # Stomp 1.1+ NACK.
+    def nack(message_id, headers = {})
+      @connection.nack(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
+
+    # Return the broker's CONNECTED frame to the client.  Misnamed.
+    def connection_frame()
+      @connection.connection_frame
+    end
+
+    # Return any RECEIPT frame received by DISCONNECT.
+    def disconnect_receipt()
+      @connection.disconnect_receipt
+    end
+
+    # open? tests if this client connection is open.
+    def open?
+      @connection.open?()
+    end
+
+    # close? tests if this client connection is closed.
+    def closed?()
+      @connection.closed?()
+    end
+
+    # close frees resources in use by this client.  The listener thread is
+    # terminated, and disconnect on the connection is called.
+    def close(headers={})
+      @listener_thread.exit
+      @connection.disconnect(headers)
+    end
+
+    # running checks if the thread was created and is not dead.
+    def running()
+      @listener_thread && !!@listener_thread.status
+    end
+
+    # set_logger identifies a new callback logger.
+    def set_logger(logger)
+      @connection.set_logger(logger)
+    end
+
+    # protocol returns the current client's protocol level.
+    def protocol()
+      @connection.protocol()
+    end
+
+    # valid_utf8? validates any given string for UTF8 compliance.
+    def valid_utf8?(s)
+      @connection.valid_utf8?(s)
+    end
+
+    # sha1 returns a SHA1 sum of a given string.
+    def sha1(data)
+      @connection.sha1(data)
+    end
+
+    # uuid returns a type 4 UUID.
+    def uuid()
+      @connection.uuid()
+    end
+
+    # hbsend_interval returns the connection's heartbeat send interval.
+    def hbsend_interval()
+      @connection.hbsend_interval()
+    end
+
+    # hbrecv_interval returns the connection's heartbeat receive interval.
+    def hbrecv_interval()
+      @connection.hbrecv_interval()
+    end
+
+    # hbsend_count returns the current connection's heartbeat send count.
+    def hbsend_count()
+      @connection.hbsend_count()
+    end
+
+    # hbrecv_count returns the current connection's heartbeat receive count.
+    def hbrecv_count()
+      @connection.hbrecv_count()
+    end
+
+    # Poll for asynchronous messages issued by broker.
+    # Return nil of no message available, else the message
+    def poll()
+      @connection.poll()
+    end
+
+    # autoflush= sets the current connection's autoflush setting.
+    def autoflush=(af)
+      @connection.autoflush = af
+    end
+
+    # autoflush returns the current connection's autoflush setting.
+    def autoflush()
+      @connection.autoflush()
+    end
+
+  end # Class
+
+end # Module
+

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/lib/stomp/codec.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+module Stomp
+  #
+  # == Purpose
+  #
+  # A general CODEC for STOMP 1.1 header keys and values.
+  #
+  # See:
+  #
+  # * http://stomp.github.com/index.html
+  #
+  # for encode/decode rules.
+  #
+  class HeaderCodec
+
+    public
+
+    # encode encodes header data per the STOMP 1.1 specification.
+    def self.encode(in_string = nil)
+      return in_string unless in_string
+      ev = Stomp::ENCODE_VALUES # avoid typing below
+      os = in_string + ""
+      0.step(ev.length-2,2) do |i| # [encoded, decoded]
+        os.gsub!(ev[i+1], ev[i])
+      end
+      os
+    end
+
+    # decode decodes header data per the STOMP 1.1 specification.
+    def self.decode(in_string = nil)
+      return in_string unless in_string
+      ev = Stomp::DECODE_VALUES # avoid typing below
+      os = in_string + ""
+      0.step(ev.length-2,2) do |i| # [encoded, decoded]
+        os.gsub!(ev[i], ev[i+1])
+      end
+      os
+    end
+
+  end # of class HeaderCodec
+
+end # of module Stomp
+

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/lib/stomp/connection.rb

@@ -0,0 +1,452 @@
+# -*- encoding: utf-8 -*-
+
+require 'socket'
+require 'timeout'
+require 'io/wait'
+require 'digest/sha1'
+
+module Stomp
+
+  # Low level connection which maps commands and supports
+  # synchronous receives
+  class Connection
+
+    public
+
+    # The CONNECTED frame from the broker.
+    attr_reader   :connection_frame
+
+    # Any disconnect RECEIPT frame if requested.
+    attr_reader   :disconnect_receipt
+
+    # The Stomp Protocol version.
+    attr_reader   :protocol
+
+    # A unique session ID, assigned by the broker.
+    attr_reader   :session
+
+    # Heartbeat receive has been on time.
+    attr_reader   :hb_received # Heartbeat received on time
+
+    # Heartbeat send has been successful.
+    attr_reader   :hb_sent # Heartbeat sent successfully
+
+    # Autoflush forces a flush on each transmit.  This may be changed
+    # dynamically by calling code.
+    attr_accessor :autoflush
+
+    # default_port returns the default port used by the gem for TCP or SSL.
+    def self.default_port(ssl)
+      ssl ? 61612 : 61613
+    end
+
+    # A new Connection object can be initialized using two forms:
+    #
+    # Hash (this is the recommended Connection initialization method):
+    #
+    #   hash = {
+    #     :hosts => [
+    #       {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+    #       {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+    #     ],
+    #     :reliable => true,
+    #     :initial_reconnect_delay => 0.01,
+    #     :max_reconnect_delay => 30.0,
+    #     :use_exponential_back_off => true,
+    #     :back_off_multiplier => 2,
+    #     :max_reconnect_attempts => 0,
+    #     :randomize => false,
+    #     :connect_timeout => 0,
+    #     :connect_headers => {},
+    #     :parse_timeout => 5,
+    #     :logger => nil,
+    #     :dmh => false,
+    #     :closed_check => true,
+    #     :hbser => false,
+    #     :stompconn => false,
+    #     :usecrlf => false,
+    #   }
+    #
+    #   e.g. c = Stomp::Connection.new(hash)
+    #
+    # Positional 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 = Stomp::Connection.new("username", "password", "localhost", 61613, true)
+    #
+    def initialize(login = '', passcode = '', host = 'localhost', port = 61613, reliable = false, reconnect_delay = 5, connect_headers = {})
+      @protocol = Stomp::SPL_10 # Assumed at first
+      @hb_received = true       # Assumed at first
+      @hb_sent = true           # Assumed at first
+      @hbs = @hbr = false       # Sending/Receiving heartbeats. Assume no for now.
+
+      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
+        @connect_timeout = 0	# To override, use hashed parameters
+        @logger = nil     		# To override, use hashed parameters
+        @autoflush = false    # To override, use hashed parameters or setter
+        @closed_check = true  # Run closed check in each protocol method
+        @hbser = false        # Raise if heartbeat send exception
+        @stompconn = false    # If true, use STOMP rather than CONNECT
+        @usecrlf = false      # If true, use \r\n as line ends (1.2 only)
+        warn "login looks like a URL, do you have the correct parameters?" if @login =~ /:\/\//
+      end
+
+      # Use Mutexes:  only one lock per each thread.
+      # Reverted to original implementation attempt using Mutex.
+      @transmit_semaphore = Mutex.new
+      @read_semaphore = Mutex.new
+      @socket_semaphore = Mutex.new
+
+      @subscriptions = {}
+      @failure = nil
+      @connection_attempts = 0
+
+      socket
+    end
+
+    # hashed_initialize prepares a new connection with a Hash of initialization
+    # parameters.
+    def hashed_initialize(params)
+
+      @parameters = refine_params(params)
+      @reliable =  @parameters[:reliable]
+      @reconnect_delay = @parameters[:initial_reconnect_delay]
+      @connect_headers = @parameters[:connect_headers]
+      @parse_timeout =  @parameters[:parse_timeout]
+      @connect_timeout =  @parameters[:connect_timeout]
+      @logger =  @parameters[:logger]
+      @autoflush = @parameters[:autoflush]
+      @closed_check = @parameters[:closed_check]
+      @hbser = @parameters[:hbser]
+      @stompconn = @parameters[:stompconn]
+      @usecrlf = @parameters[:usecrlf]
+      #sets the first host to connect
+      change_host
+    end
+
+    # open is 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
+
+    # open? tests if this connection is open.
+    def open?
+      !@closed
+    end
+
+    # closed? tests if this connection is closed.
+    def closed?
+      @closed
+    end
+
+    # Begin starts a transaction, and requires a name for the transaction
+    def begin(name, headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      headers[:transaction] = name
+      _headerCheck(headers)
+      transmit(Stomp::CMD_BEGIN, headers)
+    end
+
+    # Acknowledge a message, used when a subscription has specified
+    # client acknowledgement i.e. connection.subscribe("/queue/a", :ack => 'client').
+    # Accepts an optional transaction header ( :transaction => 'some_transaction_id' )
+    # Behavior is protocol level dependent, see the specifications or comments below.
+    def ack(message_id, headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      raise Stomp::Error::MessageIDRequiredError if message_id.nil? || message_id == ""
+      headers = headers.symbolize_keys
+
+      case @protocol
+        when Stomp::SPL_12
+          # The ACK frame MUST include an id header matching the ack header 
+          # of the MESSAGE being acknowledged.
+          headers[:id] = message_id
+        when Stomp::SPL_11
+          # ACK has two REQUIRED headers: message-id, which MUST contain a value 
+          # matching the message-id for the MESSAGE being acknowledged and 
+          # subscription, which MUST be set to match the value of the subscription's 
+          # id header.
+          headers[:'message-id'] = message_id
+          raise Stomp::Error::SubscriptionRequiredError unless headers[:subscription]
+        else # Stomp::SPL_10
+          # ACK has one required header, message-id, which must contain a value 
+          # matching the message-id for the MESSAGE being acknowledged.
+          headers[:'message-id'] = message_id
+      end
+      _headerCheck(headers)
+      transmit(Stomp::CMD_ACK, headers)
+    end
+
+    # STOMP 1.1+ NACK.
+    def nack(message_id, headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      raise Stomp::Error::UnsupportedProtocolError if @protocol == Stomp::SPL_10
+      raise Stomp::Error::MessageIDRequiredError if message_id.nil? || message_id == ""
+      headers = headers.symbolize_keys
+      case @protocol
+        when Stomp::SPL_12
+          # The ACK frame MUST include an id header matching the ack header 
+          # of the MESSAGE being acknowledged.
+          headers[:id] = message_id
+        else # Stomp::SPL_11 only
+          # ACK has two REQUIRED headers: message-id, which MUST contain a value 
+          # matching the message-id for the MESSAGE being acknowledged and 
+          # subscription, which MUST be set to match the value of the subscription's 
+          # id header.
+          headers[:'message-id'] = message_id
+          raise Stomp::Error::SubscriptionRequiredError unless headers[:subscription]
+      end
+      _headerCheck(headers)
+      transmit(Stomp::CMD_NACK, headers)
+    end
+
+    # Commit commits a transaction by name.
+    def commit(name, headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      headers[:transaction] = name
+      _headerCheck(headers)
+      transmit(Stomp::CMD_COMMIT, headers)
+    end
+
+    # Abort aborts a transaction by name.
+    def abort(name, headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      headers[:transaction] = name
+      _headerCheck(headers)
+      transmit(Stomp::CMD_ABORT, headers)
+    end
+
+    # Subscribe subscribes to a destination.  A subscription name is required.
+    # For Stomp 1.1+ a session unique subscription ID is also required.
+    def subscribe(name, headers = {}, subId = nil)
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      headers[:destination] = name
+      if @protocol >= Stomp::SPL_11
+        raise Stomp::Error::SubscriptionRequiredError if (headers[:id].nil? && subId.nil?)
+        headers[:id] = subId if headers[:id].nil?
+      end
+      _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_subscribe)
+        @logger.on_subscribe(log_params, headers)
+      end
+
+      # Store the subscription so that we can replay if we reconnect.
+      if @reliable
+        subId = name if subId.nil?
+        raise Stomp::Error::DuplicateSubscription if @subscriptions[subId]
+        @subscriptions[subId] = headers
+      end
+
+      transmit(Stomp::CMD_SUBSCRIBE, headers)
+    end
+
+    # Unsubscribe from a destination.   A subscription name is required.
+    # For Stomp 1.1+ a session unique subscription ID is also required.
+    def unsubscribe(dest, headers = {}, subId = nil)
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      headers[:destination] = dest
+      if @protocol >= Stomp::SPL_11
+        raise Stomp::Error::SubscriptionRequiredError if (headers[:id].nil? && subId.nil?)
+      end
+      _headerCheck(headers)
+      transmit(Stomp::CMD_UNSUBSCRIBE, headers)
+      if @reliable
+        subId = dest if subId.nil?
+        @subscriptions.delete(subId)
+      end
+    end
+
+    # Publish message to destination.
+    # To disable content length header use header ( :suppress_content_length => true ).
+    # Accepts a transaction header ( :transaction => 'some_transaction_id' ).
+    def publish(destination, message, headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      headers[:destination] = destination
+      _headerCheck(headers)
+      if @logger && @logger.respond_to?(:on_publish)
+        @logger.on_publish(log_params, message, headers)
+      end
+      transmit(Stomp::CMD_SEND, headers, message)
+    end
+
+    # Send a message back to the source or to the dead letter queue.
+    # Accepts a dead letter queue option ( :dead_letter_queue => "/queue/DLQ" ).
+    # Accepts a limit number of redeliveries option ( :max_redeliveries => 6 ).
+    # Accepts a force client acknowledgement option (:force_client_ack => true).
+    def unreceive(message, options = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      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
+
+    # client_ack? determines if headers contain :ack => "client".
+    def client_ack?(message)
+      headers = @subscriptions[message.headers[:destination]]
+      !headers.nil? && headers[:ack] == "client"
+    end
+
+    # disconnect closes this connection.  If requested, a disconnect RECEIPT 
+    # will be received.
+    def disconnect(headers = {})
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      headers = headers.symbolize_keys
+      _headerCheck(headers)
+      if @protocol >= Stomp::SPL_11
+        @st.kill if @st # Kill ticker thread if any
+        @rt.kill if @rt # Kill ticker thread if any
+      end
+      transmit(Stomp::CMD_DISCONNECT, headers)
+      @disconnect_receipt = receive if headers[:receipt]
+      if @logger && @logger.respond_to?(:on_disconnect)
+        @logger.on_disconnect(log_params)
+      end
+      close_socket
+    end
+
+    # poll returns a pending message if one is available, otherwise
+    # returns nil.
+    def poll()
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      # No need for a read lock here.  The receive method eventually fulfills
+      # that requirement.
+      return nil if @socket.nil? || !@socket.ready?
+      receive()
+    end
+
+    # receive returns the next Message off of the wire.
+    def receive()
+      raise Stomp::Error::NoCurrentConnection if @closed_check && closed?
+      super_result = __old_receive
+      if super_result.nil? && @reliable && !closed?
+        errstr = "connection.receive returning EOF as nil - resetting connection.\n"
+        if @logger && @logger.respond_to?(:on_miscerr)
+          @logger.on_miscerr(log_params, "es_recv: " + errstr)
+        else
+          $stderr.print errstr
+        end
+        @socket = nil
+        super_result = __old_receive
+      end
+      #
+      if @logger && @logger.respond_to?(:on_receive)
+        @logger.on_receive(log_params, super_result)
+      end
+      return super_result
+    end
+
+    # set_logger selects a new callback logger instance.
+    def set_logger(logger)
+      @logger = logger
+    end
+
+    # valid_utf8? returns an indicator if the given string is a valid UTF8 string.
+    def valid_utf8?(s)
+      case RUBY_VERSION
+      when /1\.8/
+        rv = _valid_utf8?(s)
+      else
+        rv = s.encoding.name != Stomp::UTF8 ? false : s.valid_encoding?
+      end
+      rv
+    end
+
+    # sha1 returns a SHA1 digest for arbitrary string data.
+    def sha1(data)
+      Digest::SHA1.hexdigest(data)
+    end
+
+    # uuid returns a type 4 UUID.
+    def uuid()
+      b = []
+      0.upto(15) do |i|
+        b << rand(255)
+      end
+      b[6] = (b[6] & 0x0F) | 0x40
+      b[8] = (b[8] & 0xbf) | 0x80
+      #             0  1  2  3   4   5  6  7   8  9  10 11 12 13 14 15
+      rs = sprintf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x%02x%02x",
+      b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15])
+      rs
+    end
+
+    # hbsend_interval returns the connection's heartbeat send interval.
+    def hbsend_interval()
+      return 0 unless @hbsend_interval
+      @hbsend_interval / 1000.0 # ms
+    end
+
+    # hbrecv_interval returns the connection's heartbeat receive interval.
+    def hbrecv_interval()
+      return 0 unless @hbrecv_interval
+      @hbrecv_interval / 1000.0 # ms
+    end
+
+    # hbsend_count returns the current connection's heartbeat send count.
+    def hbsend_count()
+      return 0 unless @hbsend_count
+      @hbsend_count
+    end
+
+    # hbrecv_count returns the current connection's heartbeat receive count.
+    def hbrecv_count()
+      return 0 unless @hbrecv_count
+      @hbrecv_count
+    end
+
+  end # class
+
+end # module
+