puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/util/adsi.rb

@@ -45,18 +45,20 @@ module Puppet::Util::ADSI
       "#{computer_uri}/#{resource_name},#{resource_type}"
     end
 
-    def wmi_connection
-      connect(wmi_resource_uri)
-    end
-
     def execquery(query)
-      wmi_connection.execquery(query)
+      connect(wmi_resource_uri).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)
+      sid = nil
+      if name =~ /\\/
+        domain, name = name.split('\\', 2)
+        query = "SELECT Sid from Win32_Account WHERE Name = '#{name}' AND Domain = '#{domain}' AND LocalAccount = true"
+      else
+        query = "SELECT Sid from Win32_Account WHERE Name = '#{name}' AND LocalAccount = true"
+      end
+      execquery(query).each { |u| sid ||= u.Sid }
+      sid
     end
   end
 
@@ -83,7 +85,19 @@ module Puppet::Util::ADSI
     end
 
     def self.logon(name, password)
-      Puppet::Util::Windows::User.password_is?(name, password)
+      fLOGON32_LOGON_NETWORK = 3
+      fLOGON32_PROVIDER_DEFAULT = 0
+
+      logon_user = Win32API.new("advapi32", "LogonUser", ['P', 'P', 'P', 'L', 'L', 'P'], 'L')
+      close_handle = Win32API.new("kernel32", "CloseHandle", ['P'], 'V')
+
+      token = ' ' * 4
+      if logon_user.call(name, "", password, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, token) != 0
+        close_handle.call(token.unpack('L')[0])
+        true
+      else
+        false
+      end
     end
 
     def [](attribute)
@@ -186,22 +200,6 @@ module Puppet::Util::ADSI
     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
 

data/lib/puppet/util/autoload.rb

@@ -1,158 +1,228 @@
+require 'pathname'
+require 'puppet/util/rubygems'
 require 'puppet/util/warnings'
+require 'puppet/util/methodhelper'
 
 # 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
+  include Puppet::Util::MethodHelper
 
   @autoloaders = {}
-  @loaded = []
+  @loaded = {}
 
   class << self
     attr_reader :autoloaders
-    private :autoloaders
-  end
+    attr_accessor :loaded
+    private :autoloaders, :loaded
 
-  # 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]}"
+    def gem_source
+      @gem_source ||= Puppet::Util::RubyGems::Source.new
     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
+    # List all loaded files.
+    def list_loaded
+      loaded.keys.sort { |a,b| a[0] <=> b[0] }.collect do |path, hash|
+        "#{path}: #{hash[:file]}"
+      end
+    end
 
-  def initialize(obj, path, options = {})
-    @path = path.to_s
-    raise ArgumentError, "Autoload paths cannot be fully qualified" if absolute_path?(@path)
-    @object = obj
+    # 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 loaded?(path)
+      path = cleanpath(path).chomp('.rb')
+      loaded.include?(path)
+    end
 
-    self.class[obj] = self
+    # 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 mark_loaded(name, file)
+      name = cleanpath(name).chomp('.rb')
+      ruby_file = name + ".rb"
+      $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
+      loaded[name] = [file, File.mtime(file)]
+    end
 
-    options.each do |opt, value|
-      opt = opt.intern if opt.is_a? String
+    def changed?(name)
+      name = cleanpath(name).chomp('.rb')
+      return true unless loaded.include?(name)
+      file, old_mtime = loaded[name]
+      return true unless file == get_file(name)
       begin
-        self.send(opt.to_s + "=", value)
-      rescue NoMethodError
-        raise ArgumentError, "#{opt} is not a valid option"
+        old_mtime != File.mtime(file)
+      rescue Errno::ENOENT
+        true
       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)
+    # Load a single plugin by name.  We use 'load' here so we can reload a
+    # given plugin.
+    def load_file(name, env=nil)
+      file = get_file(name.to_s, env)
+      return false unless file
       begin
+        mark_loaded(name, file)
         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}"
