puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/resource/status.rb

@@ -1,3 +1,5 @@
+require 'time'
+
 module Puppet
   class Resource
     class Status
@@ -9,12 +11,14 @@ module Puppet
       STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
       attr_accessor *STATES
 
-      attr_reader :source_description, :default_log_level, :time, :resource
-      attr_reader :change_count, :out_of_sync_count, :resource_type, :title
+      attr_reader :source_description, :containment_path,
+                  :default_log_level, :time, :resource, :change_count,
+                  :out_of_sync_count, :resource_type, :title
 
       YAML_ATTRIBUTES = %w{@resource @file @line @evaluation_time @change_count
                            @out_of_sync_count @tags @time @events @out_of_sync
-                           @changed @resource_type @title @skipped @failed}.
+                           @changed @resource_type @title @skipped @failed
+                           @containment_path}.
         map(&:to_sym)
 
 
@@ -54,8 +58,20 @@ module Puppet
         @events
       end
 
+      def failed_because(detail)
+        @real_resource.log_exception(detail, "Could not evaluate: #{detail}")
+        failed = true
+        # There's a contract (implicit unfortunately) that a status of failed
+        # will always be accompanied by an event with some explanatory power.  This
+        # is useful for reporting/diagnostics/etc.  So synthesize an event here
+        # with the exception detail as the message.
+        add_event(@real_resource.event(:status => "failure", :message => detail.to_s))
+      end
+
       def initialize(resource)
+        @real_resource = resource
         @source_description = resource.path
+        @containment_path = resource.pathbuilder
         @resource = resource.to_s
         @change_count = 0
         @out_of_sync_count = 0
@@ -78,6 +94,7 @@ module Puppet
         @resource_type = data['resource_type']
         @title = data['title']
         @resource = data['resource']
+        @containment_path = data['containment_path']
         @file = data['file']
         @line = data['line']
         @evaluation_time = data['evaluation_time']
@@ -85,6 +102,7 @@ module Puppet
         @out_of_sync_count = data['out_of_sync_count']
         @tags = data['tags']
         @time = data['time']
+        @time = Time.parse(@time) if @time.is_a? String
         @out_of_sync = data['out_of_sync']
         @changed = data['changed']
         @skipped = data['skipped']
@@ -95,6 +113,27 @@ module Puppet
         end
       end
 
+      def to_pson
+        {
+          'title' => @title,
+          'file' => @file,
+          'line' => @line,
+          'resource' => @resource,
+          'resource_type' => @resource_type,
+          'containment_path' => @containment_path,
+          'evaluation_time' => @evaluation_time,
+          'tags' => @tags,
+          'time' => @time.iso8601(9),
+          'failed' => @failed,
+          'changed' => @changed,
+          'out_of_sync' => @out_of_sync,
+          'skipped' => @skipped,
+          'change_count' => @change_count,
+          'out_of_sync_count' => @out_of_sync_count,
+          'events' => @events,
+        }.to_pson
+      end
+
       def to_yaml_properties
         YAML_ATTRIBUTES & instance_variables
       end

data/lib/puppet/resource/type.rb

@@ -6,6 +6,14 @@ require 'puppet/parser/ast/leaf'
 require 'puppet/parser/ast/block_expression'
 require 'puppet/dsl'
 
+# Puppet::Resource::Type represents nodes, classes and defined types.
+#
+# It has a standard format for external consumption, usable from the
+# resource_type indirection via rest and the resource_type face. See the
+# {file:api_docs/http_resource_type.md#Schema resource type schema
+# description}.
+#
+# @api public
 class Puppet::Resource::Type
   Puppet::ResourceType = self
   include Puppet::Util::InlineDocs
@@ -14,13 +22,7 @@ class Puppet::Resource::Type
 
   RESOURCE_KINDS = [:hostclass, :node, :definition]
 
-  # We have reached a point where we've established some naming conventions
-  #  in our documentation that don't entirely match up with our internal names
-  #  for things.  Ideally we'd change the internal representation to match the
-  #  conventions expressed in our docs, but that would be a fairly far-reaching
-  #  and risky change.  For the time being, we're settling for mapping the
-  #  internal names to the external ones (and vice-versa) during serialization
-  #  and deserialization.  These two hashes is here to help with that mapping.
+  # Map the names used in our documentation to the names used internally
   RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
       :hostclass => "class",
       :node => "node",
