puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet.rb

@@ -7,14 +7,12 @@ rescue LoadError
 end
 
 # see the bottom of the file for further inclusions
-# Also see the new Vendor support - towards the end
-
 require 'singleton'
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
 require 'puppet/util/autoload'
-require 'puppet/util/settings'
+require 'puppet/settings'
 require 'puppet/util/feature'
 require 'puppet/util/suidmanager'
 require 'puppet/util/run_mode'
@@ -28,8 +26,6 @@ require 'puppet/util/run_mode'
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
-  require 'puppet/file_system'
-
   class << self
     include Puppet::Util
     attr_reader :features
@@ -37,7 +33,7 @@ module Puppet
   end
 
   # the hash that determines how our system behaves
-  @@settings = Puppet::Util::Settings.new
+  @@settings = Puppet::Settings.new
 
   # The services running in this process.
   @services ||= []
@@ -53,8 +49,8 @@ module Puppet
   require 'puppet/feature/base'
 
   # Store a new default value.
-  def self.setdefaults(section, hash)
-    @@settings.setdefaults(section, hash)
+  def self.define_settings(section, hash)
+    @@settings.define_settings(section, hash)
   end
 
   # configuration parameter access and stuff
@@ -87,12 +83,19 @@ module Puppet
     @@settings
   end
 
-  def self.run_mode
-    $puppet_application_mode || Puppet::Util::RunMode[:user]
-  end
 
-  def self.application_name
-    $puppet_application_name ||= "apply"
+  def self.run_mode
+    # This sucks (the existence of this method); there are a lot of places in our code that branch based the value of
+    # "run mode", but there used to be some really confusing code paths that made it almost impossible to determine
+    # when during the lifecycle of a puppet application run the value would be set properly.  A lot of the lifecycle
+    # stuff has been cleaned up now, but it still seems frightening that we rely so heavily on this value.
+    #
+    # I'd like to see about getting rid of the concept of "run_mode" entirely, but there are just too many places in
+    # the code that call this method at the moment... so I've settled for isolating it inside of the Settings class
+    # (rather than using a global variable, as we did previously...).  Would be good to revisit this at some point.
+    #
+    # --cprice 2012-03-16
+    Puppet::Util::RunMode[@@settings.run_mode]
   end
 
   # Load all of the configuration parameters.
@@ -106,33 +109,55 @@ module Puppet
   end
 
   # Parse the config file for this process.
-  def self.parse_config
-    Puppet.settings.parse
+  def self.parse_config()
+    Puppet.deprecation_warning("Puppet.parse_config is deprecated; please use Faces API (which will handle settings and state management for you), or (less desirable) call Puppet.initialize_settings")
+    Puppet.initialize_settings
+  end
+
+  # Initialize puppet's settings.  This is intended only for use by external tools that are not
+  #  built off of the Faces API or the Puppet::Util::Application class.  It may also be used
+  #  to initialize state so that a Face may be used programatically, rather than as a stand-alone
+  #  command-line tool.
+  #
+  # Note that this API may be subject to change in the future.
+  def self.initialize_settings()
+    do_initialize_settings_for_run_mode(:user)
   end
 
+  # Initialize puppet's settings for a specified run_mode.  This
+  def self.initialize_settings_for_run_mode(run_mode)
+    Puppet.deprecation_warning("initialize_settings_for_run_mode may be removed in a future release, as may run_mode itself")
+    do_initialize_settings_for_run_mode(run_mode)
+  end
+
+  # private helper method to provide the implementation details of initializing for a run mode,
+  #  but allowing us to control where the deprecation warning is issued
+  def self.do_initialize_settings_for_run_mode(run_mode)
+    Puppet.settings.initialize_global_settings
+    run_mode = Puppet::Util::RunMode[run_mode]
+    Puppet.settings.initialize_app_defaults(Puppet::Settings.app_defaults_for_run_mode(run_mode))
+  end
+  private_class_method :do_initialize_settings_for_run_mode
+
   # Create a new type.  Just proxy to the Type class.  The mirroring query
   # code was deprecated in 2008, but this is still in heavy use.  I suppose
   # this can count as a soft deprecation for the next dev. --daniel 2011-04-12
   def self.newtype(name, options = {}, &block)
     Puppet::Type.newtype(name, options, &block)
   end
