openvox 7.37.1

data/lib/puppet/util/splayer.rb

@@ -0,0 +1,18 @@
+# Handle splay options (sleeping for a random interval before executing)
+module Puppet::Util::Splayer
+  # Have we splayed already?
+  def splayed?
+    !!@splayed
+  end
+
+  # Sleep when splay is enabled; else just return.
+  def splay(do_splay = Puppet[:splay])
+    return unless do_splay
+    return if splayed?
+
+    time = rand(Puppet[:splaylimit] + 1)
+    Puppet.info _("Sleeping for %{time} seconds (splay is enabled)") % { time: time }
+    sleep(time)
+    @splayed = true
+  end
+end

data/lib/puppet/util/storage.rb

@@ -0,0 +1,100 @@
+require 'yaml'
+require 'singleton'
+require_relative '../../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") % { filename: filename })
+      return
+    end
+    Puppet::Util.benchmark(:debug, "Loaded state in %{seconds} seconds") do
+      begin
+        @@state = Puppet::Util::Yaml.safe_load_file(filename, [Symbol, Time])
+      rescue Puppet::Util::Yaml::YamlLoadError => detail
+        Puppet.err _("Checksumfile %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail }
+
+        begin
+          File.rename(filename, filename + ".bad")
+        rescue
+          raise Puppet::Error, _("Could not rename corrupt %{filename}; remove manually") % { filename: filename }, 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 %{file}") % { file: Puppet[:statefile] } unless Puppet::FileSystem.exist?(Puppet[:statefile])
+
+    if Puppet[:statettl] == 0 || Puppet[:statettl] == Float::INFINITY
+      Puppet.debug "Not pruning old state cache entries"
+    else
+      Puppet::Util.benchmark(:debug, "Pruned old state cache entries in %{seconds} seconds") do
+        ttl_cutoff = Time.now - Puppet[:statettl]
+
+        @@state.reject! do |k,v|
+          @@state[k][:checked] && @@state[k][:checked] < ttl_cutoff
+        end
+      end
+    end
+
+    Puppet::Util.benchmark(:debug, "Stored state in %{seconds} seconds") do
+      Puppet::Util::Yaml.dump(@@state, Puppet[:statefile])
+    end
+  end
+end

data/lib/puppet/util/suidmanager.rb

@@ -0,0 +1,166 @@
+require_relative '../../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 = Puppet.runtime[: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?
+    if Puppet::Util::Platform.windows?
+      require_relative '../../puppet/util/windows/user'
+      Puppet::Util::Windows::User.admin?
+    else
+      Process.uid == 0
+    end
+  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::Util::Platform.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}") % { group: group } unless gid
+
+    return if Process.egid == 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}") % { user: user } unless uid
+
+    return if Process.euid == 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)
+    return id if id.kind_of? Integer
+    map = {:gid => :group, :uid => :user}
+    raise ArgumentError, _("Invalid id type %{type}") % { type: type } unless map.include?(type)
+    ret = Puppet::Util.send(type, id)
+    if ret == nil
+      raise Puppet::Error, _("Invalid %{klass}: %{id}") % { klass: map[type], id: 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
+end

data/lib/puppet/util/symbolic_file_mode.rb

@@ -0,0 +1,156 @@
+require_relative '../../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 display_mode(value)
+    if value =~ /^0?[0-7]{1,4}$/
+      value.rjust(4, "0")
+    else
+      value
+    end
+  end
+
+  def normalize_symbolic_mode(value)
+    return nil if value.nil?
+
+    # We need to treat integers as octal numbers.
+    #
+    # "A numeric mode is from one to four octal digits (0-7), derived by adding
+    # up the bits with values 4, 2, and 1. Omitted digits are assumed to be
+    # leading zeros."
+    if value.is_a? Numeric
+      value.to_s(8)
+    elsif value =~ /^0?[0-7]{1,4}$/
+      value.to_i(8).to_s(8) # strip leading 0's
+    else
+      value
+    end
+  end
+
+  def symbolic_mode_to_int(modification, to_mode = 0, is_a_directory = false)
+    if modification.nil? or modification == ''
+      raise Puppet::Error, _("An empty mode string is illegal")
+    elsif modification =~ /^[0-7]+$/
+      return modification.to_i(8)
+    elsif modification =~ /^\d+$/
+      raise Puppet::Error, _("Numeric modes must be in octal, not decimal!")
+    end
+
+    fail _("non-numeric current mode (%{mode})") % { 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 /[-+=]/
+              action = op
+              # Clear all bits, if this is assignment
+              value  = 0 if op == '='
+
+            when /[ugo]/
+              value = actions[action].call(value, snapshot_mode[op])
+
+            when /[rwx]/
+              value = actions[action].call(value, SymbolicMode[op])
+
+            when 'X'
+              # Only meaningful in combination with "set" actions.
+              if action != '+'
+                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?']
+                value = actions[action].call(value, ExecBit)
+              end
+
+            when /[st]/
+              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
+          rest = " at #{part.inspect}"
+        else
+          rest = ''
+        end
+
+        raise Puppet::Error, _("%{error}%{rest} in symbolic mode %{modification}") % { error: e, rest: rest, modification: 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/lib/puppet/util/tag_set.rb

@@ -0,0 +1,27 @@
+require 'set'
+require_relative '../../puppet/network/format_support'
+
+class Puppet::Util::TagSet < Set
+  include Puppet::Network::FormatSupport
+
+  def self.from_yaml(yaml)
+    self.new(Puppet::Util::Yaml.safe_load(yaml, [Symbol]))
+  end
+
+  def to_yaml
+    @hash.keys.to_yaml
+  end
+
+  def self.from_data_hash(data)
+    self.new(data)
+  end
+
+  # TODO: A method named #to_data_hash should not return an array
+  def to_data_hash
+    to_a
+  end
+
+  def join(*args)
+    to_a.join(*args)
+  end
+end

data/lib/puppet/util/tagging.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+require_relative '../../puppet/util/tag_set'
+
+module Puppet::Util::Tagging
+  ValidTagRegex = /\A[[:alnum:]_][[:alnum:]_:.-]*\Z/u
+
+  # Add a tag to the current tag set.
+  # When a tag set is used for a scope, these tags will be added to all of
+  # the objects contained in this scope when the objects are finished.
+  #
+  def tag(*ary)
+    @tags ||= new_tags
+
+    ary.flatten.compact.each do |tag|
+      name = tag.to_s.downcase
+      # Add the tag before testing if it's valid since this means that
+      # we never need to test the same valid tag twice. This speeds things
+      # up since we get a lot of duplicates and rarely fail on bad tags
+      if @tags.add?(name)
+        # not seen before, so now we test if it is valid
+        if valid_tag?(name)
+          if split_qualified_tags?
+          # avoid adding twice by first testing if the string contains '::'
+            @tags.merge(name.split('::')) if name.include?('::')
+          end
+        else
+          @tags.delete(name)
+          fail(Puppet::ParseError, _("Invalid tag '%{name}'") % { name: name })
+        end
+      end
+    end
+  end
+
+  # Add a name to the current tag set. Silently ignore names that does not
+  # represent valid tags.
+  # 
+  # Use this method instead of doing this:
+  #
+  #  tag(name) if is_valid?(name)
+  #
+  # since that results in testing the same string twice
+  #
+  def tag_if_valid(name)
+    if name.is_a?(String) && valid_tag?(name)
+      name = name.downcase
+      @tags ||= new_tags
+      if @tags.add?(name) && name.include?('::')
+        @tags.merge(name.split('::'))
+      end
+    end
+  end
+
+  # Answers if this resource is tagged with at least one of the given tags.
+  #
+  # The given tags are converted to downcased strings before the match is performed.
+  #
+  # @param *tags [String] splat of tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def tagged?(*tags)
+    raw_tagged?(tags.collect {|t| t.to_s.downcase})
+  end
+
+  # Answers if this resource is tagged with at least one of the tags given in downcased string form.
+  #
+  # The method is a faster variant of the tagged? method that does no conversion of its
+  # arguments.
+  #
+  # @param tag_array [Array[String]] array of tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def raw_tagged?(tag_array)
+    my_tags = self.tags
+    !tag_array.index { |t| my_tags.include?(t) }.nil?
+  end
+
+  # Only use this method when copying known tags from one Tagging instance to another
+  def set_tags(tag_source)
+    @tags = tag_source.tags
+  end
+
+  # Return a copy of the tag list, so someone can't ask for our tags
+  # and then modify them.
+  def tags
+    @tags ||= new_tags
+    @tags.dup
+  end
+
+  # Merge tags from a tagged instance with no attempts to split, downcase
+  # or verify the tags
+  def merge_tags_from(tag_source)
+    @tags ||= new_tags
+    tag_source.merge_into(@tags)
+  end
+
+  # Merge the tags of this instance into the provide TagSet
+  def merge_into(tag_set)
+    tag_set.merge(@tags) unless @tags.nil?
+  end
+
+  def tags=(tags)
+    @tags = new_tags
+
+    return if tags.nil?
+
+    tags = tags.strip.split(/\s*,\s*/) if tags.is_a?(String)
+    tag(*tags)
+  end
+
+  def valid_tag?(maybe_tag)
+    begin
+      tag_enc = maybe_tag.encoding
+      if tag_enc == Encoding::UTF_8 || tag_enc == Encoding::ASCII
+        maybe_tag =~ ValidTagRegex
+      else
+        maybe_tag.encode(Encoding::UTF_8) =~ ValidTagRegex
+      end
+    rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+      false
+    end
+  end
+
+  private
+
+  def split_qualified_tags?
+    true
+  end
+
+  def new_tags
+    Puppet::Util::TagSet.new
+  end
+end

data/lib/puppet/util/terminal.rb

@@ -0,0 +1,16 @@
+module Puppet::Util::Terminal
+  # Attempts to determine the width of the terminal.  This is currently only
+  # supported on POSIX systems, and relies on the claims of `stty` (or `tput`).
+  #
+  # Inspired by code from Thor; thanks wycats!
+  # @return [Number] The column width of the terminal.  Defaults to 80 columns.
+  def self.width
+    if Puppet.features.posix?
+      result = %x{stty size 2>/dev/null}.split[1] ||
+               %x{tput cols 2>/dev/null}.split[0]
+    end
+    return (result || '80').to_i
+  rescue
+    return 80
+  end
+end

data/lib/puppet/util/user_attr.rb

@@ -0,0 +1,21 @@
+class UserAttr
+  def self.get_attributes_by_name(name)
+    attributes = nil
+
+    File.readlines('/etc/user_attr').each do |line|
+      next if line =~ /^#/
+
+      token = line.split(':')
+
+      if token[0] == name
+        attributes = {:name => name}
+        token[4].split(';').each do |attr|
+          key_value = attr.split('=')
+          attributes[key_value[0].intern] = key_value[1].strip
+        end
+        break
+      end
+    end
+    attributes
+  end
+end

data/lib/puppet/util/warnings.rb

@@ -0,0 +1,31 @@
+# Methods to help with handling warnings.
+module Puppet::Util::Warnings
+  module_function
+
+  def notice_once(msg)
+    Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.notice msg }
+  end
+
+  def debug_once(msg)
+    return nil unless Puppet[:debug]
+    Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.debug msg }
+  end
+
+  def warnonce(msg)
+    Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.warning msg }
+  end
+
+  def clear_warnings
+    @stampwarnings = {}
+    nil
+  end
+
+  def self.maybe_log(message, klass)
+    @stampwarnings ||= {}
+    @stampwarnings[klass] ||= []
+    return nil if @stampwarnings[klass].include? message
+    yield
+    @stampwarnings[klass] << message
+    nil
+  end
+end