torquebox-console 0.2.5 → 0.3.0

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

@@ -1,294 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'socket'
-require 'timeout'
-require 'io/wait'
-require 'digest/sha1'
-
-module Stomp
-
-  class Connection
-
-    private
-
-    # Ref:
-    # http://unicode.org/mail-arch/unicode-ml/y2003-m02/att-0467/01-The_Algorithm_to_Valide_an_UTF-8_String
-    #
-    # *CONSIDER* replacing this with a dependency on the utf8_validator gem.
-    # This code has been copied from there.
-    #
-    def _valid_utf8?(string)
-      case RUBY_VERSION
-      when /1\.8\.[56]/
-        bytes = []
-        0.upto(string.length-1) {|i|
-          bytes << string[i]
-        }
-      else
-        bytes = string.bytes
-      end
-
-      #
-      valid = true
-      index = -1
-      nb_hex = nil
-      ni_hex = nil
-      state = "start"
-      next_byte_save = nil
-      #
-      bytes.each do |next_byte|
-        index += 1
-        next_byte_save = next_byte
-        ni_hex = sprintf "%x", index
-        nb_hex = sprintf "%x", next_byte
-        # puts "Top: #{next_byte}(0x#{nb_hex}), index: #{index}(0x#{ni_hex})" if DEBUG
-        case state
-
-          # State: 'start'
-          # The 'start' state:
-          # * handles all occurrences of valid single byte characters i.e., the ASCII character set
-          # * provides state transition logic for start bytes of valid characters with 2-4 bytes
-          # * signals a validation failure for all other single bytes
-          #
-        when "start"
-          # puts "state: start" if DEBUG
-          case next_byte
-
-            # ASCII
-            # * Input = 0x00-0x7F : change state to START
-          when (0x00..0x7f)
-            # puts "state: start 1" if DEBUG
-            state = "start"
-
-            # Start byte of two byte characters
-            # * Input = 0xC2-0xDF: change state to A
-          when (0xc2..0xdf)
-            # puts "state: start 2" if DEBUG
-            state = "a"
-
-            # Start byte of some three byte characters
-            # * Input = 0xE1-0xEC, 0xEE-0xEF: change state to B
-          when (0xe1..0xec)
-            # puts "state: start 3" if DEBUG
-            state = "b"
-          when (0xee..0xef)
-            # puts "state: start 4" if DEBUG
-            state = "b"
-
-            # Start byte of special three byte characters
-            # * Input = 0xE0: change state to C
-          when 0xe0
-            # puts "state: start 5" if DEBUG
-            state = "c"
-
-            # Start byte of the remaining three byte characters
-            # * Input = 0xED: change state to D
-          when 0xed
-            # puts "state: start 6" if DEBUG
-            state = "d"
-
-            # Start byte of some four byte characters
-            # * Input = 0xF1-0xF3:change state to E
-          when (0xf1..0xf3)
-            # puts "state: start 7" if DEBUG
-            state = "e"
-
-            # Start byte of special four byte characters
-            # * Input = 0xF0: change state to F
-          when 0xf0
-            # puts "state: start 8" if DEBUG
-            state = "f"
-
-            # Start byte of very special four byte characters
-            # * Input = 0xF4: change state to G
-          when 0xf4
-            # puts "state: start 9" if DEBUG
-            state = "g"
-
-            # All other single characters are invalid
-            # * Input = Others (0x80-0xBF,0xC0-0xC1, 0xF5-0xFF): ERROR
-          else
-            valid = false
-            break
-          end # of the inner case, the 'start' state
-
-          # The last continuation byte of a 2, 3, or 4 byte character
-          # State: 'a'
-          #  o Input = 0x80-0xBF: change state to START
-          #  o Others: ERROR
-        when "a"
-          # puts "state: a" if DEBUG
-          if (0x80..0xbf) === next_byte
-            state = "start"
-          else
-            valid = false
-            break
-          end
-
-          # The first continuation byte for most 3 byte characters
-          # (those with start bytes in: 0xe1-0xec or 0xee-0xef)
-          # State: 'b'
-          # o Input = 0x80-0xBF: change state to A
-          # o Others: ERROR
-        when "b"
-          # puts "state: b" if DEBUG
-          if (0x80..0xbf) === next_byte
-            state = "a"
-          else
-            valid = false
-            break
-          end
-
-          # The first continuation byte for some special 3 byte characters
-          # (those with start byte 0xe0)
-          # State: 'c'
-          # o Input = 0xA0-0xBF: change state to A
-          # o Others: ERROR
-        when "c"
-          # puts "state: c" if DEBUG
-          if (0xa0..0xbf) === next_byte
-            state = "a"
-          else
-            valid = false
-            break
-          end
-
-          # The first continuation byte for the remaining 3 byte characters
-          # (those with start byte 0xed)
-          # State: 'd'
-          # o Input = 0x80-0x9F: change state to A
-          # o Others: ERROR
-        when "d"
-          # puts "state: d" if DEBUG
-          if (0x80..0x9f) === next_byte
-            state = "a"
-          else
-            valid = false
-            break
-          end
-
-          # The first continuation byte for some 4 byte characters
-          # (those with start bytes in: 0xf1-0xf3)
-          # State: 'e'
-          # o Input = 0x80-0xBF: change state to B
-          # o Others: ERROR
-        when "e"
-          # puts "state: e" if DEBUG
-          if (0x80..0xbf) === next_byte
-            state = "b"
-          else
-            valid = false
-            break
-          end
-
-          # The first continuation byte for some special 4 byte characters
-          # (those with start byte 0xf0)
-          # State: 'f'
-          # o Input = 0x90-0xBF: change state to B
-          # o Others: ERROR
-        when "f"
-          # puts "state: f" if DEBUG
-          if (0x90..0xbf) === next_byte
-            state = "b"
-          else
-            valid = false
-            break
-          end
-
-          # The first continuation byte for the remaining 4 byte characters
-          # (those with start byte 0xf4)
-          # State: 'g'
-          # o Input = 0x80-0x8F: change state to B
-          # o Others: ERROR
-        when "g"
-          # puts "state: g" if DEBUG
-          if (0x80..0x8f) === next_byte
-            state = "b"
-          else
-            valid = false
-            break
-          end
-
-          #
-        else
-          raise RuntimeError, "state: default"
-        end
-      end
-      #
-      # puts "State at end: #{state}" if DEBUG
-      # Catch truncation at end of string
-      if valid and state != 'start'
-        # puts "Resetting valid value" if DEBUG
-        valid = false
-      end
-      #
-      valid
-    end # of _valid_utf8?
-
-    # Stomp 1.1+ header check for UTF8 validity. Raises Stomp::Error::UTF8ValidationError if header data is not valid UTF8.
-    def _headerCheck(h)
-      return if @protocol == Stomp::SPL_10 # Do nothing for this environment
-      #
-      h.each_pair do |k,v|
-        # Keys here are symbolized
-        ks = k.to_s
-        ks.force_encoding(Stomp::UTF8) if ks.respond_to?(:force_encoding)
-        raise Stomp::Error::UTF8ValidationError unless valid_utf8?(ks)
-        #
-        if v.is_a?(Array)
-          v.each do |e|
-            e.force_encoding(Stomp::UTF8) if e.respond_to?(:force_encoding)
-            raise Stomp::Error::UTF8ValidationError unless valid_utf8?(e)
-          end
-        else
-          vs = v.to_s + "" # Values are usually Strings, but could be TrueClass or Symbol
-          # The + "" above forces an 'unfreeze' if necessary
-          vs.force_encoding(Stomp::UTF8) if vs.respond_to?(:force_encoding)
-          raise Stomp::Error::UTF8ValidationError unless valid_utf8?(vs)
-        end
-      end
-    end
-
-    # encode returns a Hash of encoded headers per the Stomp 1.1 specification.
-    def _encodeHeaders(h)
-      eh = {}
-      h.each_pair do |k,v|
-        # Keys are symbolized
-        ks = k.to_s
-        if v.is_a?(Array)
-          kenc = Stomp::HeaderCodec::encode(ks)
-          eh[kenc] = []
-          v.each do |e|
-            eh[kenc] << Stomp::HeaderCodec::encode(e)
-          end
-        else
-          vs = v.to_s
-          eh[Stomp::HeaderCodec::encode(ks)] = Stomp::HeaderCodec::encode(vs)
-        end
-      end
-      eh
-    end
-
-    # decode returns a Hash of decoded headers per the Stomp 1.1 specification.
-    def _decodeHeaders(h)
-      dh = {}
-      h.each_pair do |k,v|
-        # Keys here are NOT! symbolized
-        if v.is_a?(Array)
-          kdec = Stomp::HeaderCodec::decode(k)
-          dh[kdec] = []
-          v.each do |e|
-            dh[kdec] << Stomp::HeaderCodec::decode(e)
-          end
-        else
-          vs = v.to_s
-          dh[Stomp::HeaderCodec::decode(k)] = Stomp::HeaderCodec::decode(vs)
-        end
-      end
-      dh
-    end
-
-  end # class Connection
-
-end # module Stomp
-

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