@@ -54,41 +56,26 @@ class Puppet::Resource::Type
 
     data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
 
-    # This is a bit of a hack; when we serialize, we use the term "parameters" because that
-    #  is the terminology that we use in our documentation.  However, internally to this
-    #  class we use the term "arguments".  Ideally we'd change the implementation to be consistent
-    #  with the documentation, but that would be challenging right now because it could potentially
-    #  touch a lot of places in the code, not to mention that we already have another meaning for
-    #  "parameters" internally.  So, for now, we will simply transform the internal "arguments"
-    #  value to "parameters" when serializing, and the opposite when deserializing.
-    #     --cprice 2012-04-23
+    # External documentation uses "parameters" but the internal name
+    # is "arguments"
     data[:arguments] = data.delete(:parameters)
 
     new(type, name, data)
   end
 
-  # This method doesn't seem like it has anything to do with PSON in particular, and it shouldn't.
-  #  It's just transforming to a simple object that can be serialized and de-serialized via
-  #  any transport format.  Should probably be renamed if we get a chance to clean up our
-  #  serialization / deserialization, and there are probably many other similar methods in
-  #  other classes.
-  #  --cprice 2012-04-23
+  def to_pson(*args)
+    to_data_hash.to_pson(*args)
+  end
 
-  def to_pson_data_hash
+  def to_data_hash
     data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
       next hash unless (value = self.send(param)) and (value != "")
       hash[param.to_s] = value
       hash
     end
 
-    # This is a bit of a hack; when we serialize, we use the term "parameters" because that
-    #  is the terminology that we use in our documentation.  However, internally to this
-    #  class we use the term "arguments".  Ideally we'd change the implementation to be consistent
-    #  with the documentation, but that would be challenging right now because it could potentially
-    #  touch a lot of places in the code, not to mention that we already have another meaning for
-    #  "parameters" internally.  So, for now, we will simply transform the internal "arguments"
-    #  value to "parameters" when serializing, and the opposite when deserializing.
-    #     --cprice 2012-04-23
+    # External documentation uses "parameters" but the internal name
+    # is "arguments"
     data['parameters'] = arguments.dup unless arguments.empty?
 
     data['name'] = name
@@ -100,19 +87,6 @@ class Puppet::Resource::Type
     data
   end
 
-  # It seems wrong that we have a 'to_pson' method on this class, but not a 'to_yaml'.
-  #  As a result, if you use the REST API to retrieve one or more objects of this type,
-  #  you will receive different data if you use 'Accept: yaml' vs 'Accept: pson'.  That
-  #  seems really, really wrong.  The "Accept" header should never affect what data is
-  #  being returned--only the format of the data.  If the data itself is going to differ,
-  #  then there should be a different request URL.  Documenting the REST API becomes
-  #  a much more complex problem when the "Accept" header can change the semantics
-  #  of the response.  --cprice 2012-04-23
-
-  def to_pson(*args)
-    to_pson_data_hash.to_pson(*args)
-  end
-
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
@@ -134,7 +108,19 @@ class Puppet::Resource::Type
 
     resource.add_edge_to_stage
 
-    code.safeevaluate(scope) if code
+    if code
+      if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
+        begin
+          elevel = scope.ephemeral_level
+          scope.ephemeral_from(@match, file, line)
+          code.safeevaluate(scope)
+        ensure
+          scope.unset_ephemeral_var(elevel)
+        end
+      else
+        code.safeevaluate(scope)
+      end
+    end
 
     evaluate_ruby_code(resource, scope) if ruby_code
   end
@@ -154,6 +140,8 @@ class Puppet::Resource::Type
 
     set_arguments(options[:arguments])
 
+    @match = nil
+
     @module_name = options[:module_name]
   end
 
@@ -162,7 +150,7 @@ class Puppet::Resource::Type
   def match(string)
     return string.to_s.downcase == name unless name_is_regex?
 
-    @name =~ string
+    @match = @name.match(string)
   end
 
   # Add code from a new instance to our code.
@@ -242,7 +230,6 @@ class Puppet::Resource::Type
 
   def assign_parameter_values(parameters, resource)
     return unless parameters
