puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

data/lib/puppet/util/checksums.rb

@@ -1,5 +1,6 @@
 require 'digest/md5'
 require 'digest/sha1'
+require 'time'
 
 # A stand-alone module for calculating checksums
 # in a generic way.
@@ -41,8 +42,8 @@ module Puppet::Util::Checksums
     Digest::SHA256.hexdigest(content)
   end
 
-  def sha256lite(content)
-    sha256(content[0..511])
+  def sha256?(string)
+    string =~ /^\h{64}$/
   end
 
   def sha256_file(filename, lite = false)
@@ -52,10 +53,6 @@ module Puppet::Util::Checksums
     checksum_file(digest, filename,  lite)
   end
 
-  def sha256lite_file(filename)
-    sha256_file(filename, true)
-  end
-
   def sha256_stream(lite = false, &block)
     require 'digest/sha2'
     digest = Digest::SHA256.new
@@ -66,6 +63,18 @@ module Puppet::Util::Checksums
     64
   end
 
+  def sha256lite(content)
+    sha256(content[0..511])
+  end
+
+  def sha256lite?(string)
+    sha256?(string)
+  end
+
+  def sha256lite_file(filename)
+    sha256_file(filename, true)
+  end
+
   def sha256lite_stream(&block)
     sha256_stream(true, &block)
   end
@@ -79,9 +88,8 @@ module Puppet::Util::Checksums
     Digest::MD5.hexdigest(content)
   end
 
-  # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
-  def md5lite(content)
-    md5(content[0..511])
+  def md5?(string)
+    string =~ /^\h{32}$/
   end
 
   # Calculate a checksum of a file's content using Digest::MD5.
@@ -90,11 +98,6 @@ module Puppet::Util::Checksums
     checksum_file(digest, filename,  lite)
   end
 
-  # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
-  def md5lite_file(filename)
-    md5_file(filename, true)
-  end
-
   def md5_stream(lite = false, &block)
     digest = Digest::MD5.new
     checksum_stream(digest, block, lite)
@@ -104,6 +107,20 @@ module Puppet::Util::Checksums
     32
   end
 
+  # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
+  def md5lite(content)
+    md5(content[0..511])
+  end
+
+  def md5lite?(string)
+    md5?(string)
+  end
+
+  # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
+  def md5lite_file(filename)
+    md5_file(filename, true)
+  end
+
   def md5lite_stream(&block)
     md5_stream(true, &block)
   end
@@ -112,6 +129,17 @@ module Puppet::Util::Checksums
     md5_hex_length
   end
 
+  def mtime(content)
+    ""
+  end
+
+  def mtime?(string)
+    return true if string.is_a? Time
+    !!DateTime.parse(string)
+  rescue
+    false
+  end
+
   # Return the :mtime timestamp of a file.
   def mtime_file(filename)
     Puppet::FileSystem.stat(filename).send(:mtime)
@@ -125,18 +153,13 @@ module Puppet::Util::Checksums
     nil
   end
 
-  def mtime(content)
-    ""
-  end
-
   # Calculate a checksum using Digest::SHA1.
   def sha1(content)
     Digest::SHA1.hexdigest(content)
   end
 
-  # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
-  def sha1lite(content)
-    sha1(content[0..511])
+  def sha1?(string)
+    string =~ /^\h{40}$/
   end
 
   # Calculate a checksum of a file's content using Digest::SHA1.
@@ -145,11 +168,6 @@ module Puppet::Util::Checksums
     checksum_file(digest, filename, lite)
   end
 
-  # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
-  def sha1lite_file(filename)
-    sha1_file(filename, true)
-  end
-
   def sha1_stream(lite = false, &block)
     digest = Digest::SHA1.new
     checksum_stream(digest, block, lite)
@@ -159,6 +177,20 @@ module Puppet::Util::Checksums
     40
   end
 
+  # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
+  def sha1lite(content)
+    sha1(content[0..511])
+  end
+
+  def sha1lite?(string)
+    sha1?(string)
+  end
+
+  # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
+  def sha1lite_file(filename)
+    sha1_file(filename, true)
+  end
+
   def sha1lite_stream(&block)
     sha1_stream(true, &block)
   end
@@ -167,6 +199,17 @@ module Puppet::Util::Checksums
     sha1_hex_length
   end
 
+  def ctime(content)
+    ""
+  end
+
+  def ctime?(string)
+    return true if string.is_a? Time
+    !!DateTime.parse(string)
+  rescue
+    false
+  end
+
   # Return the :ctime of a file.
   def ctime_file(filename)
     Puppet::FileSystem.stat(filename).send(:ctime)
