puppet 0.25.5 → 2.6.0

data/lib/puppet/network/http/compression.rb

@@ -0,0 +1,111 @@
+require 'puppet/network/http'
+
+module Puppet::Network::HTTP::Compression
+
+  # this module function allows to use the right underlying
+  # methods depending on zlib presence
+  def module
+    return(Puppet.features.zlib? ? Active : None)
+  end
+  module_function :module
+
+  module Active
+    require 'zlib'
+    require 'stringio'
+
+    # return an uncompressed body if the response has been
+    # compressed
+    def uncompress_body(response)
+      case response['content-encoding']
+      when 'gzip'
+        return Zlib::GzipReader.new(StringIO.new(response.body)).read
+      when 'deflate'
+        return Zlib::Inflate.new.inflate(response.body)
+      when nil, 'identity'
+        return response.body
+      else
+        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
+      end
+    end
+
+    def uncompress(response)
+      raise Net::HTTPError.new("No block passed") unless block_given?
+
+      case response['content-encoding']
+      when 'gzip','deflate'
+        uncompressor = ZlibAdapter.new
+      when nil, 'identity'
+        uncompressor = IdentityAdapter.new
+      else
+        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
+      end
+
+      yield uncompressor
+
+      uncompressor.close
+    end
+
+    def add_accept_encoding(headers={})
+      headers['accept-encoding'] = 'gzip; q=1.0, deflate; q=1.0; identity' if Puppet.settings[:http_compression]
+      headers
+    end
+
+    # This adapters knows how to uncompress both 'zlib' stream (the deflate algorithm from Content-Encoding)
+    # and GZip streams.
+    class ZlibAdapter
+      def initialize
+        # Create an inflater that knows to parse GZip streams and zlib streams.
+        # This uses a property of the C Zlib library, documented as follow:
+        #   windowBits can also be greater than 15 for optional gzip decoding. Add
+        #   32 to windowBits to enable zlib and gzip decoding with automatic header
+        #   detection, or add 16 to decode only the gzip format (the zlib format will
+        #   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
+        #   a crc32 instead of an adler32.
+        @uncompressor = Zlib::Inflate.new(15 + 32)
+        @first = true
+      end
+
+      def uncompress(chunk)
+        out = @uncompressor.inflate(chunk)
+        @first = false
+        return out
+      rescue Zlib::DataError => z
+        # it can happen that we receive a raw deflate stream
+        # which might make our inflate throw a data error.
+        # in this case, we try with a verbatim (no header)
+        # deflater.
+        @uncompressor = Zlib::Inflate.new
+        retry if @first
+        raise
+      end
+
+      def close
+        @uncompressor.finish
+        @uncompressor.close
+      end
+    end
+  end
+
+  module None
+    def uncompress_body(response)
+      response.body
+    end
+
+    def add_accept_encoding(headers)
+      headers
+    end
+
+    def uncompress(response)
+      yield IdentityAdapter.new
+    end
+  end
+
+  class IdentityAdapter
+    def uncompress(chunk)
+      chunk
+    end
+
+    def close
+    end
+  end
+end

data/lib/puppet/network/http/handler.rb

@@ -7,223 +7,223 @@ require 'puppet/network/rights'
 require 'resolv'
 
 module Puppet::Network::HTTP::Handler
-    include Puppet::Network::HTTP::API::V1
-    include Puppet::Network::RestAuthorization
+  include Puppet::Network::HTTP::API::V1
+  include Puppet::Network::RestAuthorization
 
-    attr_reader :server, :handler
+  attr_reader :server, :handler
 
-    # Retrieve the accept header from the http request.
-    def accept_header(request)
-        raise NotImplementedError
-    end
+  # Retrieve the accept header from the http request.
+  def accept_header(request)
+    raise NotImplementedError
+  end
 
-    # Retrieve the Content-Type header from the http request.
-    def content_type_header(request)
-        raise NotImplementedError
-    end
+  # Retrieve the Content-Type header from the http request.
+  def content_type_header(request)
+    raise NotImplementedError
+  end
 
