puppet 4.1.0 → 5.0.0

data/lib/puppet/util/at_fork/solaris.rb

@@ -0,0 +1,158 @@
+require 'puppet'
+require 'fiddle'
+
+# Early versions of Fiddle relied on the deprecated DL module and used
+# classes defined in the namespace of that module instead of classes defined
+# in the Fiddle's own namespace e.g. DL::Handle instead of Fiddle::Handle.
+# We don't support those.
+raise LoadError, _('The loaded Fiddle version is not supported.') unless defined?(Fiddle::Handle)
+
+# Solaris implementation of the Puppet::Util::AtFork handler.
+# The callbacks defined in this implementation ensure the forked process runs
+# in a different contract than the parent process. This is necessary in order
+# for the child process to be able to survive termination of the contract its
+# parent process runs in. This is needed notably for an agent run executed
+# by a puppet agent service to be able to restart that service without being
+# killed in the process as a consequence of running in the same contract as
+# the service, as all processes in the contract are killed when the contract
+# is terminated during the service restart.
+class Puppet::Util::AtFork::Solaris
+  private
+
+  {
+    'libcontract.so.1' => [
+      #function name,            return value type, parameter types, ...
+      [:ct_ctl_abandon,          Fiddle::TYPE_INT,  Fiddle::TYPE_INT],
+      [:ct_tmpl_activate,        Fiddle::TYPE_INT,  Fiddle::TYPE_INT],
+      [:ct_tmpl_clear,           Fiddle::TYPE_INT,  Fiddle::TYPE_INT],
+
+      [:ct_tmpl_set_informative, Fiddle::TYPE_INT,  Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+      [:ct_tmpl_set_critical,    Fiddle::TYPE_INT,  Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+      [:ct_pr_tmpl_set_param,    Fiddle::TYPE_INT,  Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+      [:ct_pr_tmpl_set_fatal,    Fiddle::TYPE_INT,  Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+
+      [:ct_status_read,          Fiddle::TYPE_INT,  Fiddle::TYPE_INT, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+
+      [:ct_status_get_id,        Fiddle::TYPE_INT,  Fiddle::TYPE_VOIDP],
+      [:ct_status_free,          Fiddle::TYPE_VOID, Fiddle::TYPE_VOIDP],
+    ],
+  }.each do |library, functions|
+    libhandle = Fiddle::Handle.new(library)
+
+    functions.each do |f|
+      define_method f[0], Fiddle::Function.new(libhandle[f[0].to_s], f[2..-1], f[1]).method(:call).to_proc
+    end
+  end
+
+  CTFS_PR_ROOT = File.join('', %w(system contract process))
+  CTFS_PR_TEMPLATE = File.join(CTFS_PR_ROOT, %q(template))
+  CTFS_PR_LATEST = File.join(CTFS_PR_ROOT, %q(latest))
+
+  CT_PR_PGRPONLY = 0x4
+  CT_PR_EV_HWERR = 0x20
+
+  CTD_COMMON = 0
+
+  def raise_if_error(&block)
+    unless (e = yield) == 0
+      e = SystemCallError.new(nil, e)
+      raise e, e.message, caller
+    end
+  end
+
+  def activate_new_contract_template
+    begin
+      tmpl = File.open(CTFS_PR_TEMPLATE, File::RDWR)
+
+      begin
+        tmpl_fd = tmpl.fileno
+
+        raise_if_error { ct_pr_tmpl_set_param(tmpl_fd, CT_PR_PGRPONLY) }
+        raise_if_error { ct_pr_tmpl_set_fatal(tmpl_fd, CT_PR_EV_HWERR) }
+        raise_if_error { ct_tmpl_set_critical(tmpl_fd, 0) }
+        raise_if_error { ct_tmpl_set_informative(tmpl_fd, CT_PR_EV_HWERR) }
+
+        raise_if_error { ct_tmpl_activate(tmpl_fd) }
+      rescue
+        tmpl.close
+        raise
+      end
+
+      @tmpl = tmpl
+    rescue => detail
+      Puppet.log_exception(detail, _('Failed to activate a new process contract template'))
+    end
+  end
+
+  def deactivate_contract_template(parent)
+    return if @tmpl.nil?
+
+    tmpl = @tmpl
+    @tmpl = nil
+
+    begin
+      raise_if_error { ct_tmpl_clear(tmpl.fileno) }
+    rescue => detail
+      Puppet.log_exception(detail, parent \
+        ? _('Failed to deactivate process contract template in the parent process')
+        : _('Failed to deactivate process contract template in the child process')
+      )
+      exit(1)
+    ensure
+      tmpl.close
+    end
+  end
+
+  def get_latest_child_contract_id
+    begin
+      stat = File.open(CTFS_PR_LATEST, File::RDONLY)
+
+      begin
+        stathdl = Fiddle::Pointer.new(0)
+
+        raise_if_error { ct_status_read(stat.fileno, CTD_COMMON, stathdl.ref) }
+        ctid = ct_status_get_id(stathdl)
+        ct_status_free(stathdl)
+      ensure
+        stat.close
+      end
+
+      ctid
+    rescue => detail
+      Puppet.log_exception(detail, _('Failed to get latest child process contract id'))
+      nil
+    end
+  end
+
+  def abandon_latest_child_contract
+    ctid = get_latest_child_contract_id
+    return if ctid.nil?
+
+    begin
+      ctl = File.open(File.join(CTFS_PR_ROOT, ctid.to_s, %q(ctl)), File::WRONLY)
+
+      begin
+        raise_if_error { ct_ctl_abandon(ctl.fileno) }
+      ensure
+        ctl.close
+      end
+    rescue => detail
+      Puppet.log_exception(detail, _('Failed to abandon a child process contract'))
+    end
+  end
+
+  public
+
+  def prepare
+    activate_new_contract_template
+  end
+
+  def parent
+    deactivate_contract_template(true)
+    abandon_latest_child_contract
+  end
+
+  def child
+    deactivate_contract_template(false)
+  end
+end

data/lib/puppet/util/at_fork.rb

@@ -0,0 +1,35 @@
+require 'puppet'
+
+# A module for building AtFork handlers. These handlers are objects providing
+# pre/post fork callbacks modeled after those registered by the `pthread_atfork`
+# function.
+# Currently there are two AtFork handler implementations:
+# - a noop implementation used on all platforms except Solaris (and possibly
+#   even there as a fallback)
+# - a Solaris implementation which ensures the forked process runs in a different
+#   contract than the parent process. This is necessary for agent runs started by
+#   the puppet agent service to be able to restart that service without being
+#   killed in the process as a consequence of running in the same contract as the
+#   service.
+module Puppet::Util::AtFork
+  @handler_class = loop do
+    if Facter.value(:operatingsystem) == 'Solaris'
+      begin
+        require 'puppet/util/at_fork/solaris'
+        # using break to return a value from the loop block
+        break Puppet::Util::AtFork::Solaris
+      rescue LoadError => detail
+        Puppet.log_exception(detail, _('Failed to load Solaris implementation of the Puppet::Util::AtFork handler. Child process contract management will be unavailable, which means that agent runs executed by the puppet agent service will be killed when they attempt to restart the service.'))
+        # fall through to use the no-op implementation
+      end
+    end
+
+    require 'puppet/util/at_fork/noop'
+    # using break to return a value from the loop block
+    break Puppet::Util::AtFork::Noop
+  end
+
+  def self.get_handler
+    @handler_class.new
+  end
+end

data/lib/puppet/util/autoload.rb

@@ -2,6 +2,15 @@ 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
+# adapter ensures that the life-cycle of this cache doesn't exceed  the life-cycle of the environment.
+#
+# @api private
+class Puppet::Util::ModuleDirectoriesAdapter < Puppet::Pops::Adaptable::Adapter
+  attr_accessor :directories
+end
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
@@ -61,7 +70,7 @@ class Puppet::Util::Autoload
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
-        message = "Could not autoload #{name}: #{detail}"
+        message = _("Could not autoload %{name}: %{detail}") % { name: name, detail: detail }
         Puppet.log_exception(detail, message)
         raise Puppet::Error, message, detail.backtrace
       end
@@ -99,12 +108,6 @@ class Puppet::Util::Autoload
     end
 
     def module_directories(env)
-      # We're using a per-thread cache of module directories so that we don't
-      # scan the filesystem each time we try to load something. This is reset
-      # at the beginning of compilation and at the end of an agent run.
-      $env_module_directories ||= {}
-
-
       # 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
@@ -129,11 +132,13 @@ class Puppet::Util::Autoload
 
         if env
           # if the app defaults have been initialized then it should be safe to access the module path setting.
-          $env_module_directories[env] ||= 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
+          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
           []
         end
@@ -179,7 +184,7 @@ class Puppet::Util::Autoload
 
   def initialize(obj, path, options = {})
     @path = path.to_s
-    raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
+    raise ArgumentError, _("Autoload paths cannot be fully qualified") if Puppet::Util.absolute_path?(@path)
     @object = obj
 
     set_options(options)

data/lib/puppet/util/backups.rb

@@ -23,7 +23,7 @@ module Puppet::Util::Backups
     when "directory"
       # we don't need to backup directories when recurse is on
       return true if self[:recurse]
-      info "Recursively backing up to filebucket"
+      info _("Recursively backing up to filebucket")
       Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
     when "file"; backup_file_with_filebucket(file)
     when "link";
@@ -46,7 +46,7 @@ module Puppet::Util::Backups
     rescue => detail
       # since they said they want a backup, let's error out
       # if we couldn't make one
-      self.fail Puppet::Error, "Could not back #{file} up: #{detail.message}", detail
+      self.fail Puppet::Error, _("Could not back %{file} up: %{message}") % { file: file, message: detail.message }, detail
     end
   end
 
@@ -64,15 +64,15 @@ module Puppet::Util::Backups
     end
 
     if stat.ftype == "directory"
-      raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
+      raise Puppet::Error, _("Will not remove directory backup %{newfile}; use a filebucket") % { newfile: newfile }
     end
 
-    info "Removing old backup of type #{stat.ftype}"
+    info _("Removing old backup of type %{file_type}") % { file_type: stat.ftype }
 
     begin
       Puppet::FileSystem.unlink(newfile)
     rescue => detail
-      message = "Could not remove old backup: #{detail}"
+      message = _("Could not remove old backup: %{detail}") % { detail: detail }
       self.log_exception(detail, message)
       self.fail Puppet::Error, message, detail
     end
@@ -80,7 +80,7 @@ module Puppet::Util::Backups
 
   def backup_file_with_filebucket(f)
     sum = self.bucket.backup(f)
-    self.info "Filebucketed #{f} to #{self.bucket.name} with sum #{sum}"
+    self.info _("Filebucketed %{f} to %{filebucket} with sum %{sum}") % { f: f, filebucket: self.bucket.name, sum: sum }
     return sum
     end
 end

data/lib/puppet/util/character_encoding.rb

@@ -0,0 +1,98 @@
+# A module to centralize heuristics/practices for managing character encoding in Puppet
+
+module Puppet::Util::CharacterEncoding
+  class << self
+    # Given a string, attempts to convert a copy of the string to UTF-8. Conversion uses
+    # encode - the string's internal byte representation is modifed to UTF-8.
+    #
+    # This method is intended for situations where we generally trust that the
+    # string's bytes are a faithful representation of the current encoding
+    # associated with it, and can use it as a starting point for transcoding
+    # (conversion) to UTF-8.
+    #
+    # @api public
+    # @param [String] string a string to transcode
+    # @return [String] copy of the original string, in UTF-8 if transcodable
+    def convert_to_utf_8(string)
+      original_encoding = string.encoding
+      string_copy = string.dup
+      begin
+        if original_encoding == Encoding::UTF_8
+          if !string_copy.valid_encoding?
+            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
+          return string_copy
+        else
+          # If the string comes to us as BINARY encoded, we don't know what it
+          # started as. However, to encode! we need a starting place, and our
+          # best guess is whatever the system currently is (default_external).
+          # So set external_encoding to default_external before we try to
+          # transcode to UTF-8.
+          string_copy.force_encoding(Encoding.default_external) if original_encoding == Encoding::BINARY
+          return string_copy.encode(Encoding::UTF_8)
+        end
+      rescue EncodingError => detail
+        # Set the encoding on our copy back to its original if we modified it
+        string_copy.force_encoding(original_encoding) if original_encoding == Encoding::BINARY
+
+        # Catch both our own self-determined failure to transcode as well as any
+        # error on ruby's part, ie Encoding::UndefinedConversionError on a
+        # failure to encode!.
+        Puppet.debug(_("%{error}: %{value} cannot be transcoded by Puppet.") %
+          { error: detail.inspect, value: string.dump })
+        return string_copy
+      end
+    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
+    # not modify the byte representation of the string. If the string does not
+    # represent valid UTF-8, does not set the external encoding.
+    #
+    # This method is intended for situations where we do not believe that the
+    # encoding associated with a string is an accurate reflection of its actual
+    # bytes, i.e., effectively when we believe Ruby is incorrect in its
+    # assertion of the encoding of the string.
+    #
+    # @api public
+    # @param [String] string to set external encoding (re-label) to utf-8
+    # @return [String] a copy of string with external encoding set to utf-8, or
+    # a copy of the original string if override would result in invalid encoding.
+    def override_encoding_to_utf_8(string)
+      string_copy = string.dup
+      original_encoding = string_copy.encoding
+      return string_copy if original_encoding == Encoding::UTF_8
+      if string_copy.force_encoding(Encoding::UTF_8).valid_encoding?
+        return string_copy
+      else
+        Puppet.debug(_("%{value} is not valid UTF-8 and result of overriding encoding would be invalid.") % { value: string.dump })
+        # Set copy back to its original encoding before returning
+        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

@@ -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/classgen.rb

@@ -153,15 +153,15 @@ module Puppet::Util::ClassGen
   # @api private
   #
   def handleclassconst(klass, name, options)
-    const = genconst_string(name, options)
+   const = genconst_string(name, options)
 
     if is_constant_defined?(const)
       if options[:overwrite]
-        Puppet.info "Redefining #{name} in #{self}"
+        Puppet.info _("Redefining %{name} in %{klass}") % { name: name, klass: self }
         remove_const(const)
       else
         raise Puppet::ConstantAlreadyDefined,
-          "Class #{const} is already defined in #{self}"
+          _("Class %{const} is already defined in %{klass}") % { const: const, klass: self }
       end
     end
     const_set(const, klass)
@@ -206,7 +206,7 @@ module Puppet::Util::ClassGen
     if hash = options[:hash]
       if hash.include? klassname and ! options[:overwrite]
         raise Puppet::SubclassAlreadyDefined,
-          "Already a generated class named #{klassname}"
+          _("Already a generated class named %{klassname}") % { klassname: klassname }
       end
 
       hash[klassname] = klass
@@ -218,7 +218,7 @@ module Puppet::Util::ClassGen
               array.find { |c| c.name == klassname } and
               ! options[:overwrite])
         raise Puppet::SubclassAlreadyDefined,
-          "Already a generated class named #{klassname}"
+          _("Already a generated class named %{klassname}") % { klassname: klassname }
       end
 
       array << klass

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

@@ -44,7 +44,7 @@ module Puppet
           elsif args.length == 4
             long, short, desc, type = args
           else
-            raise ArgumentError, "this method only takes 3 or 4 arguments. Given: #{args.inspect}"
+            raise ArgumentError, _("this method only takes 3 or 4 arguments. Given: %{args}") % { args: args.inspect }
           end
 
           options = {
@@ -61,7 +61,7 @@ module Puppet
             when :NONE
               options[:type] = :flag
             else
-              raise PuppetOptionError.new("Unsupported type: '#{type}'")
+              raise PuppetOptionError.new(_("Unsupported type: '%{type}'") % { type: type })
           end
 
           @parser.opt long.sub("^--", "").intern, desc, options
@@ -73,7 +73,7 @@ module Puppet
           begin
             @parser.parse args_copy
           rescue Puppet::Util::CommandLine::Trollop::CommandlineError => err
-            raise PuppetOptionError.new("Error parsing arguments", err)
+            raise PuppetOptionError.new(_("Error parsing arguments"), err)
           end
         end