+        message = "Could not autoload #{name}: #{detail}"
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message
+      end
+    end
+
+    def loadall(path)
+      # Load every instance of everything we can find.
+      files_to_load(path).each do |file|
+        name = file.chomp(".rb")
+        load_file(name) unless loaded?(name)
+      end
+    end
+
+    def reload_changed
+      loaded.keys.each { |file| load_file(file) if changed?(file) }
+    end
+
+    # Get the correct file to load for a given path
+    # returns nil if no file is found
+    def get_file(name, env=nil)
+      name = name + '.rb' unless name =~ /\.rb$/
+      dirname, base = File.split(name)
+      path = search_directories(env).find { |dir| File.exist?(File.join(dir, name)) }
+      path and File.join(path, name)
+    end
+
+    def files_to_load(path)
+      search_directories.map {|dir| files_in_dir(dir, path) }.flatten.uniq
+    end
+
+    def files_in_dir(dir, path)
+      dir = Pathname.new(File.expand_path(dir))
+      Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
+        Pathname.new(file).relative_path_from(dir).to_s
+      end
+    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 module directories so that we don't
+      # scan the filesystem each time we try to load something. This is reset
+      # at the beginning of compilation and at the end of an agent run.
+      Thread.current[:env_module_directories] ||= {}
+
+
+      # This is a little bit of a hack.  Basically, the autoloader is being
+      # called indirectly during application bootstrapping when we do things
+      # such as check "features".  However, during bootstrapping, we haven't
+      # yet parsed all of the command line parameters nor the config files,
+      # and thus we don't yet know with certainty what the module path is.
+      # This should be irrelevant during bootstrapping, because anything that
+      # we are attempting to load during bootstrapping should be something
+      # that we ship with puppet, and thus the module path is irrelevant.
+      #
+      # In the long term, I think the way that we want to handle this is to
+      # have the autoloader ignore the module path in all cases where it is
+      # not specifically requested (e.g., by a constructor param or
+      # something)... because there are very few cases where we should
+      # actually be loading code from the module path.  However, until that
+      # happens, we at least need a way to prevent the autoloader from
+      # attempting to access the module path before it is initialized.  For
+      # now we are accomplishing that by calling the
+      # "app_defaults_initialized?" method on the main puppet Settings object.
+      # --cprice 2012-03-16
+      if Puppet.settings.app_defaults_initialized?
+        # if the app defaults have been initialized then it should be safe to access the module path setting.
+        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, "lib") }.find_all do |d|
+          FileTest.directory?(d)
+        end
+      else
+        # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
+        []
+      end
+    end
+
+    def libdirs()
+      # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
+      # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
+      if (Puppet.settings.app_defaults_initialized?)
+        Puppet[:libdir].split(File::PATH_SEPARATOR)
+      else
+        []
+      end
+    end
+
+    def gem_directories
+      gem_source.directories
+    end
+
+    def search_directories(env=nil)
+      [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
+    end
+
+    # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
+    # and eliminates unnecessary parts of a path.
+    def cleanpath(path)
+      # There are two cases here because cleanpath does not handle absolute
+      # paths correctly on windows (c:\ and c:/ are treated as distinct) but
+      # we don't want to convert relative paths to absolute
+      if Puppet::Util.absolute_path?(path)
+        File.expand_path(path)
+      else
+        Pathname.new(path).cleanpath.to_s
       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))
+  # Send [] and []= to the @autoloaders hash
+  Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
+
+  attr_accessor :object, :path, :objwarn, :wrap
+
+  def initialize(obj, path, options = {})
+    @path = path.to_s
+    raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
+    @object = obj
+
+    self.class[obj] = self
+
+    set_options(options)
+
+    @wrap = true unless defined?(@wrap)
   end
 
-  # Indicate whether the specfied plugin has been loaded.
-  def loaded?(name)
-    self.class.loaded?(File.join(@path, name.to_s))
+  def load(name, env=nil)
+    self.class.load_file(File.join(@path, name.to_s), env)
   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
+    self.class.loadall(@path)
   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) }
+  def loaded?(name)
+    self.class.loaded?(File.join(@path, name.to_s))
   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
+  def changed?(name)
+    self.class.changed?(File.join(@path, name.to_s))
   end
 
-  def search_directories(env=nil)
-    [module_directories(env), Puppet[:libdir].split(File::PATH_SEPARATOR), $LOAD_PATH].flatten
+  def files_to_load
+    self.class.files_to_load(@path)
   end
 end

