puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/resource/catalog.rb

@@ -1,7 +1,6 @@
 require 'puppet/node'
 require 'puppet/indirector'
 require 'puppet/transaction'
-require 'puppet/util/pson'
 require 'puppet/util/tagging'
 require 'puppet/graph'
 
@@ -20,7 +19,6 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   indirects :catalog, :terminus_setting => :catalog_terminus
 
   include Puppet::Util::Tagging
-  extend Puppet::Util::Pson
 
   # The host name this is a catalog for.
   attr_accessor :name
@@ -63,8 +61,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
 
   def title_key_for_ref( ref )
-    ref =~ /^([-\w:]+)\[(.*)\]$/m
-    [$1, $2]
+    s = ref.index('[')
+    e = ref.index(']')
+    if s && e && e > s
+      a = [ref[0, s], ref[s+1, e-s-1]]
+    else
+      a = [nil, nil]
+    end
+    return a
   end
 
   def add_resource(*resources)
@@ -107,8 +111,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   private :add_resource_to_graph
 
   def create_resource_aliases(resource)
-    if resource.respond_to?(:isomorphic?) and resource.isomorphic? and resource.name != resource.title
-      self.alias(resource, resource.uniqueness_key)
+    # Skip creating aliases and checking collisions for non-isomorphic resources.
+    return unless resource.respond_to?(:isomorphic?) and resource.isomorphic?
+
+    # Add an alias if the uniqueness key is valid and not the title, which has already been checked.
+    ukey = resource.uniqueness_key
+    if ukey.any? and ukey != [resource.title]
+      self.alias(resource, ukey)
     end
   end
   private :create_resource_aliases
@@ -168,6 +177,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       transaction.report.as_logging_destination do
         transaction.evaluate
       end
+    rescue Puppet::Error => detail
+      Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
+    rescue => detail
+      Puppet.log_exception(detail, "Got an uncaught exception of type #{detail.class}: #{detail}")
     ensure
       # Don't try to store state unless we're a host config
       # too recursive.
@@ -347,12 +360,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       edges.each do |edge_hash|
         edge = Puppet::Relationship.from_data_hash(edge_hash)
         unless source = result.resource(edge.source)
-          raise ArgumentError, "Could not intern from data: Could not find relationship source #{edge.source.inspect}"
+          raise ArgumentError, "Could not intern from data: Could not find relationship source #{edge.source.inspect} for #{edge.target.to_s}"
         end
         edge.source = source
 
         unless target = result.resource(edge.target)
-          raise ArgumentError, "Could not intern from data: Could not find relationship target #{edge.target.inspect}"
+          raise ArgumentError, "Could not intern from data: Could not find relationship target #{edge.target.inspect} for #{edge.source.to_s}"
         end
         edge.target = target
 
@@ -367,38 +380,18 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     result
   end
 
-  def self.from_pson(data)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(data)
-  end
-
   def to_data_hash
     {
       'tags'      => tags,
       'name'      => name,
       'version'   => version,
       'environment' => environment.to_s,
-      'resources' => @resources.collect { |v| @resource_table[v].to_pson_data_hash },
-      'edges'     => edges.   collect { |e| e.to_pson_data_hash },
+      'resources' => @resources.collect { |v| @resource_table[v].to_data_hash },
+      'edges'     => edges.   collect { |e| e.to_data_hash },
       'classes'   => classes
     }
   end
 
-  PSON.register_document_type('Catalog',self)
-  def to_pson_data_hash
-    {
-      'document_type' => 'Catalog',
-      'data'       => to_data_hash,
-      'metadata' => {
-        'api_version' => 1
-        }
-    }
-  end
-
-  def to_pson(*args)
-    to_pson_data_hash.to_pson(*args)
-  end
-
   # Convert our catalog into a RAL catalog.
   def to_ral
     to_catalog :to_ral

data/lib/puppet/resource/status.rb

@@ -1,40 +1,102 @@
 require 'time'
 require 'puppet/network/format_support'
+require 'puppet/util/psych_support'
 
 module Puppet
   class Resource
