puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,56 @@
+require 'puppet/util/tag_set'
+
+module Puppet::Util::Tagging
+  ValidTagRegex = /^\w[-\w:.]*$/
+
+  # 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.each do |tag|
+      name = tag.to_s.downcase
+      if name =~ ValidTagRegex
+        @tags << name
+        name.split("::").each do |section|
+          @tags << section
+        end
+      else
+        fail(Puppet::ParseError, "Invalid tag '#{name}'")
+      end
+    end
+  end
+
+  # Is the receiver tagged with the given tags?
+  def tagged?(*tags)
+    not ( self.tags & tags.flatten.collect { |t| t.to_s } ).empty?
+  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
+
+  def tags=(tags)
+    @tags = new_tags
+
+    return if tags.nil? or tags == ""
+
+    tags = tags.strip.split(/\s*,\s*/) if tags.is_a?(String)
+    tags.each {|t| tag(t) }
+  end
+
+  private
+
+  def valid_tag?(tag)
+    tag.is_a?(String) and tag =~ ValidTagRegex
+  end
+
+  def new_tags
+    Puppet::Util::TagSet.new
+  end
+end

data/vendor/gems/puppet-3.7.3/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/vendor/gems/puppet-3.7.3/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/vendor/gems/puppet-3.7.3/lib/puppet/util/warnings.rb

@@ -0,0 +1,32 @@
+# 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)
+    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
+
+  protected
+
+  def self.maybe_log(message, klass)
+    @stampwarnings ||= {}
+    @stampwarnings[klass] ||= []
+    return nil if @stampwarnings[klass].include? message
+    yield
+    @stampwarnings[klass] << message
+    nil
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'puppet/util/watcher'
+
+# Monitor a given file for changes on a periodic interval. Changes are detected
+# by looking for a change in the file ctime.
+class Puppet::Util::WatchedFile
+  # @!attribute [r] filename
+  #   @return [String] The fully qualified path to the file.
+  attr_reader :filename
+
+  # @param filename [String] The fully qualified path to the file.
+  # @param timer [Puppet::Util::Watcher::Timer] The polling interval for checking for file
+  #   changes. Setting the timeout to a negative value will treat the file as
+  #   always changed. Defaults to `Puppet[:filetimeout]`
+  def initialize(filename, timer = Puppet::Util::Watcher::Timer.new(Puppet[:filetimeout]))
+    @filename = filename
+    @timer = timer
+
+    @info = Puppet::Util::Watcher::PeriodicWatcher.new(
+      Puppet::Util::Watcher::Common.file_ctime_change_watcher(@filename),
+      timer)
+  end
+
+  # @return [true, false] If the file has changed since it was last checked.
+  def changed?
+    @info.changed?
+  end
+
+  # Allow this to be used as the name of the file being watched in various
+  # other methods (such as Puppet::FileSystem.exist?)
+  def to_str
+    @filename
+  end
+
+  def to_s
+    "<WatchedFile: filename = #{@filename}, timeout = #{@timer.timeout}>"
+  end
+end

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

@@ -0,0 +1,17 @@
+module Puppet::Util::Watcher
+  require 'puppet/util/watcher/timer'
+  require 'puppet/util/watcher/change_watcher'
+  require 'puppet/util/watcher/periodic_watcher'
+
+  module Common
+    def self.file_ctime_change_watcher(filename)
+      Puppet::Util::Watcher::ChangeWatcher.watch(lambda do
+        begin
+          Puppet::FileSystem.stat(filename).ctime
+        rescue Errno::ENOENT, Errno::ENOTDIR
+          :absent
+        end
+      end)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/watcher/change_watcher.rb

@@ -0,0 +1,33 @@
+# Watches for changes over time. It only re-examines the values when it is requested to update readings.
+# @api private
+class Puppet::Util::Watcher::ChangeWatcher
+  def self.watch(reader)
+    Puppet::Util::Watcher::ChangeWatcher.new(nil, nil, reader).next_reading
+  end
+
+  def initialize(previous, current, value_reader)
+    @previous = previous
+    @current = current
+    @value_reader = value_reader
+  end
+
+  def changed?
+    if uncertain?
+      false
+    else
+      @previous != @current
+    end
+  end
+
+  def uncertain?
+    @previous.nil? || @current.nil?
+  end
+
+  def change_current_reading_to(new_value)
+    Puppet::Util::Watcher::ChangeWatcher.new(@current, new_value, @value_reader)
+  end
+
+  def next_reading
+    change_current_reading_to(@value_reader.call)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/watcher/periodic_watcher.rb

