openvox 7.37.1

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

@@ -0,0 +1,18 @@
+# A noop implementation of the Puppet::Util::AtFork handler
+class Puppet::Util::AtFork::Noop
+  class << self
+    def new
+      # no need to instantiate every time, return the class object itself
+      self
+    end
+
+    def prepare
+    end
+
+    def parent
+    end
+
+    def child
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+require_relative '../../../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
+      msg = if parent
+              _('Failed to deactivate process contract template in the parent process')
+            else
+              _('Failed to deactivate process contract template in the child process')
+            end
+      Puppet.log_exception(detail, msg)
+      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_relative '../../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 Puppet::Util::Platform.solaris?
+      begin
+        require_relative '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_relative '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

@@ -0,0 +1,215 @@
+require 'pathname'
+require_relative '../../puppet/util/rubygems'
+require_relative '../../puppet/util/warnings'
+require_relative '../../puppet/pops/adaptable'
+require_relative '../../puppet/concurrent/synchronized'
+
+# 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
+
+  def self.create_adapter(env)
+    adapter = super(env)
+    adapter.directories = env.modulepath.flat_map do |dir|
+      Dir.glob(File.join(dir, '*', 'lib'))
+    end
+    adapter
+  end
+end
+
+# Autoload paths, either based on names or all at once.
+class Puppet::Util::Autoload
+  include Puppet::Concurrent::Synchronized
+  extend Puppet::Concurrent::Synchronized
+
+  @loaded = {}
+
+  class << self
+    attr_accessor :loaded
+
+    def gem_source
+      @gem_source ||= Puppet::Util::RubyGems::Source.new
+    end
+
+    # Has a given path been loaded?  This is used for testing whether a
+    # changed file should be loaded or just ignored.  This is only
+    # used in network/client/master, when downloading plugins, to
+    # see if a given plugin is currently loaded and thus should be
+    # reloaded.
+    def loaded?(path)
+      path = cleanpath(path).chomp('.rb')
+      loaded.include?(path)
+    end
+
+    # 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')
+      file = File.expand_path(file)
+      $LOADED_FEATURES << file unless $LOADED_FEATURES.include?(file)
+      loaded[name] = [file, File.mtime(file)]
+    end
+
+    # @api private
+    def changed?(name, env)
+      name = cleanpath(name).chomp('.rb')
+      return true unless loaded.include?(name)
+      file, old_mtime = loaded[name]
+      return true unless file == get_file(name, env)
+      begin
+        old_mtime.to_i != File.mtime(file).to_i
+      rescue Errno::ENOENT
+        true
+      end
+    end
+
+    # Load a single plugin by name.  We use 'load' here so we can reload a
+    # given plugin.
+    def load_file(name, env)
+      file = get_file(name.to_s, env)
+      return false unless file
+      begin
+        mark_loaded(name, file)
+        Kernel.load file
+        return true
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        message = _("Could not autoload %{name}: %{detail}") % { name: name, detail: detail }
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message, detail.backtrace
+      end
+    end
+
+    def loadall(path, env)
+      # Load every instance of everything we can find.
+      files_to_load(path, env).each do |file|
+        name = file.chomp(".rb")
+        load_file(name, env) unless loaded?(name)
+      end
+    end
+
+    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)
+      search_directories(env).map {|dir| files_in_dir(dir, path) }.flatten.uniq
+    end
+
+    # @api private
+    def files_in_dir(dir, path)
+      dir = Pathname.new(Puppet::FileSystem.expand_path(dir))
+      Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
+        Pathname.new(file).relative_path_from(dir).to_s
+      end
+    end
+
+    # @api private
+    def module_directories(env)
+      raise ArgumentError, "Autoloader requires an environment" unless env
+
+      Puppet::Util::ModuleDirectoriesAdapter.adapt(env).directories
+    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
+      # yet parsed all of the command line parameters nor the config files,
+      # and thus we don't yet know with certainty what the module path is.
+      # This should be irrelevant during bootstrapping, because anything that
+      # we are attempting to load during bootstrapping should be something
+      # that we ship with puppet, and thus the module path is irrelevant.
+      #
+      # In the long term, I think the way that we want to handle this is to
+      # have the autoloader ignore the module path in all cases where it is
+      # not specifically requested (e.g., by a constructor param or
+      # something)... because there are very few cases where we should
+      # actually be loading code from the module path.  However, until that
+      # happens, we at least need a way to prevent the autoloader from
+      # attempting to access the module path before it is initialized.  For
+      # now we are accomplishing that by calling the
+      # "app_defaults_initialized?" method on the main puppet Settings object.
+      # --cprice 2012-03-16
+      if Puppet.settings.app_defaults_initialized?
+        gem_directories + module_directories(env) + $LOAD_PATH
+      else
+        gem_directories + $LOAD_PATH
+      end
+    end
+
+    # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
+    # and eliminates unnecessary parts of a path.
+    def cleanpath(path)
+      Pathname.new(path).cleanpath.to_s
+    end
+  end
+
+  attr_accessor :object, :path
+
+  def initialize(obj, path)
+    @path = path.to_s
+    raise ArgumentError, _("Autoload paths cannot be fully qualified") if Puppet::Util.absolute_path?(@path)
+    @object = obj
+  end
+
+  def load(name, env)
+    self.class.load_file(expand(name), env)
+  end
+
+  # Load all instances from a path of Autoload.search_directories matching the
+  # relative path this Autoloader was initialized with.  For example, if we
+  # have created a Puppet::Util::Autoload for Puppet::Type::User with a path of
+  # 'puppet/provider/user', the search_directories path will be searched for
+  # all ruby files matching puppet/provider/user/*.rb and they will then be
+  # loaded from the first directory in the search path providing them.  So
+  # earlier entries in the search path may shadow later entries.
+  #
+  # This uses require, rather than load, so that already-loaded files don't get
+  # reloaded unnecessarily.
+  def loadall(env)
+    self.class.loadall(@path, env)
+  end
+
+  def loaded?(name)
+    self.class.loaded?(expand(name))
+  end
+
+  # @api private
+  def changed?(name, env)
+    self.class.changed?(expand(name), env)
+  end
+
+  def files_to_load(env)
+    self.class.files_to_load(@path, env)
+  end
+
+  def expand(name)
+    ::File.join(@path, name.to_s)
+  end
+end