-    scope = resource.scope || {}
 
     # It'd be nice to assign default parameter values here,
     # but we can't because they often rely on local variables

data/lib/puppet/resource/type_collection.rb

@@ -1,9 +1,13 @@
 require 'puppet/parser/type_loader'
+require 'puppet/util/file_watcher'
+require 'puppet/util/warnings'
 
 class Puppet::Resource::TypeCollection
   attr_reader :environment
   attr_accessor :parse_failed
 
+  include Puppet::Util::Warnings
+
   def clear
     @hostclasses.clear
     @definitions.clear
@@ -22,7 +26,7 @@ class Puppet::Resource::TypeCollection
     # So we can keep a list and match the first-defined regex
     @node_list = []
 
-    @watched_files = {}
+    @watched_files = Puppet::Util::FileWatcher.new
   end
 
   def import_ast(ast, modname)
@@ -130,29 +134,29 @@ class Puppet::Resource::TypeCollection
   end
 
   def stale?
-    @watched_files.values.detect { |file| file.changed? }
+    @watched_files.changed?
   end
 
   def version
-    return @version if defined?(@version)
-
-    if environment[:config_version] == ""
-      @version = Time.now.to_i
-      return @version
+    if !defined?(@version)
+      if environment[:config_version] == ""
+        @version = Time.now.to_i
+      else
+        @version = Puppet::Util::Execution.execute([environment[:config_version]]).strip
+      end
     end
 
-    @version = Puppet::Util::Execution.execute([environment[:config_version]]).strip
-
+    @version
   rescue Puppet::ExecutionFailure => e
-    raise Puppet::ParseError, "Unable to set config_version: #{e.message}"
+    raise Puppet::ParseError, "Execution of config_version command `#{environment[:config_version]}` failed: #{e.message}"
   end
 
-  def watch_file(file)
-    @watched_files[file] = Puppet::Util::LoadedFile.new(file)
+  def watch_file(filename)
+    @watched_files.watch(filename)
   end
 
-  def watching_file?(file)
-    @watched_files.include?(file)
+  def watching_file?(filename)
+    @watched_files.watching?(filename)
   end
 
   private
@@ -202,7 +206,7 @@ class Puppet::Resource::TypeCollection
         if @notfound[fqname] and Puppet[:ignoremissingtypes]
           # do not try to autoload if we already tried and it wasn't conclusive
           # as this is a time consuming operation. Warn the user.
-          Puppet.warning "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
+          debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
         else
           result = loader.try_load_fqname(type, fqname)
           @notfound[fqname] = result.nil?

data/lib/puppet/run.rb

@@ -95,6 +95,10 @@ class Puppet::Run
   end
 
   def to_pson
-    @options.merge(:background => @background).to_pson
+    {
+      :options => @options,
+      :background => @background,
+      :status => @status
+    }.to_pson
   end
 end

data/lib/puppet/scheduler/scheduler.rb

@@ -1,38 +1,37 @@
 module Puppet::Scheduler
   class Scheduler
-    def initialize(jobs, timer=Puppet::Scheduler::Timer.new)
+    def initialize(timer=Puppet::Scheduler::Timer.new)
       @timer = timer
-      @jobs = jobs
     end
 
-    def run_loop
-      mark_start_times(@timer.now)
-      while not enabled_jobs.empty?
-        @timer.wait_for(min_interval_to_next_run_from(@timer.now))
-        run_ready(@timer.now)
+    def run_loop(jobs)
+      mark_start_times(jobs, @timer.now)
+      while not enabled(jobs).empty?
+        @timer.wait_for(min_interval_to_next_run_from(jobs, @timer.now))
+        run_ready(jobs, @timer.now)
       end
     end
 
     private
 
-    def enabled_jobs
-      @jobs.select(&:enabled?)
+    def enabled(jobs)
+      jobs.select(&:enabled?)
     end
 
-    def mark_start_times(start_time)
-      @jobs.each do |job|
+    def mark_start_times(jobs, start_time)
+      jobs.each do |job|
         job.start_time = start_time
       end
     end
 
-    def min_interval_to_next_run_from(from_time)
-      enabled_jobs.map do |j|
+    def min_interval_to_next_run_from(jobs, from_time)
+      enabled(jobs).map do |j|
         j.interval_to_next_from(from_time)
       end.min
     end
 
