puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,296 @@
+module Puppet::Util::ADSI
+  class << self
+    def connectable?(uri)
+      begin
+        !! connect(uri)
+      rescue
+        false
+      end
+    end
+
+    def connect(uri)
+      begin
+        WIN32OLE.connect(uri)
+      rescue Exception => e
+        raise Puppet::Error.new( "ADSI connection error: #{e}" )
+      end
+    end
+
+    def create(name, resource_type)
+      Puppet::Util::ADSI.connect(computer_uri).Create(resource_type, name)
+    end
+
+    def delete(name, resource_type)
+      Puppet::Util::ADSI.connect(computer_uri).Delete(resource_type, name)
+    end
+
+    def computer_name
+      unless @computer_name
+        buf = " " * 128
+        Win32API.new('kernel32', 'GetComputerName', ['P','P'], 'I').call(buf, buf.length.to_s)
+        @computer_name = buf.unpack("A*")
+      end
+      @computer_name
+    end
+
+    def computer_uri
+      "WinNT://#{computer_name}"
+    end
+
+    def wmi_resource_uri( host = '.' )
+      "winmgmts:{impersonationLevel=impersonate}!//#{host}/root/cimv2"
+    end
+
+    def uri(resource_name, resource_type)
+      "#{computer_uri}/#{resource_name},#{resource_type}"
+    end
+
+    def wmi_connection
+      connect(wmi_resource_uri)
+    end
+
+    def execquery(query)
+      wmi_connection.execquery(query)
+    end
+
+    def sid_for_account(name)
+      Puppet.deprecation_warning "Puppet::Util::ADSI.sid_for_account is deprecated and will be removed in 3.0, use Puppet::Util::Windows::SID.name_to_account instead."
+
+      Puppet::Util::Windows::Security.name_to_sid(name)
+    end
+  end
+
+  class User
+    extend Enumerable
+
+    attr_accessor :native_user
+    attr_reader :name
+    def initialize(name, native_user = nil)
+      @name = name
+      @native_user = native_user
+    end
+
+    def native_user
+      @native_user ||= Puppet::Util::ADSI.connect(uri)
+    end
+
+    def self.uri(name)
+      Puppet::Util::ADSI.uri(name, 'user')
+    end
+
+    def uri
+      self.class.uri(name)
+    end
+
+    def self.logon(name, password)
+      Puppet::Util::Windows::User.password_is?(name, password)
+    end
+
+    def [](attribute)
+      native_user.Get(attribute)
+    end
+
+    def []=(attribute, value)
+      native_user.Put(attribute, value)
+    end
+
+    def commit
+      begin
+        native_user.SetInfo unless native_user.nil?
+      rescue Exception => e
+        raise Puppet::Error.new( "User update failed: #{e}" )
+      end
+      self
+    end
+
+    def password_is?(password)
+      self.class.logon(name, password)
+    end
+
+    def add_flag(flag_name, value)
+      flag = native_user.Get(flag_name) rescue 0
+
+      native_user.Put(flag_name, flag | value)
+
+      commit
+    end
+
+    def password=(password)
+      native_user.SetPassword(password)
+      commit
+      fADS_UF_DONT_EXPIRE_PASSWD = 0x10000
+      add_flag("UserFlags", fADS_UF_DONT_EXPIRE_PASSWD)
+    end
+
+    def groups
+      # WIN32OLE objects aren't enumerable, so no map
+      groups = []
+      native_user.Groups.each {|g| groups << g.Name} rescue nil
+      groups
+    end
+
+    def add_to_groups(*group_names)
+      group_names.each do |group_name|
+        Puppet::Util::ADSI::Group.new(group_name).add_member(@name)
+      end
+    end
+    alias add_to_group add_to_groups
+
+    def remove_from_groups(*group_names)
+      group_names.each do |group_name|
+        Puppet::Util::ADSI::Group.new(group_name).remove_member(@name)
+      end
+    end
+    alias remove_from_group remove_from_groups
+
+    def set_groups(desired_groups, minimum = true)
+      return if desired_groups.nil? or desired_groups.empty?
+
+      desired_groups = desired_groups.split(',').map(&:strip)
+
+      current_groups = self.groups
+
+      # First we add the user to all the groups it should be in but isn't
+      groups_to_add = desired_groups - current_groups
+      add_to_groups(*groups_to_add)
+
+      # Then we remove the user from all groups it is in but shouldn't be, if
+      # that's been requested
+      groups_to_remove = current_groups - desired_groups
+      remove_from_groups(*groups_to_remove) unless minimum
+    end
+
+    def self.create(name)
+      # Windows error 1379: The specified local group already exists.
+      raise Puppet::Error.new( "Cannot create user if group '#{name}' exists." ) if Puppet::Util::ADSI::Group.exists? name
+      new(name, Puppet::Util::ADSI.create(name, 'user'))
+    end
+
+    def self.exists?(name)
+      Puppet::Util::ADSI::connectable?(User.uri(name))
+    end
+
+    def self.delete(name)
+      Puppet::Util::ADSI.delete(name, 'user')
+    end
+
+    def self.each(&block)
+      wql = Puppet::Util::ADSI.execquery("select * from win32_useraccount")
+
+      users = []
+      wql.each do |u|
+        users << new(u.name, u)
+      end
+
+      users.each(&block)
+    end
+  end
+
+  class UserProfile
+    def self.delete(sid)
+      begin
+        Puppet::Util::ADSI.wmi_connection.Delete("Win32_UserProfile.SID='#{sid}'")
+      rescue => e
+        # http://social.technet.microsoft.com/Forums/en/ITCG/thread/0f190051-ac96-4bf1-a47f-6b864bfacee5
+        # Prior to Vista SP1, there's no builtin way to programmatically
+        # delete user profiles (except for delprof.exe). So try to delete
+        # but warn if we fail
+        raise e unless e.message.include?('80041010')
+
+        Puppet.warning "Cannot delete user profile for '#{sid}' prior to Vista SP1"
+      end
+    end
+  end
+
+  class Group
+    extend Enumerable
+
+    attr_accessor :native_group
+    attr_reader :name
+    def initialize(name, native_group = nil)
+      @name = name
+      @native_group = native_group
+    end
+
+    def uri
+      self.class.uri(name)
+    end
+
+    def self.uri(name)
+      Puppet::Util::ADSI.uri(name, 'group')
+    end
+
+    def native_group
+      @native_group ||= Puppet::Util::ADSI.connect(uri)
+    end
+
+    def commit
+      begin
+        native_group.SetInfo unless native_group.nil?
+      rescue Exception => e
+        raise Puppet::Error.new( "Group update failed: #{e}" )
+      end
+      self
+    end
+
+    def add_members(*names)
+      names.each do |name|
+        native_group.Add(Puppet::Util::ADSI::User.uri(name))
+      end
+    end
+    alias add_member add_members
+
+    def remove_members(*names)
+      names.each do |name|
+        native_group.Remove(Puppet::Util::ADSI::User.uri(name))
+      end
+    end
+    alias remove_member remove_members
+
+    def members
+      # WIN32OLE objects aren't enumerable, so no map
+      members = []
+      native_group.Members.each {|m| members << m.Name}
+      members
+    end
+
+    def set_members(desired_members)
+      return if desired_members.nil? or desired_members.empty?
+
+      current_members = self.members
+
+      # First we add all missing members
+      members_to_add = desired_members - current_members
+      add_members(*members_to_add)
+
+      # Then we remove all extra members
+      members_to_remove = current_members - desired_members
+      remove_members(*members_to_remove)
+    end
+
+    def self.create(name)
+      # Windows error 2224: The account already exists.
+      raise Puppet::Error.new( "Cannot create group if user '#{name}' exists." ) if Puppet::Util::ADSI::User.exists? name
+      new(name, Puppet::Util::ADSI.create(name, 'group'))
+    end
+
+    def self.exists?(name)
+      Puppet::Util::ADSI.connectable?(Group.uri(name))
+    end
+
+    def self.delete(name)
+      Puppet::Util::ADSI.delete(name, 'group')
+    end
+
+    def self.each(&block)
+      wql = Puppet::Util::ADSI.execquery( "select * from win32_group" )
+
+      groups = []
+      wql.each do |g|
+        groups << new(g.name, g)
+      end
+
+      groups.each(&block)
+    end
+  end
+end

