torquebox-console 0.2.5 → 0.3.0

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

@@ -1,39 +0,0 @@
-# -*- 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

@@ -1,350 +0,0 @@
-# -*- 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

@@ -1,44 +0,0 @@
-# -*- 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

@@ -1,452 +0,0 @@
-# -*- 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
-