-    def run_ready(at_time)
-      enabled_jobs.each do |j|
+    def run_ready(jobs, at_time)
+      enabled(jobs).each do |j|
         # This check intentionally happens right before each run,
         # instead of filtering on ready schedulers, since one may adjust
         # the readiness of a later one

data/lib/puppet/settings.rb

@@ -1,23 +1,26 @@
 require 'puppet'
 require 'sync'
 require 'getoptlong'
-require 'puppet/util/loadedfile'
+require 'puppet/util/watched_file'
 require 'puppet/util/command_line/puppet_option_parser'
-require 'puppet/settings/errors'
-require 'puppet/settings/string_setting'
-require 'puppet/settings/file_setting'
-require 'puppet/settings/directory_setting'
-require 'puppet/settings/path_setting'
-require 'puppet/settings/boolean_setting'
-require 'puppet/settings/terminus_setting'
-require 'puppet/settings/duration_setting'
-require 'puppet/settings/config_file'
-require 'puppet/settings/value_translator'
 
 # The class for handling configuration files.
 class Puppet::Settings
   include Enumerable
 
+  require 'puppet/settings/errors'
+  require 'puppet/settings/base_setting'
+  require 'puppet/settings/string_setting'
+  require 'puppet/settings/enum_setting'
+  require 'puppet/settings/file_setting'
+  require 'puppet/settings/directory_setting'
+  require 'puppet/settings/path_setting'
+  require 'puppet/settings/boolean_setting'
+  require 'puppet/settings/terminus_setting'
+  require 'puppet/settings/duration_setting'
+  require 'puppet/settings/config_file'
+  require 'puppet/settings/value_translator'
+
   # local reference for convenience
   PuppetOptionParser = Puppet::Util::CommandLine::PuppetOptionParser
 
@@ -156,7 +159,34 @@ class Puppet::Settings
   end
   private :unsafe_clear
 
-  # This is mostly just used for testing.
+  # Clear @cache, @used and the Environment.
+  #
+  # Whenever an object is returned by Settings, a copy is stored in @cache.
+  # As long as Setting attributes that determine the content of returned
+  # objects remain unchanged, Settings can keep returning objects from @cache
+  # without re-fetching or re-generating them.
+  #
+  # Whenever a Settings attribute changes, such as @values or @preferred_run_mode,
+  # this method must be called to clear out the caches so that updated
+  # objects will be returned.
+  def flush_cache
+    @sync.synchronize do
+      unsafe_flush_cache
+    end
+  end
+
+  def unsafe_flush_cache
+    clearused
+
+    # Clear the list of environments, because they cache, at least, the module path.
+    # We *could* preferentially just clear them if the modulepath is changed,
+    # but we don't really know if, say, the vardir is changed and the modulepath
+    # is defined relative to it. We need the defined?(stuff) because of loading
+    # order issues.
+    Puppet::Node::Environment.clear if defined?(Puppet::Node) and defined?(Puppet::Node::Environment)
+  end
+  private :unsafe_flush_cache
+
   def clearused
     @cache.clear
     @used = []
@@ -222,7 +252,7 @@ class Puppet::Settings
   # "no-" prefix on flag/boolean options).
   #
   # @param [String] opt the command line option that we are munging
-  # @param [String, TrueClass, FalseClass] the value for the setting (as determined by the OptionParser)
+  # @param [String, TrueClass, FalseClass] val the value for the setting (as determined by the OptionParser)
   def self.clean_opt(opt, val)
     # rewrite --[no-]option to --no-option if that's what was given
     if opt =~ /\[no-\]/ and !val
@@ -455,6 +485,10 @@ class Puppet::Settings
     mode = mode.to_s.downcase.intern
     raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
     @preferred_run_mode_name = mode
+    # Changing the run mode has far-reaching consequences. Flush any cached
+    # settings so they will be re-generated.
+    flush_cache
+    mode
   end
 
   # Return all of the parameters associated with a given section.
@@ -506,7 +540,7 @@ class Puppet::Settings
   def config_file_name
     begin
       return self[:config_file_name] if self[:config_file_name]
-    rescue SettingsError => err
+    rescue SettingsError
       # This just means that the setting wasn't explicitly set on the command line, so we will ignore it and
       #  fall through to the default name.
     end