@@ -176,10 +219,14 @@ module Puppet::Util::Checksums
     mtime_stream(&block)
   end
 
-  def ctime(content)
+  def none(content)
     ""
   end
 
+  def none?(string)
+    string.empty?
+  end
+
   # Return a "no checksum"
   def none_file(filename)
     ""
@@ -191,10 +238,6 @@ module Puppet::Util::Checksums
     ""
   end
 
-  def none(content)
-    ""
-  end
-
   class DigestLite
     def initialize(digest, lite = false)
       @digest = digest

data/lib/puppet/util/execution.rb

@@ -317,7 +317,7 @@ module Puppet::Util::Execution
     end.join(" ") if command.is_a?(Array)
 
     options[:custom_environment] ||= {}
-    Puppet::Util.withenv(options[:custom_environment]) do
+    Puppet::Util.withenv(options[:custom_environment], :windows) do
       Puppet::Util::Windows::Process.execute(command, options, stdin, stdout, stderr)
     end
   end

data/lib/puppet/util/http_proxy.rb

@@ -1,3 +1,6 @@
+require 'uri'
+require 'openssl'
+
 module Puppet::Util::HttpProxy
   def self.proxy(uri)
     if self.no_proxy?(uri)
@@ -122,4 +125,73 @@ module Puppet::Util::HttpProxy
 
     return Puppet.settings[:http_proxy_password]
   end
+
+  # Return a Net::HTTP::Proxy object.
+  #
+  # This method optionally configures SSL correctly if the URI scheme is
+  # 'https', including setting up the root certificate store so remote server
+  # SSL certificates can be validated.
+  #
+  # @param [URI] uri The URI that is to be accessed.
+  # @return [Net::HTTP::Proxy] object constructed tailored for the passed URI
+  def self.get_http_object(uri)
+    proxy = proxy(uri)
+
+    if uri.scheme == 'https'
+      cert_store = OpenSSL::X509::Store.new
+      cert_store.set_default_paths
+
+      proxy.use_ssl = true
+      proxy.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      proxy.cert_store = cert_store
+    end
+
+    if Puppet[:http_debug]
+      proxy.set_debug_output($stderr)
+    end
+
+    proxy.open_timeout = Puppet[:http_connect_timeout]
+    proxy.read_timeout = Puppet[:http_read_timeout]
+
+    proxy
+  end
+
+  # Retrieve a document through HTTP(s), following redirects if necessary.
+  # 
+  # Based on the the client implementation in the HTTP pool.
+  #
+  # @see Puppet::Network::HTTP::Connection#request_with_redirects
+  #
+  # @param [URI] uri The address of the resource to retrieve.
+  # @param [symbol] method The name of the Net::HTTP method to use, typically :get, :head, :post etc.
+  # @param [FixNum] redirect_limit The number of redirections that can be followed.
+  # @return [Net::HTTPResponse] a response object
+  def self.request_with_redirects(uri, method, redirect_limit = 10, &block)
+    current_uri = uri
+    response = nil
+
+    0.upto(redirect_limit) do |redirection|
+      proxy = get_http_object(current_uri)
+      response = proxy.send(:head, current_uri.path)
+
+      if [301, 302, 307].include?(response.code.to_i)
+        # handle the redirection
+        current_uri = URI.parse(response['location'])
+        next
+      end
+
+      if block_given?
+        headers = {'Accept' => 'binary', 'accept-encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'}
+        response = proxy.send("request_#{method}".to_sym, current_uri.path, headers, &block)
+      else
+        response = proxy.send(method, current_uri.path)
+      end
+
+      Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
+
+      return response
+    end
+
+    raise RedirectionLimitExceededException, "Too many HTTP redirections for #{uri}"
+  end
 end

data/lib/puppet/util/log.rb

@@ -1,5 +1,6 @@
 require 'puppet/util/tagging'
 require 'puppet/util/classgen'
+require 'puppet/util/psych_support'
 require 'puppet/network/format_support'
 require 'facter'
 
@@ -9,6 +10,7 @@ require 'facter'
 class Puppet::Util::Log
   include Puppet::Util
   extend Puppet::Util::ClassGen
+  include Puppet::Util::PsychSupport
   include Puppet::Util::Tagging
   include Puppet::Network::FormatSupport
 

data/lib/puppet/util/logging.rb

@@ -1,9 +1,12 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 require 'puppet/error'
+require 'puppet/util/multi_match.rb'
+
 require 'facter'
 