data/lib/vendor/puppet/util/autoload/file_cache.rb

@@ -0,0 +1,92 @@
+module Puppet::Util::Autoload::FileCache
+  @found_files = {}
+  @missing_files = {}
+  class << self
+    attr_reader :found_files, :missing_files
+  end
+
+  # Only used for testing.
+  def self.clear
+    @found_files.clear
+    @missing_files.clear
+  end
+
+  def found_files
+    Puppet::Util::Autoload::FileCache.found_files
+  end
+
+  def missing_files
+    Puppet::Util::Autoload::FileCache.missing_files
+  end
+
+  def directory_exist?(path)
+    cache = cached_data?(path, :directory?)
+    return cache unless cache.nil?
+
+    protect(path) do
+      stat = File.lstat(path)
+      if stat.directory?
+        found_file(path, stat)
+        return true
+      else
+        missing_file(path)
+        return false
+      end
+    end
+  end
+
+  def file_exist?(path)
+    cache = cached_data?(path)
+    return cache unless cache.nil?
+
+    protect(path) do
+      stat = File.lstat(path)
+      found_file(path, stat)
+      return true
+    end
+  end
+
+  def found_file?(path, type = nil)
+    if data = found_files[path] and ! data_expired?(data[:time])
+      return(type and ! data[:stat].send(type)) ? false : true
+    else
+      return false
+    end
+  end
+
+  def found_file(path, stat)
+    found_files[path] = {:stat => stat, :time => Time.now}
+  end
+
+  def missing_file?(path)
+    !!(time = missing_files[path] and ! data_expired?(time))
+  end
+
+  def missing_file(path)
+    missing_files[path] = Time.now
+  end
+
+  private
+
+  def cached_data?(path, type = nil)
+    if found_file?(path, type)
+      return true
+    elsif missing_file?(path)
+      return false
+    else
+      return nil
+    end
+  end
+
+  def data_expired?(time)
+    Time.now - time > 15
+  end
+
+  def protect(path)
+      yield
+  rescue => detail
+      raise unless detail.class.to_s.include?("Errno")
+      missing_file(path)
+      return false
+  end
+end

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

