puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/network/authorization.rb

@@ -7,7 +7,7 @@ module Puppet::Network
     # Create our config object if necessary. If there's no configuration file
     # we install our defaults
     def self.authconfig
-      @auth_config_file ||= Puppet::Util::LoadedFile.new(Puppet[:rest_authconfig])
+      @auth_config_file ||= Puppet::Util::WatchedFile.new(Puppet[:rest_authconfig])
       if (not @auth_config) or @auth_config_file.changed?
         begin
           @auth_config = Puppet::Network::AuthConfigParser.new_from_file(Puppet[:rest_authconfig]).parse

data/lib/puppet/network/authstore.rb

@@ -232,7 +232,7 @@ module Puppet
         name.downcase.split(".").reverse
       end
 
-      # Parse our input pattern and figure out what kind of allowal
+      # Parse our input pattern and figure out what kind of allowable
       # statement it is.  The output of this is used for later matching.
       Octet = '(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
       IPv4 = "#{Octet}\.#{Octet}\.#{Octet}\.#{Octet}"
@@ -246,7 +246,7 @@ module Puppet
       def parse_ip(value)
         @name = :ip
         @exact, @length, @pattern = *case value
-        when /^(?:#{IP})\/(\d+)$/                                   # 12.34.56.78/24, a001:b002::efff/120, c444:1000:2000::9:192.168.0.1/112
+        when /^(?:#{IP})\/(\d+)$/                                 # 12.34.56.78/24, a001:b002::efff/120, c444:1000:2000::9:192.168.0.1/112
           [:inexact, $1.to_i, IPAddr.new(value)]
         when /^(#{IP})$/                                          # 10.20.30.40,
           [:exact, nil, IPAddr.new(value)]

data/lib/puppet/network/format_handler.rb

@@ -5,33 +5,10 @@ require 'puppet/network/format'
 module Puppet::Network::FormatHandler
   class FormatError < Puppet::Error; end
 
-  class FormatProtector
-    attr_reader :format
-
-    def protect(method, args)
-        Puppet::Network::FormatHandler.format(format).send(method, *args)
-    rescue => details
-        direction = method.to_s.include?("intern") ? "from" : "to"
-        error = FormatError.new("Could not #{method} #{direction} #{format}: #{details}")
-        error.set_backtrace(details.backtrace)
-        raise error
-    end
-
-    def initialize(format)
-      @format = format
-    end
-
-    [:intern, :intern_multiple, :render, :render_multiple, :mime].each do |method|
-      define_method(method) do |*args|
-        protect(method, args)
-      end
-    end
-  end
-
   @formats = {}
+
   def self.create(*args, &block)
-    instance = Puppet::Network::Format.new(*args)
-    instance.instance_eval(&block) if block_given?
+    instance = Puppet::Network::Format.new(*args, &block)
 
     @formats[instance.name] = instance
     instance
@@ -43,18 +20,15 @@ module Puppet::Network::FormatHandler
     }
   end
 
-  def self.extended(klass)
-    klass.extend(ClassMethods)
-
-    # LAK:NOTE This won't work in 1.9 ('send' won't be able to send
-    # private methods, but I don't know how else to do it.
-    klass.send(:include, InstanceMethods)
-  end
-
   def self.format(name)
     @formats[name.to_s.downcase.intern]
   end
 
+  def self.format_for(name)
+    name = format_to_canonical_name(name)
+    format(name)
+  end
+
   def self.format_by_extension(ext)
     @formats.each do |name, format|
       return format if format.extension == ext
@@ -73,15 +47,6 @@ module Puppet::Network::FormatHandler
     @formats.values.find { |format| format.mime == mimetype }
   end
 
-  # Use a delegator to make sure any exceptions generated by our formats are
-  # handled intelligently.
-  def self.protected_format(name)
-    name = format_to_canonical_name(name)
-    @format_protectors ||= {}
-    @format_protectors[name] ||= FormatProtector.new(name)
-    @format_protectors[name]
-  end
-
   # Return a format name given:
   #  * a format name
   #  * a mime-type
@@ -99,81 +64,27 @@ module Puppet::Network::FormatHandler
     out.name
   end
 
-  module ClassMethods
-    def format_handler
-      Puppet::Network::FormatHandler
-    end
-
-    def convert_from(format, data)
-      format_handler.protected_format(format).intern(self, data)
-    end
-
-    def convert_from_multiple(format, data)
-      format_handler.protected_format(format).intern_multiple(self, data)
-    end
-
-    def render_multiple(format, instances)
-      format_handler.protected_format(format).render_multiple(instances)
-    end
-
-    def default_format
-      supported_formats[0]
-    end
-
-    def support_format?(name)
-      Puppet::Network::FormatHandler.format(name).supported?(self)
-    end
-
-    def supported_formats
-      result = format_handler.formats.collect { |f| format_handler.format(f) }.find_all { |f| f.supported?(self) }.collect { |f| f.name }.sort do |a, b|
-        # It's an inverse sort -- higher weight formats go first.
-        format_handler.format(b).weight <=> format_handler.format(a).weight
-      end
-
-      result = put_preferred_format_first(result)
-
-      Puppet.debug "#{friendly_name} supports formats: #{result.map{ |f| f.to_s }.sort.join(' ')}; using #{result.first}"
-
-      result
-    end
-
-    private
-
-    def friendly_name
-      if self.respond_to? :indirection
-        indirection.name
-      else
-        self
-      end
-    end
-
-    def put_preferred_format_first(list)
-      preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
-      if list.include?(preferred_format)
-        list.delete(preferred_format)
-        list.unshift(preferred_format)
-      else
-        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first})"
+  # Determine which of the accepted formats should be used given what is supported.
+  #
+  # @param accepted [Array<String, Symbol>] the accepted formats in a form a
+  #   that can be understood by #format_to_canonical_name and is in order of
+  #   preference (most preferred is first)
+  # @param supported [Array<Symbol>] the names of the supported formats (order
+  #   does not matter)
+  # @return [Puppet::Network::Format, nil] the most suitable format
+  # @api private
+  def self.most_suitable_format_for(accepted, supported)
+    format_name = accepted.find do |accepted|
+      begin
+        format_name = format_to_canonical_name(accepted)
+        supported.include?(format_name)
+      rescue ArgumentError
+        false
       end
