abiquo-etk 0.4.13

data/vendor/resourceful-1.0.1/lib/resourceful/request.rb

@@ -0,0 +1,235 @@
+require 'pathname'
+require 'benchmark'
+require 'resourceful/response'
+require 'resourceful/net_http_adapter'
+require 'resourceful/exceptions'
+
+module Resourceful
+
+  class Request
+
+    REDIRECTABLE_METHODS = [:get, :head]
+    CACHEABLE_METHODS = [:get, :head]
+    INVALIDATING_METHODS = [:post, :put, :delete]
+
+    attr_accessor :method, :resource, :body, :header
+    attr_reader   :request_time, :accessor
+
+    # @param [Symbol] http_method
+    #   :get, :put, :post, :delete or :head
+    # @param [Resourceful::Resource] resource
+    # @param [String] body
+    # @param [Resourceful::Header, Hash] header
+    def initialize(http_method, resource, body = nil, header = nil)
+      @method, @resource, @body = http_method, resource, body
+      @accessor = @resource.accessor
+      @header = header.is_a?(Resourceful::Header) ? header : Resourceful::Header.new(header)
+
+      # Resourceful handled gzip encoding transparently, so set that up
+      @header.accept_encoding ||= 'gzip, identity'
+
+      # 'Host' is a required HTTP/1.1 header, overrides Host in user-provided headers
+      @header.host = @resource.host
+
+      # Setting the date isn't a bad idea, either
+      @header.date ||= Time.now.httpdate
+
+      # Add any auth credentials we might want
+      add_credentials!
+
+    end
+
+    # Uses the auth manager to add any valid credentials to this request
+    def add_credentials!
+      @accessor.auth_manager.add_credentials(self)
+    end
+
+    # Performs all the work. Handles caching, redirects, auth retries, etc
+    def fetch_response
+      if cached_response
+        if needs_revalidation?(cached_response)
+          logger.info("    Cache needs revalidation")
+          set_validation_headers!(cached_response)
+        else
+          # We're done!
+          return cached_response
+        end
+      end
+
+      response = perform!
+
+      response = revalidate_cached_response(response) if cached_response && response.not_modified?
+      response = follow_redirect(response)            if should_be_redirected?(response)
+      response = retry_with_auth(response)            if needs_authorization?(response)
+
+      raise UnsuccessfulHttpRequestError.new(self, response) if response.error?
+
+      if cacheable?(response)
+        store_in_cache(response)
+      elsif invalidates_cache?
+        invalidate_cache
+      end
+
+      return response
+    end
+
+    # Should we look for a response to this request in the cache?
+    def skip_cache?
+      return true unless method.in? CACHEABLE_METHODS
+      header.cache_control && header.cache_control.include?('no-cache')
+    end
+
+    # The cached response
+    def cached_response
+      return if skip_cache?
+      return if @cached_response.nil? && @already_checked_cache
+      @cached_response ||= begin
+        @already_checked_cache = true
+        resp = accessor.cache_manager.lookup(self)
+        logger.info("    Retrieved from cache") if resp
+        resp
+      end
+    end
+
+    # Revalidate the cached response with what we got from a 304 response
+    def revalidate_cached_response(not_modified_response)
+      logger.info("    Resource not modified")
+      cached_response.revalidate!(not_modified_response)
+      cached_response
+    end
+
+    # Follow a redirect response
+    def follow_redirect(response)
+      raise MalformedServerResponse.new(self, response) unless response.header.location
+      if response.moved_permanently?
+        new_uri = response.header.location.first
+        logger.info("    Permanently redirected to #{new_uri} - Storing new location.")
+        resource.update_uri new_uri
+        @header.host = resource.host
+        response = fetch_response
+      elsif response.see_other? # Always use GET for this redirect, regardless of initial method
+        redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
+        response = Request.new(:get, redirected_resource, body, header).fetch_response
+      else
+        redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
+        logger.info("    Redirected to #{redirected_resource.uri} - Caching new location.")
+        response = Request.new(method, redirected_resource, body, header).fetch_response
+      end
+    end
+
+    # Add any auth headers from the response to the auth manager, and try the request again
+    def retry_with_auth(response)
+      @already_tried_with_auth = true
+      logger.info("Authentication Required. Retrying with auth info")
+      accessor.auth_manager.associate_auth_info(response)
+      add_credentials!
+      @body.rewind if @body # Its a stringIO, and we already fed it to the adapter once, so rewind it when we try again
+      response = fetch_response
+    end
+
+    # Does this request need to be authorized? Will only be true if we haven't already tried with auth
+    def needs_authorization?(response)
+      !@already_tried_with_auth && response.unauthorized?
+    end
+
+    # Store the response to this request in the cache
+    def store_in_cache(response)
+      # RFC2618 - 14.18 : A received message that does not have a Date header 
+      # field MUST be assigned one by the recipient if the message will be cached 
+      # by that recipient.
+      response.header.date ||= response.response_time.httpdate
+
+      accessor.cache_manager.store(self, response) 
+    end
+
+    # Invalidated the cache for this uri (eg, after a POST)
+    def invalidate_cache
+      accessor.cache_manager.invalidate(resource.uri)
+    end
+
+    # Is this request & response permitted to be stored in this (private) cache?
+    def cacheable?(response)
+      return false unless response.success?
+      return false unless method.in? CACHEABLE_METHODS
+      return false if header.cache_control && header.cache_control.include?('no-store')
+      true
+    end
+
+    # Does this request invalidate the cache?
+    def invalidates_cache?
+      return true if method.in? INVALIDATING_METHODS
+    end
+
+    # Perform the request, with no magic handling of anything.
+    def perform!
+      @request_time = Time.now
+
+      http_resp = adapter.make_request(@method, @resource.uri, @body, @header)
+      @response = Resourceful::Response.new(uri, *http_resp)
+      @response.request_time = @request_time
+      @response.authoritative = true
+
+      @response
+    end
+
+    # Is this a response a redirect, and are we permitted to follow it?
+    def should_be_redirected?(response)
+      return false unless response.redirect?
+      if resource.on_redirect.nil?
+        return true if method.in? REDIRECTABLE_METHODS
+        false
+      else
+        resource.on_redirect.call(self, response)
+      end
+    end
+
+    # Do we need to revalidate our cache?
+    def needs_revalidation?(response)
+      return true if forces_revalidation?
+      return true if response.stale?
+      return true if max_age && response.current_age > max_age
+      return true if response.must_be_revalidated?
+      false
+    end
+
+    # Set the validation headers of a request based on the response in the cache
+    def set_validation_headers!(response)
+      @header['If-None-Match'] = response.header['ETag'] if response.header.has_key?('ETag')
+      @header['If-Modified-Since'] = response.header['Last-Modified'] if response.header.has_key?('Last-Modified')
+      @header['Cache-Control'] = 'max-age=0' if response.must_be_revalidated?    
+    end
+
+    # @return [String]   The URI against which this request will be, or was, made.
+    def uri
+      resource.uri
+    end
+
+    # Does this request force us to revalidate the cache?
+    def forces_revalidation?
+      if max_age == 0 || skip_cache?
+        logger.info("    Client forced revalidation")
+        true
+      else 
+        false
+      end
+    end
+
+    # Indicates the maxmimum response age in seconds we are willing to accept
+    #
+    # Returns nil if we don't care how old the response is
+    def max_age
+      if header['Cache-Control'] and header['Cache-Control'].include?('max-age')
+        header['Cache-Control'].split(',').grep(/max-age/).first.split('=').last.to_i
+      end
+    end
+
+    def logger
+      resource.logger
+    end
+
+    def adapter
+      accessor.http_adapter
+    end
+  end
+
+end