+
+    # This class represents the result of evaluating a given resource. It
+    # contains file and line information about the source, events generated
+    # while evaluating the resource, timing information, and the status of the
+    # resource evaluation.
+    #
+    # @api private
     class Status
       include Puppet::Util::Tagging
-      include Puppet::Util::Logging
       include Puppet::Network::FormatSupport
+      include Puppet::Util::PsychSupport
+
+      # @!attribute [rw] file
+      #   @return [String] The file where `@real_resource` was defined.
+      attr_accessor :file
+
+      # @!attribute [rw] line
+      #   @return [Integer] The line number in the file where `@real_resource` was defined.
+      attr_accessor :line
 
-      attr_accessor :resource, :node, :file, :line, :current_values, :status, :evaluation_time
+      # @!attribute [rw] evaluation_time
+      #   @return [Float] The time elapsed in sections while evaluating `@real_resource`.
+      #     measured in seconds.
+      attr_accessor :evaluation_time
 
+      # Boolean status types set while evaluating `@real_resource`.
       STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
       attr_accessor *STATES
 
-      attr_reader :source_description, :containment_path,
-                  :default_log_level, :time, :resource, :change_count,
-                  :out_of_sync_count, :resource_type, :title
-
+      # @!attribute [r] source_description
+      #   @return [String] The textual description of the path to `@real_resource`
+      #     based on the containing structures. This is in contrast to
+      #     `@containment_path` which is a list of containment path components.
+      #   @example
+      #     status.source_description #=> "/Stage[main]/Myclass/Exec[date]"
+      attr_reader :source_description
+
+      # @!attribute [r] containment_path
+      #   @return [Array<String>] A list of resource references that contain
+      #     `@real_resource`.
+      #   @example A normal contained type
+      #     status.containment_path #=> ["Stage[main]", "Myclass", "Exec[date]"]
+      #   @example A whit associated with a class
+      #     status.containment_path #=> ["Whit[Admissible_class[Main]]"]
+      attr_reader :containment_path
+
+      # @!attribute [r] time
+      #   @return [Time] The time that this status object was created
+      attr_reader :time
+
+      # @!attribute [r] resource
+      #   @return [String] The resource reference for `@real_resource`
+      attr_reader :resource
+
+      # @!attribute [r] change_count
+      #   @return [Integer] A count of the successful changes made while
+      #     evaluating `@real_resource`.
+      attr_reader :change_count
+
+      # @!attribute [r] out_of_sync_count
+      #   @return [Integer] A count of the audited changes made while
+      #     evaluating `@real_resource`.
+      attr_reader :out_of_sync_count
+
+      # @!attribute [r] resource_type
+      #   @example
+      #     status.resource_type #=> 'Notify'
+      #   @return [String] The class name of `@real_resource`
+      attr_reader :resource_type
+
+      # @!attribute [r] title
+      #   @return [String] The title of `@real_resource`
+      attr_reader :title
+
+      # @!attribute [r] events
+      #   @return [Array<Puppet::Transaction::Event>] A list of events generated
+      #     while evaluating `@real_resource`.
+      attr_reader :events
+
+      # A list of instance variables that should be serialized with this object
+      # when converted to YAML.
       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
                            @containment_path}.
         map(&:to_sym)
 
-
       def self.from_data_hash(data)
         obj = self.allocate
         obj.initialize_from_hash(data)
         obj
       end
 
-      def self.from_pson(data)
-        Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-        self.from_data_hash(data)
-      end
-
       # Provide a boolean method for each of the states.
       STATES.each do |attr|
         define_method("#{attr}?") do
@@ -61,10 +123,6 @@ module Puppet
         end
       end
 
-      def events
-        @events
-      end
-
       def failed_because(detail)
         @real_resource.log_exception(detail, "Could not evaluate: #{detail}")
         failed = true
@@ -144,12 +202,6 @@ module Puppet
       def to_yaml_properties
         YAML_ATTRIBUTES & super
       end
-
-      private
-
-      def log_source
-        source_description
-      end
     end
   end
 end

data/lib/puppet/resource/type.rb

@@ -1,10 +1,7 @@
 require 'puppet/parser'
 require 'puppet/util/warnings'
 require 'puppet/util/errors'