data/lib/puppet/util/backups.rb

@@ -74,8 +74,9 @@ module Puppet::Util::Backups
     begin
       File.unlink(newfile)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      self.fail "Could not remove old backup: #{detail}"
+      message = "Could not remove old backup: #{detail}"
+      self.log_exception(detail, message)
+      self.fail message
     end
   end
 

data/lib/puppet/util/colors.rb

@@ -82,7 +82,6 @@ module Puppet::Util::Colors
   if Puppet::Util::Platform.windows?
     # We're on windows, need win32console for color to work
     begin
-      require 'rubygems'
       require 'win32console'
     rescue LoadError
       def console_has_color?

data/lib/puppet/util/command_line.rb

@@ -1,23 +1,11 @@
+require 'puppet'
 require "puppet/util/plugins"
+require "puppet/util/rubygems"
 
 module Puppet
   module Util
     class CommandLine
 
-      LegacyName = Hash.new{|h,k| k}.update(
-        'agent'      => 'puppetd',
-        'cert'       => 'puppetca',
-        'doc'        => 'puppetdoc',
-        'filebucket' => 'filebucket',
-        'apply'      => 'puppet',
-        'describe'   => 'pi',
-        'queue'      => 'puppetqd',
-        'resource'   => 'ralsh',
-        'kick'       => 'puppetrun',
-        'master'     => 'puppetmasterd',
-        'device'     => 'puppetdevice'
-      )
-
       def initialize(zero = $0, argv = ARGV, stdin = STDIN)
         @zero  = zero
         @argv  = argv.dup
@@ -35,7 +23,15 @@ module Puppet
       end
 
       def self.available_subcommands
-        absolute_appdirs = $LOAD_PATH.collect do |x|
+        # Eventually we probably want to replace this with a call to the
+        # autoloader.  however, at the moment the autoloader considers the
+        # module path when loading, and we don't want to allow apps / faces to
+        # load from there.  Once that is resolved, this should be replaced.
+        # --cprice 2012-03-06
+        #
+        # But we do want to load from rubygems --hightower
+        search_path = Puppet::Util::RubyGems::Source.new.directories + $LOAD_PATH
+        absolute_appdirs = search_path.uniq.collect do |x|
           File.join(x,'puppet','application')
         end.select{ |x| File.directory?(x) }
         absolute_appdirs.inject([]) do |commands, dir|
@@ -54,24 +50,41 @@ module Puppet
         require File.join(appdir, application)
       end
 
+      # This is the main entry point for all puppet applications / faces; it
+      # is basically where the bootstrapping process / lifecycle of an app
+      # begins.
       def execute
+        # Build up our settings - we don't need that until after version check.
+        Puppet::Util.exit_on_fail("intialize global default settings") do
+          Puppet.settings.initialize_global_settings(args)
+        end
+
+        # OK, now that we've processed the command line options and the config
+        # files, we should be able to say that we definitively know where the
+        # libdir is... which means that we can now look for our available
+        # applications / subcommands / faces.
+
         if subcommand_name and available_subcommands.include?(subcommand_name) then
           require_application subcommand_name
+          # This will need to be cleaned up to do something that is not so
+          #  application-specific (i.e.. so that we can load faces).
+          #  Longer-term, use the autoloader.  See comments in
+          #  #available_subcommands method above.  --cprice 2012-03-06
           app = Puppet::Application.find(subcommand_name).new(self)
-          Puppet::Plugins.on_application_initialization(:appliation_object => self)
-
-          # See the note in 'warn_later' down below. --daniel 2011-06-01
-          if $delayed_deprecation_warning_for_p_u_cl.is_a? String then
-            Puppet.deprecation_warning($delayed_deprecation_warning_for_p_u_cl)
-            $delayed_deprecation_warning_for_p_u_cl = true
-          end
+          Puppet::Plugins.on_application_initialization(:application_object => self)
 
           app.run
         elsif ! execute_external_subcommand then
           unless subcommand_name.nil? then
             puts "Error: Unknown Puppet subcommand '#{subcommand_name}'"
           end
-          puts "See 'puppet help' for help on available puppet subcommands"
+
+          # If the user is just checking the version, print that and exit
+          if @argv.include? "--version" or @argv.include? "-V"
+            puts Puppet.version
+          else
+            puts "See 'puppet help' for help on available puppet subcommands"
+          end
         end
       end
 