-    # Which format to use when serializing our response or interpreting the request.  
-    # IF the client provided a Content-Type use this, otherwise use the Accept header
-    # and just pick the first value.
-    def format_to_use(request)
-        unless header = accept_header(request)
-            raise ArgumentError, "An Accept header must be provided to pick the right format"
-        end
-
-        format = nil
-        header.split(/,\s*/).each do |name|
-            next unless format = Puppet::Network::FormatHandler.format(name)
-            next unless format.suitable?
-            return format
-        end
-
-        raise "No specified acceptable formats (%s) are functional on this machine" % header
+  # Which format to use when serializing our response or interpreting the request.
+  # IF the client provided a Content-Type use this, otherwise use the Accept header
+  # and just pick the first value.
+  def format_to_use(request)
+    unless header = accept_header(request)
+      raise ArgumentError, "An Accept header must be provided to pick the right format"
     end
 
-    def request_format(request)
-        if header = content_type_header(request)
-            header.gsub!(/\s*;.*$/,'') # strip any charset
-            format = Puppet::Network::FormatHandler.mime(header)
-            raise "Client sent a mime-type (%s) that doesn't correspond to a format we support" % header if format.nil?
-            return format.name.to_s if format.suitable?
-        end
-
-        raise "No Content-Type header was received, it isn't possible to unserialize the request"
+    format = nil
+    header.split(/,\s*/).each do |name|
+      next unless format = Puppet::Network::FormatHandler.format(name)
+      next unless format.suitable?
+      return format
     end
 
-    def format_to_mime(format)
-        format.is_a?(Puppet::Network::Format) ? format.mime : format
-    end
+    raise "No specified acceptable formats (#{header}) are functional on this machine"
+  end
 
-    def initialize_for_puppet(server)
-        @server = server
+  def request_format(request)
+    if header = content_type_header(request)
+      header.gsub!(/\s*;.*$/,'') # strip any charset
+      format = Puppet::Network::FormatHandler.mime(header)
+      raise "Client sent a mime-type (#{header}) that doesn't correspond to a format we support" if format.nil?
+      return format.name.to_s if format.suitable?
     end
 
-    # handle an HTTP request
-    def process(request, response)
-        indirection_request = uri2indirection(http_method(request), path(request), params(request))
+    raise "No Content-Type header was received, it isn't possible to unserialize the request"
+  end
+
+  def format_to_mime(format)
+    format.is_a?(Puppet::Network::Format) ? format.mime : format
+  end
 
-        check_authorization(indirection_request)
+  def initialize_for_puppet(server)
+    @server = server
+  end
 
-        send("do_%s" % indirection_request.method, indirection_request, request, response)
-    rescue SystemExit,NoMemoryError
-        raise
-    rescue Exception => e
-        return do_exception(response, e)
-    end
-
-    # Set the response up, with the body and status.
-    def set_response(response, body, status = 200)
-        raise NotImplementedError
-    end
+  # handle an HTTP request
+  def process(request, response)
+    indirection_request = uri2indirection(http_method(request), path(request), params(request))
 
-    # Set the specified format as the content type of the response.
-    def set_content_type(response, format)
-        raise NotImplementedError
-    end
+    check_authorization(indirection_request)
 
-    def do_exception(response, exception, status=400)
-        if exception.is_a?(Puppet::Network::AuthorizationError)
-            # make sure we return the correct status code
-            # for authorization issues
-            status = 403 if status == 400
-        end
-        if exception.is_a?(Exception)
-            puts exception.backtrace if Puppet[:trace]
-            Puppet.err(exception)
-        end
-        set_content_type(response, "text/plain")
-        set_response(response, exception.to_s, status)
-    end
+    send("do_#{indirection_request.method}", indirection_request, request, response)
+  rescue SystemExit,NoMemoryError
+    raise
+  rescue Exception => e
+    return do_exception(response, e)
+  end
 