-require 'puppet/util/inline_docs'
 require 'puppet/parser/ast/leaf'
-require 'puppet/parser/ast/block_expression'
-require 'puppet/dsl'
 
 # Puppet::Resource::Type represents nodes, classes and defined types.
 #
@@ -16,7 +13,6 @@ require 'puppet/dsl'
 # @api public
 class Puppet::Resource::Type
   Puppet::ResourceType = self
-  include Puppet::Util::InlineDocs
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
@@ -30,7 +26,7 @@ class Puppet::Resource::Type
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
-  attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
+  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
   # Map from argument (aka parameter) names to Puppet Type
@@ -68,11 +64,6 @@ class Puppet::Resource::Type
     new(type, name, data)
   end
 
-  def self.from_pson(data)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(data)
-  end
-
   def to_data_hash
     data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
       next hash unless (value = self.send(param)) and (value != "")
@@ -82,10 +73,8 @@ class Puppet::Resource::Type
 
     # External documentation uses "parameters" but the internal name
     # is "arguments"
-    # Dump any arguments as source
-    data['parameters'] = Hash[arguments.map do |k,v|
-                                [k, v.respond_to?(:source_text) ? v.source_text : v]
-                              end]
+    data['parameters'] = arguments.dup unless arguments.empty?
+
     data['name'] = name
 
     unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
@@ -129,8 +118,6 @@ class Puppet::Resource::Type
         code.safeevaluate(scope)
       end
     end
-
-    evaluate_ruby_code(resource, scope) if ruby_code
   end
 
   def initialize(type, name, options = {})
@@ -189,7 +176,6 @@ class Puppet::Resource::Type
     end
 
     self.code = Puppet::Parser::ParserFactory.code_merger.concatenate([self, other])
-#    self.code = self.code.sequence_with(other.code)
   end
 
   # Make an instance of the resource type, and place it in the catalog
@@ -230,8 +216,11 @@ class Puppet::Resource::Type
   end
 
   def name
-    return @name unless @name.is_a?(Regexp)
-    @name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
+    if type == :node && name_is_regex?
+      "__node_regexp__#{@name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')}"
+    else
+      @name
+    end
   end
 
   def name_is_regex?
@@ -249,34 +238,11 @@ class Puppet::Resource::Type
     end
   end
 
-  # MQR TODO:
-  #
-  # The change(s) introduced by the fix for #4270 are mostly silly & should be
-  # removed, though we didn't realize it at the time.  If it can be established/
-  # ensured that nodes never call parent_type and that resource_types are always
-  # (as they should be) members of exactly one resource_type_collection the
-  # following method could / should be replaced with:
-  #
-  # def parent_type
-  #   @parent_type ||= parent && (
-  #     resource_type_collection.find_or_load([name],parent,type.to_sym) ||
-  #     fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
-  #   )
-  # end
-  #
-  # ...and then the rest of the changes around passing in scope reverted.
-  #
   def parent_type(scope = nil)
     return nil unless parent
 
-    unless @parent_type
-      raise "Must pass scope to parent_type when called first time" unless scope
-      unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
-        fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
-      end
-    end
-
-    @parent_type
+    @parent_type ||= scope.environment.known_resource_types.send("find_#{type}", parent) ||
+      fail(Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}")
   end
 
   # Set any arguments passed by the resource as variables in the scope.
@@ -337,13 +303,11 @@ class Puppet::Resource::Type
 
   # Sets the argument name to Puppet Type hash used for type checking.
   # Names must correspond to available arguments (they must be defined first).
-  # Arguments not mentioned will not be type-checked. Only supported when parser == "future"
+  # Arguments not mentioned will not be type-checked.
   #
   def set_argument_types(name_to_type_hash)
     @argument_types = {}
-    # Stop here if not running under future parser, the rest requires pops to be initialized
-    # and that the type system is available
-    return unless Puppet.future_parser? && name_to_type_hash
+    return unless name_to_type_hash
     name_to_type_hash.each do |name, t|
       # catch internal errors
       unless @arguments.include?(name)
@@ -373,10 +337,6 @@ class Puppet::Resource::Type
     parent_scope(resource.scope, klass)
   end
 
