puppet 4.2.3-x86-mingw32 → 4.3.0-x86-mingw32

data/lib/puppet/reference/report.rb

@@ -5,19 +5,16 @@ report = Puppet::Util::Reference.newreference :report, :doc => "All available tr
 end
 
 report.header = "
-Puppet clients can report back to the server after each transaction.  This
-transaction report is sent as a YAML dump of the
-`Puppet::Transaction::Report` class and includes every log message that was
-generated during the transaction along with as many metrics as Puppet knows how
-to collect.  See [Reports and Reporting](http://docs.puppetlabs.com/guides/reporting.html) for more information on how to use reports.
+Puppet can generate a report after applying a catalog. This report includes
+events, log messages, resource statuses, and metrics and metadata about the run.
+Puppet agent sends its report to a Puppet master server, and Puppet apply
+processes its own reports.
 
-Currently, clients default to not sending in reports; you can enable reporting
-by setting the `report` parameter to true.
+Puppet master and Puppet apply will handle every report with a set of report
+processors, configurable with the `reports` setting in puppet.conf. This page
+documents the built-in report processors.
 
-To use a report, set the `reports` parameter on the server; multiple
-reports must be comma-separated.  You can also specify `none` to disable
-reports entirely.
-
-Puppet provides multiple report handlers that will process client reports:
+See [About Reporting](https://docs.puppetlabs.com/puppet/latest/reference/reporting_about.html)
+for more details.
 
 "

data/lib/puppet/reports.rb

@@ -54,7 +54,11 @@ class Puppet::Reports
   def self.register_report(name, options = {}, &block)
     name = name.intern
 
-    mod = genmodule(name, :extend => Puppet::Util::Docs, :hash => instance_hash(:report), :block => block)
+    mod = genmodule(name,
+                    :extend    => Puppet::Util::Docs,
+                    :hash      => instance_hash(:report),
+                    :overwrite => true,
+                    :block     => block)
 
     mod.useyaml = true if options[:useyaml]
 

data/lib/puppet/resource.rb

@@ -11,9 +11,12 @@ class Puppet::Resource
   include Puppet::Util::Tagging
 
   include Enumerable
-  attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
+  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
   attr_reader :type, :title
 
+  # @deprecated
+  attr_accessor :validate_parameters
+
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
@@ -274,6 +277,29 @@ class Puppet::Resource
     catalog ? catalog.resource(to_s) : nil
   end
 
+  # A resource is an application component if it exports or consumes
+  # one or more capabilities, or if it requires a capability resource
+  def is_application_component?
+    return true if ! export.empty? || self[:consume]
+    # Array(self[:require]) does not work for Puppet::Resource instances
+    req = self[:require] || []
+    req = [ req ] unless req.is_a?(Array)
+    req.any? { |r| r.is_capability? }
+  end
+
+  # A resource is a capability (instance) if its underlying type is a
+  # capability type
+  def is_capability?
+    resource_type and resource_type.is_capability?
+  end
+
+  # Returns the value of the 'export' metaparam as an Array
+  # @api private
+  def export
+    v = self[:export] || []
+    v.is_a?(Array) ? v : [ v ]
+  end
+
   # The resource's type implementation
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
@@ -281,8 +307,14 @@ class Puppet::Resource
     @rstype ||= case type
     when "Class"; environment.known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; environment.known_resource_types.node(title)
+    when "Site"; environment.known_resource_types.site(nil)
     else
-      Puppet::Type.type(type) || environment.known_resource_types.definition(type)
+      result = Puppet::Type.type(type)
+      if !result
+        krt = environment.known_resource_types
+        result = krt.definition(type) || krt.application(type)
+      end
+      result
     end
   end
 
@@ -364,7 +396,8 @@ class Puppet::Resource
       "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
 
-    "%s { '%s':\n%s}" % [self.type.to_s.downcase, self.title, attributes]
+    escaped = self.title.gsub(/'/,"\\\\'")
+    "%s { '%s':\n%s}" % [self.type.to_s.downcase, escaped, attributes]
   end
 
   def to_ref
@@ -393,74 +426,11 @@ class Puppet::Resource
   end
   private :missing_arguments
 
-  # Consult external data bindings for class parameter values which must be
-  # namespaced in the backend.
-  #
-  # Example:
-  #
-  #   class foo($port=0){ ... }
-  #
-  # We make a request to the backend for the key 'foo::port' not 'foo'
-  #
-  def lookup_external_default_for(param, scope)
-    # Only lookup parameters for host classes
-    return nil unless resource_type.type == :hostclass
-
-    name = "#{resource_type.name}::#{param}"
-    in_global = lambda { lookup_with_databinding(name, scope) }
-    in_env = lambda { lookup_in_environment(name, scope) }
-    in_module = lambda { lookup_in_module(name, scope) }
-    search(in_global, in_env, in_module)
-  end
-
-  def search(*search_functions)
-    search_functions.each {|f| x = f.call(); return x unless x.nil? }
-    nil
-  end
-
-  private :lookup_external_default_for
-
-  def lookup_with_databinding(name, scope)
-    begin
-      found = false
-      value = catch(:no_such_key) do
-        v = Puppet::DataBinding.indirection.find(
-          name,
-          :environment => scope.environment.to_s,
-          :variables => scope)
-        found = true
-        v
-      end
-      found ? value : nil
-    rescue Puppet::DataBinding::LookupError => e
-      raise Puppet::Error.new("Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e)
-    end
-  end
-  private :lookup_with_databinding
-
-  def lookup_in_environment(name, scope)
-    found = false
-    value = catch(:no_such_key) do
-      v = Puppet::DataProviders.lookup_in_environment(name, scope, nil)
-      found = true
-      v
-    end
-    found ? value : nil
-  end
-  private :lookup_in_environment
-
-  def lookup_in_module(name, scope)
-    found = false
-    value = catch(:no_such_key) do
-      v = Puppet::DataProviders.lookup_in_module(name, scope, nil)
-      found = true
-      v
-    end
-    found ? value : nil
-  end
-  private :lookup_in_module
-
+  # @deprecated Not used by Puppet
+  # @api private
   def set_default_parameters(scope)
+    Puppet.deprecation_warning('The method Puppet::Resource.set_default_parameters is deprecated and will be removed in the next major release of Puppet.')
+
     return [] unless resource_type and resource_type.respond_to?(:arguments)
 
     unless is_a?(Puppet::Parser::Resource)
@@ -468,7 +438,9 @@ class Puppet::Resource
     end
 
     missing_arguments.collect do |param, default|
-      external_value = lookup_external_default_for(param, scope)
+      # Using 'send' since this private method moved from here to type. The caller method is deprecated
+      # and doesn't really motivate making the callee public
+      external_value = resource_type.send(:lookup_external_default_for, param, scope)
 
       if external_value.nil? && default.nil?
         next
@@ -495,7 +467,12 @@ class Puppet::Resource
   # have been provided with defaults.
   # Must be called after 'set_default_parameters'.  We can't join the methods
   # because Type#set_parameters needs specifically ordered behavior.
+  #
+  # @deprecated Not used by Puppet
+  # @api private
   def validate_complete
+    Puppet.deprecation_warning('The method Puppet::Resource.validate_complete is deprecated and will be removed in the next major release of Puppet.')
+
     return unless resource_type and resource_type.respond_to?(:arguments)
 
     resource_type.arguments.each do |param, default|
@@ -510,14 +487,14 @@ class Puppet::Resource
       next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
       unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
         inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
-        actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
+        actual = inferred_type.generalize()
         fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
       end
     end
   end
 
   def validate_parameter(name)
-    raise ArgumentError, "Invalid parameter: '#{name}'" unless valid_parameter?(name)
+    raise Puppet::ParseError.new("no parameter named '#{name}'", file, line) unless valid_parameter?(name)
   end
 
   def prune_parameters(options = {})

data/lib/puppet/resource/capability_finder.rb

@@ -0,0 +1,95 @@
+#
+# A helper module to look a capability up from PuppetDB
+#
+# @todo lutter 2015-03-10: determine whether this should be based on
+# Puppet::Pops::Evaluator::Collectors, or at least use
+# Puppet::Util::Puppetdb::Http
+
+require 'net/http'
+require 'cgi'
+require 'json'
+
+# @api private
+module Puppet::Resource::CapabilityFinder
+
+  # Looks the capability resource from PuppetDB.
+  # @param environment [String] environment name
+  # @param code_id [String,nil] code_id of the catalog
+  # @param cap [Puppet::Type] the capability resource type instance
+  # @return [Puppet::Resource,nil] The found capability resource or `nil` if it could not be found
+  def self.find(environment, code_id, cap)
+    unless Puppet::Util.const_defined?('Puppetdb')
+      raise Puppet::DevError, 'PuppetDB is not available'
+    end
+
+    query_terms = [
+      'and',
+      ['=', 'type', cap.type.capitalize],
+      ['=', 'title', cap.title.to_s],
+      ['=', 'tag', "producer:#{environment}"]
+    ]
+
+    unless code_id.nil?
+      query_terms << ['in', 'certname',
+        ['extract', 'certname',
+          ['select_catalogs',
+            ['=', 'code_id', code_id]]]]
+    end
+    query = query_terms.to_json
+
+    Puppet.notice "Capability lookup #{cap}]: #{query}"
+
+    http = Puppet::Util.const_get('Puppetdb').const_get('Http')
+    response = http.action("/pdb/query/v4/resources?query=#{CGI.escape(query)}") do |conn, uri|
+      conn.get(uri, { 'Accept' => 'application/json'})
+    end
+    json = response.body
+
+    # The format of the response body is documented at
+    #   http://docs.puppetlabs.com/puppetdb/3.0/api/query/v4/resources.html#response-format
+    # In a nutshell, we expect to get an array of resources back. If the
+    # array is empty, the lookup failed and we return +nil+, if it
+    # contains exactly one, we turn that resource back into a Puppet
+    # ::Resource. If the array contains more than one entry, we have a
+    # bug in the overall system, as we allowed multiple capabilities with
+    # the same type and title to be produced in this environment.
+    begin
+      data = JSON.parse(json)
+    rescue JSON::JSONError => e
+      raise Puppet::DevError,
+      "Invalid JSON from PuppetDB when looking up #{cap}\n#{e}\nRaw JSON was:\n#{json}"
+    end
+    unless data.is_a?(Array)
+      raise Puppet::DevError,
+      "Unexpected response from PuppetDB when looking up #{cap}: " +
+        "expected an Array but got #{data.inspect}"
+    end
+    if data.size > 1
+      raise Puppet::DevError,
+      "Unexpected response from PuppetDB when looking up #{cap}:\n" +
+        "expected exactly one resource but got #{data.size};\n" +
+        "returned data is:\n#{data.inspect}"
+    end
+
+    unless data.empty?
+      resource_hash = data.first
+      resource = Puppet::Resource.new(resource_hash['type'],
+                                      resource_hash['title'])
+      real_type = Puppet::Type.type(resource.type)
+      if real_type.nil?
+        fail Puppet::ParseError,
+          "Could not find resource type #{resource.type} returned from PuppetDB"
+      end
+      real_type.parameters.each do |param|
+        param = param.to_s
+        next if param == 'name'
+        if value = resource_hash['parameters'][param]
+          resource[param] = value
+        else
+          Puppet.debug "No capability value for #{resource}->#{param}"
+        end
+      end
+      return resource
+    end
+  end
+end

data/lib/puppet/resource/catalog.rb

@@ -4,6 +4,8 @@ require 'puppet/transaction'
 require 'puppet/util/tagging'
 require 'puppet/graph'
 
+require 'puppet/resource/capability_finder'
+
 # This class models a node catalog.  It is the thing meant to be passed
 # from server to client, and it contains all of the information in the
 # catalog, including the resources and the relationships between them.
@@ -27,6 +29,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # is up to date.
   attr_accessor :version
 
+  # The id of the code input to the compiler.
+  attr_accessor :code_id
+
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
@@ -71,6 +76,25 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     return a
   end
 
+  def add_resource_before(other, *resources)
+    resources.each do |resource|
+      other_title_key = title_key_for_ref(other.ref)
+      idx = @resources.index(other_title_key)
+      raise ArgumentError, "Cannot add resource #{resource.ref} before #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      add_one_resource(resource, idx)
+    end
+  end
+
+  def add_resource_after(other, *resources)
+    resources.each do |resource|
+      other_title_key = title_key_for_ref(other.ref)
+      idx = @resources.index(other_title_key)
+      raise ArgumentError, "Cannot add resource #{resource.ref} after #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      add_one_resource(resource, idx+1)
+    end
+  end
+
+
   def add_resource(*resources)
     resources.each do |resource|
       add_one_resource(resource)
@@ -84,13 +108,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     adjacent(resource, :direction => :in)[0]
   end
 
-  def add_one_resource(resource)
+  def add_one_resource(resource, idx=-1)
     title_key = title_key_for_ref(resource.ref)
     if @resource_table[title_key]
       fail_on_duplicate_type_and_title(resource, title_key)
     end
 
-    add_resource_to_table(resource, title_key)
+    add_resource_to_table(resource, title_key, idx)
     create_resource_aliases(resource)
 
     resource.catalog = self if resource.respond_to?(:catalog=)
@@ -98,9 +122,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
   private :add_one_resource
 
-  def add_resource_to_table(resource, title_key)
+  def add_resource_to_table(resource, title_key, idx)
     @resource_table[title_key] = resource
-    @resources << title_key
+    @resources.insert(idx, title_key)
   end
   private :add_resource_to_table
 
@@ -245,7 +269,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     host_config
   end
 
-  def initialize(name = nil, environment = Puppet::Node::Environment::NONE)
+  def initialize(name = nil, environment = Puppet::Node::Environment::NONE, code_id = nil)
     super()
     @name = name
     @classes = []
@@ -256,6 +280,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     @host_config = true
     @environment_instance = environment
     @environment = environment.to_s
+    @code_id = code_id
 
     @aliases = {}
 
@@ -293,7 +318,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       @resources.delete(title_key)
-      resource.remove
+      # Only Puppet::Type kind of resources respond to :remove, not Puppet::Resource
+      resource.remove if resource.respond_to?(:remove)
     end
   end
 
@@ -313,7 +339,15 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     res.catalog = self
     title_key      = [res.type, res.title.to_s]
     uniqueness_key = [res.type, res.uniqueness_key].flatten
-    @resource_table[title_key] || @resource_table[uniqueness_key]
+    result = @resource_table[title_key] || @resource_table[uniqueness_key]
+    if ! result && res.resource_type && res.resource_type.is_capability?
+      # @todo lutter 2015-03-10: this assumes that it is legal to just
+      # mention a capability resource in code and have it automatically
+      # made available, even if the current component does not require it
+      result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
+      add_resource(result) if result
+    end
+    result
   end
 
   def resource_refs
@@ -341,6 +375,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       result.version = version
     end
 
+    if code_id = data['code_id']
+      result.code_id = code_id
+    end
+
     if environment = data['environment']
       result.environment = environment
       result.environment_instance = Puppet::Node::Environment.remote(environment.to_sym)
@@ -381,6 +419,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       'tags'      => tags,
       'name'      => name,
       'version'   => version,
+      'code_id'   => code_id,
       'environment' => environment.to_s,
       'resources' => @resources.collect { |v| @resource_table[v].to_data_hash },
       'edges'     => edges.   collect { |e| e.to_data_hash },
@@ -496,6 +535,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     result = self.class.new(self.name, self.environment_instance)
 
     result.version = self.version
+    result.code_id = self.code_id
 
     map = {}
     resources.each do |resource|