bolt 0.24.0 → 0.25.0

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

@@ -1,46 +0,0 @@
-module Puppet::Util::RetryAction
-  class RetryException < Exception; end
-  class RetryException::NoBlockGiven < RetryException; end
-  class RetryException::NoRetriesGiven < RetryException;end
-  class RetryException::RetriesExceeded < RetryException; end
-
-  # Execute the supplied block retrying with exponential backoff.
-  #
-  # @param [Hash] options the retry options
-  # @option options [FixNum] :retries Maximum number of times to retry.
-  # @option options [Array<Exception>] :retry_exceptions ([StandardError]) Optional array of exceptions that are allowed to be retried.
-  # @yield The block to be executed.
-  def self.retry_action(options = {})
-    # Retry actions for a specified amount of time. This method will allow the final
-    # retry to complete even if that extends beyond the timeout period.
-    if !block_given?
-      raise RetryException::NoBlockGiven
-    end
-
-    retries = options[:retries]
-    if retries.nil?
-      raise RetryException::NoRetriesGiven
-    end
-
-    retry_exceptions = options[:retry_exceptions] || [StandardError]
-    failures = 0
-    begin
-      yield
-    rescue *retry_exceptions => e
-      if failures >= retries
-        raise RetryException::RetriesExceeded, _("%{retries} exceeded") % { retries: retries }, e.backtrace
-      end
-
-      Puppet.info(_("Caught exception %{klass}:%{error} retrying") % { klass: e.class, error: e })
-
-      failures += 1
-
-      # Increase the amount of time that we sleep after every
-      # failed retry attempt.
-      sleep (((2 ** failures) -1) * 0.1)
-
-      retry
-
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require 'puppet/util'
-
-module Puppet::Util::RubyGems
-
-  # Base/factory class for rubygems source. These classes introspec into
-  # rubygems to in order to list where the rubygems system will look for files
-  # to load.
-  class Source
-    class << self
-      # @api private
-      def has_rubygems?
-        # Gems are not actually available when Bundler is loaded, even
-        # though the Gem constant is defined. This is because Bundler
-        # loads in rubygems, but then removes the custom require that
-        # rubygems installs. So when Bundler is around we have to act
-        # as though rubygems is not, e.g. we shouldn't be able to load
-        # a gem that Bundler doesn't want us to see.
-        defined? ::Gem and not defined? ::Bundler
-      end
-
-      # @api private
-      def source
-        if has_rubygems?
-          Gems18Source
-        else
-          NoGemsSource
-        end
-      end
-
-      def new(*args)
-        object = source.allocate
-        object.send(:initialize, *args)
-        object
-      end
-    end
-  end
-
-  # For RubyGems >= 1.8.0
-  # @api private
-  class Gems18Source < Source
-    def directories
-      # `require 'mygem'` will consider and potentially load
-      # prerelease gems, so we need to match that behavior.
-      Gem::Specification.latest_specs(true).collect do |spec|
-        File.join(spec.full_gem_path, 'lib')
-      end
-    end
-
-    def clear_paths
-      Gem.clear_paths
-    end
-  end
-
-  # @api private
-  class NoGemsSource < Source
-    def directories
-      []
-    end
-
-    def clear_paths; end
-  end
-end
-

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

@@ -1,110 +0,0 @@
-require 'etc'
-
-module Puppet
-  module Util
-    class RunMode
-      def initialize(name)
-        @name = name.to_sym
-      end
-
-      attr :name
-
-      def self.[](name)
-        @run_modes ||= {}
-        if Puppet::Util::Platform.windows?
-          @run_modes[name] ||= WindowsRunMode.new(name)
-        else
-          @run_modes[name] ||= UnixRunMode.new(name)
-        end
-      end
-
-      def master?
-        name == :master
-      end
-
-      def agent?
-        name == :agent
-      end
-
-      def user?
-        name == :user
-      end
-
-      def run_dir
-        RunMode[name].run_dir
-      end
-
-      def log_dir
-        RunMode[name].log_dir
-      end
-
-      private
-
-      ##
-      # select the system or the user directory depending on the context of
-      # this process.  The most common use is determining filesystem path
-      # values for confdir and vardir.  The intended semantics are:
-      # {https://projects.puppetlabs.com/issues/16637 #16637} for Puppet 3.x
-      #
-      # @todo this code duplicates {Puppet::Settings#which\_configuration\_file}
-      #   as described in {https://projects.puppetlabs.com/issues/16637 #16637}
-      def which_dir( system, user )
-        if Puppet.features.root?
-          File.expand_path(system)
-        else
-          File.expand_path(user)
-        end
-      end
-    end
-
-    class UnixRunMode < RunMode
-      def conf_dir
-        which_dir("/etc/puppetlabs/puppet", "~/.puppetlabs/etc/puppet")
-      end
-
-      def code_dir
-        which_dir("/etc/puppetlabs/code", "~/.puppetlabs/etc/code")
-      end
-
-      def var_dir
-        which_dir("/opt/puppetlabs/puppet/cache", "~/.puppetlabs/opt/puppet/cache")
-      end
-
-      def run_dir
-        which_dir("/var/run/puppetlabs", "~/.puppetlabs/var/run")
-      end
-
-      def log_dir
-        which_dir("/var/log/puppetlabs/puppet", "~/.puppetlabs/var/log")
-      end
-    end
-
-    class WindowsRunMode < RunMode
-      def conf_dir
-        which_dir(File.join(windows_common_base("puppet/etc")), "~/.puppetlabs/etc/puppet")
-      end
-
-      def code_dir
-        which_dir(File.join(windows_common_base("code")), "~/.puppetlabs/etc/code")
-      end
-
-      def var_dir
-        which_dir(File.join(windows_common_base("puppet/cache")), "~/.puppetlabs/opt/puppet/cache")
-      end
-
-      def run_dir
-        which_dir(File.join(windows_common_base("puppet/var/run")), "~/.puppetlabs/var/run")
-      end
-
-      def log_dir
-        which_dir(File.join(windows_common_base("puppet/var/log")), "~/.puppetlabs/var/log")
-      end
-
-    private
-
-      def windows_common_base(*extra)
-        [Dir::COMMON_APPDATA, "PuppetLabs"] + extra
-      end
-    end
-  end
-end

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

