puppet 5.0.0 → 6.0.0

data/lib/puppet/util/autoload.rb

@@ -1,7 +1,6 @@
 require 'pathname'
 require 'puppet/util/rubygems'
 require 'puppet/util/warnings'
-require 'puppet/util/methodhelper'
 require 'puppet/pops/adaptable'
 
 # An adapter that ties the module_directories cache to the environment where the modules are parsed. This
@@ -14,8 +13,6 @@ end
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
-  include Puppet::Util::MethodHelper
-
   @loaded = {}
 
   class << self
@@ -38,19 +35,20 @@ class Puppet::Util::Autoload
     # Save the fact that a given path has been loaded.  This is so
     # we can load downloaded plugins if they've already been loaded
     # into memory.
+    # @api private
     def mark_loaded(name, file)
       name = cleanpath(name).chomp('.rb')
-      ruby_file = name + ".rb"
-      $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
+      file = File.expand_path(file)
+      $LOADED_FEATURES << file unless $LOADED_FEATURES.include?(file)
       loaded[name] = [file, File.mtime(file)]
     end
 
-    def changed?(name)
+    # @api private
+    def changed?(name, env)
       name = cleanpath(name).chomp('.rb')
       return true unless loaded.include?(name)
       file, old_mtime = loaded[name]
-      environment = Puppet.lookup(:current_environment)
-      return true unless file == get_file(name, environment)
+      return true unless file == get_file(name, env)
       begin
         old_mtime.to_i != File.mtime(file).to_i
       rescue Errno::ENOENT
@@ -76,7 +74,7 @@ class Puppet::Util::Autoload
       end
     end
 
-    def loadall(path, env = nil)
+    def loadall(path, env)
       # Load every instance of everything we can find.
       files_to_load(path, env).each do |file|
         name = file.chomp(".rb")
@@ -84,22 +82,28 @@ class Puppet::Util::Autoload
       end
     end
 
-    def reload_changed
-      loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
+    def reload_changed(env)
+      loaded.keys.each do |file|
+        if changed?(file, env)
+          load_file(file, env)
+        end
+      end
     end
 
     # Get the correct file to load for a given path
     # returns nil if no file is found
+    # @api private
     def get_file(name, env)
       name = name + '.rb' unless name =~ /\.rb$/
       path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
       path and File.join(path, name)
     end
 
-    def files_to_load(path, env = nil)
+    def files_to_load(path, env)
       search_directories(env).map {|dir| files_in_dir(dir, path) }.flatten.uniq
     end
 
+    # @api private
     def files_in_dir(dir, path)
       dir = Pathname.new(File.expand_path(dir))
       Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
@@ -107,7 +111,39 @@ class Puppet::Util::Autoload
       end
     end
 
+    # @api private
     def module_directories(env)
+      raise ArgumentError, "Autoloader requires an environment" unless env
+
+      Puppet::Util::ModuleDirectoriesAdapter.adapt(env) do |a|
+        a.directories ||= env.modulepath.collect do |dir|
+          Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
+        end.flatten.find_all do |d|
+          FileTest.directory?(d)
+        end
+      end.directories
+    end
+
+    # @api private
+    def vendored_modules
+      dir = Puppet[:vendormoduledir]
+      if dir && File.directory?(dir)
+        Dir.entries(dir)
+          .reject { |f| f =~ /^\./ }
+          .collect { |f| File.join(dir, f, "lib") }
+          .find_all { |d| FileTest.directory?(d) }
+      else
+        []
+      end
+    end
+
+    # @api private
+    def gem_directories
+      gem_source.directories
+    end
+
+    # @api private
+    def search_directories(env)
       # This is a little bit of a hack.  Basically, the autoloader is being
       # called indirectly during application bootstrapping when we do things
       # such as check "features".  However, during bootstrapping, we haven't
@@ -128,44 +164,17 @@ class Puppet::Util::Autoload
       # "app_defaults_initialized?" method on the main puppet Settings object.
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
-        env ||= Puppet.lookup(:environments).get(Puppet[:environment])
-
-        if env
-          # if the app defaults have been initialized then it should be safe to access the module path setting.
-          Puppet::Util::ModuleDirectoriesAdapter.adapt(env) do |a|
-            a.directories ||= env.modulepath.collect do |dir|
-              Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
-            end.flatten.find_all do |d|
-              FileTest.directory?(d)
-            end
-          end.directories
-        else
-          []
+        unless @initialized
+          $LOAD_PATH.unshift(Puppet[:libdir])
+          $LOAD_PATH.concat(vendored_modules)
+          @initialized = true
         end
