puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/storage.rb

@@ -0,0 +1,96 @@
+require 'yaml'
+require 'sync'
+
+require 'puppet/util/file_locking'
+
+# 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
+    Storage.init
+  end
+
+  def self.init
+    @@state = {}
+    @@splitchar = "\t"
+  end
+
+  self.init
+
+  def self.load
+    Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
+
+    unless File.exists?(Puppet[:statefile])
+      self.init unless !@@state.nil?
+      return
+    end
+    unless File.file?(Puppet[:statefile])
+      Puppet.warning("Checksumfile #{Puppet[:statefile]} is not a file, ignoring")
+      return
+    end
+    Puppet::Util.benchmark(:debug, "Loaded state") do
+      Puppet::Util::FileLocking.readlock(Puppet[:statefile]) do |file|
+        begin
+          @@state = YAML.load(file)
+        rescue => detail
+          Puppet.err "Checksumfile #{Puppet[:statefile]} is corrupt (#{detail}); replacing"
+          begin
+            File.rename(Puppet[:statefile], Puppet[:statefile] + ".bad")
+          rescue
+            raise Puppet::Error,
+              "Could not rename corrupt #{Puppet[:statefile]}; remove manually"
+          end
+        end
+      end
+    end
+
+    unless @@state.is_a?(Hash)
+      Puppet.err "State got corrupted"
+      self.init
+    end
+
+    #Puppet.debug "Loaded state is #{@@state.inspect}"
+  end
+
+  def self.stateinspect
+    @@state.inspect
+  end
+
+  def self.store
+    Puppet.debug "Storing state"
+
+    Puppet.info "Creating state file #{Puppet[:statefile]}" unless FileTest.exist?(Puppet[:statefile])
+
+    Puppet::Util.benchmark(:debug, "Stored state") do
+      Puppet::Util::FileLocking.writelock(Puppet[:statefile], 0660) do |file|
+        file.print YAML.dump(@@state)
+      end
+    end
+  end
+end

data/lib/vendor/puppet/util/subclass_loader.rb

@@ -0,0 +1,82 @@
+# A module for loading subclasses into an array and retrieving
+# them by name.  Also sets up a method for each class so
+# that you can just do Klass.subclass, rather than Klass.subclass(:subclass).
+#
+# This module is currently used by network handlers and clients.
+module Puppet::Util::SubclassLoader
+  attr_accessor :loader, :classloader
+
+  # Iterate over each of the subclasses.
+  def each
+    @subclasses ||= []
+    @subclasses.each { |c| yield c }
+  end
+
+  # The hook method that sets up subclass loading.  We need the name
+  # of the method to create and the path in which to look for them.
+  def handle_subclasses(name, path)
+    raise ArgumentError, "Must be a class to use SubclassLoader" unless self.is_a?(Class)
+    @subclasses = []
+
+          @loader = Puppet::Util::Autoload.new(
+        self,
+        
+      path, :wrap => false
+    )
+
+    @subclassname = name
+
+    @classloader = self
+
+    # Now create a method for retrieving these subclasses by name.  Note
+    # that we're defining a class method here, not an instance.
+    meta_def(name) do |subname|
+      subname = subname.to_s.downcase
+
+      unless c = @subclasses.find { |c| c.name.to_s.downcase == subname }
+        loader.load(subname)
+        c = @subclasses.find { |c| c.name.to_s.downcase == subname }
+
+        # Now make the method that returns this subclass.  This way we
+        # normally avoid the method_missing method.
+        define_method(subname) { c } if c and ! respond_to?(subname)
+      end
+      return c
+    end
+  end
+
+  # Add a new class to our list.  Note that this has to handle subclasses of
+  # subclasses, thus the reason we're keeping track of the @@classloader.
+  def inherited(sub)
+    @subclasses ||= []
+    sub.classloader = self.classloader
+    if self.classloader == self
+      @subclasses << sub
+    else
+      @classloader.inherited(sub)
+    end
+  end
+
+  # See if we can load a class.
+  def method_missing(method, *args)
+    unless self == self.classloader
+      super
+    end
+    return nil unless defined?(@subclassname)
+    self.send(@subclassname, method) || nil
+  end
+
+  # Retrieve or calculate a name.
+  def name(dummy_argument=:work_arround_for_ruby_GC_bug)
+    @name ||= self.to_s.sub(/.+::/, '').intern
+
+    @name
+  end
+
+  # Provide a list of all subclasses.
+  def subclasses
+    @loader.loadall
+    @subclasses.collect { |klass| klass.name }
+  end
+end
+

data/lib/vendor/puppet/util/suidmanager.rb

