puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/application/secret_agent.rb

@@ -1,6 +1,9 @@
 require 'puppet/application/face_base'
 require 'puppet/face'
 
+# NOTE: this is using an "old" naming convention (underscores instead of camel-case), for backwards
+#  compatibility with 2.7.x.  When the old naming convention is officially and publicly deprecated,
+#  this should be changed to camel-case.
 class Puppet::Application::Secret_agent < Puppet::Application::FaceBase
   run_mode :agent
 end

data/lib/puppet/configurer.rb

@@ -3,18 +3,20 @@ require 'sync'
 require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
+require 'puppet/util/config_timeout'
 
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
 
+  extend Puppet::Util::ConfigTimeout
   include Puppet::Configurer::FactHandler
   include Puppet::Configurer::PluginHandler
 
   # For benchmarking
   include Puppet::Util
 
-  attr_reader :compile_time
+  attr_reader :compile_time, :environment
 
   # Provide more helpful strings to the logging that the Agent does
   def self.to_s
@@ -22,22 +24,12 @@ class Puppet::Configurer
   end
 
   class << self
-    # Puppetd should only have one instance running, and we need a way
-    # to retrieve it.
+    # Puppet agent should only have one instance running, and we need a
+    # way to retrieve it.
     attr_accessor :instance
     include Puppet::Util
   end
 
-  # How to lock instances of this class.
-  def self.lockfile_path
-    Puppet[:puppetdlockfile]
-  end
-
-  def clear
-    @catalog.clear(true) if @catalog
-    @catalog = nil
-  end
-
   def execute_postrun_command
     execute_from_setting(:postrun_command)
   end
@@ -47,18 +39,17 @@ class Puppet::Configurer
   end
 
   # Initialize and load storage
-  def dostorage
+  def init_storage
       Puppet::Util::Storage.load
       @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
   rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Corrupt state file #{Puppet[:statefile]}: #{detail}"
-      begin
-        ::File.unlink(Puppet[:statefile])
-        retry
-      rescue => detail
-        raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
-      end
+    Puppet.log_exception(detail, "Removing corrupt state file #{Puppet[:statefile]}: #{detail}")
+    begin
+      ::File.unlink(Puppet[:statefile])
+      retry
+    rescue => detail
+      raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
+    end
   end
 
   # Just so we can specify that we are "the" instance.
@@ -68,15 +59,7 @@ class Puppet::Configurer
     self.class.instance = self
     @running = false
     @splayed = false
-  end
-
-  # Prepare for catalog retrieval.  Downloads everything necessary, etc.
-  def prepare(options)
-    dostorage
-
-    download_plugins unless options[:skip_plugin_download]
-
-    download_fact_plugins unless options[:skip_plugin_download]
+    @environment = Puppet[:environment]
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
@@ -106,17 +89,36 @@ class Puppet::Configurer
     catalog
   end
 
-  # Retrieve (optionally) and apply a catalog. If a catalog is passed in
-  # the options, then apply that one, otherwise retrieve it.
-  def retrieve_and_apply_catalog(options, fact_options)
+  def get_facts(options)
+    download_plugins if options[:pluginsync]
+
+    if Puppet::Resource::Catalog.indirection.terminus_class == :rest
+      # This is a bit complicated.  We need the serialized and escaped facts,
+      # and we need to know which format they're encoded in.  Thus, we
+      # get a hash with both of these pieces of information.
+      #
+      # facts_for_uploading may set Puppet[:node_name_value] as a side effect
+      return facts_for_uploading
+    end
+  end
+
+  def prepare_and_retrieve_catalog(options, fact_options)
+    # set report host name now that we have the fact
+    options[:report].host = Puppet[:node_name_value]
+
     unless catalog = (options.delete(:catalog) || retrieve_catalog(fact_options))
       Puppet.err "Could not retrieve catalog; skipping run"
       return
     end
+    catalog
+  end
 
+  # Retrieve (optionally) and apply a catalog. If a catalog is passed in
+  # the options, then apply that one, otherwise retrieve it.
+  def apply_catalog(catalog, options)
     report = options[:report]
     report.configuration_version = catalog.version
-    report.environment = Puppet[:environment]
+    report.environment = @environment
 
     benchmark(:notice, "Finished catalog run") do
       catalog.apply(options)
@@ -132,39 +134,58 @@ class Puppet::Configurer
   def run(options = {})
     options[:report] ||= Puppet::Transaction::Report.new("apply")
     report = options[:report]
+    init_storage
 
     Puppet::Util::Log.newdestination(report)
     begin
-      prepare(options)
+      unless Puppet[:node_name_fact].empty?
+        fact_options = get_facts(options)
+      end
 