data/vendor/resourceful-1.0.1/lib/resourceful/resource.rb

@@ -0,0 +1,179 @@
+require 'pathname'
+require 'resourceful/request'
+
+module Resourceful
+
+  class Resource
+    attr_reader :accessor
+
+    # Build a new resource for a uri
+    #
+    # @param accessor<HttpAccessor>
+    #   The parent http accessor
+    # @param uri<String, Addressable::URI>
+    #   The uri for the location of the resource
+    def initialize(accessor, uri, default_header = {})
+      @accessor, @uris = accessor, [uri]
+      @default_header = Resourceful::Header.new({'User-Agent' => Resourceful::RESOURCEFUL_USER_AGENT_TOKEN}.merge(default_header))
+      @on_redirect = nil
+    end
+
+    # The uri used to identify this resource. This is almost always the uri
+    # used to create the resource, but in the case of a permanent redirect, this
+    # will always reflect the lastest uri.
+    #
+    # @return Addressable::URI
+    #   The current uri of the resource
+    def effective_uri
+      @uris.first
+    end
+    alias uri effective_uri
+
+    def default_header(temp_defaults = {})
+      @default_header.merge(temp_defaults)
+    end
+
+    # Returns the host for this Resource's current uri
+    def host
+      Addressable::URI.parse(uri).host
+    end
+
+    # Updates the effective uri after following a permanent redirect
+    def update_uri(uri)
+      @uris.unshift(uri)
+    end
+
+    # When performing a redirect, this callback will be executed first. If the callback
+    # returns true, then the redirect is followed, otherwise it is not. The request that
+    # triggered the redirect and the response will be passed into the block. This can be
+    # used to update any links on the client side.
+    #
+    # Example:
+    #
+    #   author_resource.on_redirect do |req, resp|
+    #     post.author_uri = resp.header['Location']
+    #   end
+    #
+    # @yieldparam callback<request, response>
+    #   The action to be executed when a request results in a redirect. Yields the
+    #   current request and result objects to the callback.
+    #
+    # @raise ArgumentError if called without a block
+    def on_redirect(&callback)
+      if block_given?
+        @on_redirect = callback
+      else
+        @on_redirect
+      end
+    end
+
+    # Performs a GET on the resource, following redirects as neccessary, and retriving
+    # it from the local cache if its available and valid.
+    #
+    # @return [Response] The Response to the final request made.
+    #
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def get(header = {})
+      request(:get, nil, header)
+    end
+
+    def head(header = {})
+      request(:head, nil, header)
+    end
+    # :call-seq:
+    #   post(data = "", :content_type => mime_type)
+    #
+    # Performs a POST with the given data to the resource, following redirects as
+    # neccessary.
+    #
+    # @param [String] data
+    #   The body of the data to be posted
+    # @param [Hash] options
+    #   Options to pass into the request header. At the least, :content_type is required.
+    #
+    # @return [Response]  The Response to the final request that was made.
+    #
+    # @raise [ArgumentError] unless :content-type is specified in options
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def post(data = nil, header = {})
+      request(:post, data, header)
+    end
+
+    # :call-seq:
+    #   put(data = "", :content_type => mime_type)
+    #
+    # Performs a PUT with the given data to the resource, following redirects as
+    # neccessary.
+    #
+    # @param [String] data
+    #   The body of the data to be posted
+    # @param [Hash] options
+    #   Options to pass into the request header. At the least, :content_type is required.
+    #
+    # @return [Response] The response to the final request made.
+    #
+    # @raise [ArgumentError] unless :content-type is specified in options
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def put(data, header = {})
+      request(:put, data, header)
+    end
+
+    # Performs a DELETE on the resource, following redirects as neccessary.
+    #
+    # @return <Response>
+    #
+    # @raise [UnsuccessfulHttpRequestError] unless the request is a
+    #   success, ie the final request returned a 2xx response code
+    def delete(header = {})
+      request(:delete, nil, header)
+    end
+
+    def logger
+      accessor.logger
+    end
+
+    # Actually make the request
+    def request(method, data, header)
+      header = default_header.merge(header)
+      ensure_content_type(data, header) if data
+
+      data = StringIO.new(data) if data.kind_of?(String)
+
+      log_request_with_time "#{method.to_s.upcase} [#{uri}]" do
+        request = Request.new(method, self, data, header)
+        request.fetch_response
+      end
+    end
+
+    private
+
+    # Ensures that the request has a content type header
+    def ensure_content_type(body, header)
+      return if header.has_key?('Content-Type')
+
+      if body.respond_to?(:content_type)
+        header['Content-Type'] = body.content_type
+        return
+      end
+
+      return if default_header.has_key?('Content-Type')
+
+      # could not figure it out
+      raise MissingContentType
+    end
+
+    # Log it took the time to make the request
+    def log_request_with_time(msg, indent = 2)
+      logger.info(" " * indent + msg)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      logger.info(" " * indent + "-> Returned #{result.code} in %.4fs" % time.real)
+      result
+    end
+
+  end
+
+end