+        gem_directories + module_directories(env) + $LOAD_PATH
       else
-        # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
-        []
-      end
-    end
-
-    def libdirs()
-      # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
-      # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
-      if (Puppet.settings.app_defaults_initialized?)
-        [Puppet[:libdir]]
-      else
-        []
+        gem_directories + $LOAD_PATH
       end
     end
 
-    def gem_directories
-      gem_source.directories
-    end
-
-    def search_directories(env)
-      [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
-    end
-
     # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
     # and eliminates unnecessary parts of a path.
     def cleanpath(path)
@@ -182,15 +191,13 @@ class Puppet::Util::Autoload
 
   attr_accessor :object, :path
 
-  def initialize(obj, path, options = {})
+  def initialize(obj, path)
     @path = path.to_s
     raise ArgumentError, _("Autoload paths cannot be fully qualified") if Puppet::Util.absolute_path?(@path)
     @object = obj
-
-    set_options(options)
   end
 
-  def load(name, env = nil)
+  def load(name, env)
     self.class.load_file(expand(name), env)
   end
 
@@ -204,7 +211,7 @@ class Puppet::Util::Autoload
   #
   # This uses require, rather than load, so that already-loaded files don't get
   # reloaded unnecessarily.
-  def loadall(env = nil)
+  def loadall(env)
     self.class.loadall(@path, env)
   end
 
@@ -212,12 +219,13 @@ class Puppet::Util::Autoload
     self.class.loaded?(expand(name))
   end
 
-  def changed?(name)
-    self.class.changed?(expand(name))
+  # @api private
+  def changed?(name, env)
+    self.class.changed?(expand(name), env)
   end
 
-  def files_to_load
-    self.class.files_to_load(@path)
+  def files_to_load(env)
+    self.class.files_to_load(@path, env)
   end
 
   def expand(name)

data/lib/puppet/util/backups.rb

@@ -82,5 +82,5 @@ module Puppet::Util::Backups
     sum = self.bucket.backup(f)
     self.info _("Filebucketed %{f} to %{filebucket} with sum %{sum}") % { f: f, filebucket: self.bucket.name, sum: sum }
     return sum
-    end
+  end
 end

data/lib/puppet/util/character_encoding.rb

@@ -22,7 +22,7 @@ module Puppet::Util::CharacterEncoding
             Puppet.debug(_("%{value} is already labeled as UTF-8 but this encoding is invalid. It cannot be transcoded by Puppet.") %
               { value: string.dump })
           end
-          # String is aleady valid UTF-8 - noop
+          # String is already valid UTF-8 - noop
           return string_copy
         else
           # If the string comes to us as BINARY encoded, we don't know what it
@@ -47,7 +47,7 @@ module Puppet::Util::CharacterEncoding
     end
 
     # Given a string, tests if that string's bytes represent valid UTF-8, and if
-    # so return a copy of the string with external enocding set to UTF-8. Does
+    # so return a copy of the string with external encoding set to UTF-8. Does
     # not modify the byte representation of the string. If the string does not
     # represent valid UTF-8, does not set the external encoding.
     #
@@ -72,27 +72,5 @@ module Puppet::Util::CharacterEncoding
         return string_copy.force_encoding(original_encoding)
       end
     end
-
-    REPLACEMENT_CHAR_MAP = {
-      Encoding::UTF_8 => "\uFFFD",
-      Encoding::UTF_16LE => "\xFD\xFF".force_encoding(Encoding::UTF_16LE),
-    }
-
-    # Given a string, return a copy of that string with any invalid byte
-    # sequences in its current encoding replaced with the replacement character
-    # "\uFFFD" (UTF-8) if the string is UTF-8 or UTF-16LE, or "?" otherwise.
-    # @param string a string to remove invalid byte sequences from
-    # @return a copy of string invalid byte sequences replaced by the unicode
-    #   replacement character or "?" character
-    # @note does not modify encoding, but new string will have different bytes
-    #   from original. Only needed for ruby 1.9.3 support.
-    def scrub(string)
-      if string.respond_to?(:scrub)
-        string.scrub
-      else
-        replacement_character = REPLACEMENT_CHAR_MAP[string.encoding] || '?'
-        string.chars.map { |c| c.valid_encoding? ? c : replacement_character }.join
-      end
-    end
   end
 end

data/lib/puppet/util/checksums.rb

@@ -10,7 +10,7 @@ module Puppet::Util::Checksums
   # It's not a good idea to use some of these in some contexts: for example, I
   # wouldn't try bucketing a file using the :none checksum type.
   def known_checksum_types
-    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite,
+    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, 
       :mtime, :ctime, :none]
   end
 