@@ -1,264 +0,0 @@
-# Provides utility functions to help interface Puppet to SELinux.
-#
-# This requires the very new SELinux Ruby bindings.  These bindings closely
-# mirror the SELinux C library interface.
-#
-# Support for the command line tools is not provided because the performance
-# was abysmal.  At this time (2008-11-02) the only distribution providing
-# these Ruby SELinux bindings which I am aware of is Fedora (in libselinux-ruby).
-
-Puppet.features.selinux? # check, but continue even if it's not
-
-require 'pathname'
-
-module Puppet::Util::SELinux
-
-  def selinux_support?
-    return false unless defined?(Selinux)
-    if Selinux.is_selinux_enabled == 1
-      return true
-    end
-    false
-  end
-
-  # Retrieve and return the full context of the file.  If we don't have
-  # SELinux support or if the SELinux call fails then return nil.
-  def get_selinux_current_context(file)
-    return nil unless selinux_support?
-    retval = Selinux.lgetfilecon(file)
-    if retval == -1
-      return nil
-    end
-    retval[1]
-  end
-
-  # Retrieve and return the default context of the file.  If we don't have
-  # SELinux support or if the SELinux call fails to file a default then return nil.
-  def get_selinux_default_context(file)
-    return nil unless selinux_support?
-    # If the filesystem has no support for SELinux labels, return a default of nil
-    # instead of what matchpathcon would return
-    return nil unless selinux_label_support?(file)
-    # If the file exists we should pass the mode to matchpathcon for the most specific
-    # matching.  If not, we can pass a mode of 0.
-    begin
-      filestat = file_lstat(file)
-      mode = filestat.mode
-    rescue Errno::EACCES, Errno::ENOENT
-      mode = 0
-    end
-
-    retval = Selinux.matchpathcon(file, mode)
-    if retval == -1
-      return nil
-    end
-    retval[1]
-  end
-
-  # Take the full SELinux context returned from the tools and parse it
-  # out to the three (or four) component parts.  Supports :seluser, :selrole,
-  # :seltype, and on systems with range support, :selrange.
-  def parse_selinux_context(component, context)
-    if context.nil? or context == "unlabeled"
-      return nil
-    end
-    components = /^([^\s:]+):([^\s:]+):([^\s:]+)(?::([\sa-zA-Z0-9:,._-]+))?$/.match(context)
-    unless components
-      raise Puppet::Error, _("Invalid context to parse: %{context}") % { context: context }
-    end
-    case component
-    when :seluser
-      components[1]
-    when :selrole
-      components[2]
-    when :seltype
-      components[3]
-    when :selrange
-      components[4]
-    else
-      raise Puppet::Error, _("Invalid SELinux parameter type")
-    end
-  end
-
-  # This updates the actual SELinux label on the file.  You can update
-  # only a single component or update the entire context.
-  # The caveat is that since setting a partial context makes no sense the
-  # file has to already exist.  Puppet (via the File resource) will always
-  # just try to set components, even if all values are specified by the manifest.
-  # I believe that the OS should always provide at least a fall-through context
-  # though on any well-running system.
-  def set_selinux_context(file, value, component = false)
-    return nil unless selinux_support? && selinux_label_support?(file)
-
-    if component
-      # Must first get existing context to replace a single component
-      context = Selinux.lgetfilecon(file)[1]
-      if context == -1
-        # We can't set partial context components when no context exists
-        # unless/until we can find a way to make Puppet call this method
-        # once for all selinux file label attributes.
-        Puppet.warning _("Can't set SELinux context on file unless the file already has some kind of context")
-        return nil
-      end
-      context = context.split(':')
-      case component
-        when :seluser
-          context[0] = value
-        when :selrole
-          context[1] = value
-        when :seltype
-          context[2] = value
-        when :selrange
-          context[3] = value
-        else
-          raise ArgumentError, _("set_selinux_context component must be one of :seluser, :selrole, :seltype, or :selrange")
-      end
-      context = context.join(':')
-    else
-      context = value
-    end
-
-    retval = Selinux.lsetfilecon(file, context)
-    if retval == 0
-      return true
-    else
-      Puppet.warning _("Failed to set SELinux context %{context} on %{file}") % { context: context, file: file }
-      return false
-    end
-  end
-
-  # Since this call relies on get_selinux_default_context it also needs a
-  # full non-relative path to the file.  Fortunately, that seems to be all
-  # Puppet uses.  This will set the file's SELinux context to the policy's
-  # default context (if any) if it differs from the context currently on
-  # the file.
-  def set_selinux_default_context(file)
-    new_context = get_selinux_default_context(file)
-    return nil unless new_context
-    cur_context = get_selinux_current_context(file)
-    if new_context != cur_context
-      set_selinux_context(file, new_context)
-      return new_context
-    end
-    nil
-  end
-
-  ##
-  # selinux_category_to_label is an internal method that converts all
-  # selinux categories to their internal representation, avoiding
-  # potential issues when mcstransd is not functional.
-  #
-  # It is not marked private because it is needed by File's
-  # selcontext.rb, but it is not intended for use outside of Puppet's
-  # code.
-  #
-  # @param category [String] An selinux category, such as "s0" or "SystemLow"
-  #
-  # @return [String] the numeric category name, such as "s0"
-  def selinux_category_to_label(category)
-    # We don't cache this, but there's already a ton of duplicate work
-    # in the selinux handling code.
-
-    path = Selinux.selinux_translations_path
-    begin
-      File.open(path).each do |line|
-        line.strip!
-        next if line.empty?
-        next if line[0] == "#" # skip comments
-        line.gsub!(/[[:space:]]+/m, '')
-        mapping = line.split("=", 2)
-        if category == mapping[1]
-          return mapping[0]
-        end
-      end
-    rescue SystemCallError => ex
-      log_exception(ex)
-      raise Puppet::Error, _("Could not open SELinux category translation file %{path}.") % { context: context }
-    end
-
-    category
-  end
-
-  ########################################################################
-  # Internal helper methods from here on in, kids.  Don't fiddle.
-  private
-
-  # Check filesystem a path resides on for SELinux support against
-  # whitelist of known-good filesystems.
-  # Returns true if the filesystem can support SELinux labels and
-  # false if not.
-  def selinux_label_support?(file)
-    fstype = find_fs(file)
-    return false if fstype.nil?
-    filesystems = ['ext2', 'ext3', 'ext4', 'gfs', 'gfs2', 'xfs', 'jfs', 'btrfs']
-    filesystems.include?(fstype)
-  end
-
-  # Internal helper function to read and parse /proc/mounts
-  def read_mounts
-    mounts = ""
-    begin
-      if File.method_defined? "read_nonblock"
-        # If possible we use read_nonblock in a loop rather than read to work-
-        # a linux kernel bug.  See ticket #1963 for details.
-        mountfh = File.open("/proc/mounts")
-        mounts += mountfh.read_nonblock(1024) while true
-      else
-        # Otherwise we shell out and let cat do it for us
-        mountfh = IO.popen("/bin/cat /proc/mounts")
-        mounts = mountfh.read
-      end
-    rescue EOFError
-      # that's expected
-    rescue
-      return nil
-    ensure
-      mountfh.close if mountfh
-    end
-
-    mntpoint = {}
-
-    # Read all entries in /proc/mounts.  The second column is the
-    # mountpoint and the third column is the filesystem type.
-    # We skip rootfs because it is always mounted at /
-    mounts.each_line do |line|
-      params = line.split(' ')
-      next if params[2] == 'rootfs'
-      mntpoint[params[1]] = params[2]
-    end
-    mntpoint
-  end
-
-  # Internal helper function to return which type of filesystem a given file
-  # path resides on
-  def find_fs(path)
-    return nil unless mounts = read_mounts
-
-    # cleanpath eliminates useless parts of the path (like '.', or '..', or
-    # multiple slashes), without touching the filesystem, and without
-    # following symbolic links.  This gives the right (logical) tree to follow
-    # while we try and figure out what file-system the target lives on.
-    path = Pathname(path).cleanpath
-    unless path.absolute?
-      raise Puppet::DevError, _("got a relative path in SELinux find_fs: %{path}") % { path: path }
-    end
-
-    # Now, walk up the tree until we find a match for that path in the hash.
-    path.ascend do |segment|
-      return mounts[segment.to_s] if mounts.has_key?(segment.to_s)
-    end
-
-    # Should never be reached...
-    return mounts['/']
-  end
-
-  ##
-  # file_lstat is an internal, private method to allow precise stubbing and
-  # mocking without affecting the rest of the system.
-  #
-  # @return [File::Stat] File.lstat result
-  def file_lstat(path)
-    Puppet::FileSystem.lstat(path)
-  end
-  private :file_lstat
-end