@@ -0,0 +1,158 @@
+require 'puppet/util/warnings'
+
+# Autoload paths, either based on names or all at once.
+class Puppet::Util::Autoload
+  require 'puppet/util/autoload/file_cache'
+
+  include Puppet::Util
+  include Puppet::Util::Warnings
+  include Puppet::Util::Autoload::FileCache
+
+  @autoloaders = {}
+  @loaded = []
+
+  class << self
+    attr_reader :autoloaders
+    private :autoloaders
+  end
+
+  # Send [], []=, and :clear to the @autloaders hash
+  Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
+
+  # List all loaded files.
+  def self.list_loaded
+    @loaded.sort { |a,b| a[0] <=> b[0] }.collect do |path, hash|
+      "#{path}: #{hash[:file]}"
+    end
+  end
+
+  # Has a given path been loaded?  This is used for testing whether a
+  # changed file should be loaded or just ignored.  This is only
+  # used in network/client/master, when downloading plugins, to
+  # see if a given plugin is currently loaded and thus should be
+  # reloaded.
+  def self.loaded?(path)
+    path = path.to_s.sub(/\.rb$/, '')
+    @loaded.include?(path)
+  end
+
+  # Save the fact that a given path has been loaded.  This is so
+  # we can load downloaded plugins if they've already been loaded
+  # into memory.
+  def self.loaded(file)
+    $" << file + ".rb" unless $".include?(file)
+    @loaded << file unless @loaded.include?(file)
+  end
+
+  attr_accessor :object, :path, :objwarn, :wrap
+
+  def initialize(obj, path, options = {})
+    @path = path.to_s
+    raise ArgumentError, "Autoload paths cannot be fully qualified" if absolute_path?(@path)
+    @object = obj
+
+    self.class[obj] = self
+
+    options.each do |opt, value|
+      opt = opt.intern if opt.is_a? String
+      begin
+        self.send(opt.to_s + "=", value)
+      rescue NoMethodError
+        raise ArgumentError, "#{opt} is not a valid option"
+      end
+    end
+
+    @wrap = true unless defined?(@wrap)
+  end
+
+  # Load a single plugin by name.  We use 'load' here so we can reload a
+  # given plugin.
+  def load(name,env=nil)
+    path = name.to_s + ".rb"
+
+    searchpath(env).each do |dir|
+      file = File.join(dir, path)
+      next unless file_exist?(file)
+      begin
+        Kernel.load file, @wrap
+        name = name.intern
+        loaded name, file
+        return true
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        puts detail.backtrace if Puppet[:trace]
+        raise Puppet::Error, "Could not autoload #{name}: #{detail}"
+      end
+    end
+    false
+  end
+
+  # Mark the named object as loaded.  Note that this supports unqualified
+  # queries, while we store the result as a qualified query in the class.
+  def loaded(name, file)
+    self.class.loaded(File.join(@path, name.to_s))
+  end
+
+  # Indicate whether the specfied plugin has been loaded.
+  def loaded?(name)
+    self.class.loaded?(File.join(@path, name.to_s))
+  end
+
+  # Load all instances that we can.  This uses require, rather than load,
+  # so that already-loaded files don't get reloaded unnecessarily.
+  def loadall
+    # Load every instance of everything we can find.
+    files_to_load.each do |file|
+      name = File.basename(file).chomp(".rb").intern
+      next if loaded?(name)
+      begin
+        loaded(name, file)
+        Kernel.require file
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        puts detail.backtrace if Puppet[:trace]
+        raise Puppet::Error, "Could not autoload #{file}: #{detail}"
+      end
+    end
+  end
+
+  def files_to_load
+    searchpath.map { |dir| Dir.glob("#{dir}/*.rb") }.flatten
+  end
+
+  # The list of directories to search through for loadable plugins.
+  def searchpath(env=nil)
+    search_directories(env).uniq.collect { |d| File.join(d, @path) }.find_all { |d| FileTest.directory?(d) }
+  end
+
+  def module_directories(env=nil)
+    # We have to require this late in the process because otherwise we might
+    # have load order issues. Since require is much slower than defined?, we
+    # can skip that - and save some 2,155 invocations of require in my real
+    # world testing. --daniel 2012-07-10
+    require 'puppet/node/environment' unless defined?(Puppet::Node::Environment)
+
+    real_env = Puppet::Node::Environment.new(env)
+
+    # We're using a per-thread cache of said module directories, so that
+    # we don't scan the filesystem each time we try to load something with
+    # this autoload instance. But since we don't want to cache for the eternity
+    # this env_module_directories gets reset after the compilation on the master.
+    # This is also reset after an agent ran.
+    # One of the side effect of this change is that this module directories list will be
+    # shared among all autoload that we have running at a time. But that won't be an issue
+    # as by definition those directories are shared by all autoload.
+    Thread.current[:env_module_directories] ||= {}
+    Thread.current[:env_module_directories][real_env] ||= real_env.modulepath.collect do |dir|
+        Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f) }
+      end.flatten.collect { |d| [File.join(d, "plugins"), File.join(d, "lib")] }.flatten.find_all do |d|
+        FileTest.directory?(d)
+      end
+  end
+
+  def search_directories(env=nil)
+    [module_directories(env), Puppet[:libdir].split(File::PATH_SEPARATOR), $LOAD_PATH].flatten
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'find'
+require 'fileutils'
+module Puppet::Util::Backups
+
+  # Deal with backups.
+  def perform_backup(file = nil)
+    # if they specifically don't want a backup, then just say
+    # we're good
+    return true unless self[:backup]
+
+    # let the path be specified
+    file ||= self[:path]
+    return true unless FileTest.exists?(file)
+
+    return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
+  end
+
+  private
+
+  def perform_backup_with_bucket(fileobj)
+    file = (fileobj.class == String) ? fileobj : fileobj.name
+    case File.stat(file).ftype
+    when "directory"
+      # we don't need to backup directories when recurse is on
+      return true if self[:recurse]
+      info "Recursively backing up to filebucket"
+      Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
+    when "file"; backup_file_with_filebucket(file)
+    when "link";
+    end
+    true
+  end
+
+  def perform_backup_with_backuplocal(fileobj, backup)
+    file = (fileobj.class == String) ? fileobj : fileobj.name
+    newfile = file + backup
+
+    remove_backup(newfile)
+
+    begin
+      bfile = file + backup
+
+      # Ruby 1.8.1 requires the 'preserve' addition, but
+      # later versions do not appear to require it.
+      # N.B. cp_r works on both files and directories
+      FileUtils.cp_r(file, bfile, :preserve => true)
+      return true
+    rescue => detail
+      # since they said they want a backup, let's error out
+      # if we couldn't make one
+      self.fail "Could not back #{file} up: #{detail.message}"
+    end
+  end
+
+  def remove_backup(newfile)
+    if self.class.name == :file and self[:links] != :follow
+      method = :lstat
+    else
+      method = :stat
+    end
+
+    begin
+      stat = File.send(method, newfile)
+    rescue Errno::ENOENT
+      return
+    end
+
+    if stat.ftype == "directory"
+      raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
+    end
+
+    info "Removing old backup of type #{stat.ftype}"
+
+    begin
+      File.unlink(newfile)
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      self.fail "Could not remove old backup: #{detail}"
+    end
+  end
+
+  def backup_file_with_filebucket(f)
+    sum = self.bucket.backup(f)
+    self.info "Filebucketed #{f} to #{self.bucket.name} with sum #{sum}"
+    return sum
+    end
+end

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