-      if Puppet::Resource::Catalog.indirection.terminus_class == :rest
-        # This is a bit complicated.  We need the serialized and escaped facts,
-        # and we need to know which format they're encoded in.  Thus, we
-        # get a hash with both of these pieces of information.
-        fact_options = facts_for_uploading
+      if node = Puppet::Node.indirection.find(Puppet[:node_name_value], :environment => @environment, :ignore_cache => true)
+        if node.environment.to_s != @environment
+          Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified node environment \"#{node.environment}\", switching agent to \"#{node.environment}\"."
+          @environment = node.environment.to_s
+          fact_options = nil
+        end
       end
 
-      # set report host name now that we have the fact
-      report.host = Puppet[:node_name_value]
-
-      begin
-        execute_prerun_command or return nil
-        retrieve_and_apply_catalog(options, fact_options)
-      rescue SystemExit,NoMemoryError
-        raise
-      rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Failed to apply catalog: #{detail}"
+      fact_options = get_facts(options) unless fact_options
+
+      unless catalog = prepare_and_retrieve_catalog(options, fact_options)
         return nil
-      ensure
-        execute_postrun_command or return nil
       end
+
+      # Here we set the local environment based on what we get from the
+      # catalog. Since a change in environment means a change in facts, and
+      # facts may be used to determine which catalog we get, we need to
+      # rerun the process if the environment is changed.
+      tries = 0
+      while catalog.environment and not catalog.environment.empty? and catalog.environment != @environment
+        if tries > 3
+          raise Puppet::Error, "Catalog environment didn't stabilize after #{tries} fetches, aborting run"
+        end
+        Puppet.warning "Local environment: \"#{@environment}\" doesn't match server specified environment \"#{catalog.environment}\", restarting agent run with environment \"#{catalog.environment}\""
+        @environment = catalog.environment
+        return nil unless catalog = prepare_and_retrieve_catalog(options, fact_options)
+        tries += 1
+      end
+
+      execute_prerun_command or return nil
+      apply_catalog(catalog, options)
+      report.exit_status
+    rescue => detail
+      Puppet.log_exception(detail, "Failed to apply catalog: #{detail}")
+      return nil
     ensure
-      # Make sure we forget the retained module_directories of any autoload
-      # we might have used.
-      Thread.current[:env_module_directories] = nil
+      execute_postrun_command or return nil
     end
   ensure
+    # Between Puppet runs we need to forget the cached values.  This lets us
+    # pick up on new functions installed by gems or new modules being added
+    # without the daemon being restarted.
+    Thread.current[:env_module_directories] = nil
+
     Puppet::Util::Log.close(report)
     send_report(report)
   end
@@ -172,10 +193,9 @@ class Puppet::Configurer
   def send_report(report)
     puts report.summary if Puppet[:summarize]
     save_last_run_summary(report)
-    Puppet::Transaction::Report.indirection.save(report) if Puppet[:report]
+    Puppet::Transaction::Report.indirection.save(report, nil, :environment => @environment) if Puppet[:report]
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not send report: #{detail}"
+    Puppet.log_exception(detail, "Could not send report: #{detail}")
   end
 
   def save_last_run_summary(report)
@@ -184,38 +204,19 @@ class Puppet::Configurer
       fh.print YAML.dump(report.raw_summary)
     end
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not save last run local report: #{detail}"
+    Puppet.log_exception(detail, "Could not save last run local report: #{detail}")
   end
 
   private
 
-  def self.timeout
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
-  end
-
   def execute_from_setting(setting)
     return true if (command = Puppet[setting]) == ""
 
     begin
-      Puppet::Util.execute([command])
+      Puppet::Util::Execution.execute([command])
       true
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not run command from #{setting}: #{detail}"
+      Puppet.log_exception(detail, "Could not run command from #{setting}: #{detail}")
       false
     end
   end
@@ -223,27 +224,25 @@ class Puppet::Configurer
   def retrieve_catalog_from_cache(fact_options)
     result = nil
     @duration = thinmark do
-      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_terminus => true))
+      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_terminus => true, :environment => @environment))
     end
     Puppet.notice "Using cached catalog"
     result
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not retrieve catalog from cache: #{detail}"
+    Puppet.log_exception(detail, "Could not retrieve catalog from cache: #{detail}")
     return nil
   end
 
   def retrieve_new_catalog(fact_options)
     result = nil
     @duration = thinmark do
-      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_cache => true))
+      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_cache => true, :environment => @environment))
     end
     result
   rescue SystemExit,NoMemoryError
     raise
   rescue Exception => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not retrieve catalog from remote server: #{detail}"