@@ -0,0 +1,37 @@
+# Monitor a given watcher for changes on a periodic interval.
+class Puppet::Util::Watcher::PeriodicWatcher
+  # @param watcher [Puppet::Util::Watcher::ChangeWatcher] a watcher for the value to watch
+  # @param timer [Puppet::Util::Watcher::Timer] A timer to determin when to
+  #   recheck the watcher. If the timout of the timer is negative, then the
+  #   watched value is always considered to be changed
+  def initialize(watcher, timer)
+    @watcher = watcher
+    @timer = timer
+
+    @timer.start
+  end
+
+  # @return [true, false] If the file has changed since it was last checked.
+  def changed?
+    return true if always_consider_changed?
+
+    @watcher = examine_watched_info(@watcher)
+    @watcher.changed?
+  end
+
+  private
+
+  def always_consider_changed?
+    @timer.timeout < 0
+  end
+
+  def examine_watched_info(known)
+    if @timer.expired?
+      @timer.start
+      known.next_reading
+    else
+      known
+    end
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/util/watcher/timer.rb

@@ -0,0 +1,19 @@
+class Puppet::Util::Watcher::Timer
+  attr_reader :timeout
+
+  def initialize(timeout)
+    @timeout = timeout
+  end
+
+  def start
+    @start_time = now
+  end
+
+  def expired?
+    (now - @start_time) >= @timeout
+  end
+
+  def now
+    Time.now.to_i
+  end
+end

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

@@ -0,0 +1,28 @@
+module Puppet::Util::Windows
+  module ADSI
+    class User; end
+    class UserProfile; end
+    class Group; end
+  end
+  module Registry
+  end
+
+  if Puppet::Util::Platform.windows?
+    # these reference platform specific gems
+    require 'puppet/util/windows/api_types'
+    require 'puppet/util/windows/string'
+    require 'puppet/util/windows/error'
+    require 'puppet/util/windows/com'
+    require 'puppet/util/windows/sid'
+    require 'puppet/util/windows/file'
+    require 'puppet/util/windows/security'
+    require 'puppet/util/windows/user'
+    require 'puppet/util/windows/process'
+    require 'puppet/util/windows/root_certs'
+    require 'puppet/util/windows/access_control_entry'
+    require 'puppet/util/windows/access_control_list'
+    require 'puppet/util/windows/security_descriptor'
+    require 'puppet/util/windows/adsi'
+    require 'puppet/util/windows/registry'
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/windows/access_control_entry.rb

@@ -0,0 +1,84 @@
+# Windows Access Control Entry
+#
+# Represents an access control entry, which grants or denies a subject,
+# identified by a SID, rights to a securable object.
+#
+# @see http://msdn.microsoft.com/en-us/library/windows/desktop/aa374868(v=vs.85).aspx
+# @api private
+class Puppet::Util::Windows::AccessControlEntry
+  require 'puppet/util/windows/security'
+  include Puppet::Util::Windows::SID
+
+  attr_accessor :sid
+  attr_reader :mask, :flags, :type
+
+  OBJECT_INHERIT_ACE                      = 0x1
+  CONTAINER_INHERIT_ACE                   = 0x2
+  NO_PROPAGATE_INHERIT_ACE                = 0x4
+  INHERIT_ONLY_ACE                        = 0x8
+  INHERITED_ACE                           = 0x10
+
+  ACCESS_ALLOWED_ACE_TYPE                 = 0x0
+  ACCESS_DENIED_ACE_TYPE                  = 0x1
+
+  def initialize(sid, mask, flags = 0, type = ACCESS_ALLOWED_ACE_TYPE)
+    @sid = sid
+    @mask = mask
+    @flags = flags
+    @type = type
+  end
+
+  # Returns true if this ACE is inherited from a parent. If false,
+  # then the ACE is set directly on the object to which it refers.
+  #
+  # @return [Boolean] true if the ACE is inherited
+  def inherited?
+    (@flags & INHERITED_ACE) == INHERITED_ACE
+  end
+
+  # Returns true if this ACE only applies to children of the object.
+  # If false, it applies to the object.
+  #
+  # @return [Boolean] true if the ACE only applies to children and
+  # not the object itself.
+  def inherit_only?
+    (@flags & INHERIT_ONLY_ACE) == INHERIT_ONLY_ACE
+  end
+
+  # Returns true if this ACE applies to child directories.
+  #
+  # @return [Boolean] true if the ACE applies to child direcories
+  def container_inherit?
+    (@flags & CONTAINER_INHERIT_ACE) == CONTAINER_INHERIT_ACE
+  end
+
+  # Returns true if this ACE applies to child files.
+  #
+  # @return [Boolean] true if the ACE applies to child files.
+  def object_inherit?
+    (@flags & OBJECT_INHERIT_ACE) == OBJECT_INHERIT_ACE
+  end
+
+  def inspect
+    inheritance = ""
+    inheritance << '(I)' if inherited?
+    inheritance << '(OI)' if object_inherit?
+    inheritance << '(CI)' if container_inherit?
+    inheritance << '(IO)' if inherit_only?
+
+    left = "#{sid_to_name(sid)}:#{inheritance}"
+    left = left.ljust(45)
+    "#{left} 0x#{mask.to_s(16)}"
+  end
+
+  # Returns true if this ACE is equal to +other+
+  def ==(other)
+    self.class == other.class &&
+      sid == other.sid &&
+      mask == other.mask &&
+      flags == other.flags &&
+      type == other.type
+  end
+
+  alias eql? ==
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/windows/access_control_list.rb