@@ -0,0 +1,173 @@
+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?
+    # 'kernel' is available without explicitly loading all facts
+    if Facter.value('kernel') != 'Darwin'
+      @osx_maj_ver = false
+      return @osx_maj_ver
+    end
+    # But 'macosx_productversion_major' requires it.
+    Facter.loadfacts
+    @osx_maj_ver = Facter.value('macosx_productversion_major')
+  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
+
+  def run_and_capture(command, new_uid=nil, new_gid=nil)
+    output = Puppet::Util.execute(command, :failonfail => false, :combine => true, :uid => new_uid, :gid => new_gid)
+    [output, $CHILD_STATUS.dup]
+  end
+  module_function :run_and_capture
+end

data/lib/vendor/puppet/util/symbolic_file_mode.rb

@@ -0,0 +1,140 @@
+require 'puppet/util'
+
+module Puppet::Util::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}"
+      end
+    end
+
+    result =
+      final_mode['s'] << 9 |
+      final_mode['u'] << 6 |
+      final_mode['g'] << 3 |
+      final_mode['o'] << 0
+    return result
+  end
+end

data/lib/vendor/puppet/util/tagging.rb

@@ -0,0 +1,78 @@
+# Created on 2008-01-19
+# Copyright Luke Kanies
+
+# A common module to handle tagging.
+#
+# So, do you want the bad news or the good news first?
+#
+# The bad news is that using an array here is hugely costly compared to using
+# a hash.  Like, the same speed empty, 50 percent slower with one item, and
+# 300 percent slower at 6 - one of our common peaks for tagging items.
+#
+# ...and that assumes an efficient implementation, just using include?.  These
+# methods have even more costs hidden in them.
+#
+# The good news is that this module has no API.  Various objects directly
+# interact with their `@tags` member as an array, or dump it directly in YAML,
+# or whatever.
+#
+# So, er, you can't actually change this.  No matter how much you want to be
+# cause it is inefficient in both CPU and object allocation terms.
+#
+# Good luck, my friend. --daniel 2012-07-17
+module Puppet::Util::Tagging
+  # Add a tag to our current list.  These tags will be added to all
+  # of the objects contained in this scope.
+  def tag(*ary)
+    @tags ||= []
+
+    qualified = []
+
+    ary.collect { |tag| tag.to_s.downcase }.each do |tag|
+      fail(Puppet::ParseError, "Invalid tag #{tag.inspect}") unless valid_tag?(tag)
+      qualified << tag if tag.include?("::")
+      @tags << tag unless @tags.include?(tag)
+    end
+
+    handle_qualified_tags( qualified )
+  end
+
+  # Are we tagged with the provided tag?
+  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 ||= []
+    @tags.dup
+  end
+
+  def tags=(tags)
+    @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 handle_qualified_tags(qualified)
+    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+    x = 1
+    qualified.each do |name|
+      name.split("::").each do |tag|
+        @tags << tag unless @tags.include?(tag)
+      end
+    end
+  end
+
+  ValidTagRegex = /^\w[-\w:.]*$/
+  def valid_tag?(tag)
+    tag.is_a?(String) and tag =~ ValidTagRegex
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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 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/lib/vendor/puppet/util/windows/error.rb

@@ -0,0 +1,16 @@
+require 'puppet/util/windows'
+
+# represents an error resulting from a Win32 error code
+class Puppet::Util::Windows::Error < Puppet::Error
+  require 'windows/error'
+  include ::Windows::Error
+
+  attr_reader :code
+
+  def initialize(message, code = GetLastError.call)
+    super(message + ":  #{get_last_error(code)}")
+
+    @code = code
+  end
+end
+

data/lib/vendor/puppet/util/windows/file.rb

@@ -0,0 +1,27 @@
+require 'puppet/util/windows'
+
+module Puppet::Util::Windows::File
+  require 'windows/api'
+  require 'windows/wide_string'
+
+  ReplaceFileWithoutBackupW = Windows::API.new('ReplaceFileW', 'PPVLVV', 'B')
+  def replace_file(target, source)
+    result = ReplaceFileWithoutBackupW.call(WideString.new(target.to_s),
+                                   WideString.new(source.to_s),
+                                   0, 0x1, 0, 0)
+    return true unless result == 0
+    raise Puppet::Util::Windows::Error.new("ReplaceFile(#{target}, #{source})")
+  end
+  module_function :replace_file
+
+  MoveFileEx = Windows::API.new('MoveFileExW', 'PPL', 'B')
+  def move_file_ex(source, target, flags = 0)
+    result = MoveFileEx.call(WideString.new(source.to_s),
+                             WideString.new(target.to_s),
+                             flags)
+    return true unless result == 0
+    raise Puppet::Util::Windows::Error.
+      new("MoveFileEx(#{source}, #{target}, #{flags.to_s(8)})")
+  end
+  module_function :move_file_ex
+end