puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/util/storage.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'sync'
+require 'singleton'
+require 'puppet/util/yaml'
+
+# a class for storing state
+class Puppet::Util::Storage
+  include Singleton
+  include Puppet::Util
+
+  def self.state
+    @@state
+  end
+
+  def initialize
+    self.class.load
+  end
+
+  # Return a hash that will be stored to disk.  It's worth noting
+  # here that we use the object's full path, not just the name/type
+  # combination.  At the least, this is useful for those non-isomorphic
+  # types like exec, but it also means that if an object changes locations
+  # in the configuration it will lose its cache.
+  def self.cache(object)
+    if object.is_a?(Symbol)
+      name = object
+    else
+      name = object.to_s
+    end
+
+    @@state[name] ||= {}
+  end
+
+  def self.clear
+    @@state.clear
+  end
+
+  def self.init
+    @@state = {}
+  end
+
+  self.init
+
+  def self.load
+    Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
+    filename = Puppet[:statefile]
+
+    unless Puppet::FileSystem.exist?(filename)
+      self.init if @@state.nil?
+      return
+    end
+    unless File.file?(filename)
+      Puppet.warning("Checksumfile #{filename} is not a file, ignoring")
+      return
+    end
+    Puppet::Util.benchmark(:debug, "Loaded state") do
+      begin
+        @@state = Puppet::Util::Yaml.load_file(filename)
+      rescue Puppet::Util::Yaml::YamlLoadError => detail
+        Puppet.err "Checksumfile #{filename} is corrupt (#{detail}); replacing"
+
+        begin
+          File.rename(filename, filename + ".bad")
+        rescue
+          raise Puppet::Error, "Could not rename corrupt #{filename}; remove manually", detail.backtrace
+        end
+      end
+    end
+
+    unless @@state.is_a?(Hash)
+      Puppet.err "State got corrupted"
+      self.init
+    end
+  end
+
+  def self.stateinspect
+    @@state.inspect
+  end
+
+  def self.store
+    Puppet.debug "Storing state"
+
+    Puppet.info "Creating state file #{Puppet[:statefile]}" unless Puppet::FileSystem.exist?(Puppet[:statefile])
+
+    Puppet::Util.benchmark(:debug, "Stored state") do
+      Puppet::Util::Yaml.dump(@@state, Puppet[:statefile])
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/suidmanager.rb

