torquebox-console 0.2.3 → 0.2.4

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

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

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