-  def evaluate_ruby_code(resource, scope)
-    Puppet::DSL::ResourceAPI.new(resource, scope, ruby_code).evaluate
-  end
-
   # Split an fq name into a namespace and name
   def namesplit(fullname)
     ary = fullname.split("::")

data/lib/puppet/resource/type_collection.rb

@@ -12,7 +12,6 @@ class Puppet::Resource::TypeCollection
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
-    @watched_files.clear
     @notfound.clear
   end
 
@@ -25,8 +24,6 @@ class Puppet::Resource::TypeCollection
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
-
-    @watched_files = Puppet::Util::FileWatcher.new
   end
 
   def import_ast(ast, modname)
@@ -86,9 +83,9 @@ class Puppet::Resource::TypeCollection
       return node
     end
 
-    @node_list.each do |node|
-      next unless node.name_is_regex?
-      return node if node.match(name)
+    @node_list.each do |n|
+      next unless n.name_is_regex?
+      return n if n.match(name)
     end
     nil
   end
@@ -111,16 +108,16 @@ class Puppet::Resource::TypeCollection
     @definitions[munge_name(name)]
   end
 
-  def find_node(namespaces, name)
+  def find_node(name)
     @nodes[munge_name(name)]
   end
 
-  def find_hostclass(namespaces, name, options = {})
-    find_or_load(namespaces, name, :hostclass, options)
+  def find_hostclass(name)
+    find_or_load(name, :hostclass)
   end
 
-  def find_definition(namespaces, name)
-    find_or_load(namespaces, name, :definition)
+  def find_definition(name)
+    find_or_load(name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
@@ -129,12 +126,8 @@ class Puppet::Resource::TypeCollection
     end
   end
 
-  def require_reparse?
-    @parse_failed || stale?
-  end
-
-  def stale?
-    @watched_files.changed?
+  def parse_failed?
+    @parse_failed
   end
 
   def version
@@ -151,71 +144,31 @@ class Puppet::Resource::TypeCollection
     raise Puppet::ParseError, "Execution of config_version command `#{environment.config_version}` failed: #{e.message}", e.backtrace
   end
 
-  def watch_file(filename)
-    @watched_files.watch(filename)
-  end
-
-  def watching_file?(filename)
-    @watched_files.watching?(filename)
-  end
-
   private
 
-  # Return a list of all possible fully-qualified names that might be
-  # meant by the given name, in the context of namespaces.
-  def resolve_namespaces(namespaces, name)
-    name      = name.downcase
-    if name =~ /^::/
-      # name is explicitly fully qualified, so just return it, sans
-      # initial "::".
-      return [name.sub(/^::/, '')]
-    end
-    if name == ""
-      # The name "" has special meaning--it always refers to a "main"
-      # hostclass which contains all toplevel resources.
-      return [""]
-    end
-
-    namespaces = [namespaces] unless namespaces.is_a?(Array)
-    namespaces = namespaces.collect { |ns| ns.downcase }
-
-    result = []
-    namespaces.each do |namespace|
-      ary = namespace.split("::")
-
-      # Search each namespace nesting in innermost-to-outermost order.
-      while ary.length > 0
-        result << "#{ary.join("::")}::#{name}"
-        ary.pop
-      end
-
-      # Finally, search the toplevel namespace.
-      result << name
-    end
-
-    return result.uniq
-  end
+  COLON_COLON = "::".freeze
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
-  def find_or_load(namespaces, name, type, options = {})
-    searchspace = options[:assume_fqname] ? [name].flatten : resolve_namespaces(namespaces, name)
-    searchspace.each do |fqname|
-      result = send(type, fqname)
-      unless result
-        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.
+  def find_or_load(name, type)
+    # Name is always absolute, but may start with :: which must be removed
+    fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
+
+    result = send(type, fqname)
+    unless result
+      if @notfound[ fqname ] && 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.
+        # Check first if debugging is on since the call to debug_once is expensive
+        if Puppet[:debug]
           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?
         end
+      else
+        result = loader.try_load_fqname(type, fqname)
+        @notfound[ fqname ] = result.nil?
       end
-      return result if result
     end
-
-    return nil
+    result
   end
 
   def munge_name(name)