@@ -0,0 +1,113 @@
+# Windows Access Control List
+#
+# Represents a list of access control entries (ACEs).
+#
+# @see http://msdn.microsoft.com/en-us/library/windows/desktop/aa374872(v=vs.85).aspx
+# @api private
+class Puppet::Util::Windows::AccessControlList
+  include Enumerable
+
+  ACCESS_ALLOWED_ACE_TYPE                 = 0x0
+  ACCESS_DENIED_ACE_TYPE                  = 0x1
+
+  # Construct an ACL.
+  #
+  # @param acl [Enumerable] A list of aces to copy from.
+  def initialize(acl = nil)
+    if acl
+      @aces = acl.map(&:dup)
+    else
+      @aces = []
+    end
+  end
+
+  # Enumerate each ACE in the list.
+  #
+  # @yieldparam ace [Hash] the ace
+  def each
+    @aces.each {|ace| yield ace}
+  end
+
+  # Allow the +sid+ to access a resource with the specified access +mask+.
+  #
+  # @param sid [String] The SID that the ACE is granting access to
+  # @param mask [int] The access mask granted to the SID
+  # @param flags [int] The flags assigned to the ACE, e.g. +INHERIT_ONLY_ACE+
+  def allow(sid, mask, flags = 0)
+    @aces << Puppet::Util::Windows::AccessControlEntry.new(sid, mask, flags, ACCESS_ALLOWED_ACE_TYPE)
+  end
+
+  # Deny the +sid+ access to a resource with the specified access +mask+.
+  #
+  # @param sid [String] The SID that the ACE is denying access to
+  # @param mask [int] The access mask denied to the SID
+  # @param flags [int] The flags assigned to the ACE, e.g. +INHERIT_ONLY_ACE+
+  def deny(sid, mask, flags = 0)
+    @aces << Puppet::Util::Windows::AccessControlEntry.new(sid, mask, flags, ACCESS_DENIED_ACE_TYPE)
+  end
+
+  # Reassign all ACEs currently assigned to +old_sid+ to +new_sid+ instead.
+  # If an ACE is inherited or is not assigned to +old_sid+, then it will
+  # be copied as-is to the new ACL, preserving its order within the ACL.
+  #
+  # @param old_sid [String] The old SID, e.g. 'S-1-5-18'
+  # @param new_sid [String] The new SID
+  # @return [AccessControlList] The copied ACL.
+  def reassign!(old_sid, new_sid)
+    new_aces = []
+    prepend_needed = false
+    aces_to_prepend = []
+
+    @aces.each do |ace|
+      new_ace = ace.dup
+
+      if ace.sid == old_sid
+        if ace.inherited?
+          # create an explicit ACE granting or denying the
+          # new_sid the rights that the inherited ACE
+          # granted or denied the old_sid. We mask off all
+          # flags except those affecting inheritance of the
+          # ACE we're creating.
+          inherit_mask = Puppet::Util::Windows::AccessControlEntry::CONTAINER_INHERIT_ACE |
+            Puppet::Util::Windows::AccessControlEntry::OBJECT_INHERIT_ACE |
+            Puppet::Util::Windows::AccessControlEntry::INHERIT_ONLY_ACE
+          explicit_ace = Puppet::Util::Windows::AccessControlEntry.new(new_sid, ace.mask, ace.flags & inherit_mask, ace.type)
+          aces_to_prepend << explicit_ace
+        else
+          new_ace.sid = new_sid
+
+          prepend_needed = old_sid == Win32::Security::SID::LocalSystem
+        end
+      end
+      new_aces << new_ace
+    end
+
+    @aces = []
+
+    if prepend_needed
+      mask = Puppet::Util::Windows::File::STANDARD_RIGHTS_ALL | Puppet::Util::Windows::File::SPECIFIC_RIGHTS_ALL
+      ace = Puppet::Util::Windows::AccessControlEntry.new(
+              Win32::Security::SID::LocalSystem,
+              mask)
+      @aces << ace
+    end
+
+    @aces.concat(aces_to_prepend)
+    @aces.concat(new_aces)
+  end
+
+  def inspect
+    str = ""
+    @aces.each do |ace|
+      str << "  #{ace.inspect}\n"
+    end
+    str
+  end
+
+  def ==(other)
+    self.class == other.class &&
+      self.to_a == other.to_a
+  end
+
+  alias eql? ==
+end