@@ -0,0 +1,191 @@
+require 'facter'
+require 'puppet/util/warnings'
+require 'forwardable'
+require 'etc'
+
+module Puppet::Util::SUIDManager
+  include Puppet::Util::Warnings
+  extend Forwardable
+
+  # Note groups= is handled specially due to a bug in OS X 10.6, 10.7,
+  # and probably upcoming releases...
+  to_delegate_to_process = [ :euid=, :euid, :egid=, :egid, :uid=, :uid, :gid=, :gid, :groups ]
+
+  to_delegate_to_process.each do |method|
+    def_delegator Process, method
+    module_function method
+  end
+
+  def osx_maj_ver
+    return @osx_maj_ver unless @osx_maj_ver.nil?
+    @osx_maj_ver = Facter.value('macosx_productversion_major') || false
+  end
+  module_function :osx_maj_ver
+
+  def groups=(grouplist)
+    begin
+      return Process.groups = grouplist
+    rescue Errno::EINVAL => e
+      #We catch Errno::EINVAL as some operating systems (OS X in particular) can
+      # cause troubles when using Process#groups= to change *this* user / process
+      # list of supplementary groups membership.  This is done via Ruby's function
+      # "static VALUE proc_setgroups(VALUE obj, VALUE ary)" which is effectively
+      # a wrapper for "int setgroups(size_t size, const gid_t *list)" (part of SVr4
+      # and 4.3BSD but not in POSIX.1-2001) that fails and sets errno to EINVAL.
+      #
+      # This does not appear to be a problem with Ruby but rather an issue on the
+      # operating system side.  Therefore we catch the exception and look whether
+      # we run under OS X or not -- if so, then we acknowledge the problem and
+      # re-throw the exception otherwise.
+      if osx_maj_ver and not osx_maj_ver.empty?
+        return true
+      else
+        raise e
+      end
+    end
+  end
+  module_function :groups=
+
+  def self.root?
+    return Process.uid == 0 unless Puppet.features.microsoft_windows?
+
+    require 'puppet/util/windows/user'
+    Puppet::Util::Windows::User.admin?
+  end
+
+  # Methods to handle changing uid/gid of the running process. In general,
+  # these will noop or fail on Windows, and require root to change to anything
+  # but the current uid/gid (which is a noop).
+
+  # Runs block setting euid and egid if provided then restoring original ids.
+  # If running on Windows or without root, the block will be run with the
+  # current euid/egid.
+  def asuser(new_uid=nil, new_gid=nil)
+    return yield if Puppet.features.microsoft_windows?
+    return yield unless root?
+    return yield unless new_uid or new_gid
+
+    old_euid, old_egid = self.euid, self.egid
+    begin
+      change_privileges(new_uid, new_gid, false)
+
+      yield
+    ensure
+      change_privileges(new_uid ? old_euid : nil, old_egid, false)
+    end
+  end
+  module_function :asuser
+
+  # If `permanently` is set, will permanently change the uid/gid of the
+  # process. If not, it will only set the euid/egid. If only uid is supplied,
+  # the primary group of the supplied gid will be used. If only gid is
+  # supplied, only gid will be changed. This method will fail if used on
+  # Windows.
+  def change_privileges(uid=nil, gid=nil, permanently=false)
+    return unless uid or gid
+
+    unless gid
+      uid = convert_xid(:uid, uid)
+      gid = Etc.getpwuid(uid).gid
+    end
+
+    change_group(gid, permanently)
+    change_user(uid, permanently) if uid
+  end
+  module_function :change_privileges
+
+  # Changes the egid of the process if `permanently` is not set, otherwise
+  # changes gid. This method will fail if used on Windows, or attempting to
+  # change to a different gid without root.
+  def change_group(group, permanently=false)
+    gid = convert_xid(:gid, group)
+    raise Puppet::Error, "No such group #{group}" unless gid
+
+    if permanently
+      Process::GID.change_privilege(gid)
+    else
+      Process.egid = gid
+    end
+  end
+  module_function :change_group
+
+  # As change_group, but operates on uids. If changing user permanently,
+  # supplementary groups will be set the to default groups for the new uid.
+  def change_user(user, permanently=false)
+    uid = convert_xid(:uid, user)
+    raise Puppet::Error, "No such user #{user}" unless uid
+
+    if permanently
+      # If changing uid, we must be root. So initgroups first here.
+      initgroups(uid)
+
+      Process::UID.change_privilege(uid)
+    else
+      # We must be root to initgroups, so initgroups before dropping euid if
+      # we're root, otherwise elevate euid before initgroups.
+      # change euid (to root) first.
+      if Process.euid == 0
+        initgroups(uid)
+        Process.euid = uid
+      else
+        Process.euid = uid
+        initgroups(uid)
+      end
+    end
+  end
+  module_function :change_user
+
+  # Make sure the passed argument is a number.
+  def convert_xid(type, id)
+    map = {:gid => :group, :uid => :user}
+    raise ArgumentError, "Invalid id type #{type}" unless map.include?(type)
+    ret = Puppet::Util.send(type, id)
+    if ret == nil
+      raise Puppet::Error, "Invalid #{map[type]}: #{id}"
+    end
+    ret
+  end
+  module_function :convert_xid
+
+  # Initialize primary and supplemental groups to those of the target user.  We
+  # take the UID and manually look up their details in the system database,
+  # including username and primary group. This method will fail on Windows, or
+  # if used without root to initgroups of another user.
+  def initgroups(uid)
+    pwent = Etc.getpwuid(uid)
+    Process.initgroups(pwent.name, pwent.gid)
+  end
+
+  module_function :initgroups
+
+  # Run a command and capture the output
+  # Parameters:
+  # [command] the command to execute
+  # [new_uid] (optional) a userid to run the command as
+  # [new_gid] (optional) a groupid to run the command as
+  # [options] (optional, defaults to {}) a hash of option key/value pairs; currently supported:
+  #   :override_locale (defaults to true) a flag indicating whether or puppet should temporarily override the
+  #     system locale for the duration of the command.  If true, the locale will be set to 'C' to ensure consistent
+  #     output / formatting from the command, which makes it much easier to parse the output.  If false, the system
+  #     locale will be respected.
+  #   :custom_environment (default {}) -- a hash of key/value pairs to set as environment variables for the duration
+  #     of the command
+  def run_and_capture(command, new_uid=nil, new_gid=nil, options = {})
+    Puppet.deprecation_warning("Puppet::Util::SUIDManager.run_and_capture is deprecated; please use Puppet::Util::Execution.execute instead.")
+    # specifying these here rather than in the method signature to allow callers to pass in a partial
+    # set of overrides without affecting the default values for options that they don't pass in
+    default_options = {
+        :override_locale => true,
+        :custom_environment => {},
+    }
+
+    options = default_options.merge(options)
+
+    output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
+                                  :uid => new_uid, :gid => new_gid,
+                                  :override_locale => options[:override_locale],
+                                  :custom_environment => options[:custom_environment])
+    [output, $CHILD_STATUS.dup]
+  end
+  module_function :run_and_capture
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/symbolic_file_mode.rb