-module Puppet::Util::Logging
+module Puppet::Util
+module Logging
 
   def send_log(level, message)
     Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
@@ -148,6 +151,43 @@ module Puppet::Util::Logging
     key ||= "#{file}:#{line}"
     issue_deprecation_warning(message, key, file, line, false)
   end
+  MM = MultiMatch
+  FILE_AND_LINE = MM::TUPLE
+  FILE_NO_LINE  = MM.new(MM::NOT_NIL, nil).freeze
+  NO_FILE_LINE  = MM.new(nil, MM::NOT_NIL).freeze
+
+  # Logs a (non deprecation) warning once for a given key.
+  #
+  # @param kind [String] The kind of warning. The
+  #   kind must be one of the defined kinds for the Puppet[:disable_warnings] setting.
+  # @param message [String] The message to log (logs via warning)
+  # @param key [String] Key used to make this warning unique
+  # @param file [String,nil] the File related to the warning
+  # @param line [Integer,nil] the Line number related to the warning
+  #   warning as unique
+  #
+  # Either :file and :line and/or :key must be passed.
+  def warn_once(kind, key, message, file = nil, line = nil)
+    return if Puppet[:disable_warnings].include?(kind)
+    $unique_warnings ||= {}
+    if $unique_warnings.length < 100 then
+      if (! $unique_warnings.has_key?(key)) then
+        $unique_warnings[key] = message
+        call_trace =
+        case MM.new(file, line)
+        when FILE_AND_LINE
+          "\n   (at #{file}:#{line})"
+        when FILE_NO_LINE
+          "\n   (in #{file})"
+        when NO_FILE_LINE
+          "\n   (in unknown file, line #{line})"
+        else
+          "\n   (file & line not available)"
+        end
+        warning("#{message}#{call_trace}")
+      end
+    end
+  end
 
   def get_deprecation_offender()
     # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
@@ -163,6 +203,7 @@ module Puppet::Util::Logging
   end
 
   def clear_deprecation_warnings
+    $unique_warnings.clear if $unique_warnings
     $deprecation_warnings.clear if $deprecation_warnings
   end
 
@@ -266,3 +307,4 @@ module Puppet::Util::Logging
     to_s
   end
 end
+end

data/lib/puppet/util/monkey_patches.rb

@@ -21,7 +21,7 @@ end
 class Symbol
   def <=> (other)
     self.to_s <=> other.to_s
-  end unless method_defined? '<=>'
+  end
 
   def intern
     self
@@ -117,7 +117,7 @@ if Puppet::Util::Platform.windows?
     alias __original_set_default_paths set_default_paths
     def set_default_paths
       # This can be removed once openssl integrates with windows
-      # cert store, see http://rt.openssl.org/Ticket/Display.html?id=2158
+      # cert store, see https://rt.openssl.org/Ticket/Display.html?id=2158
       Puppet::Util::Windows::RootCerts.instance.to_a.uniq.each do |x509|
         begin
           add_cert(x509)

data/lib/puppet/util/multi_match.rb

@@ -0,0 +1,51 @@
+# MultiMatch allows multiple values to be tested at once in a case expression.
+# This class is needed since Array does not implement the === operator to mean
+# "each v === other.each v". 
+#
+# This class is useful in situations when the Puppet Type System cannot be used
+# (e.g. in Logging, since it needs to be able to log very early i the intialization
+# cycle of puppet)
+#
+# Typically used with the constants
+# NOT_NIL
+# TUPLE
+# TRIPLE
+# 
+# which test against single NOT_NIL value, Array with two NOT_NIL, and Array with three NOT_NIL
+#
+module Puppet::Util
+class MultiMatch
+  attr_reader :values
+
+  def initialize(*values)
+    @values = values
+  end
+
+  def ===(other)
+    lv = @values  # local var is faster than instance var
+    case other
+    when MultiMatch
+      return false unless other.values.size == values.size
+      other.values.each_with_index {|v, i| return false unless lv[i] === v || v === lv[i]}
+    when Array
+      return false unless other.size == values.size
+      other.each_with_index {|v, i| return false unless lv[i] === v || v === lv[i]}
+    else
+      false
+    end
+    true
+  end
+
+  # Matches any value that is not nil using the === operator.
+  #
+  class MatchNotNil
+    def ===(v)
+      !v.nil?
+    end
+  end
+
+  NOT_NIL = MatchNotNil.new().freeze
+  TUPLE = MultiMatch.new(NOT_NIL, NOT_NIL).freeze
+  TRIPLE = MultiMatch.new(NOT_NIL, NOT_NIL, NOT_NIL).freeze
+end
+end