@@ -1,239 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'socket'
-require 'timeout'
-require 'io/wait'
-require 'digest/sha1'
-
-module Stomp
-
-  class Connection
-
-    private
-
-    # Support multi-homed servers.  
-    def _expand_hosts(hash)
-      new_hash = hash.clone
-      new_hash[:hosts_cloned] = hash[:hosts].clone
-      new_hash[:hosts] = []
-      #
-      hash[:hosts].each do |host_parms|
-        ai = Socket.getaddrinfo(host_parms[:host], nil, nil, Socket::SOCK_STREAM)
-        next if ai.nil? || ai.size == 0
-        info6 = ai.detect {|info| info[4] == Socket::AF_INET6}
-        info4 = ai.detect {|info| info[4] == Socket::AF_INET}
-        if info6
-          new_hostp = host_parms.clone
-          new_hostp[:host] = info6[3]
-          new_hash[:hosts] << new_hostp
-        end
-        if info4
-          new_hostp = host_parms.clone
-          new_hostp[:host] = info4[3]
-          new_hash[:hosts] << new_hostp
-        end
-      end
-      return new_hash
-    end
-
-    # Handle 1.9+ character representation.
-    def parse_char(char)
-      RUBY_VERSION > '1.9' ? char : char.chr
-    end
-
-    # Create parameters for any callback logger.
-    def log_params()
-      lparms = @parameters.clone if @parameters
-      lparms = {} unless lparms
-      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[:openstat] = open?
-      #
-      lparms
-    end
-
-    # _pre_connect handles low level logic just prior to a physical connect.
-    def _pre_connect()
-      @connect_headers = @connect_headers.symbolize_keys
-      raise Stomp::Error::ProtocolErrorConnect if (@connect_headers[:"accept-version"] && !@connect_headers[:host])
-      raise Stomp::Error::ProtocolErrorConnect if (!@connect_headers[:"accept-version"] && @connect_headers[:host])
-      return unless (@connect_headers[:"accept-version"] && @connect_headers[:host]) # 1.0
-      # Try 1.1 or greater
-      @hhas10 = false
-      okvers = []
-      avers = @connect_headers[:"accept-version"].split(",")
-      avers.each do |nver|
-        if Stomp::SUPPORTED.index(nver)
-          okvers << nver
-          @hhas10 = true if nver == Stomp::SPL_10
-        end
-      end
-      raise Stomp::Error::UnsupportedProtocolError if okvers == []
-      @connect_headers[:"accept-version"] = okvers.join(",") # This goes to server
-      # Heartbeats - pre connect
-      return unless @connect_headers[:"heart-beat"]
-      _validate_hbheader()
-    end
-
-    # _post_connect handles low level logic just after a physical connect.
-    def _post_connect()
-      return unless (@connect_headers[:"accept-version"] && @connect_headers[:host]) # 1.0
-      if @connection_frame.command == Stomp::CMD_ERROR
-        @connection_frame.headers = _decodeHeaders(@connection_frame.headers)
-        return
-      end
-      # We are CONNECTed
-      cfh = @connection_frame.headers.symbolize_keys
-      @protocol = cfh[:version]
-      if @protocol
-        # Should not happen, but check anyway
-        raise Stomp::Error::UnsupportedProtocolError unless Stomp::SUPPORTED.index(@protocol)
-      else # CONNECTed to a 1.0 server that does not return *any* 1.1 type headers
-        @protocol = Stomp::SPL_10 # reset
-        return
-      end
-      # Heartbeats
-      return unless @connect_headers[:"heart-beat"]
-      _init_heartbeats()
-    end
-
-    # socket creates and returns a new socket for use by the connection.
-    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() # sets @closed = false if OK
-            # Open is 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
-            raise if @failure.is_a?(Stomp::Error::LoggerConnectionError)
-            @closed = true
-            if @logger && @logger.respond_to?(:on_connectfail)
-              # on_connectfail may raise
-              begin
-                @logger.on_connectfail(log_params)
-              rescue Exception => aex
-                raise if aex.is_a?(Stomp::Error::LoggerConnectionError)
-              end
-            else
-              $stderr.print "connect to #{@host} failed: #{$!} will retry(##{@connection_attempts}) in #{@reconnect_delay}\n"
-            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
-
-    # refine_params sets up defaults for a Hash initialize.
-    def refine_params(params)
-      params = params.uncamelize_and_symbolize_keys
-      default_params = {
-        :connect_headers => {},
-        :reliable => true,
-        # Failover parameters
-        :initial_reconnect_delay => 0.01,
-        :max_reconnect_delay => 30.0,
-        :use_exponential_back_off => true,
-        :back_off_multiplier => 2,
-        :max_reconnect_attempts => 0,
-        :randomize => false,
-        :connect_timeout => 0,
-        # Parse Timeout
-        :parse_timeout => 5,
-        :dmh => false,
-        # Closed check logic
-        :closed_check => true,
-        :hbser => false,
-        :stompconn => false,
-      }
-
-      res_params = default_params.merge(params)
-      if res_params[:dmh]
-        res_params = _expand_hosts(res_params)
-      end
-      return res_params
-    end
-
-    # change_host selects the next host for retires.
-    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
-
-    # max_reconnect_attempts? returns nil or the number of maximum reconnect
-    # attempts.
-    def max_reconnect_attempts?
-      !(@parameters.nil? || @parameters[:max_reconnect_attempts].nil?) && @parameters[:max_reconnect_attempts] != 0 && @connection_attempts >= @parameters[:max_reconnect_attempts]
-    end
-
-    # increase_reconnect_delay increases the reconnect delay for the next connection
-    # attempt.
-    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
-
-    # __old_receive receives a frame, blocks until the frame is received.
-    def __old_receive()
-      # The receive may 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, "es_oldrecv: " + errstr)
-          else
-            $stderr.print errstr
-          end
-        end
-      end
-    end
-
-  end # class Connection
-
-end # module Stomp
-