-
-  # Load vendored (setup paths, and load what is needed upfront).
-  # See the Vendor class for how to add additional vendored gems/code
-  require "puppet/vendor"
-  Puppet::Vendor.load_vendored
-
-  # Set default for YAML.load to unsafe so we don't affect programs
-  # requiring puppet -- in puppet we will call safe explicitly
-  SafeYAML::OPTIONS[:default_mode] = :unsafe
 end
 
+# This feels weird to me; I would really like for us to get to a state where there is never a "require" statement
+#  anywhere besides the very top of a file.  That would not be possible at the moment without a great deal of
+#  effort, but I think we should strive for it and revisit this at some point.  --cprice 2012-03-16
+
 require 'puppet/type'
 require 'puppet/parser'
 require 'puppet/resource'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
+require 'puppet/data_binding'
 require 'puppet/util/storage'
 require 'puppet/status'
 require 'puppet/file_bucket/file'

data/lib/puppet/agent.rb

@@ -7,7 +7,11 @@ class Puppet::Agent
   require 'puppet/agent/locker'
   include Puppet::Agent::Locker
 
+  require 'puppet/agent/disabler'
+  include Puppet::Agent::Disabler
+
   attr_reader :client_class, :client, :splayed
+  attr_accessor :should_fork
 
   # Just so we can specify that we are "the" instance.
   def initialize(client_class)
@@ -16,36 +20,34 @@ class Puppet::Agent
     @client_class = client_class
   end
 
-  def lockfile_path
-    client_class.lockfile_path
-  end
-
   def needing_restart?
     Puppet::Application.restart_requested?
   end
 
   # Perform a run with our client.
-  def run(*args)
+  def run(client_options = {})
     if running?
       Puppet.notice "Run of #{client_class} already in progress; skipping"
       return
     end
     if disabled?
-      Puppet.notice "Skipping run of #{client_class}; administratively disabled; use 'puppet agent --enable' to re-enable."
+      Puppet.notice "Skipping run of #{client_class}; administratively disabled (Reason: '#{disable_message}');\nUse 'puppet agent --enable' to re-enable."
       return
     end
 
     result = nil
     block_run = Puppet::Application.controlled_run do
       splay
-      with_client do |client|
-        begin
-          sync.synchronize { lock { result = client.run(*args) } }
-        rescue SystemExit,NoMemoryError
-          raise
-        rescue Exception => detail
-          puts detail.backtrace if Puppet[:trace]
-          Puppet.err "Could not run #{client_class}: #{detail}"
+      result = run_in_fork(should_fork) do
+        with_client do |client|
+          begin
+            client_args = client_options.merge(:pluginsync => Puppet[:pluginsync])
+            sync.synchronize { lock { client.run(client_args) } }
+          rescue SystemExit,NoMemoryError
+            raise
+          rescue Exception => detail
+            Puppet.log_exception(detail, "Could not run #{client_class}: #{detail}")
+          end
         end
       end
       true
@@ -78,6 +80,29 @@ class Puppet::Agent
     @sync ||= Sync.new
   end
 
+  def run_in_fork(forking = true)
+    return yield unless forking or Puppet.features.windows?
+
+    child_pid = Kernel.fork do
+      $0 = "puppet agent: applying configuration"
+      begin
+        exit(yield)
+      rescue SystemExit
+        exit(-1)
+      rescue NoMemoryError
+        exit(-2)
+      end
+    end
+    exit_code = Process.waitpid2(child_pid)
+    case exit_code[1].exitstatus
+    when -1
+      raise SystemExit
+    when -2
+      raise NoMemoryError
+    end
+    exit_code[1].exitstatus
+  end
+
   private
 
   # Create and yield a client instance, keeping a reference
@@ -88,8 +113,7 @@ class Puppet::Agent
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not create instance of #{client_class}: #{detail}"
+      Puppet.log_exception(detail, "Could not create instance of #{client_class}: #{detail}")
       return
     end
     yield @client

data/lib/puppet/agent/disabler.rb