@@ -83,6 +83,87 @@ module Puppet::Util::Checksums
     sha256_hex_length
   end
 
+  # Calculate a checksum using Digest::SHA384.
+  def sha384(content)
+    require 'digest/sha2'
+    Digest::SHA384.hexdigest(content)
+  end
+
+  def sha384?(string)
+    string =~ /^\h{96}$/
+  end
+
+  def sha384_file(filename, lite = false)
+    require 'digest/sha2'
+
+    digest = Digest::SHA384.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha384_stream(lite = false, &block)
+    require 'digest/sha2'
+    digest = Digest::SHA384.new
+    checksum_stream(digest, block, lite)
+  end
+
+  def sha384_hex_length
+    96
+  end
+
+  # Calculate a checksum using Digest::SHA512.
+  def sha512(content)
+    require 'digest/sha2'
+    Digest::SHA512.hexdigest(content)
+  end
+
+  def sha512?(string)
+    string =~ /^\h{128}$/
+  end
+
+  def sha512_file(filename, lite = false)
+    require 'digest/sha2'
+
+    digest = Digest::SHA512.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha512_stream(lite = false, &block)
+    require 'digest/sha2'
+    digest = Digest::SHA512.new
+    checksum_stream(digest, block, lite)
+  end
+
+  def sha512_hex_length
+    128
+  end
+
+  # Calculate a checksum using Digest::SHA224.
+  def sha224(content)
+    require 'openssl'
+    OpenSSL::Digest::SHA224.new.hexdigest(content)
+  end
+
+  def sha224?(string)
+    string =~ /^\h{56}$/
+  end
+
+  def sha224_file(filename, lite = false)
+    require 'openssl'
+
+    digest = OpenSSL::Digest::SHA224.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha224_stream(lite = false, &block)
+    require 'openssl'
+    digest = OpenSSL::Digest::SHA224.new
+    checksum_stream(digest, block, lite)
+  end
+
+  def sha224_hex_length
+    56
+  end
+
   # Calculate a checksum using Digest::MD5.
   def md5(content)
     Digest::MD5.hexdigest(content)
@@ -259,8 +340,6 @@ module Puppet::Util::Checksums
     end
   end
 
-  private_class_method
-
   # Perform an incremental checksum on a file.
   def checksum_file(digest, filename, lite = false)
     buffer = lite ? 512 : 4096

data/lib/puppet/util/classgen.rb

@@ -1,5 +1,3 @@
-require 'puppet/util/methodhelper'
-
 module Puppet
   class ConstantAlreadyDefined < Error; end
   class SubclassAlreadyDefined < Error; end
@@ -9,7 +7,6 @@ end
 # @api public
 #
 module Puppet::Util::ClassGen
-  include Puppet::Util::MethodHelper
   include Puppet::Util
 
   # Create a new class.
@@ -66,7 +63,6 @@ module Puppet::Util::ClassGen
   # @return [Boolean] whether the class was removed or not
   #
   def rmclass(name, options)
-    options = symbolize_options(options)
     const = genconst_string(name, options)
     retval = false
     if is_constant_defined?(const)
@@ -100,8 +96,6 @@ module Puppet::Util::ClassGen
   # slightly abstract version of genclass.
   # @api private
   def genthing(name, type, options, block)
-    options = symbolize_options(options)
-
     name = name.to_s.downcase.intern
 
     if type == Module

data/lib/puppet/util/command_line/trollop.rb

@@ -165,11 +165,11 @@ class Parser
         when 'IO'; :io
         when 'Date'; :date
         else