@@ -0,0 +1,144 @@
+require 'puppet/util'
+
+module Puppet
+module Util
+module SymbolicFileMode
+  SetUIDBit = ReadBit  = 4
+  SetGIDBit = WriteBit = 2
+  StickyBit = ExecBit  = 1
+  SymbolicMode = { 'x' => ExecBit, 'w' => WriteBit, 'r' => ReadBit }
+  SymbolicSpecialToBit = {
+    't' => { 'u' => StickyBit, 'g' => StickyBit, 'o' => StickyBit },
+    's' => { 'u' => SetUIDBit, 'g' => SetGIDBit, 'o' => StickyBit }
+  }
+
+  def valid_symbolic_mode?(value)
+    value = normalize_symbolic_mode(value)
+    return true if value =~ /^0?[0-7]{1,4}$/
+    return true if value =~ /^([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*$/
+    return false
+  end
+
+  def normalize_symbolic_mode(value)
+    return nil if value.nil?
+
+    # We need to treat integers as octal numbers.
+    if value.is_a? Numeric then
+      return value.to_s(8)
+    elsif value =~ /^0?[0-7]{1,4}$/ then
+      return value.to_i(8).to_s(8)
+    else
+      return value
+    end
+  end
+
+  def symbolic_mode_to_int(modification, to_mode = 0, is_a_directory = false)
+    if modification.nil? or modification == '' then
+      raise Puppet::Error, "An empty mode string is illegal"
+    end
+    if modification =~ /^[0-7]+$/ then return modification.to_i(8) end
+    if modification =~ /^\d+$/ then
+      raise Puppet::Error, "Numeric modes must be in octal, not decimal!"
+    end
+
+    fail "non-numeric current mode (#{to_mode.inspect})" unless to_mode.is_a?(Numeric)
+
+    original_mode = {
+      's' => (to_mode & 07000) >> 9,
+      'u' => (to_mode & 00700) >> 6,
+      'g' => (to_mode & 00070) >> 3,
+      'o' => (to_mode & 00007) >> 0,
+      # Are there any execute bits set in the original mode?
+      'any x?' => (to_mode & 00111) != 0
+    }
+    final_mode = {
+      's' => original_mode['s'],
+      'u' => original_mode['u'],
+      'g' => original_mode['g'],
+      'o' => original_mode['o'],
+    }
+
+    modification.split(/\s*,\s*/).each do |part|
+      begin
+        _, to, dsl = /^([ugoa]*)([-+=].*)$/.match(part).to_a
+        if dsl.nil? then raise Puppet::Error, 'Missing action' end
+        to = "a" unless to and to.length > 0
+
+        # We want a snapshot of the mode before we start messing with it to
+        # make actions like 'a-g' atomic.  Various parts of the DSL refer to
+        # the original mode, the final mode, or the current snapshot of the
+        # mode, for added fun.
+        snapshot_mode = {}
+        final_mode.each {|k,v| snapshot_mode[k] = v }
+
+        to.gsub('a', 'ugo').split('').uniq.each do |who|
+          value = snapshot_mode[who]
+
+          action = '!'
+          actions = {
+            '!' => lambda {|_,_| raise Puppet::Error, 'Missing operation (-, =, or +)' },
+            '=' => lambda {|m,v| m | v },
+            '+' => lambda {|m,v| m | v },
+            '-' => lambda {|m,v| m & ~v },
+          }
+
+          dsl.split('').each do |op|
+            case op
+            when /[-+=]/ then
+              action = op
+              # Clear all bits, if this is assignment
+              value  = 0 if op == '='
+
+            when /[ugo]/ then
+              value = actions[action].call(value, snapshot_mode[op])
+
+            when /[rwx]/ then
+              value = actions[action].call(value, SymbolicMode[op])
+
+            when 'X' then
+              # Only meaningful in combination with "set" actions.
+              if action != '+' then
+                raise Puppet::Error, "X only works with the '+' operator"
+              end
+
+              # As per the BSD manual page, set if this is a directory, or if
+              # any execute bit is set on the original (unmodified) mode.
+              # Ignored otherwise; it is "add if", not "add or clear".
+              if is_a_directory or original_mode['any x?'] then
+                value = actions[action].call(value, ExecBit)
+              end
+
+            when /[st]/ then
+              bit = SymbolicSpecialToBit[op][who] or fail "internal error"
+              final_mode['s'] = actions[action].call(final_mode['s'], bit)
+
+            else
+              raise Puppet::Error, 'Unknown operation'
+            end
+          end
+
+          # Now, assign back the value.
+          final_mode[who] = value
+        end
+
+      rescue Puppet::Error => e
+        if part.inspect != modification.inspect then
+          rest = " at #{part.inspect}"
+        else
+          rest = ''
+        end
+
+        raise Puppet::Error, "#{e}#{rest} in symbolic mode #{modification.inspect}", e.backtrace
+      end
+    end
+
+    result =
+      final_mode['s'] << 9 |
+      final_mode['u'] << 6 |
+      final_mode['g'] << 3 |
+      final_mode['o'] << 0
+    return result
+  end
+end
+end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/tag_set.rb

@@ -0,0 +1,41 @@
+require 'set'
+require 'puppet/network/format_support'
+
+class Puppet::Util::TagSet < Set
+  include Puppet::Network::FormatSupport
+
+  def self.from_yaml(yaml)
+    self.new(YAML.load(yaml))
+  end
+
+  def to_yaml
+    @hash.keys.to_yaml
+  end
+
+  def self.from_data_hash(data)
+    self.new(data)
+  end
+
+  def self.from_pson(data)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(data)
+  end
+
+  def to_data_hash
+    to_a
+  end
+
+  def to_pson(*args)
+    to_data_hash.to_pson
+  end
+
+  # this makes puppet serialize it as an array for backwards
+  # compatibility
+  def to_zaml(z)
+    to_data_hash.to_zaml(z)
+  end
+
+  def join(*args)
+    to_a.join(*args)
+  end
+end