@@ -0,0 +1,53 @@
+require 'puppet/util/json_lockfile'
+
+# This module is responsible for encapsulating the logic for
+#  "disabling" the puppet agent during a run; in other words,
+#  keeping track of enough state to answer the question
+#  "has the puppet agent been administratively disabled?"
+#
+# The implementation involves writing a lockfile with JSON
+#  contents, and is considered part of the public Puppet API
+#  because it used by external tools such as mcollective.
+#
+# For more information, please see docs on the website.
+#  http://links.puppetlabs.com/agent_lockfiles
+module Puppet::Agent::Disabler
+  DISABLED_MESSAGE_JSON_KEY = "disabled_message"
+
+  # Let the daemon run again, freely in the filesystem.
+  def enable
+    Puppet.notice "Enabling Puppet."
+    disable_lockfile.unlock
+  end
+
+  # Stop the daemon from making any catalog runs.
+  def disable(msg=nil)
+    data = {}
+    Puppet.notice "Disabling Puppet."
+    if (! msg.nil?)
+      data[DISABLED_MESSAGE_JSON_KEY] = msg
+    end
+    disable_lockfile.lock(data)
+  end
+
+  def disabled?
+    disable_lockfile.locked?
+  end
+
+  def disable_message
+    data = disable_lockfile.lock_data
+    return nil if data.nil?
+    if data.has_key?(DISABLED_MESSAGE_JSON_KEY)
+      return data[DISABLED_MESSAGE_JSON_KEY]
+    end
+    nil
+  end
+
+
+  def disable_lockfile
+    @disable_lockfile ||= Puppet::Util::JsonLockfile.new(Puppet[:agent_disabled_lockfile])
+
+    @disable_lockfile
+  end
+  private :disable_lockfile
+end

data/lib/puppet/agent/locker.rb

@@ -1,20 +1,18 @@
 require 'puppet/util/pidlock'
 
-# Break out the code related to locking the agent.  This module is just
-# included into the agent, but having it here makes it easier to test.
+# This module is responsible for encapsulating the logic for
+#  "locking" the puppet agent during a run; in other words,
+#  keeping track of enough state to answer the question
+#  "is there a puppet agent currently running?"
+#
+# The implementation involves writing a lockfile whose contents
+#  are simply the PID of the running agent process.  This is
+#  considered part of the public Puppet API because it used
+#  by external tools such as mcollective.
+#
+# For more information, please see docs on the website.
+#  http://links.puppetlabs.com/agent_lockfiles
 module Puppet::Agent::Locker
-  # Let the daemon run again, freely in the filesystem.
-  def enable
-    Puppet.notice "Enabling Puppet."
-    lockfile.unlock(:anonymous => true)
-  end
-
-  # Stop the daemon from making any catalog runs.
-  def disable
-    Puppet.notice "Disabling Puppet."
-    lockfile.lock(:anonymous => true)
-  end
-
   # Yield if we get a lock, else do nothing.  Return
   # true/false depending on whether we get the lock.
   def lock
@@ -24,23 +22,19 @@ module Puppet::Agent::Locker
       ensure
         lockfile.unlock
       end
-      return true
-    else
-      return false
     end
   end
 
+  def running?
+    lockfile.locked?
+  end
+
   def lockfile
-    @lockfile ||= Puppet::Util::Pidlock.new(lockfile_path)
+    @lockfile ||= Puppet::Util::Pidlock.new(Puppet[:agent_pidfile])
 
     @lockfile
   end
+  private :lockfile
 
-  def running?
-    lockfile.locked? and !lockfile.anonymous?
-  end
 
-  def disabled?
-    lockfile.locked? and lockfile.anonymous?
-  end
 end

data/lib/puppet/application.rb

@@ -1,5 +1,7 @@
 require 'optparse'
 require 'puppet/util/plugins'
+require 'puppet/util/constant_inflector'
+require 'puppet/error'
 
 # This class handles all the aspects of a Puppet application/executable
 # * setting up options
@@ -121,6 +123,7 @@ class Application
 
   DOCPATTERN = ::File.expand_path(::File.dirname(__FILE__) + "/util/command_line/*" )
 
+
   class << self
     include Puppet::Util
 
@@ -174,17 +177,21 @@ class Application
       result
     end
 
+    SHOULD_PARSE_CONFIG_DEPRECATION_MSG = "is no longer supported; config file parsing " +
+        "is now controlled by the puppet engine, rather than by individual applications.  This " +
+        "method will be removed in a future version of puppet."
+
     def should_parse_config