+    Puppet.log_exception(detail, "Could not retrieve catalog from remote server: #{detail}")
     return nil
   end
 end

data/lib/puppet/configurer/downloader.rb

@@ -1,34 +1,19 @@
 require 'puppet/configurer'
 require 'puppet/resource/catalog'
+require 'puppet/util/config_timeout'
 
 class Puppet::Configurer::Downloader
+  extend Puppet::Util::ConfigTimeout
+  
   attr_reader :name, :path, :source, :ignore
 
-  # Determine the timeout value to use.
-  def self.timeout
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
-  end
-
   # Evaluate our download, returning the list of changed values.
   def evaluate
     Puppet.info "Retrieving #{name}"
 
     files = []
     begin
-      Timeout.timeout(self.class.timeout) do
+      ::Timeout.timeout(self.class.timeout_interval) do
         catalog.apply do |trans|
           trans.changed?.find_all do |resource|
             yield resource if block_given?
@@ -37,21 +22,21 @@ class Puppet::Configurer::Downloader
         end
       end
     rescue Puppet::Error, Timeout::Error => detail
-      puts detail.backtrace if Puppet[:debug]
-      Puppet.err "Could not retrieve #{name}: #{detail}"
+      Puppet.log_exception(detail, "Could not retrieve #{name}: #{detail}")
     end
 
     files
   end
 
-  def initialize(name, path, source, ignore = nil)
-    @name, @path, @source, @ignore = name, path, source, ignore
+  def initialize(name, path, source, ignore = nil, environment = nil)
+    @name, @path, @source, @ignore, @environment = name, path, source, ignore, environment
   end
 
   def catalog
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false
     catalog.add_resource(file)
+    catalog.environment = @environment
     catalog
   end
 

data/lib/puppet/configurer/fact_handler.rb

@@ -1,21 +1,18 @@
 require 'puppet/indirector/facts/facter'
 
+require 'puppet/configurer'
 require 'puppet/configurer/downloader'
 
 # Break out the code related to facts.  This module is
 # just included into the agent, but having it here makes it
 # easier to test.
 module Puppet::Configurer::FactHandler
-  def download_fact_plugins?
-    Puppet[:factsync]
-  end
-
   def find_facts
     # This works because puppet agent configures Facts to use 'facter' for
     # finding facts and the 'rest' terminus for caching them.  Thus, we'll
     # compile them and then "cache" them on the server.
     begin
-      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
+      facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value], :environment => @environment)
       unless Puppet[:node_name_fact].empty?
         Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
         facts.name = Puppet[:node_name_value]
@@ -24,8 +21,9 @@ module Puppet::Configurer::FactHandler
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Could not retrieve local facts: #{detail}"
+      message = "Could not retrieve local facts: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
   end
 
@@ -43,14 +41,4 @@ module Puppet::Configurer::FactHandler
 
     {:facts_format => format, :facts => CGI.escape(text)}
   end
-
-  # Retrieve facts from the central server.
-  def download_fact_plugins
-    return unless download_fact_plugins?
-
-    # Deprecated prior to 0.25, as of 5/19/2008
-    Puppet.warning "Fact syncing is deprecated as of 0.25 -- use 'pluginsync' instead"
-
-    Puppet::Configurer::Downloader.new("fact", Puppet[:factdest], Puppet[:factsource], Puppet[:factsignore]).evaluate
-  end
 end

data/lib/puppet/configurer/plugin_handler.rb

@@ -2,36 +2,17 @@
 # just included into the agent, but having it here makes it
 # easier to test.
 module Puppet::Configurer::PluginHandler
-  def download_plugins?
-    Puppet[:pluginsync]
-  end
-
   # Retrieve facts from the central server.
   def download_plugins
-    return nil unless download_plugins?
     plugin_downloader = Puppet::Configurer::Downloader.new(
       "plugin",
       Puppet[:plugindest],
       Puppet[:pluginsource],
-      Puppet[:pluginsignore]
+      Puppet[:pluginsignore],
+      @environment
     )
 
-    plugin_downloader.evaluate.each { |file| load_plugin(file) }
-  end
-
-  def load_plugin(file)
-    return unless FileTest.exist?(file)
-    return if FileTest.directory?(file)
-
-    begin
-      if file =~ /.rb$/
-        Puppet.info "Loading downloaded plugin #{file}"
-        load file
-      else
-        Puppet.debug "Skipping downloaded plugin #{file}"
-      end
-    rescue Exception => detail
-      Puppet.err "Could not load downloaded file #{file}: #{detail}"
-    end
+    plugin_downloader.evaluate
+    Puppet::Util::Autoload.reload_changed
   end
 end