poolparty 1.3.15 → 1.4.0

data/vendor/gems/right_aws/lib/awsbase/right_awsbase.rb

@@ -1,797 +0,0 @@
-#
-# Copyright (c) 2007-2008 RightScale Inc
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-
-# Test
-module RightAws
-  require 'md5'
-  require 'pp'
-  
-  class AwsUtils #:nodoc:
-    @@digest1   = OpenSSL::Digest::Digest.new("sha1")
-    @@digest256 = nil
-    if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00908000
-      @@digest256 = OpenSSL::Digest::Digest.new("sha256") rescue nil # Some installation may not support sha256
-    end
-    
-    def self.sign(aws_secret_access_key, auth_string)
-      Base64.encode64(OpenSSL::HMAC.digest(@@digest1, aws_secret_access_key, auth_string)).strip
-    end
-
-    # Escape a string accordingly Amazon rulles
-    # http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?REST_RESTAuth.html
-    def self.amz_escape(param)
-      param.to_s.gsub(/([^a-zA-Z0-9._~-]+)/n) do
-        '%' + $1.unpack('H2' * $1.size).join('%').upcase
-      end
-    end
-
-    # Set a timestamp and a signature version
-    def self.fix_service_params(service_hash, signature)
-      service_hash["Timestamp"] ||= Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z") unless service_hash["Expires"]
-      service_hash["SignatureVersion"] = signature
-      service_hash
-    end
-
-    # Signature Version 0
-    # A deprecated guy (should work till septemper 2009)
-    def self.sign_request_v0(aws_secret_access_key, service_hash)
-      fix_service_params(service_hash, '0')
-      string_to_sign = "#{service_hash['Action']}#{service_hash['Timestamp'] || service_hash['Expires']}"
-      service_hash['Signature'] = AwsUtils::sign(aws_secret_access_key, string_to_sign)
-      service_hash.to_a.collect{|key,val| "#{amz_escape(key)}=#{amz_escape(val.to_s)}" }.join("&")
-    end
-
-    # Signature Version 1
-    # Another deprecated guy (should work till septemper 2009)
-    def self.sign_request_v1(aws_secret_access_key, service_hash)
-      fix_service_params(service_hash, '1')
-      string_to_sign = service_hash.sort{|a,b| (a[0].to_s.downcase)<=>(b[0].to_s.downcase)}.to_s
-      service_hash['Signature'] = AwsUtils::sign(aws_secret_access_key, string_to_sign)
-      service_hash.to_a.collect{|key,val| "#{amz_escape(key)}=#{amz_escape(val.to_s)}" }.join("&")
-    end
-
-    # Signature Version 2
-    # EC2, SQS and SDB requests must be signed by this guy.
-    # See:  http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?REST_RESTAuth.html
-    #       http://developer.amazonwebservices.com/connect/entry.jspa?externalID=1928
-    def self.sign_request_v2(aws_secret_access_key, service_hash, http_verb, host, uri)
-      fix_service_params(service_hash, '2')
-      # select a signing method (make an old openssl working with sha1)
-      # make 'HmacSHA256' to be a default one
-      service_hash['SignatureMethod'] = 'HmacSHA256' unless ['HmacSHA256', 'HmacSHA1'].include?(service_hash['SignatureMethod'])
-      service_hash['SignatureMethod'] = 'HmacSHA1'   unless @@digest256
-      # select a digest
-      digest = (service_hash['SignatureMethod'] == 'HmacSHA256' ? @@digest256 : @@digest1)
-      # form string to sign
-      canonical_string = service_hash.keys.sort.map do |key|
-        "#{amz_escape(key)}=#{amz_escape(service_hash[key])}"
-      end.join('&')
-      string_to_sign = "#{http_verb.to_s.upcase}\n#{host.downcase}\n#{uri}\n#{canonical_string}"
-      # sign the string
-      signature      = amz_escape(Base64.encode64(OpenSSL::HMAC.digest(digest, aws_secret_access_key, string_to_sign)).strip)
-      "#{canonical_string}&Signature=#{signature}"
-    end
-
-    # From Amazon's SQS Dev Guide, a brief description of how to escape:
-    # "URL encode the computed signature and other query parameters as specified in 
-    # RFC1738, section 2.2. In addition, because the + character is interpreted as a blank space 
-    # by Sun Java classes that perform URL decoding, make sure to encode the + character 
-    # although it is not required by RFC1738."
-    # Avoid using CGI::escape to escape URIs. 
-    # CGI::escape will escape characters in the protocol, host, and port
-    # sections of the URI.  Only target chars in the query
-    # string should be escaped.
-    def self.URLencode(raw)
-      e = URI.escape(raw)
-      e.gsub(/\+/, "%2b")
-    end
-    
-    def self.allow_only(allowed_keys, params)
-      bogus_args = []
-      params.keys.each {|p| bogus_args.push(p) unless allowed_keys.include?(p) }
-      raise AwsError.new("The following arguments were given but are not legal for the function call #{caller_method}: #{bogus_args.inspect}") if bogus_args.length > 0
-    end
-    
-    def self.mandatory_arguments(required_args, params)
-      rargs = required_args.dup
-      params.keys.each {|p| rargs.delete(p)}
-      raise AwsError.new("The following mandatory arguments were not provided to #{caller_method}: #{rargs.inspect}") if rargs.length > 0
-    end
-    
-    def self.caller_method
-      caller[1]=~/`(.*?)'/
-      $1
-    end
-
-  end
-
-  class AwsBenchmarkingBlock #:nodoc:
-    attr_accessor :xml, :service
-    def initialize
-      # Benchmark::Tms instance for service (Ec2, S3, or SQS) access benchmarking.
-      @service = Benchmark::Tms.new()
-      # Benchmark::Tms instance for XML parsing benchmarking.
-      @xml = Benchmark::Tms.new()
-    end
-  end
-
-  class AwsNoChange < RuntimeError
-  end
-  
-  class RightAwsBase
-
-    # Amazon HTTP Error handling
-
-    # Text, if found in an error message returned by AWS, indicates that this may be a transient
-    # error. Transient errors are automatically retried with exponential back-off.
-    AMAZON_PROBLEMS = [ 'internal service error', 
-                      'is currently unavailable', 
-                      'no response from', 
-                      'Please try again',
-                      'InternalError',
-                      'ServiceUnavailable', #from SQS docs
-                      'Unavailable',
-                      'This application is not currently available',
-                      'InsufficientInstanceCapacity'
-                    ]
-    @@amazon_problems = AMAZON_PROBLEMS
-      # Returns a list of Amazon service responses which are known to be transient problems. 
-      # We have to re-request if we get any of them, because the problem will probably disappear. 
-      # By default this method returns the same value as the AMAZON_PROBLEMS const.
-    def self.amazon_problems
-      @@amazon_problems
-    end
-    
-      # Sets the list of Amazon side problems.  Use in conjunction with the
-      # getter to append problems.
-    def self.amazon_problems=(problems_list)
-      @@amazon_problems = problems_list
-    end
-    
-  end
-
-  module RightAwsBaseInterface
-    DEFAULT_SIGNATURE_VERSION = '2'
-    
-    @@caching = false
-    def self.caching
-      @@caching
-    end
-    def self.caching=(caching)
-      @@caching = caching
-    end
-
-      # Current aws_access_key_id
-    attr_reader :aws_access_key_id
-      # Last HTTP request object
-    attr_reader :last_request
-      # Last HTTP response object
-    attr_reader :last_response
-      # Last AWS errors list (used by AWSErrorHandler)
-    attr_accessor :last_errors
-      # Last AWS request id (used by AWSErrorHandler)
-    attr_accessor :last_request_id
-      # Logger object
-    attr_accessor :logger
-      # Initial params hash
-    attr_accessor :params
-      # RightHttpConnection instance
-    attr_reader :connection
-      # Cache
-    attr_reader :cache
-      # Signature version (all services except s3)
-    attr_reader :signature_version
-
-    def init(service_info, aws_access_key_id, aws_secret_access_key, params={}) #:nodoc:
-      @params = params
-      raise AwsError.new("AWS access keys are required to operate on #{service_info[:name]}") \
-        if aws_access_key_id.blank? || aws_secret_access_key.blank?
-      @aws_access_key_id     = aws_access_key_id
-      @aws_secret_access_key = aws_secret_access_key
-      # if the endpoint was explicitly defined - then use it
-      if @params[:endpoint_url]
-        @params[:server]   = URI.parse(@params[:endpoint_url]).host
-        @params[:port]     = URI.parse(@params[:endpoint_url]).port
-        @params[:service]  = URI.parse(@params[:endpoint_url]).path
-        @params[:protocol] = URI.parse(@params[:endpoint_url]).scheme
-        @params[:region]   = nil
-      else
-        @params[:server]   ||= service_info[:default_host]
-        @params[:server]     = "#{@params[:region]}.#{@params[:server]}" if @params[:region]
-        @params[:port]     ||= service_info[:default_port]
-        @params[:service]  ||= service_info[:default_service]
-        @params[:protocol] ||= service_info[:default_protocol]
-      end
-      @params[:multi_thread] ||= defined?(AWS_DAEMON)
-      @logger = @params[:logger]
-      @logger = RAILS_DEFAULT_LOGGER if !@logger && defined?(RAILS_DEFAULT_LOGGER)
-      @logger = Logger.new(STDOUT)   if !@logger
-      @logger.info "New #{self.class.name} using #{@params[:multi_thread] ? 'multi' : 'single'}-threaded mode"
-      @error_handler = nil
-      @cache = {}
-      @signature_version = (params[:signature_version] || DEFAULT_SIGNATURE_VERSION).to_s
-    end
-
-    def signed_service_params(aws_secret_access_key, service_hash, http_verb=nil, host=nil, service=nil )
-      case signature_version.to_s
-      when '0' then AwsUtils::sign_request_v0(aws_secret_access_key, service_hash)
-      when '1' then AwsUtils::sign_request_v1(aws_secret_access_key, service_hash)
-      when '2' then AwsUtils::sign_request_v2(aws_secret_access_key, service_hash, http_verb, host, service)
-      else raise AwsError.new("Unknown signature version (#{signature_version.to_s}) requested")
-      end
-    end
-
-    # Returns +true+ if the describe_xxx responses are being cached 
-    def caching?
-      @params.key?(:cache) ? @params[:cache] : @@caching
-    end
-    
-    # Check if the aws function response hits the cache or not.
-    # If the cache hits:
-    # - raises an +AwsNoChange+ exception if +do_raise+ == +:raise+.
-    # - returnes parsed response from the cache if it exists or +true+ otherwise.
-    # If the cache miss or the caching is off then returns +false+.
-    def cache_hits?(function, response, do_raise=:raise)
-      result = false
-      if caching?
-        function = function.to_sym
-        # get rid of requestId (this bad boy was added for API 2008-08-08+ and it is uniq for every response)
-        response = response.sub(%r{<requestId>.+?</requestId>}, '')
-        response_md5 = MD5.md5(response).to_s
-        # check for changes
-        unless @cache[function] && @cache[function][:response_md5] == response_md5
-          # well, the response is new, reset cache data
-          update_cache(function, {:response_md5 => response_md5, 
-                                  :timestamp    => Time.now, 
-                                  :hits         => 0, 
-                                  :parsed       => nil})
-        else
-          # aha, cache hits, update the data and throw an exception if needed
-          @cache[function][:hits] += 1
-          if do_raise == :raise
-            raise(AwsNoChange, "Cache hit: #{function} response has not changed since "+
-                               "#{@cache[function][:timestamp].strftime('%Y-%m-%d %H:%M:%S')}, "+
-                               "hits: #{@cache[function][:hits]}.")
-          else
-            result = @cache[function][:parsed] || true
-          end
-        end
-      end
-      result
-    end
-    
-    def update_cache(function, hash)
-      (@cache[function.to_sym] ||= {}).merge!(hash) if caching?
-    end
-    
-    def on_exception(options={:raise=>true, :log=>true}) # :nodoc:
-      raise if $!.is_a?(AwsNoChange)
-      AwsError::on_aws_exception(self, options)
-    end
-    
-      # Return +true+ if this instance works in multi_thread mode and +false+ otherwise.
-    def multi_thread
-      @params[:multi_thread]
-    end
-
-    def request_info_impl(connection, benchblock, request, parser, &block) #:nodoc:
-      @connection    = connection
-      @last_request  = request[:request]
-      @last_response = nil
-      response=nil
-      blockexception = nil
-
-      if(block != nil)
-        # TRB 9/17/07 Careful - because we are passing in blocks, we get a situation where
-        # an exception may get thrown in the block body (which is high-level
-        # code either here or in the application) but gets caught in the
-        # low-level code of HttpConnection.  The solution is not to let any
-        # exception escape the block that we pass to HttpConnection::request.
-        # Exceptions can originate from code directly in the block, or from user
-        # code called in the other block which is passed to response.read_body.
-        benchblock.service.add! do
-          responsehdr = @connection.request(request) do |response|
-          #########
-            begin
-              @last_response = response
-              if response.is_a?(Net::HTTPSuccess)
-                @error_handler = nil
-                response.read_body(&block)
-              else
-                @error_handler = AWSErrorHandler.new(self, parser, :errors_list => self.class.amazon_problems) unless @error_handler
-                check_result   = @error_handler.check(request)
-                if check_result
-                  @error_handler = nil
-                  return check_result 
-                end
-                raise AwsError.new(@last_errors, @last_response.code, @last_request_id)
-              end
-            rescue Exception => e
-              blockexception = e
-            end
-          end
-          #########
-
-          #OK, now we are out of the block passed to the lower level
-          if(blockexception)
-            raise blockexception
-          end
-          benchblock.xml.add! do
-            parser.parse(responsehdr)
-          end
-          return parser.result
-        end
-      else
-        benchblock.service.add!{ response = @connection.request(request) }
-          # check response for errors...
-        @last_response = response
-        if response.is_a?(Net::HTTPSuccess)
-          @error_handler = nil
-          benchblock.xml.add! { parser.parse(response) }
-          return parser.result
-        else
-          @error_handler = AWSErrorHandler.new(self, parser, :errors_list => self.class.amazon_problems) unless @error_handler
-          check_result   = @error_handler.check(request)
-          if check_result
-            @error_handler = nil
-            return check_result 
-          end
-          raise AwsError.new(@last_errors, @last_response.code, @last_request_id)
-        end
-      end
-    rescue
-      @error_handler = nil
-      raise
-    end
-
-    def request_cache_or_info(method, link, parser_class, benchblock, use_cache=true) #:nodoc:
-      # We do not want to break the logic of parsing hence will use a dummy parser to process all the standard
-      # steps (errors checking etc). The dummy parser does nothig - just returns back the params it received.
-      # If the caching is enabled and hit then throw  AwsNoChange.
-      # P.S. caching works for the whole images list only! (when the list param is blank)
-      # check cache
-      response, params = request_info(link, RightDummyParser.new)
-      cache_hits?(method.to_sym, response.body) if use_cache
-      parser = parser_class.new(:logger => @logger)
-      benchblock.xml.add!{ parser.parse(response, params) }
-      result = block_given? ? yield(parser) : parser.result
-      # update parsed data
-      update_cache(method.to_sym, :parsed => result) if use_cache
-      result
-    end
-
-    # Returns Amazons request ID for the latest request
-    def last_request_id
-      @last_response && @last_response.body.to_s[%r{<requestId>(.+?)</requestId>}] && $1
-    end
-
-  end
-
-
-  # Exception class to signal any Amazon errors. All errors occuring during calls to Amazon's
-  # web services raise this type of error.
-  # Attribute inherited by RuntimeError:
-  #  message    - the text of the error, generally as returned by AWS in its XML response.
-  class AwsError < RuntimeError
-    
-    # either an array of errors where each item is itself an array of [code, message]),
-    # or an error string if the error was raised manually, as in <tt>AwsError.new('err_text')</tt>
-    attr_reader :errors
-    
-    # Request id (if exists)
-    attr_reader :request_id
-    
-    # Response HTTP error code
-    attr_reader :http_code
-    
-    def initialize(errors=nil, http_code=nil, request_id=nil)
-      @errors      = errors
-      @request_id  = request_id
-      @http_code   = http_code
-      super(@errors.is_a?(Array) ? @errors.map{|code, msg| "#{code}: #{msg}"}.join("; ") : @errors.to_s)
-    end
-    
-    # Does any of the error messages include the regexp +pattern+?
-    # Used to determine whether to retry request.
-    def include?(pattern)
-      if @errors.is_a?(Array)
-        @errors.each{ |code, msg| return true if code =~ pattern } 
-      else
-        return true if @errors_str =~ pattern 
-      end
-      false
-    end
-    
-    # Generic handler for AwsErrors. +aws+ is the RightAws::S3, RightAws::EC2, or RightAws::SQS
-    # object that caused the exception (it must provide last_request and last_response). Supported
-    # boolean options are:
-    # * <tt>:log</tt> print a message into the log using aws.logger to access the Logger
-    # * <tt>:puts</tt> do a "puts" of the error
-    # * <tt>:raise</tt> re-raise the error after logging
-    def self.on_aws_exception(aws, options={:raise=>true, :log=>true})
- 	    # Only log & notify if not user error
-      if !options[:raise] || system_error?($!)
-        error_text = "#{$!.inspect}\n#{$@}.join('\n')}"
-        puts error_text if options[:puts]
-          # Log the error
-        if options[:log]
-          request  = aws.last_request  ? aws.last_request.path :  '-none-'
-          response = aws.last_response ? "#{aws.last_response.code} -- #{aws.last_response.message} -- #{aws.last_response.body}" : '-none-'
-          aws.logger.error error_text
-          aws.logger.error "Request was:  #{request}"
-          aws.logger.error "Response was: #{response}"
-        end
-      end
-      raise if options[:raise]  # re-raise an exception
-      return nil
-    end
-    
-    # True if e is an AWS system error, i.e. something that is for sure not the caller's fault.
-    # Used to force logging.
-    def self.system_error?(e)
- 	    !e.is_a?(self) || e.message =~ /InternalError|InsufficientInstanceCapacity|Unavailable/
-    end
-
-  end
-
-
-  class AWSErrorHandler
-    # 0-100 (%) 
-    DEFAULT_CLOSE_ON_4XX_PROBABILITY = 10     
-    
-    @@reiteration_start_delay = 0.2
-    def self.reiteration_start_delay
-      @@reiteration_start_delay
-    end
-    def self.reiteration_start_delay=(reiteration_start_delay)
-      @@reiteration_start_delay = reiteration_start_delay
-    end
-
-    @@reiteration_time = 5
-    def self.reiteration_time
-      @@reiteration_time
-    end
-    def self.reiteration_time=(reiteration_time)
-      @@reiteration_time = reiteration_time
-    end
-    
-    @@close_on_error = true 
-    def self.close_on_error 
-      @@close_on_error 
-    end 
-    def self.close_on_error=(close_on_error) 
-      @@close_on_error = close_on_error 
-    end 
- 
-    @@close_on_4xx_probability = DEFAULT_CLOSE_ON_4XX_PROBABILITY 
-    def self.close_on_4xx_probability 
-      @@close_on_4xx_probability 
-    end 
-    def self.close_on_4xx_probability=(close_on_4xx_probability) 
-      @@close_on_4xx_probability = close_on_4xx_probability 
-    end 
- 
-    # params: 
-    #  :reiteration_time 
-    #  :errors_list 
-    #  :close_on_error           = true | false 
-    #  :close_on_4xx_probability = 1-100 
-    def initialize(aws, parser, params={}) #:nodoc:     
-      @aws           = aws              # Link to RightEc2 | RightSqs | RightS3 instance
-      @parser        = parser           # parser to parse Amazon response
-      @started_at    = Time.now
-      @stop_at       = @started_at  + (params[:reiteration_time] || @@reiteration_time) 
-      @errors_list   = params[:errors_list] || [] 
-      @reiteration_delay = @@reiteration_start_delay
-      @retries       = 0
-      # close current HTTP(S) connection on 5xx, errors from list and 4xx errors 
-      @close_on_error           = params[:close_on_error].nil? ? @@close_on_error : params[:close_on_error] 
-      @close_on_4xx_probability = params[:close_on_4xx_probability] || @@close_on_4xx_probability       
-    end
-    
-      # Returns false if 
-    def check(request)  #:nodoc:
-      result           = false
-      error_found      = false
-      redirect_detected= false
-      error_match      = nil
-      last_errors_text = ''
-      response         = @aws.last_response
-      # log error
-      request_text_data = "#{request[:server]}:#{request[:port]}#{request[:request].path}"
-      # is this a redirect?
-      # yes!
-      if response.is_a?(Net::HTTPRedirection)
-        redirect_detected = true 
-      else
-        # no, it's an error ...
-        @aws.logger.warn("##### #{@aws.class.name} returned an error: #{response.code} #{response.message}\n#{response.body} #####")
-        @aws.logger.warn("##### #{@aws.class.name} request: #{request_text_data} ####")
-      end
-        # Check response body: if it is an Amazon XML document or not:
-      if redirect_detected || (response.body && response.body[/<\?xml/])   # ... it is a xml document
-        @aws.class.bench_xml.add! do
-          error_parser = RightErrorResponseParser.new
-          error_parser.parse(response)
-          @aws.last_errors     = error_parser.errors
-          @aws.last_request_id = error_parser.requestID
-          last_errors_text     = @aws.last_errors.flatten.join("\n")
-          # on redirect :
-          if redirect_detected
-            location = response['location']
-            # ... log information and ...
-            @aws.logger.info("##### #{@aws.class.name} redirect requested: #{response.code} #{response.message} #####")
-            @aws.logger.info("##### New location: #{location} #####")
-            # ... fix the connection data
-            request[:server]   = URI.parse(location).host
-            request[:protocol] = URI.parse(location).scheme
-            request[:port]     = URI.parse(location).port
-          end
-        end
-      else                               # ... it is not a xml document(probably just a html page?)
-        @aws.last_errors     = [[response.code, "#{response.message} (#{request_text_data})"]]
-        @aws.last_request_id = '-undefined-'
-        last_errors_text     = response.message
-      end
-        # now - check the error
-      unless redirect_detected
-        @errors_list.each do |error_to_find|
-          if last_errors_text[/#{error_to_find}/i]
-            error_found = true
-            error_match = error_to_find
-            @aws.logger.warn("##### Retry is needed, error pattern match: #{error_to_find} #####")
-            break
-          end
-        end
-      end
-        # check the time has gone from the first error come
-      if redirect_detected || error_found
-        # Close the connection to the server and recreate a new one. 
-        # It may have a chance that one server is a semi-down and reconnection 
-        # will help us to connect to the other server 
-        if !redirect_detected && @close_on_error
-          @aws.connection.finish "#{self.class.name}: error match to pattern '#{error_match}'" 
-        end 
-                 
-        if (Time.now < @stop_at)
-          @retries += 1
-          unless redirect_detected
-            @aws.logger.warn("##### Retry ##{@retries} is being performed. Sleeping for #{@reiteration_delay} sec. Whole time: #{Time.now-@started_at} sec ####")
-            sleep @reiteration_delay 
-            @reiteration_delay *= 2
-
-            # Always make sure that the fp is set to point to the beginning(?)
-            # of the File/IO. TODO: it assumes that offset is 0, which is bad.
-            if(request[:request].body_stream && request[:request].body_stream.respond_to?(:pos))
-              begin
-                request[:request].body_stream.pos = 0
-              rescue Exception => e
-                @logger.warn("Retry may fail due to unable to reset the file pointer" +
-                             " -- #{self.class.name} : #{e.inspect}")
-              end
-            end
-          else
-            @aws.logger.info("##### Retry ##{@retries} is being performed due to a redirect.  ####")
-          end
-          result = @aws.request_info(request, @parser)
-        else
-          @aws.logger.warn("##### Ooops, time is over... ####")
-        end 
-      # aha, this is unhandled error: 
-      elsif @close_on_error 
-        # Is this a 5xx error ? 
-        if @aws.last_response.code.to_s[/^5\d\d$/] 
-          @aws.connection.finish "#{self.class.name}: code: #{@aws.last_response.code}: '#{@aws.last_response.message}'" 
-        # Is this a 4xx error ? 
-        elsif @aws.last_response.code.to_s[/^4\d\d$/] && @close_on_4xx_probability > rand(100) 
-          @aws.connection.finish "#{self.class.name}: code: #{@aws.last_response.code}: '#{@aws.last_response.message}', " + 
-                                 "probability: #{@close_on_4xx_probability}%"           
-        end
-      end
-      result
-    end
-    
-  end
-
-
-  #-----------------------------------------------------------------
-
-  class RightSaxParserCallback #:nodoc:
-    def self.include_callback 
-      include XML::SaxParser::Callbacks       
-    end 
-    def initialize(right_aws_parser) 
-      @right_aws_parser = right_aws_parser 
-    end 
-    def on_start_element(name, attr_hash) 
-      @right_aws_parser.tag_start(name, attr_hash) 
-    end   
-    def on_characters(chars) 
-      @right_aws_parser.text(chars) 
-    end 
-    def on_end_element(name) 
-      @right_aws_parser.tag_end(name) 
-    end 
-    def on_start_document; end 
-    def on_comment(msg); end 
-    def on_processing_instruction(target, data); end 
-    def on_cdata_block(cdata); end 
-    def on_end_document; end 
-  end 
- 
-  class RightAWSParser  #:nodoc:
-      # default parsing library 
-    DEFAULT_XML_LIBRARY = 'rexml' 
-      # a list of supported parsers 
-    @@supported_xml_libs = [DEFAULT_XML_LIBRARY, 'libxml'] 
-     
-    @@xml_lib = DEFAULT_XML_LIBRARY # xml library name: 'rexml' | 'libxml' 
-    def self.xml_lib
-      @@xml_lib
-    end
-    def self.xml_lib=(new_lib_name)
-      @@xml_lib = new_lib_name
-    end
-    
-    attr_accessor :result
-    attr_reader   :xmlpath
-    attr_accessor :xml_lib
-    
-    def initialize(params={})
-      @xmlpath = ''
-      @result  = false
-      @text    = ''
-      @xml_lib = params[:xml_lib] || @@xml_lib
-      @logger  = params[:logger]
-      reset
-    end
-    def tag_start(name, attributes)
-      @text = ''
-      tagstart(name, attributes)
-      @xmlpath += @xmlpath.empty? ? name : "/#{name}"
-    end
-    def tag_end(name)
-      if @xmlpath =~ /^(.*?)\/?#{name}$/
-        @xmlpath = $1
-      end
-      tagend(name)
-    end
-    def text(text)
-      @text += text
-      tagtext(text)
-    end
-      # Parser method.
-      # Params:
-      #   xml_text         - xml message text(String) or Net:HTTPxxx instance (response)
-      #   params[:xml_lib] - library name: 'rexml' | 'libxml'
-    def parse(xml_text, params={})
-        # Get response body
-      xml_text = xml_text.body unless xml_text.is_a?(String)
-      @xml_lib = params[:xml_lib] || @xml_lib
-        # check that we had no problems with this library otherwise use default 
-      @xml_lib = DEFAULT_XML_LIBRARY unless @@supported_xml_libs.include?(@xml_lib)       
-        # load xml library
-      if @xml_lib=='libxml' && !defined?(XML::SaxParser)
-        begin
-          require 'xml/libxml'
-          # is it new ? - Setup SaxParserCallback 
-          if XML::Parser::VERSION >= '0.5.1.0'
-            RightSaxParserCallback.include_callback 
-          end           
-        rescue LoadError => e
-          @@supported_xml_libs.delete(@xml_lib) 
-          @xml_lib = DEFAULT_XML_LIBRARY           
-          if @logger
-            @logger.error e.inspect
-            @logger.error e.backtrace
-            @logger.info "Can not load 'libxml' library. '#{DEFAULT_XML_LIBRARY}' is used for parsing." 
-          end
-        end
-      end
-        # Parse the xml text
-      case @xml_lib
-      when 'libxml'  
-        xml        = XML::SaxParser.new 
-        xml.string = xml_text 
-        # check libxml-ruby version 
-        if XML::Parser::VERSION >= '0.5.1.0'
-          xml.callbacks = RightSaxParserCallback.new(self) 
-        else 
-          xml.on_start_element{|name, attr_hash| self.tag_start(name, attr_hash)} 
-          xml.on_characters{   |text|            self.text(text)} 
-          xml.on_end_element{  |name|            self.tag_end(name)} 
-        end 
-        xml.parse
-      else
-        REXML::Document.parse_stream(xml_text, self)
-      end
-    end
-      # Parser must have a lots of methods 
-      # (see /usr/lib/ruby/1.8/rexml/parsers/streamparser.rb)
-      # We dont need most of them in RightAWSParser and method_missing helps us
-      # to skip their definition
-    def method_missing(method, *params)
-        # if the method is one of known - just skip it ...
-      return if [:comment, :attlistdecl, :notationdecl, :elementdecl, 
-                 :entitydecl, :cdata, :xmldecl, :attlistdecl, :instruction, 
-                 :doctype].include?(method)
-        # ... else - call super to raise an exception
-      super(method, params)
-    end
-      # the functions to be overriden by children (if nessesery)
-    def reset                     ; end
-    def tagstart(name, attributes); end
-    def tagend(name)              ; end
-    def tagtext(text)             ; end
-  end
-
-  #-----------------------------------------------------------------
-  #      PARSERS: Errors
-  #-----------------------------------------------------------------
-
-#<Error>
-#  <Code>TemporaryRedirect</Code>
-#  <Message>Please re-send this request to the specified temporary endpoint. Continue to use the original request endpoint for future requests.</Message>
-#  <RequestId>FD8D5026D1C5ABA3</RequestId>
-#  <Endpoint>bucket-for-k.s3-external-3.amazonaws.com</Endpoint>
-#  <HostId>ItJy8xPFPli1fq/JR3DzQd3iDvFCRqi1LTRmunEdM1Uf6ZtW2r2kfGPWhRE1vtaU</HostId>
-#  <Bucket>bucket-for-k</Bucket>
-#</Error>
-
-  class RightErrorResponseParser < RightAWSParser #:nodoc:
-    attr_accessor :errors  # array of hashes: error/message
-    attr_accessor :requestID
-#    attr_accessor :endpoint, :host_id, :bucket
-    def tagend(name)
-      case name
-        when 'RequestID' ; @requestID = @text
-        when 'Code'      ; @code      = @text
-        when 'Message'   ; @message   = @text
-#       when 'Endpoint'  ; @endpoint  = @text
-#       when 'HostId'    ; @host_id   = @text
-#       when 'Bucket'    ; @bucket    = @text
-        when 'Error'     ; @errors   << [ @code, @message ]
-      end
-    end
-    def reset
-      @errors = []
-    end
-  end
-
-  # Dummy parser - does nothing
-  # Returns the original params back
-  class RightDummyParser  # :nodoc:
-    attr_accessor :result
-    def parse(response, params={})
-      @result = [response, params]
-    end
-  end
-
-  class RightHttp2xxParser < RightAWSParser # :nodoc:
-    def parse(response)
-      @result = response.is_a?(Net::HTTPSuccess)
-    end
-  end
-
-end
-