-      list
-    end
-  end
-
-  module InstanceMethods
-    def render(format = nil)
-      format ||= self.class.default_format
-
-      Puppet::Network::FormatHandler.protected_format(format).render(self)
-    end
-
-    def mime(format = nil)
-      format ||= self.class.default_format
-
-      Puppet::Network::FormatHandler.protected_format(format).mime
     end
 
-    def support_format?(name)
-      self.class.support_format?(name)
+    if format_name
+      format_for(format_name)
     end
   end
 end

data/lib/puppet/network/format_support.rb

@@ -0,0 +1,106 @@
+require 'puppet/network/format_handler'
+
+# Provides network serialization support when included
+module Puppet::Network::FormatSupport
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def convert_from(format, data)
+      get_format(format).intern(self, data)
+    rescue => err
+      raise Puppet::Network::FormatHandler::FormatError, "Could not intern from #{format}: #{err}", err.backtrace
+    end
+
+    def convert_from_multiple(format, data)
+      get_format(format).intern_multiple(self, data)
+    rescue => err
+      raise Puppet::Network::FormatHandler::FormatError, "Could not intern_multiple from #{format}: #{err}", err.backtrace
+    end
+
+    def render_multiple(format, instances)
+      get_format(format).render_multiple(instances)
+    rescue => err
+      raise Puppet::Network::FormatHandler::FormatError, "Could not render_multiple to #{format}: #{err}", err.backtrace
+    end
+
+    def default_format
+      supported_formats[0]
+    end
+
+    def support_format?(name)
+      Puppet::Network::FormatHandler.format(name).supported?(self)
+    end
+
+    def supported_formats
+      result = format_handler.formats.collect do |f|
+        format_handler.format(f)
+      end.find_all do |f|
+        f.supported?(self)
+      end.sort do |a, b|
+        # It's an inverse sort -- higher weight formats go first.
+        b.weight <=> a.weight
+      end.collect do |f|
+        f.name
+      end
+
+      result = put_preferred_format_first(result)
+
+      Puppet.debug "#{friendly_name} supports formats: #{result.join(' ')}"
+
+      result
+    end
+
+    # @api private
+    def get_format(format_name)
+      format_handler.format_for(format_name)
+    end
+
+    private
+
+    def format_handler
+      Puppet::Network::FormatHandler
+    end
+
+    def friendly_name
+      if self.respond_to? :indirection
+        indirection.name
+      else
+        self
+      end
+    end
+
+    def put_preferred_format_first(list)
+      preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
+      if list.include?(preferred_format)
+        list.delete(preferred_format)
+        list.unshift(preferred_format)
+      else
+        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first})"
+      end
+      list
+    end
+  end
+
+  def render(format = nil)
+    format ||= self.class.default_format
+
+    self.class.get_format(format).render(self)
+  rescue => err
+    raise Puppet::Network::FormatHandler::FormatError, "Could not render to #{format}: #{err}", err.backtrace
+  end
+
+  def mime(format = nil)
+    format ||= self.class.default_format
+
+    self.class.get_format(format).mime
+  rescue => err
+    raise Puppet::Network::FormatHandler::FormatError, "Could not mime to #{format}: #{err}", err.backtrace
+  end
+
+  def support_format?(name)
+    self.class.support_format?(name)
+  end
+end
+