-          raise ArgumentError, "unsupported argument type '#{opts[:type].class.name}'"
+          raise ArgumentError, _("unsupported argument type '%{type}'") % { type: opts[:type].class.name }
         end
       when nil; nil
       else
-        raise ArgumentError, "unsupported argument type '#{opts[:type]}'" unless TYPES.include?(opts[:type])
+        raise ArgumentError, _("unsupported argument type '%{type}'") % { type: opts[:type] } unless TYPES.include?(opts[:type])
         opts[:type]
       end
 
@@ -223,7 +223,7 @@ class Parser
       when /^[^-]/
         opts[:long]
       else
-        raise ArgumentError, "invalid long option name #{opts[:long].inspect}"
+        raise ArgumentError, _("invalid long option name %{name}") % { name: opts[:long].inspect }
       end
     raise ArgumentError, _("long option name %{value0} is already taken; please specify a (different) :long") % { value0: opts[:long].inspect } if @long[opts[:long]]
 
@@ -232,7 +232,7 @@ class Parser
     opts[:short] = case opts[:short]
       when /^-(.)$/; $1
       when nil, :none, /^.$/; opts[:short]
-      else raise ArgumentError, "invalid short option name '#{opts[:short].inspect}'"
+      else raise ArgumentError, _("invalid short option name '%{name}'") % { name: opts[:short].inspect }
     end
 
     if opts[:short]
@@ -812,7 +812,8 @@ def die arg, msg=nil
   if @last_parser
     @last_parser.die arg, msg
   else
-    raise ArgumentError, "Trollop::die can only be called after Trollop::options"
+    #TRANSLATORS 'Trollop' is the name of a module and 'die' and 'options' are methods in it and should not be translated.
+    raise ArgumentError, _("Trollop::die can only be called after Trollop::options")
   end
 end
 

data/lib/puppet/util/command_line.rb

@@ -14,6 +14,7 @@ require 'puppet/util'
 require "puppet/util/rubygems"
 require "puppet/util/limits"
 require 'puppet/util/colors'
+require 'puppet/gettext/module_translations'
 
 module Puppet
   module Util
@@ -63,7 +64,7 @@ module Puppet
       #
       # @return [void]
       def execute
-        Puppet::Util.exit_on_fail(_("initialize global default settings")) do
+        Puppet::Util.exit_on_fail(_("Could not initialize global default settings")) do
           Puppet.initialize_settings(args)
         end
 
@@ -122,6 +123,9 @@ module Puppet
                 $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
               end
 
+              Puppet::ModuleTranslations.load_from_modulepath(configured_environment.modules)
+              Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+
               # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
               # pickup the new $LOAD_PATH.
               Facter.reset

data/lib/puppet/util/connection.rb

@@ -0,0 +1,74 @@
+require 'puppet'
+
+module Puppet::Util
+  module Connection
+    # The logic for server and port is kind of gross. In summary:
+    # IF an endpoint-specific setting is requested AND that setting has been set by the user
+    #    Use that setting.
+    #         The defaults for these settings are the "normal" server/masterport settings, so
+    #         when they are unset we instead want to "fall back" to the failover-selected
+    #         host/port pair.
+    # ELSE IF we have a failover-selected host/port
+    #    Use what the failover logic came up with
+    # ELSE IF the server_list setting is in use
+    #    Use the first entry - failover hasn't happened yet, but that
+    #    setting is still authoritative
+    # ELSE
+    #    Go for the legacy server/masterport settings, and hope for the best
+
+    # Determines which server to use based on the specified setting, taking into
+    # account HA fallback from server_list.
+    # @param [Symbol] setting The preferred server setting to use
+    # @return [String] the name of the server for use in the request
+    def self.determine_server(setting)
+      if setting && setting != :server && Puppet.settings.set_by_config?(setting)
+        Puppet[setting]
+      else
+        server = Puppet.lookup(:server) do
+          if primary_server = Puppet.settings[:server_list][0]
+            Puppet.debug "Dynamically-bound server lookup failed; using first entry"
+            primary_server[0]
+          else
+            setting ||= :server
+            Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
+            Puppet.settings[setting]
+          end
+        end
+        server
+      end
+    end
+
+    # Determines which port to use based on the specified setting, taking into
+    # account HA fallback from server_list.
+    # For port there's a little bit of an extra snag: setting a specific
+    # server setting and relying on the default port for that server is
+    # common, so we also want to check if the assocaited SERVER setting
+    # has been set by the user. If either of those are set we ignore the
+    # failover-selected port.
+    # @param [Symbol] port_setting The preferred port setting to use
+    # @param [Symbol] server_setting The server setting assoicated with this route.
+    # @return [String] the port to use for use in the request
+    def self.determine_port(port_setting, server_setting)
+      if (port_setting && port_setting != :masterport && Puppet.settings.set_by_config?(port_setting)) ||
+         (server_setting && server_setting != :server && Puppet.settings.set_by_config?(server_setting))
+        Puppet.settings[port_setting].to_i
+      else
+        port = Puppet.lookup(:serverport) do
+          if primary_server = Puppet.settings[:server_list][0]
+            Puppet.debug "Dynamically-bound port lookup failed; using first entry"
+
+            # Port might not be set, so we want to fallback in that
+            # case. We know we don't need to use `setting` here, since
+            # the default value of every port setting is `masterport`
+            (primary_server[1] || Puppet.settings[:masterport])
+          else
+            port_setting ||= :masterport
+            Puppet.debug "Dynamically-bound port lookup failed; falling back to #{port_setting} setting"
+            Puppet.settings[port_setting]
+          end
+        end
+        port.to_i
+      end
+    end
+  end
+end

