bolt 0.20.0 → 0.20.2

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

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

@@ -0,0 +1,75 @@
+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?
+          Gem::Specification.respond_to?(:latest_specs) ? Gems18Source : OldGemsSource
+        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
+
+  # RubyGems < 1.8.0
+  # @api private
+  class OldGemsSource < Source
+    def directories
+      @paths ||= Gem.latest_load_paths
+    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

@@ -0,0 +1,110 @@
+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.features.microsoft_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

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