-    # Execute our find.
-    def do_find(indirection_request, request, response)
-        unless result = indirection_request.model.find(indirection_request.key, indirection_request.to_hash)
-            Puppet.info("Could not find %s for '%s'" % [indirection_request.indirection_name, indirection_request.key])
-            return do_exception(response, "Could not find %s %s" % [indirection_request.indirection_name, indirection_request.key], 404)
-        end
+  # Set the response up, with the body and status.
+  def set_response(response, body, status = 200)
+    raise NotImplementedError
+  end
 
-        # The encoding of the result must include the format to use,
-        # and it needs to be used for both the rendering and as
-        # the content type.
-        format = format_to_use(request)
-        set_content_type(response, format)
+  # Set the specified format as the content type of the response.
+  def set_content_type(response, format)
+    raise NotImplementedError
+  end
 
-        set_response(response, result.render(format))
+  def do_exception(response, exception, status=400)
+    if exception.is_a?(Puppet::Network::AuthorizationError)
+      # make sure we return the correct status code
+      # for authorization issues
+      status = 403 if status == 400
     end
-
-    # Execute our search.
-    def do_search(indirection_request, request, response)
-        result = indirection_request.model.search(indirection_request.key, indirection_request.to_hash)
-
-        if result.nil? or (result.is_a?(Array) and result.empty?)
-            return do_exception(response, "Could not find instances in %s with '%s'" % [indirection_request.indirection_name, indirection_request.to_hash.inspect], 404)
-        end
-
-        format = format_to_use(request)
-        set_content_type(response, format)
-
-        set_response(response, indirection_request.model.render_multiple(format, result))
+    if exception.is_a?(Exception)
+      puts exception.backtrace if Puppet[:trace]
+      Puppet.err(exception)
     end
+    set_content_type(response, "text/plain")
+    set_response(response, exception.to_s, status)
+  end
 
-    # Execute our destroy.
-    def do_destroy(indirection_request, request, response)
-        result = indirection_request.model.destroy(indirection_request.key, indirection_request.to_hash)
-
-        return_yaml_response(response, result)
+  # Execute our find.
+  def do_find(indirection_request, request, response)
+    unless result = indirection_request.model.find(indirection_request.key, indirection_request.to_hash)
+      Puppet.info("Could not find #{indirection_request.indirection_name} for '#{indirection_request.key}'")
+      return do_exception(response, "Could not find #{indirection_request.indirection_name} #{indirection_request.key}", 404)
     end
 
-    # Execute our save.
-    def do_save(indirection_request, request, response)
-        data = body(request).to_s
-        raise ArgumentError, "No data to save" if !data or data.empty?
+    # The encoding of the result must include the format to use,
+    # and it needs to be used for both the rendering and as
+    # the content type.
+    format = format_to_use(request)
+    set_content_type(response, format)
 
-        format = request_format(request)
-        obj = indirection_request.model.convert_from(format, data)
-        result = save_object(indirection_request, obj)
-        return_yaml_response(response, result)
-    end
+    set_response(response, result.render(format))
+  end
 
-    # resolve node name from peer's ip address
-    # this is used when the request is unauthenticated
-    def resolve_node(result)
-        begin
-            return Resolv.getname(result[:ip])
-        rescue => detail
-            Puppet.err "Could not resolve %s: %s" % [result[:ip], detail]
-        end
-        return result[:ip]
-    end
+  # Execute our search.
+  def do_search(indirection_request, request, response)
+    result = indirection_request.model.search(indirection_request.key, indirection_request.to_hash)
 
-  private
-
-    def return_yaml_response(response, body)
-        set_content_type(response, Puppet::Network::FormatHandler.format("yaml"))
-        set_response(response, body.to_yaml)
+    if result.nil? or (result.is_a?(Array) and result.empty?)
+      return do_exception(response, "Could not find instances in #{indirection_request.indirection_name} with '#{indirection_request.to_hash.inspect}'", 404)
     end
 
-    # LAK:NOTE This has to be here for testing; it's a stub-point so
-    # we keep infinite recursion from happening.
-    def save_object(ind_request, object)
-        object.save(ind_request.to_hash)
-    end
+    format = format_to_use(request)
+    set_content_type(response, format)
 