@@ -0,0 +1,80 @@
+require 'monitor'
+
+module Puppet::Util::Cacher
+  # Our module has been extended in a class; we can only add the Instance methods,
+  # which become *class* methods in the class.
+  def self.extended(other)
+    class << other
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+
+  # Our module has been included in a class, which means the class gets the class methods
+  # and all of its instances get the instance methods.
+  def self.included(other)
+    other.extend(ClassMethods)
+    other.send(:include, InstanceMethods)
+  end
+
+  # Methods that can get added to a class.
+  module ClassMethods
+    # Provide a means of defining an attribute whose value will be cached.
+    # Must provide a block capable of defining the value if it's flushed..
+    def cached_attr(name, ttl, &block)
+      init_method = "init_#{name}"
+      define_method(init_method, &block)
+
+      set_attr_ttl(name, ttl)
+
+      define_method(name) do
+        cached_value(name)
+      end
+
+      define_method(name.to_s + "=") do |value|
+        # Make sure the cache timestamp is set
+        value_cache.synchronize do
+          value_cache[name] = value
+          set_expiration(name)
+        end
+      end
+    end
+
+    def attr_ttl(name)
+      @attr_ttls[name]
+    end
+
+    def set_attr_ttl(name, value)
+      @attr_ttls ||= {}
+      @attr_ttls[name] = Integer(value)
+    end
+  end
+
+  # Methods that get added to instances.
+  module InstanceMethods
+    private
+
+    def cached_value(name)
+      value_cache.synchronize do
+        if value_cache[name].nil? or expired_by_ttl?(name)
+          value_cache[name] = send("init_#{name}")
+          set_expiration(name)
+        end
+        value_cache[name]
+      end
+    end
+
+    def expired_by_ttl?(name)
+      @attr_expirations[name] < Time.now
+    end
+
+    def set_expiration(name)
+      @attr_expirations ||= {}
+      @attr_expirations[name] = Time.now + self.class.attr_ttl(name)
+    end
+
+    def value_cache
+      @value_cache ||= {}.extend(MonitorMixin)
+    end
+  end
+end