data/lib/puppet/network/formats.rb

@@ -1,14 +1,12 @@
 require 'puppet/network/format_handler'
 
 Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
-  # Yaml doesn't need the class name; it's serialized.
   def intern(klass, text)
     data = YAML.load(text, :safe => true, :deserialize_symbols => true)
     return data if data.is_a?(klass)
     klass.from_pson(data)
   end
 
-  # Yaml doesn't need the class name; it's serialized.
   def intern_multiple(klass, text)
     YAML.load(text, :safe => true, :deserialize_symbols => true).collect do |data|
       if data.is_a?(klass)
@@ -28,7 +26,6 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
     instances.to_yaml
   end
 
-  # Unlike core's yaml, ZAML should support 1.8.1 just fine
   def supported?(klass)
     true
   end
@@ -159,7 +156,6 @@ Puppet::Network::FormatHandler.create(:console,
     if datum.is_a? Hash and datum.keys.all? { |x| x.is_a? String or x.is_a? Numeric }
       output = ''
       column_a = datum.empty? ? 2 : datum.map{ |k,v| k.to_s.length }.max + 2
-      column_b = 79 - column_a
       datum.sort_by { |k,v| k.to_s } .each do |key, value|
         output << key.to_s.ljust(column_a)
         output << json.render(value).
@@ -169,6 +165,16 @@ Puppet::Network::FormatHandler.create(:console,
       return output
     end
 
+    # Print one item per line for arrays
+    if datum.is_a? Array
+      output = ''
+      datum.each do |item|
+        output << item.to_s
+        output << "\n"
+      end
+      return output
+    end
+
     # ...or pretty-print the inspect outcome.
     return json.render(datum)
   end

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

@@ -69,7 +69,7 @@ module Puppet::Network::HTTP::Compression
         out = @uncompressor.inflate(chunk)
         @first = false
         return out
-      rescue Zlib::DataError => z
+      rescue Zlib::DataError
         # 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)

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

@@ -3,9 +3,13 @@ require 'puppet/ssl/host'
 require 'puppet/ssl/configuration'
 require 'puppet/ssl/validator'
 require 'puppet/network/authentication'
+require 'uri'
 
 module Puppet::Network::HTTP
 
+  # This will be raised if too many redirects happen for a given HTTP request
+  class RedirectionLimitExceededException < Puppet::Error ; end
+
   # This class provides simple methods for issuing various types of HTTP
   # requests.  It's interface is intended to mirror Ruby's Net::HTTP
   # object, but it provides a few important bits of additional
@@ -18,10 +22,34 @@ module Puppet::Network::HTTP
   class Connection
     include Puppet::Network::Authentication
 
-    def initialize(host, port, use_ssl = true)
+    OPTION_DEFAULTS = {
+      :use_ssl => true,
+      :verify_peer => true,
+      :redirect_limit => 10
+    }
+
+    # Creates a new HTTP client connection to `host`:`port`. 
+    # @param host [String] the host to which this client will connect to
+    # @param port [Fixnum] the port to which this client will connect to
+    # @param options [Hash] options influencing the properties of the created connection,
+    #   the following options are recognized:
+    #     :use_ssl [Boolean] true to connect with SSL, false otherwise, defaults to true
+    #     :verify_peer [Boolean] true to verify the peer's certificate, false otherwise, defaults to true
+    #     :redirect_limit [Fixnum] the number of allowed redirections, defaults to 10
+    #   passing any other option in the options hash results in a Puppet::Error exception
+    # @note the HTTP connection itself happens lazily only when {#request}, or one of the {#get}, {#post}, {#delete}, {#head} or {#put} is called
+    # @api private
+    def initialize(host, port, options = {})
       @host = host
       @port = port
-      @use_ssl = use_ssl
+
+      unknown_options = options.keys - OPTION_DEFAULTS.keys
+      raise Puppet::Error, "Unrecognized option(s): #{unknown_options.map(&:inspect).sort.join(', ')}" unless unknown_options.empty?
+
+      options = OPTION_DEFAULTS.merge(options)
+      @use_ssl = options[:use_ssl]
+      @verify_peer = options[:verify_peer]
+      @redirect_limit = options[:redirect_limit]
     end
 
     def get(*args)
@@ -45,32 +73,22 @@ module Puppet::Network::HTTP
     end
 
     def request(method, *args)
-      ssl_validator = Puppet::SSL::Validator.new(:ssl_configuration => ssl_configuration)
-      # Perform our own validation of the SSL connection in addition to OpenSSL
-      ssl_validator.register_verify_callback(connection)
-      response = connection.send(method, *args)
-      # Check the peer certs and warn if they're nearing expiration.
-      warn_if_near_expiration(*ssl_validator.peer_certs)
-
-      response
-    rescue OpenSSL::SSL::SSLError => error
-      if error.message.include? "certificate verify failed"
-        msg = error.message
-        msg << ": [" + ssl_validator.verify_errors.join('; ') + "]"
-        raise Puppet::Error, msg
-      elsif error.message =~ /hostname (\w+ )?not match/
-        leaf_ssl_cert = ssl_validator.peer_certs.last
-
-        valid_certnames = [leaf_ssl_cert.name, *leaf_ssl_cert.subject_alt_names].uniq
-        msg = valid_certnames.length > 1 ? "one of #{valid_certnames.join(', ')}" : valid_certnames.first
-
-        raise Puppet::Error, "Server hostname '#{connection.address}' did not match server certificate; expected #{msg}"
-      else
-        raise
+      current_args = args.dup
+      @redirect_limit.times do |redirection|
+        response = execute_request(method, *args)
+        return response unless [301, 302, 307].include?(response.code.to_i)
+
+        # handle the redirection
+        location = URI.parse(response['location'])
+        @connection = initialize_connection(location.host, location.port, location.scheme == 'https')
+
+        # update to the current request path
+        current_args = [location.path] + current_args.drop(1)
+        # and try again...
       end
+      raise RedirectionLimitExceededException, "Too many HTTP redirections for #{@host}:#{@port}"
     end
 
-
     # TODO: These are proxies for the Net::HTTP#request_* methods, which are
     # almost the same as the "get", "post", etc. methods that we've ported above,
     # but they are able to accept a code block and will yield to it.  For now
@@ -91,7 +109,6 @@ module Puppet::Network::HTTP
     end
     # end of Net::HTTP#request_* proxies
 
-
     def address
       connection.address
     end
@@ -104,15 +121,42 @@ module Puppet::Network::HTTP
       connection.use_ssl?
     end
 
-
     private
 
     def connection
-      @connection || initialize_connection
+      @connection || initialize_connection(@host, @port, @use_ssl)
+    end
+
+    def execute_request(method, *args)
+      ssl_validator = Puppet::SSL::Validator.new(:ssl_configuration => ssl_configuration)
+      # Perform our own validation of the SSL connection in addition to OpenSSL
+      ssl_validator.register_verify_callback(connection)
+
+      response = connection.send(method, *args)
+
+      # Check the peer certs and warn if they're nearing expiration.
+      warn_if_near_expiration(*ssl_validator.peer_certs)
+
+      response
+    rescue OpenSSL::SSL::SSLError => error
+      if error.message.include? "certificate verify failed"
+        msg = error.message
+        msg << ": [" + ssl_validator.verify_errors.join('; ') + "]"
+        raise Puppet::Error, msg
+      elsif error.message =~ /hostname (\w+ )?not match/
+        leaf_ssl_cert = ssl_validator.peer_certs.last
+
+        valid_certnames = [leaf_ssl_cert.name, *leaf_ssl_cert.subject_alt_names].uniq
+        msg = valid_certnames.length > 1 ? "one of #{valid_certnames.join(', ')}" : valid_certnames.first
+
+        raise Puppet::Error, "Server hostname '#{connection.address}' did not match server certificate; expected #{msg}"
+      else
+        raise
+      end
     end
 
-    def initialize_connection
-      args = [@host, @port]
+    def initialize_connection(host, port, use_ssl)
+      args = [host, port]
       if Puppet[:http_proxy_host] == "none"
         args << nil << nil
       else
@@ -125,7 +169,7 @@ module Puppet::Network::HTTP
       # give us a reader for ca_file... Grr...
       class << @connection; attr_accessor :ca_file; end
 
-      @connection.use_ssl = @use_ssl
+      @connection.use_ssl = use_ssl
       # Use configured timeout (#1176)
       @connection.read_timeout = Puppet[:configtimeout]
       @connection.open_timeout = Puppet[:configtimeout]
@@ -137,7 +181,7 @@ module Puppet::Network::HTTP
 
     # Use cert information from a Puppet client to set up the http object.
     def cert_setup
-      if FileTest.exist?(Puppet[:hostcert]) and FileTest.exist?(ssl_configuration.ca_auth_file)
+      if @verify_peer and FileTest.exist?(Puppet[:hostcert]) and FileTest.exist?(ssl_configuration.ca_auth_file)
         @connection.cert_store  = ssl_host.ssl_store
         @connection.ca_file     = ssl_configuration.ca_auth_file
         @connection.cert        = ssl_host.certificate.content