-    def get?(request)
-        http_method(request) == 'GET'
-    end
+    set_response(response, indirection_request.model.render_multiple(format, result))
+  end
 
-    def put?(request)
-        http_method(request) == 'PUT'
-    end
+  # Execute our destroy.
+  def do_destroy(indirection_request, request, response)
+    result = indirection_request.model.destroy(indirection_request.key, indirection_request.to_hash)
 
-    def delete?(request)
-        http_method(request) == 'DELETE'
-    end
+    return_yaml_response(response, result)
+  end
 
-    # methods to be overridden by the including web server class
+  # Execute our save.
+  def do_save(indirection_request, request, response)
+    data = body(request).to_s
+    raise ArgumentError, "No data to save" if !data or data.empty?
 
-    def http_method(request)
-        raise NotImplementedError
-    end
+    format = request_format(request)
+    obj = indirection_request.model.convert_from(format, data)
+    result = save_object(indirection_request, obj)
+    return_yaml_response(response, result)
+  end
 
-    def path(request)
-        raise NotImplementedError
-    end
+  # resolve node name from peer's ip address
+  # this is used when the request is unauthenticated
+  def resolve_node(result)
+    begin
+      return Resolv.getname(result[:ip])
+    rescue => detail
+      Puppet.err "Could not resolve #{result[:ip]}: #{detail}"
+    end
+    result[:ip]
+  end
 
-    def request_key(request)
-        raise NotImplementedError
-    end
-
-    def body(request)
-        raise NotImplementedError
-    end
-
-    def params(request)
-        raise NotImplementedError
-    end
+  private
 
-    def decode_params(params)
-        params.inject({}) do |result, ary|
-            param, value = ary
-            next result if param.nil? || param.empty?
-
-            param = param.to_sym
-
-            # These shouldn't be allowed to be set by clients
-            # in the query string, for security reasons.
-            next result if param == :node
-            next result if param == :ip
-            value = CGI.unescape(value)
-            if value =~ /^---/
-                value = YAML.load(value)
-            else
-                value = true if value == "true"
-                value = false if value == "false"
-                value = Integer(value) if value =~ /^\d+$/
-                value = value.to_f if value =~ /^\d+\.\d+$/
-            end
-            result[param] = value
-            result
-        end
-    end
+  def return_yaml_response(response, body)
+    set_content_type(response, Puppet::Network::FormatHandler.format("yaml"))
+    set_response(response, body.to_yaml)
+  end
+
+  # LAK:NOTE This has to be here for testing; it's a stub-point so
+  # we keep infinite recursion from happening.
+  def save_object(ind_request, object)
+    object.save(ind_request.key)
+  end
+
+  def get?(request)
+    http_method(request) == 'GET'
+  end
+
+  def put?(request)
+    http_method(request) == 'PUT'
+  end
+
+  def delete?(request)
+    http_method(request) == 'DELETE'
+  end
+
+  # methods to be overridden by the including web server class
+
+  def http_method(request)
+    raise NotImplementedError
+  end
+
+  def path(request)
+    raise NotImplementedError
+  end
+
+  def request_key(request)
+    raise NotImplementedError
+  end
+
+  def body(request)
+    raise NotImplementedError
+  end
+
+  def params(request)
+    raise NotImplementedError
+  end
+
+  def decode_params(params)
+    params.inject({}) do |result, ary|
+      param, value = ary
+      next result if param.nil? || param.empty?
+
+      param = param.to_sym
+
+      # These shouldn't be allowed to be set by clients
+      # in the query string, for security reasons.
+      next result if param == :node
+      next result if param == :ip
+      value = CGI.unescape(value)
+      if value =~ /^---/
+        value = YAML.load(value)
+      else
+        value = true if value == "true"
+        value = false if value == "false"
+        value = Integer(value) if value =~ /^\d+$/
+        value = value.to_f if value =~ /^\d+\.\d+$/
+      end
+      result[param] = value
+      result
+    end
+  end
 end