@@ -562,7 +596,7 @@ class Puppet::Settings
     # Call any hooks we should be calling.
     settings_with_hooks.each do |setting|
       each_source(env) do |source|
-        if value = @values[source][setting.name]
+        if @values[source][setting.name]
           # We still have to use value to retrieve the value, since
           # we want the fully interpolated value, not $vardir/lib or whatever.
           # This results in extra work, but so few of the settings
@@ -593,6 +627,17 @@ class Puppet::Settings
   end
   private :apply_metadata
 
+  SETTING_TYPES = {
+      :string     => StringSetting,
+      :file       => FileSetting,
+      :directory  => DirectorySetting,
+      :path       => PathSetting,
+      :boolean    => BooleanSetting,
+      :terminus   => TerminusSetting,
+      :duration   => DurationSetting,
+      :enum       => EnumSetting,
+  }
+
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
   # a default or a value, so we can't actually assign it.
@@ -603,15 +648,7 @@ class Puppet::Settings
     hash[:section] = hash[:section].to_sym if hash[:section]
 
     if type = hash[:type]
-      unless klass = {
-          :string     => StringSetting,
-          :file       => FileSetting,
-          :directory  => DirectorySetting,
-          :path       => PathSetting,
-          :boolean    => BooleanSetting,
-          :terminus   => TerminusSetting,
-          :duration   => DurationSetting,
-      } [type]
+      unless klass = SETTING_TYPES[type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
       hash.delete(:type)
@@ -656,7 +693,7 @@ class Puppet::Settings
     @files = []
     [main_config_file, user_config_file].each do |path|
       if FileTest.exist?(path)
-        @files << Puppet::Util::LoadedFile.new(path)
+        @files << Puppet::Util::WatchedFile.new(path)
       end
     end
     @files
@@ -664,10 +701,11 @@ class Puppet::Settings
   private :files
 
   # Checks to see if any of the config files have been modified
-  # @return the filename of the first file that is found to have changed, or nil if no files have changed
+  # @return the filename of the first file that is found to have changed, or
+  #   nil if no files have changed
   def any_files_changed?
     files.each do |file|
-      return file.file if file.changed?
+      return file.to_str if file.changed?
     end
     nil
   end
@@ -753,16 +791,8 @@ class Puppet::Settings
     @sync.synchronize do # yay, thread-safe
 
       @values[type][param] = value
-      @cache.clear
-
-      clearused
+      unsafe_flush_cache
 
-      # Clear the list of environments, because they cache, at least, the module path.
-      # We *could* preferentially just clear them if the modulepath is changed,
-      # but we don't really know if, say, the vardir is changed and the modulepath
-      # is defined relative to it. We need the defined?(stuff) because of loading
-      # order issues.
-      Puppet::Node::Environment.clear if defined?(Puppet::Node) and defined?(Puppet::Node::Environment)
     end
 
     value
@@ -952,8 +982,15 @@ Generated on #{Time.now}.
   end
   private :find_value
 
-  # Find the correct value using our search path.  Optionally accept an environment
-  # in which to search before the other configuration sections.
+  # Find the correct value using our search path.
+  #
+  # @param param [String, Symbol] The value to look up
+  # @param environment [String, Symbol] The environment to check for the value
+  # @param bypass_interpolation [true, false] Whether to skip interpolation
+  #
+  # @return [Object] The looked up value
+  #
+  # @raise [InterpolationError]
   def value(param, environment = nil, bypass_interpolation = false)
     param = param.to_sym
     environment &&= environment.to_sym
@@ -969,8 +1006,8 @@ Generated on #{Time.now}.
     # Check the cache first.  It needs to be a per-environment
     # cache so that we don't spread values from one env
     # to another.
-    if cached = @cache[environment||"none"][param]
-      return cached
+    if @cache[environment||"none"].has_key?(param)
+      return @cache[environment||"none"][param]
     end
 
     val = uninterpolated_value(param, environment)
@@ -1183,7 +1220,7 @@ Generated on #{Time.now}.
     #
     begin
       return true if self[:config]
-    rescue InterpolationError => err
+    rescue InterpolationError
       # This means we failed to interpolate, which means that they didn't
       #  explicitly specify either :config or :confdir... so we'll fall out to
       #  the default value.