data/lib/puppet/util/backups.rb

@@ -0,0 +1,86 @@
+require 'find'
+require 'fileutils'
+module Puppet::Util::Backups
+
+  # Deal with backups.
+  def perform_backup(file = nil)
+    # if they specifically don't want a backup, then just say
+    # we're good
+    return true unless self[:backup]
+
+    # let the path be specified
+    file ||= self[:path]
+    return true unless Puppet::FileSystem.exist?(file)
+
+    return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
+  end
+
+  private
+
+  def perform_backup_with_bucket(fileobj)
+    file = (fileobj.class == String) ? fileobj : fileobj.name
+    case Puppet::FileSystem.lstat(file).ftype
+    when "directory"
+      # we don't need to backup directories when recurse is on
+      return true if self[:recurse]
+      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";
+    end
+    true
+  end
+
+  def perform_backup_with_backuplocal(fileobj, backup)
+    file = (fileobj.class == String) ? fileobj : fileobj.name
+    newfile = file + backup
+
+    remove_backup(newfile)
+
+    begin
+      bfile = file + backup
+
+      # N.B. cp_r works on both files and directories
+      FileUtils.cp_r(file, bfile, :preserve => true)
+      return true
+    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: %{message}") % { file: file, message: detail.message }, detail
+    end
+  end
+
+  def remove_backup(newfile)
+    if self.class.name == :file and self[:links] != :follow
+      method = :lstat
+    else
+      method = :stat
+    end
+
+    begin
+      stat = Puppet::FileSystem.send(method, newfile)
+    rescue Errno::ENOENT
+      return
+    end
+
+    if stat.ftype == "directory"
+      raise Puppet::Error, _("Will not remove directory backup %{newfile}; use a filebucket") % { newfile: newfile }
+    end
+
+    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}") % { detail: detail }
+      self.log_exception(detail, message)
+      self.fail Puppet::Error, message, detail
+    end
+  end
+
+  def backup_file_with_filebucket(f)
+    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

data/lib/puppet/util/character_encoding.rb

@@ -0,0 +1,80 @@
+# 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 already 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 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.
+    #
+    # 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
+  end
+end