bolt 0.19.1 → 0.20.0

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

@@ -1,35 +0,0 @@
-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/vendored/puppet/lib/puppet/util/at_fork/noop.rb

@@ -1,18 +0,0 @@
-# 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/vendored/puppet/lib/puppet/util/at_fork/solaris.rb

@@ -1,160 +0,0 @@
-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
-      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/vendored/puppet/lib/puppet/util/autoload.rb

@@ -1,226 +0,0 @@
-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
-  include Puppet::Util::MethodHelper
-
-  @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.
-    def mark_loaded(name, file)
-      name = cleanpath(name).chomp('.rb')
-      ruby_file = name + ".rb"
-      $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
-      loaded[name] = [file, File.mtime(file)]
-    end
-
-    def changed?(name)
-      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)
-      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 = nil)
-      # 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
-      loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
-    end
-
-    # Get the correct file to load for a given path
-    # returns nil if no file is found
-    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)
-      search_directories(env).map {|dir| files_in_dir(dir, path) }.flatten.uniq
-    end
-
-    def files_in_dir(dir, path)
-      dir = Pathname.new(File.expand_path(dir))
-      Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
-        Pathname.new(file).relative_path_from(dir).to_s
-      end
-    end
-
-    def module_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?
-        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
-          []
-        end
-      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
-        []
-      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)
-      # There are two cases here because cleanpath does not handle absolute
-      # paths correctly on windows (c:\ and c:/ are treated as distinct) but
-      # we don't want to convert relative paths to absolute
-      if Puppet::Util.absolute_path?(path)
-        File.expand_path(path)
-      else
-        Pathname.new(path).cleanpath.to_s
-      end
-    end
-  end
-
-  attr_accessor :object, :path
-
-  def initialize(obj, path, options = {})
-    @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)
-    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 = nil)
-    self.class.loadall(@path, env)
-  end
-
-  def loaded?(name)
-    self.class.loaded?(expand(name))
-  end
-
-  def changed?(name)
-    self.class.changed?(expand(name))
-  end
-
-  def files_to_load
-    self.class.files_to_load(@path)
-  end
-
-  def expand(name)
-    ::File.join(@path, name.to_s)
-  end
-end

data/vendored/puppet/lib/puppet/util/backups.rb

@@ -1,86 +0,0 @@
-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