data/lib/puppet/util/errors.rb

@@ -31,22 +31,73 @@ module Puppet::Util::Errors
     error
   end
 
-  # Return a human-readable string of this object's file and line attributes,
+  # Return a human-readable string of this object's file, line, and pos attributes,
   # if set.
   #
-  # @return [String] description of file and line
-  def error_context
-    if file and line
-      _(" at %{file}:%{line}") % { file: file, line: line }
+  # @param file [String] the file path for the error (nil or "", for not known)
+  # @param line [String] the line number for the error (nil or "", for not known)
+  # @param column [String] the column number for the error (nil or "",  for not known)
+  # @return [String] description of file, line, and column
+  #
+  def self.error_location(file, line=nil, column=nil)
+    file = nil if (file.is_a?(String) && file.empty?)
+    line = nil if (line.is_a?(String) && line.empty?)
+    column = nil if (column.is_a?(String) && column.empty?)
+    if file and line and column
+      _("(file: %{file}, line: %{line}, column: %{column})") % { file: file, line: line, column: column }
+    elsif file and line
+      _("(file: %{file}, line: %{line})") % { file: file, line: line }
+    elsif line and column
+      _("(line: %{line}, column: %{column})") % { line: line, column: column }
     elsif line
-      _(" at line %{line}") % { line: line }
+      _("(line: %{line})") % { line: line }
     elsif file
-      _(" in %{file}") % { file: file }
+      _("(file: %{file})") % { file: file }
+    else
+      ''
+    end
+  end
+
+  # Return a human-readable string of this object's file, line, and pos attributes,
+  # with a proceeding space in the output
+  # if set.
+  #
+  # @param file [String] the file path for the error (nil or "", for not known)
+  # @param line [String] the line number for the error (nil or "", for not known)
+  # @param column [String] the column number for the error (nil or "",  for not known)
+  # @return [String] description of file, line, and column
+  #
+  def self.error_location_with_space(file, line=nil, column=nil)
+    error_location_str = error_location(file, line, column)
+    if error_location_str.empty?
+      ''
     else
-      ""
+      ' ' + error_location_str
     end
   end
 
+  # Return a human-readable string of this object's file and line
+  # where unknown entries are listed as 'unknown'
+  #
+  # @param file [String] the file path for the error (nil or "", for not known)
+  # @param line [String] the line number for the error (nil or "", for not known)
+  # @return [String] description of file, and line
+  def self.error_location_with_unknowns(file, line)
+    file = nil if (file.is_a?(String) && file.empty?)
+    line = nil if (line.is_a?(String) && line.empty?)
+    file = _('unknown') unless file
+    line = _('unknown') unless line
+    error_location(file, line)
+  end
+
+  # Return a human-readable string of this object's file and line attributes,
+  # if set.
+  #
+  # @return [String] description of file and line with a leading space
+  def error_context
+    Puppet::Util::Errors.error_location_with_space(file, line)
+  end
+
   # Wrap a call in such a way that we always throw the right exception and keep
   # as much context as possible.
   #