-      @parse_config = true
+      Puppet.deprecation_warning("should_parse_config " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
     end
 
     def should_not_parse_config
-      @parse_config = false
+      Puppet.deprecation_warning("should_not_parse_config " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
     end
 
     def should_parse_config?
-      @parse_config = true if ! defined?(@parse_config)
-      @parse_config
+      Puppet.deprecation_warning("should_parse_config? " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
+      true
     end
 
     # used to declare code that handle an option
@@ -212,23 +219,57 @@ class Application
       @option_parser_commands
     end
 
-    def find(name)
-      klass = name.to_s.capitalize
-
+    def find(file_name)
+      # This should probably be using the autoloader, but due to concerns about the fact that
+      #  the autoloader currently considers the modulepath when looking for things to load,
+      #  we're delaying that for now.
       begin
-        require ::File.join('puppet', 'application', name.to_s.downcase)
+        require ::File.join('puppet', 'application', file_name.to_s.downcase)
       rescue LoadError => e
-        puts "Unable to find application '#{name}'.  #{e}"
-        Kernel::exit(1)
+        Puppet.log_and_raise(e, "Unable to find application '#{file_name}'.  #{e}")
+      end
+
+      class_name = Puppet::Util::ConstantInflector.file2constant(file_name.to_s)
+
+      clazz = try_load_class(class_name)
+
+      ################################################################
+      #### Begin 2.7.x backward compatibility hack;
+      ####  eventually we need to issue a deprecation warning here,
+      ####  and then get rid of this stanza in a subsequent release.
+      ################################################################
+      if (clazz.nil?)
+        class_name = file_name.capitalize
+        clazz = try_load_class(class_name)
       end
+      ################################################################
+      #### End 2.7.x backward compatibility hack
+      ################################################################
+
+      if clazz.nil?
+        raise Puppet::Error.new("Unable to load application class '#{class_name}' from file 'puppet/application/#{file_name}.rb'")
+      end
+
+      return clazz
+    end
 
-      self.const_get(klass)
+    # Given the fully qualified name of a class, attempt to get the class instance.
+    # @param [String] class_name the fully qualified name of the class to try to load
+    # @return [Class] the Class instance, or nil? if it could not be loaded.
+    def try_load_class(class_name)
+        return self.const_defined?(class_name) ? const_get(class_name) : nil
     end
+    private :try_load_class
 
     def [](name)
       find(name).new
     end
 
+    #
+    # I think that it would be nice to look into changing this into two methods (getter/setter); however,
+    #  it sounds like this is a desirable feature of our ruby DSL. --cprice 2012-03-06
+    #
+
     # Sets or gets the run_mode name. Sets the run_mode name if a mode_name is
     # passed. Otherwise, gets the run_mode or a default run_mode
     #
@@ -243,6 +284,8 @@ class Application
   attr_reader :options, :command_line
 
   # Every app responds to --version
+  # See also `lib/puppet/util/command_line.rb` for some special case early
+  # handling of this.
   option("--version", "-V") do |arg|
     puts "#{Puppet.version}"
     exit
@@ -254,8 +297,14 @@ class Application
     exit
   end
 
-  def should_parse_config?
-    self.class.should_parse_config?
+  def app_defaults()
+    Puppet::Settings.app_defaults_for_run_mode(self.class.run_mode).merge(
+        :name => name
+    )
+  end
+
+  def initialize_app_defaults()
+    Puppet.settings.initialize_app_defaults(app_defaults)
   end
 
   # override to execute code before running anything else
@@ -266,47 +315,31 @@ class Application
 
     require 'puppet/util/command_line'
     @command_line = command_line || Puppet::Util::CommandLine.new
-    set_run_mode self.class.run_mode
     @options = {}
 
-    require 'puppet'
-    require 'puppet/util/instrumentation'
-    Puppet::Util::Instrumentation.init
-  end
-
-  # WARNING: This is a totally scary, frightening, and nasty internal API.  We
-  # strongly advise that you do not use this, and if you insist, we will
-  # politely allow you to keep both pieces of your broken code.
-  #
-  # We plan to provide a supported, long-term API to deliver this in a way
-  # that you can use.  Please make sure that you let us know if you do require
-  # this, and this message is still present in the code. --daniel 2011-02-03
-  def set_run_mode(mode)
-    @run_mode = mode
-    $puppet_application_mode = @run_mode
-    $puppet_application_name = name
-
-    if Puppet.respond_to? :settings
-      # This is to reduce the amount of confusion in rspec
-      # because it might have loaded defaults.rb before the globals were set
-      # and thus have the wrong defaults for the current application
-      Puppet.settings.set_value(:confdir, Puppet.run_mode.conf_dir, :mutable_defaults)
-      Puppet.settings.set_value(:vardir, Puppet.run_mode.var_dir, :mutable_defaults)
-      Puppet.settings.set_value(:name, Puppet.application_name.to_s, :mutable_defaults)
-      Puppet.settings.set_value(:logdir, Puppet.run_mode.logopts, :mutable_defaults)
-      Puppet.settings.set_value(:rundir, Puppet.run_mode.run_dir, :mutable_defaults)
-      Puppet.settings.set_value(:run_mode, Puppet.run_mode.name.to_s, :mutable_defaults)
-    end
   end
 
   # This is the main application entry point
   def run
-    exit_on_fail("initialize")                                   { hook('preinit')       { preinit } }
-    exit_on_fail("parse options")                                { hook('parse_options') { parse_options } }
-    exit_on_fail("parse configuration file")                     { Puppet.settings.parse } if should_parse_config?
-    exit_on_fail("prepare for execution")                        { hook('setup')         { setup } }
+
+    # I don't really like the names of these lifecycle phases.  It would be nice to change them to some more meaningful
+    # names, and make deprecated aliases.  Also, Daniel suggests that we can probably get rid of this "plugin_hook"
+    # pattern, but we need to check with PE and the community first.  --cprice 2012-03-16
+    #
+
+    exit_on_fail("get application-specific default settings") do
+      plugin_hook('initialize_app_defaults') { initialize_app_defaults }
+    end
+
+    require 'puppet'
+    require 'puppet/util/instrumentation'
+    Puppet::Util::Instrumentation.init
+
+    exit_on_fail("initialize")                                   { plugin_hook('preinit')       { preinit } }
+    exit_on_fail("parse application options")                    { plugin_hook('parse_options') { parse_options } }
+    exit_on_fail("prepare for execution")                        { plugin_hook('setup')         { setup } }
     exit_on_fail("configure routes from #{Puppet[:route_file]}") { configure_indirector_routes }
-    exit_on_fail("run")                                          { hook('run_command')   { run_command } }
+    exit_on_fail("run")                                          { plugin_hook('run_command')   { run_command } }
   end
 
   def main
@@ -347,6 +380,12 @@ class Application
     # Create an option parser
     option_parser = OptionParser.new(self.class.banner)
 
+    # He're we're building up all of the options that the application may need to handle.  The main
+    # puppet settings defined in "defaults.rb" have already been parsed once (in command_line.rb) by
+    # the time we get here; however, our app may wish to handle some of them specially, so we need to
+    # make the parser aware of them again.  We might be able to make this a bit more efficient by
+    # re-using the parser object that gets built up in command_line.rb.  --cprice 2012-03-16
+
     # Add all global options to it.
     Puppet.settings.optparse_addargs([]).each do |option|
       option_parser.on(*option) do |arg|
@@ -370,22 +409,11 @@ class Application
     option_parser.parse!(self.command_line.args)
   end
 
-  def handlearg(opt, arg)
-    # rewrite --[no-]option to --no-option if that's what was given
-    if opt =~ /\[no-\]/ and !arg
-      opt = opt.gsub(/\[no-\]/,'no-')
-    end
-    # otherwise remove the [no-] prefix to not confuse everybody
-    opt = opt.gsub(/\[no-\]/, '')
-    unless respond_to?(:handle_unknown) and send(:handle_unknown, opt, arg)
-      # Puppet.settings.handlearg doesn't handle direct true/false :-)
-      if arg.is_a?(FalseClass)
-        arg = "false"
-      elsif arg.is_a?(TrueClass)
-        arg = "true"
-      end
-      Puppet.settings.handlearg(opt, arg)
-    end
+
+
+  def handlearg(opt, val)
+    opt, val = Puppet::Settings.clean_opt(opt, val)
+    send(:handle_unknown, opt, val) if respond_to?(:handle_unknown)
   end
 
   # this is used for testing
@@ -401,21 +429,14 @@ class Application
     "No help available for puppet #{name}"
   end
 
-  private
 
-  def exit_on_fail(message, code = 1)
-    yield
-  rescue ArgumentError, RuntimeError, NotImplementedError => detail
-    puts detail.backtrace if Puppet[:trace]
-    $stderr.puts "Could not #{message}: #{detail}"
-    exit(code)
-  end
 
-  def hook(step,&block)
+  def plugin_hook(step,&block)
     Puppet::Plugins.send("before_application_#{step}",:application_object => self)
     x = yield
     Puppet::Plugins.send("after_application_#{step}",:application_object => self, :return_value => x)
     x
   end
+  private :plugin_hook
 end
 end