@@ -85,10 +98,6 @@ module Puppet
         exec(path_to_subcommand, *args)
       end
 
-      def legacy_executable_name
-        LegacyName[ subcommand_name ]
-      end
-
       private
 
       def subcommand_and_args(zero, argv, stdin)
@@ -96,90 +105,19 @@ module Puppet
 
         if zero == 'puppet'
           case argv.first
-          when nil then
-            if stdin.tty? then
-              [nil, argv]       # ttys get usage info
+            # if they didn't pass a command, or passed a help flag, we will
+            # fall back to showing a usage message.  we no longer default to
+            # 'apply'
+            when nil, "--help", "-h", /^-|\.pp$|\.rb$/
+              [nil, argv]
             else
-              # Killed for 2.7.0 --daniel 2011-06-01
-              warn_later <<EOM
-Implicit invocation of 'puppet apply' by redirection into 'puppet' is deprecated,
-and will be removed in the 2.8 series. Please invoke 'puppet apply' directly
-in the future.
-EOM
-              ["apply", argv]
-            end
-          when "--help", "-h" then
-            # help should give you usage, not the help for `puppet apply`
-            [nil, argv]
-          when /^-|\.pp$|\.rb$/ then
-            # Killed for 2.7.0 --daniel 2011-06-01
-            warn_later <<EOM
-Implicit invocation of 'puppet apply' by passing files (or flags) directly
-to 'puppet' is deprecated, and will be removed in the 2.8 series.  Please
-invoke 'puppet apply' directly in the future.
-EOM
-            ["apply", argv]
-          else
-            [argv.first, argv[1..-1]]
+              [argv.first, argv[1..-1]]
           end
         else
           [zero, argv]
         end
       end
 
-      # So, this is more than a little bit of a horror.  You see, the process
-      # of bootstrapping Puppet is ... complex.  This file, like many of our
-      # early initialization files, has an incestuous relationship between the
-      # order of files loaded, code executed at load time, and code executed
-      # in other files at runtime.
-      #
-      # When we construct this object we have not yet actually loaded the
-      # global puppet object, so we can't use any methods in it.  That
-      # includes all the logging stuff, which is used by the deprecation
-      # warning subsystem.
-      #
-      # On the other hand, we can't just load the logging system, because that
-      # depends on the top level Puppet module being bootstrapped.  It doesn't
-      # actually load the stuff it uses, though, for hysterical raisins.
-      #
-      # Finally, we can't actually just load the top level Puppet module.
-      # This one is precious: it turns out that some of the code loaded in the
-      # top level Puppet module has a dependency on the run mode values.
-      #
-      # Run mode is set correctly *only* when the application is loaded, and
-      # if it is wrong when the top level code is brought in we end up with
-      # the wrong settings scattered through some of the defaults.
-      #
-      # Which means that we have a dependency cycle that runs:
-      # 1. The binary creates an instance of P::U::CL.
-      # 2. That identifies the application to load.
-      # 3. It does, then instantiates the application.
-      #    4. That sets the run-mode.
-      #    5. That then loads the top level Puppet module.
-      # 6. Finally, we get to where we can use the top level stuff
-      #
-      # So, essentially, we see a dependency between runtime code in this
-      # file, run-time code in the application, and load-time code in the top
-      # level module.
-      #
-      # Which leads me to our current horrible hack: we stash away the message
-      # we wanted to log about deprecation, then send it to our logging system
-      # once we have done enough bootstrapping that it will, y'know, actually
-      # work.
-      #
-      # I would have liked to fix this, but that is going to be a whole pile
-      # of work digging through and decrufting all the global state from the
-      # local state, and working out what depends on what else in the product.
-      #
-      # Oh, and we use a global because we have *two* instances of a P::U::CL
-      # object during the startup sequence.  I don't know why.
-      #
-      # Maybe, one day, when I am not behind a deadline to ship code.
-      # --daniel 2011-06-01
-      def warn_later(text)
-        return if $delayed_deprecation_warning_for_p_u_cl
-        $delayed_deprecation_warning_for_p_u_cl = text
-      end
     end
   end
 end