abiquo-etk 0.4.13

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

@@ -0,0 +1,355 @@
+require 'options'
+require 'set'
+
+# Represents the header fields of an HTTP message.  To access a field
+# you can use `#[]` and `#[]=`.  For example, to get the content type
+# of a response you can do
+# 
+#     response.header['Content-Type']  # => "application/xml"
+#
+# Lookups and modifications done in this way are case insensitive, so
+# 'Content-Type', 'content-type' and :content_type are all equivalent.
+#
+# Multi-valued fields
+# -------------------
+#
+# Multi-value fields (e.g. Accept) are always returned as an Array
+# regardless of the number of values, if the field is present.
+# Single-value fields (e.g. Content-Type) are always returned as
+# strings. The multi/single valueness of a header field is determined
+# by the way it is defined in the HTTP spec.  Unknown fields are
+# treated as multi-valued.
+#
+# (This behavior is new in 0.6 and may be slightly incompatible with
+# the way previous versions worked in some situations.)
+#
+# For example
+#
+#     h = Resourceful::Header.new
+#     h['Accept'] = "application/xml"
+#     h['Accept']                      # => ["application/xml"]
+#
+module Resourceful
+  class Header
+    include Enumerable
+    
+    def initialize(hash={})
+      @raw_fields = {}
+      hash.each { |k, v| self[k] = v }
+    end
+
+    def to_hash
+      @raw_fields.dup
+    end
+
+    def [](k)
+      field_def(k).get_from(@raw_fields)
+    end
+
+    def []=(k, v)
+      field_def(k).set_to(v, @raw_fields)
+    end
+
+    def delete(k)
+      field_def(k).delete(@raw_fields)
+    end
+
+    def has_key?(k)
+      field_def(k).exists_in?(@raw_fields)
+    end
+    alias has_field? has_key?
+
+    def each(&blk)
+      @raw_fields.each(&blk)
+    end
+
+    # Iterates through the fields with values provided as message
+    # ready strings.
+    def each_field(&blk)
+      each do |k,v|
+        str_v = if field_def(k).multivalued?
+                  v.join(', ')
+                else
+                  v.to_s
+                end
+
+        yield k, str_v
+      end
+    end
+
+    def merge!(another)
+      another.each do |k,v|
+        self[k] = v
+      end
+      self
+    end
+
+    def delete(k)
+      @raw_fields.delete(field_def(k).name)
+    end
+
+    def merge(another)
+      self.class.new(self).merge!(another)
+    end
+
+    def reverse_merge(another)
+      self.class.new(another).merge!(self)
+    end
+
+    def dup
+      self.class.new(@raw_fields.dup)
+    end
+
+    # Class to handle the details of each type of field.
+    class FieldDesc
+      include Comparable
+      
+      ##
+      attr_reader :name
+      
+      # Create a new header field descriptor.
+      #
+      # @param [String] name  The canonical name of this field.
+      #
+      # @param [Hash] options hash containing extra information about
+      #   this header fields.  Valid keys are:
+      #   
+      #     `:multivalued`
+      #     `:multivalue`
+      #     `:repeatable`
+      #     :   Values of this field are comma separated list of values.  
+      #         (n#VALUE per HTTP spec.) Default: false
+      #
+      #     `:hop_by_hop`
+      #     :   True if the header is a hop-by-hop header. Default: false
+      #
+      #     `:modifiable`
+      #     :   False if the header should not be modified by intermediates or caches. Default: true
+      #
+      def initialize(name, options = {})
+        @name = name
+        options = Options.for(options).validate(:repeatable, :hop_by_hop, :modifiable)
+        
+        @repeatable = options.getopt([:repeatable, :multivalue, :multivalued]) || false
+        @hop_by_hop = options.getopt(:hop_by_hop) || false
+        @modifiable = options.getopt(:modifiable, true)
+      end
+      
+      def repeatable?
+        @repeatable
+      end
+      alias multivalued? repeatable?
+      
+      def hop_by_hop?
+        @hop_by_hop
+      end
+      
+      def modifiable?
+        @modifiable
+      end
+      
+      def get_from(raw_fields_hash)
+        raw_fields_hash[name]
+      end
+      
+      def set_to(value, raw_fields_hash)
+        raw_fields_hash[name] = if multivalued?
+                                  Array(value).map{|v| v.split(/,\s*/)}.flatten
+                                elsif value.kind_of?(Array)
+                                  raise ArgumentError, "#{name} field may only have one value" if value.size > 1
+                                  value.first
+                                else
+                                  value
+                                end
+      end
+      
+      def delete(raw_fields_hash)
+        raw_fields_hash.delete(name)
+      end
+      
+      def exists_in?(raw_fields_hash)
+        raw_fields_hash.has_key?(name)
+      end
+      
+      def <=>(another)
+        name <=> another.name
+      end
+      
+      def ==(another)
+        name_pattern === another.to_s
+      end
+      alias eql? ==
+        
+      def ===(another)
+        if another.kind_of?(FieldDesc)
+          self == another
+        else
+          name_pattern === another
+        end
+      end
+      
+      def name_pattern
+        @name_pattern ||= Regexp.new('^' + name.gsub('-', '[_-]') + '$', Regexp::IGNORECASE)
+      end
+      
+      def methodized_name
+        @methodized_name ||= name.downcase.gsub('-', '_')
+      end
+        
+      def constantized_name
+        @constantized_name ||= name.upcase.gsub('-', '_')
+      end
+      
+      alias to_s name
+      
+      def accessor_module 
+        @accessor_module ||= begin
+                               Module.new.tap{|m| m.module_eval(<<-RUBY)}
+                                 #{constantized_name} = '#{name}'
+  
+                                 def #{methodized_name}        # def accept
+                                   self[#{constantized_name}]  #   self[ACCEPT]
+                                 end                           # end
+         
+                                 def #{methodized_name}=(val)        # def accept=(val)
+                                   self[#{constantized_name}] = val  #   self[ACCEPT] = val
+                                 end                                 # end
+                               RUBY
+                             end
+      end
+
+      def hash
+        @name.hash
+      end
+        
+      # Yields each commonly used lookup key for this header field.
+      def lookup_keys(&blk)
+        yield name
+        yield name.upcase
+        yield name.downcase
+        yield methodized_name
+        yield methodized_name.to_sym
+        yield constantized_name
+        yield constantized_name.to_sym
+      end
+    end # FieldDesc
+    
+    @@known_fields = Set.new
+    @@known_fields_lookup = Hash.new
+
+    # Declares a common header field.  Header fields do not have to be
+    # defined this way but accessing them is easier, safer and faster
+    # if you do.  Declaring a field does the following things:
+    #
+    #  * defines accessor methods (e.g. `#content_type` and
+    #    `#content_type=`) on `Header`
+    #  
+    #  * defines constant that can be used to reference there field
+    #    name (e.g. `some_header[Header::CONTENT_TYPE]`)
+    #  
+    #  * includes the field in the appropriate *_fields groups (e.g. `Header.non_modifiable_fields`)
+    #
+    #  * provides improved multiple value parsing
+    #
+    # Create a new header field descriptor.
+    #
+    # @param [String] name  The canonical name of this field.
+    #
+    # @param [Hash] options hash containing extra information about
+    #   this header fields.  Valid keys are:
+    #   
+    #     `:multivalued`
+    #     `:multivalue`
+    #     `:repeatable`
+    #     :   Values of this field are comma separated list of values.  
+    #         (n#VALUE per HTTP spec.) Default: false
+    #
+    #     `:hop_by_hop`
+    #     :   True if the header is a hop-by-hop header. Default: false
+    #
+    #     `:modifiable`
+    #     :   False if the header should not be modified by intermediates or caches. Default: true
+    #
+    def self.header_field(name, options = {})
+      hfd = FieldDesc.new(name, options)
+      
+      @@known_fields << hfd      
+      hfd.lookup_keys do |a_key|
+        @@known_fields_lookup[a_key] = hfd
+      end
+
+      include(hfd.accessor_module)
+    end
+    
+    def self.hop_by_hop_fields
+      @@known_fields.select{|hfd| hfd.hop_by_hop?}
+    end
+    
+    def self.non_modifiable_fields
+      @@known_fields.reject{|hfd| hfd.modifiable?}
+    end
+
+    protected
+
+    # ---
+    #
+    # We have to fall back on a slow iteration to find the header
+    # field some times because field names are
+    def field_def(name)
+      @@known_fields_lookup[name] ||  # the fast way
+        @@known_fields.find{|hfd| hfd === name} ||  # the slow way
+        FieldDesc.new(name.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }.gsub('_', '-'), :repeatable => true)  # make up as we go
+    end
+
+    header_field('Accept', :repeatable => true)
+    header_field('Accept-Charset', :repeatable => true)
+    header_field('Accept-Encoding', :repeatable => true)
+    header_field('Accept-Language', :repeatable => true)
+    header_field('Accept-Ranges', :repeatable => true)
+    header_field('Age')
+    header_field('Allow', :repeatable => true)
+    header_field('Authorization', :repeatable => true)
+    header_field('Cache-Control', :repeatable => true)
+    header_field('Connection', :hop_by_hop => true)
+    header_field('Content-Encoding', :repeatable => true)
+    header_field('Content-Language', :repeatable => true)
+    header_field('Content-Length')
+    header_field('Content-Location', :modifiable => false)
+    header_field('Content-MD5', :modifiable => false)
+    header_field('Content-Range')
+    header_field('Content-Type')
+    header_field('Date')
+    header_field('ETag', :modifiable => false)
+    header_field('Expect', :repeatable => true)
+    header_field('Expires', :modifiable => false)
+    header_field('From')
+    header_field('Host')
+    header_field('If-Match', :repeatable => true)
+    header_field('If-Modified-Since')
+    header_field('If-None-Match', :repeatable => true)
+    header_field('If-Range')
+    header_field('If-Unmodified-Since')
+    header_field('Keep-Alive', :hop_by_hop => true)
+    header_field('Last-Modified', :modifiable => false)
+    header_field('Location')
+    header_field('Max-Forwards')
+    header_field('Pragma', :repeatable => true)
+    header_field('Proxy-Authenticate', :hop_by_hop => true)
+    header_field('Proxy-Authorization', :hop_by_hop => true)
+    header_field('Range')
+    header_field('Referer')
+    header_field('Retry-After')
+    header_field('Server')
+    header_field('TE', :repeatable => true, :hop_by_hop => true)
+    header_field('Trailer', :repeatable => true, :hop_by_hop => true)
+    header_field('Transfer-Encoding', :repeatable => true, :hop_by_hop => true)
+    header_field('Upgrade', :repeatable => true, :hop_by_hop => true)
+    header_field('User-Agent')
+    header_field('Vary', :repeatable => true)
+    header_field('Via', :repeatable => true)
+    header_field('Warning', :repeatable => true)
+    header_field('WWW-Authenticate', :repeatable => true)
+  end
+end
+
+

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

@@ -0,0 +1,103 @@
+require 'net/http'
+
+require 'resourceful/authentication_manager'
+require 'resourceful/cache_manager'
+require 'resourceful/resource'
+
+require 'options'
+
+module Resourceful
+  # This is an imitation Logger used when no real logger is
+  # registered.  This allows most of the code to assume that there
+  # is always a logger available, which significantly improved the
+  # readability of the logging related code.
+  class BitBucketLogger
+    def warn(*args); end
+    def info(*args); end
+    def debug(*args); end
+  end
+
+  # This is the simplest logger. It just writes everything to STDOUT.
+  class StdOutLogger
+    def warn(*args); puts args; end
+    def info(*args); puts args; end
+    def debug(*args); puts args; end
+  end
+  
+  # This class provides a simple interface to the functionality
+  # provided by the Resourceful library.  Conceptually this object
+  # acts a collection of all the resources available via HTTP.
+  class HttpAccessor
+    # A logger object to which messages about the activities of this
+    # object will be written.  This should be an object that responds
+    # to +#info(message)+ and +#debug(message)+.  
+    #
+    # Errors will not be logged.  Instead an exception will be raised
+    # and the application code should log it if appropriate.
+    attr_accessor :logger, :cache_manager
+    
+    attr_reader :auth_manager
+    attr_reader :user_agent_tokens  
+    
+    ##
+    # The adapter this accessor will use to make the actual HTTP requests.
+    attr_reader :http_adapter
+    
+    # Initializes a new HttpAccessor.  Valid options:
+    #
+    #  `:logger`
+    #  :    A Logger object that the new HTTP accessor should send log messages
+    #
+    #  `:user_agent`
+    #  :    One or more additional user agent tokens to added to the user agent string.
+    #
+    #  `:cache_manager`
+    #  :    The cache manager this accessor should use.
+    #
+    #  `:authenticator`
+    #  :    Add a single authenticator for this accessor.
+    #
+    #  `:authenticators`
+    #  :    Enumerable of the authenticators for this accessor.
+    #
+    #  `http_adapter`
+    #  :    The HttpAdapter to be used by this accessor
+    #
+    # 
+    def initialize(options = {})
+      options = Options.for(options).validate(:logger, :user_agent, :cache_manager, :authenticator, :authenticators, :http_adapter)
+
+      @user_agent_tokens = [RESOURCEFUL_USER_AGENT_TOKEN]
+      @auth_manager = AuthenticationManager.new()
+
+      
+      @user_agent_tokens.push(*Array(options.getopt(:user_agent)).flatten.reverse)
+      self.logger    = options.getopt(:logger) || BitBucketLogger.new
+      @cache_manager = options.getopt(:cache_manager) || NullCacheManager.new
+      @http_adapter  = options.getopt(:http_adapter) || NetHttpAdapter.new
+      
+      Array(options.getopt([:authenticator, :authenticators])).flatten.each do |an_authenticator|
+        add_authenticator(an_authenticator)
+      end
+    end
+    
+    # Returns the string that identifies this HTTP accessor.  If you
+    # want to add a token to the user agent string simply add the new
+    # token to the end of +#user_agent_tokens+.
+    def user_agent_string
+      user_agent_tokens.reverse.join(' ')
+    end
+    
+    # Returns a resource object representing the resource indicated
+    # by the specified URI.  A resource object will be created if necessary.
+    def resource(uri, opts = {})
+      resource = Resource.new(self, uri, opts)
+    end
+    alias [] resource
+
+    # Adds an Authenticator to the set used by the accessor.
+    def add_authenticator(an_authenticator)
+      auth_manager.add_auth_handler(an_authenticator)
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require "resourceful/cache_manager"
+
+require 'memcache'
+
+module Resourceful
+  class MemcacheCacheManager < AbstractCacheManager
+  
+    # Create a new Memcached backed cache manager
+    #
+    # @param [*String] memcache_servers  
+    #   list of all Memcached servers this cache manager should use.
+    def initialize(*memcache_servers)
+      @memcache = MemCache.new(memcache_servers, :multithread => true)
+    end
+
+    # Finds a previously cached response to the provided request.  The
+    # response returned may be stale.
+    #
+    # @param [Resourceful::Request] request
+    #   The request for which we are looking for a response.
+    #
+    # @return [Resourceful::Response, nil] 
+    #   A (possibly stale) response for the request provided or nil if 
+    #   no matching response is found.
+    def lookup(request)
+      resp = cache_entries_for(request)[request]
+      return if resp.nil?
+
+      resp.authoritative = false
+
+      resp
+    end
+
+    # Store a response in the cache. 
+    #
+    # This method is smart enough to not store responses that cannot be 
+    # cached (Vary: * or Cache-Control: no-cache, private, ...)
+    #
+    # @param [Resourceful::Request] request
+    #   The request used to obtain the response. This is needed so the 
+    #   values from the response's Vary header can be stored.
+    # @param [Resourceful::Response] response
+    #   The response to be stored.
+    def store(request, response)
+      return unless response.cachable?
+
+      entries = cache_entries_for(request)
+      entries[request] = response
+
+      @memcache[request.to_mc_key] = entries
+    end
+
+    # Invalidates a all cached entries for a uri. 
+    #
+    # This is used, for example, to invalidate the cache for a resource 
+    # that gets POSTed to.
+    #
+    # @param [String] uri
+    #   The uri of the resource to be invalidated
+    def invalidate(uri)
+      @memcache.delete(uri_hash(uri))
+    end
+
+
+    private 
+
+    ##
+    # The memcache proxy.
+    attr_reader :memcache
+
+    def cache_entries_for(a_request)
+      @memcache.get(uri_hash(a_request.uri)) || Resourceful::CacheEntryCollection.new
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'resourceful/abstract_form_data'
+
+module Resourceful
+  class MultipartFormData < AbstractFormData
+    FileParamValue = Struct.new(:content, :file_name, :content_type)
+
+    def add_file(name, file_name, content_type="application/octet-stream")
+      add(name, FileParamValue.new(File.new(file_name, 'r'), File.basename(file_name), content_type))
+    end
+
+    def content_type
+      "multipart/form-data; boundary=#{boundary}"
+    end
+
+    def read
+      StringIO.new.tap do |out|
+        first = true
+        form_data.each do |key, val|
+          out << "\r\n" unless first
+          out << "--" << boundary
+          out << "\r\nContent-Disposition: form-data; name=\"#{key}\""
+          if val.kind_of?(FileParamValue)
+            out << "; filename=\"#{val.file_name}\""
+            out << "\r\nContent-Type: #{val.content_type}"
+          end
+          out << "\r\n\r\n"
+          if val.kind_of?(FileParamValue)
+            out << val.content.read
+          else
+            out << val.to_s
+          end
+          first = false
+        end
+        out << "\r\n--#{boundary}--"
+      end.string
+    end
+
+    protected
+
+    def boundary
+      @boundary ||= (0..30).map{BOUNDARY_CHARS[rand(BOUNDARY_CHARS.length)]}.join
+    end
+
+    BOUNDARY_CHARS = [('a'..'z').to_a,('A'..'Z').to_a,(0..9).to_a].flatten
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'net/http'
+require 'net/https'
+require 'addressable/uri'
+
+require 'pathname'
+require 'resourceful/header'
+
+module Addressable
+  class URI
+    def absolute_path
+      absolute_path = ""
+      absolute_path << self.path.to_s
+      absolute_path << "?#{self.query}" if self.query != nil
+      absolute_path << "##{self.fragment}" if self.fragment != nil
+      return absolute_path
+    end
+  end
+end
+
+module Resourceful
+
+  class NetHttpAdapter
+    # Make an HTTP request using the standard library net/http.
+    #
+    # Will use a proxy defined in the http_proxy environment variable, if set.
+    #
+    # @param [#read] body
+    #   An IO-ish thing containing the body of the request
+    #
+    def make_request(method, uri, body = nil, header = nil)
+      uri = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
+
+      if [:put, :post].include? method
+        body = body ? body.read : ""
+        header[:content_length] = body.size 
+      end
+
+      req = net_http_request_class(method).new(uri.absolute_path)
+      header.each_field { |k,v| req[k] = v } if header
+      https = ("https" == uri.scheme)
+      conn_class = proxy_details ? Net::HTTP.Proxy(*proxy_details) : Net::HTTP
+      conn = conn_class.new(uri.host, uri.port || (https ? 443 : 80))
+      conn.use_ssl = https
+      begin 
+        conn.start
+        res = if body
+                conn.request(req, body)
+              else
+                conn.request(req)
+              end
+      ensure
+        conn.finish if conn.started?
+      end
+
+      [ Integer(res.code),
+        Resourceful::Header.new(res.header.to_hash),
+        res.body
+      ]
+    ensure
+      
+    end
+
+    private
+
+    # Parse proxy details from http_proxy environment variable
+    def proxy_details
+      proxy = Addressable::URI.parse(ENV["http_proxy"])
+      [proxy.host, proxy.port, proxy.user, proxy.password] if proxy
+    end
+
+    def net_http_request_class(method)
+      case method
+      when :get     then Net::HTTP::Get
+      when :head    then Net::HTTP::Head
+      when :post    then Net::HTTP::Post
+      when :put     then Net::HTTP::Put
+      when :delete  then Net::HTTP::Delete
+      end
+
+    end
+
+  end
+
+end