data/vendor/resourceful-1.0.1/lib/resourceful/response.rb

@@ -0,0 +1,221 @@
+require 'net/http'
+require 'time'
+require 'zlib'
+
+module Resourceful
+
+  class Response
+    REDIRECT_RESPONSE_CODES = [301,302,303,307]
+    NORMALLY_CACHEABLE_RESPONSE_CODES = [200, 203, 300, 301, 410]
+
+    attr_reader :uri, :code, :header, :body, :response_time
+    alias headers header
+
+    attr_accessor :authoritative, :request_time
+    alias authoritative? authoritative
+
+    def initialize(uri, code, header, body)
+      @uri, @code, @header, @body = uri, code, header, body
+      @response_time = Time.now
+    end
+
+    # Is this a cached response that has expired?
+    #
+    # @return true|false
+    def expired?
+      if header.cache_control and m_age_str = header.cache_control.find{|cc| /^max-age=/ === cc}
+        return current_age > m_age_str[/\d+/].to_i
+      elsif header.expires
+        return Time.httpdate(header.expires) < Time.now
+      end
+
+      false
+    end
+
+    # Is this a cached response that is stale?
+    #
+    # @return true|false
+    def stale?
+      return true if expired?
+      return false unless header.has_field?(Header::CACHE_CONTROL)
+      return true if header.cache_control.any?{|cc| /must-revalidate|no-cache/ === cc}
+
+      false
+    end
+
+    # Is this response cachable?
+    #
+    # @return true|false
+    def cacheable?
+      @cacheable ||= begin
+        @cacheable = true  if NORMALLY_CACHEABLE_RESPONSE_CODES.include?(code.to_i)
+        @cacheable = false if header.vary && header.vary.include?('*')
+        @cacheable = false if header.cache_control && header.cache_control.include?('no-cache')
+        @cacheable = true  if header.cache_control && header.cache_control.include?('public')
+        @cacheable = true  if header.cache_control && header.cache_control.include?('private')
+        @cacheable || false
+      end
+    end
+
+    # Does this response force revalidation?
+    def must_be_revalidated?
+      header.cache_control && header.cache_control.include?('must-revalidate')
+    end
+    
+    # Update our headers from a later 304 response
+    def revalidate!(not_modified_response)
+      header.merge!(not_modified_response.header)
+      @request_time  = not_modified_response.request_time
+      @response_time = not_modified_response.response_time
+      @authoritative = true
+    end
+
+    # Algorithm taken from RCF2616#13.2.3
+    def current_age
+      age_value   = header.age.to_i
+      date_value  = Time.httpdate(header.date)
+      now         = Time.now
+
+      apparent_age = [0, response_time - date_value].max
+      corrected_received_age = [apparent_age, age_value].max
+      current_age = corrected_received_age + (response_time - request_time) + (now - response_time)
+    end
+
+    def body
+      raise(NotImplementedError, 'Chained encodings are not supported') if header['Content-Encoding'] && header['Content-Encoding'].length > 1
+      encoding = header['Content-Encoding'] && header['Content-Encoding'].first
+
+      case encoding
+      when nil
+        # body is identity encoded; just return it
+        @body
+      when /^\s*gzip\s*$/i
+        gz_in = ::Zlib::GzipReader.new(StringIO.new(@body, 'r'))
+        @body = gz_in.read
+        gz_in.close
+        header.delete('Content-Encoding')
+        @body
+      else
+        raise UnsupportedContentCoding, "Resourceful does not support #{encoding} content coding" 
+      end
+    end
+
+    CODE_NAMES = {
+      100 => "Continue".freeze,
+      101 => "Switching Protocols".freeze,
+
+      200 => "OK".freeze,
+      201 => "Created".freeze,
+      202 => "Accepted".freeze,
+      203 => "Non-Authoritative Information".freeze,
+      204 => "No Content".freeze,
+      205 => "Reset Content".freeze,
+      206 => "Partial Content".freeze,
+
+      300 => "Multiple Choices".freeze,
+      301 => "Moved Permanently".freeze,
+      302 => "Found".freeze,
+      303 => "See Other".freeze,
+      304 => "Not Modified".freeze,
+      305 => "Use Proxy".freeze,
+      307 => "Temporary Redirect".freeze,
+
+      400 => "Bad Request".freeze,
+      401 => "Unauthorized".freeze,
+      402 => "Payment Required".freeze,
+      403 => "Forbidden".freeze,
+      404 => "Not Found".freeze,
+      405 => "Method Not Allowed".freeze,
+      406 => "Not Acceptable".freeze,
+      407 => "Proxy Authentication Required".freeze,
+      408 => "Request Timeout".freeze,
+      409 => "Conflict".freeze,
+      410 => "Gone".freeze,
+      411 => "Length Required".freeze,
+      412 => "Precondition Failed".freeze,
+      413 => "Request Entity Too Large".freeze,
+      414 => "Request-URI Too Long".freeze,
+      415 => "Unsupported Media Type".freeze,
+      416 => "Requested Range Not Satisfiable".freeze,
+      417 => "Expectation Failed".freeze,
+
+      500 => "Internal Server Error".freeze,
+      501 => "Not Implemented".freeze,
+      502 => "Bad Gateway".freeze,
+      503 => "Service Unavailable".freeze,
+      504 => "Gateway Timeout".freeze,
+      505 => "HTTP Version Not Supported".freeze,
+    }.freeze
+
+    CODES = CODE_NAMES.keys
+
+    CODE_NAMES.each do |code, msg|
+      method_name = msg.downcase.gsub(/[- ]/, "_")
+
+      class_eval <<-RUBY
+        def #{method_name}?                           # def ok?
+          @code == #{code}                            #   @code == 200
+        end                                           # end
+      RUBY
+    end
+
+    # Is the response informational? True for
+    # 1xx series response codes
+    #
+    # @return true|false
+    def informational?
+      @code.in? 100..199
+    end
+
+    # Is the response code sucessful? True for only 2xx series
+    # response codes.
+    #
+    # @return true|false
+    def successful?
+      @code.in? 200..299
+    end
+    alias success? successful?
+
+    # Is the response a redirect? True for
+    # 3xx series response codes
+    #
+    # @return true|false
+    def redirection?
+      @code.in? 300..399
+    end
+
+    # Is the response a actual redirect? True for
+    # 301, 302, 303, 307 response codes
+    #
+    # @return true|false
+    def redirect?
+      @code.in? REDIRECT_RESPONSE_CODES
+    end
+
+    # Is the response the result of a client error? True for
+    # 4xx series response codes
+    #
+    # @return true|false
+    def client_error?
+      @code.in? 400..499
+    end
+
+    # Is the response the result of a server error? True for
+    # 5xx series response codes
+    #
+    # @return true|false
+    def server_error?
+      @code.in? 500..599
+    end
+
+    # Is the response the result of any kind of error? True for
+    # 4xx and 5xx series response codes
+    #
+    # @return true|false
+    def error?
+      server_error? || client_error?
+    end
+
+  end
+  
+end

data/vendor/resourceful-1.0.1/lib/resourceful/simple.rb

@@ -0,0 +1,36 @@
+module Resourceful
+  module Simple
+    def request(method, uri, header = {}, data = nil)
+      default_accessor.resource(uri).request(method, data, header)
+    end
+    
+    def default_accessor
+      @default_accessor ||= Resourceful::HttpAccessor.new
+    end
+    
+    def add_authenticator(an_authenticator)
+      default_accessor.add_authenticator(an_authenticator)
+    end
+
+    def get(uri, header = {})
+      request(:get, uri, header)
+    end
+
+    def head(uri, header = {})
+      request(:head, uri, header)
+    end
+
+    def delete(uri, header = {})
+      request(:delete, uri, header)
+    end
+ 
+    def post(uri, data = nil, header = {})
+      request(:post, uri, header, data)
+    end
+
+    def put(uri, data = nil, header = {})
+      request(:put, uri, header, data)
+    end
+  end
+
+end