puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

data/lib/puppet/reference/type.rb

@@ -77,11 +77,11 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
     }.each { |sname|
       property = type.propertybyname(sname)
 
-      raise "Could not retrieve property #{sname} on type #{type.name}" unless property
+      raise _("Could not retrieve property %{sname} on type %{type_name}") % { sname: sname, type_name: type.name } unless property
 
       doc = nil
       unless doc = property.doc
-        $stderr.puts "No docs for #{type}[#{sname}]"
+        $stderr.puts _("No docs for %{type}[%{sname}]") % { type: type, sname: sname }
         next
       end
       doc = doc.dup

data/lib/puppet/relationship.rb

@@ -8,21 +8,22 @@ class Puppet::Relationship
 
   # FormatSupport for serialization methods
   include Puppet::Network::FormatSupport
+  include Puppet::Util::PsychSupport
 
   attr_accessor :source, :target, :callback
 
   attr_reader :event
 
   def self.from_data_hash(data)
-    source = data["source"]
-    target = data["target"]
+    source = data['source']
+    target = data['target']
 
     args = {}
     if event = data["event"]
-      args[:event] = event
+      args[:event] = :"#{event}"
     end
     if callback = data["callback"]
-      args[:callback] = callback
+      args[:callback] = :"#{callback}"
     end
 
     new(source, target, args)
@@ -76,11 +77,8 @@ class Puppet::Relationship
       'source' => source.to_s,
       'target' => target.to_s
     }
-
-    ["event", "callback"].each do |attr|
-      next unless value = send(attr)
-      data[attr] = value
-    end
+    data['event'] = event.to_s unless event.nil?
+    data['callback'] = callback.to_s unless callback.nil?
     data
   end
 

data/lib/puppet/reports/http.rb

@@ -6,17 +6,19 @@ Puppet::Reports.register_report(:http) do
 
   desc <<-DESC
     Send reports via HTTP or HTTPS. This report processor submits reports as
-    POST requests to the address in the `reporturl` setting. When a HTTPS URL
-    is used, the remote server must present a certificate issued by the Puppet
-    CA or the connection will fail validation. The body of each POST request
-    is the YAML dump of a Puppet::Transaction::Report object, and the
+    POST requests to the address in the `reporturl` setting. The body of each POST
+    request is the YAML dump of a Puppet::Transaction::Report object, and the
     Content-Type is set as `application/x-yaml`.
   DESC
 
   def process
     url = URI.parse(Puppet[:reporturl])
     headers = { "Content-Type" => "application/x-yaml" }
-    options = {}
+    # This metric_id option is silently ignored by Puppet's http client
+    # (Puppet::Network::HTTP) but is used by Puppet Server's http client
+    # (Puppet::Server::HttpClient) to track metrics on the request made to the
+    # `reporturl` to store a report.
+    options = { :metric_id => [:puppet, :report, :http] }
     if url.user && url.password
       options[:basic_auth] = {
         :user => url.user,
@@ -27,7 +29,7 @@ Puppet::Reports.register_report(:http) do
     conn = Puppet::Network::HttpPool.http_instance(url.host, url.port, use_ssl)
     response = conn.post(url.path, self.to_yaml, headers, options)
     unless response.kind_of?(Net::HTTPSuccess)
-      Puppet.err "Unable to submit report to #{Puppet[:reporturl].to_s} [#{response.code}] #{response.msg}"
+      Puppet.err _("Unable to submit report to %{url} [%{code}] %{message}") % { url: Puppet[:reporturl].to_s, code: response.code, message: response.msg }
     end
   end
 end

data/lib/puppet/resource.rb

@@ -8,10 +8,11 @@ require 'puppet/parameter'
 # @api public
 class Puppet::Resource
   include Puppet::Util::Tagging
+  include Puppet::Util::PsychSupport
 
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
-  attr_reader :type, :title
+  attr_reader :type, :title, :parameters, :rich_data_enabled
 
   # @!attribute [rw] sensitive_parameters
   #   @api private
@@ -25,6 +26,9 @@ class Puppet::Resource
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
+  EMPTY_ARRAY = [].freeze
+  EMPTY_HASH = {}.freeze
+
   ATTRIBUTES = [:file, :line, :exported].freeze
   TYPE_CLASS = 'Class'.freeze
   TYPE_NODE  = 'Node'.freeze
@@ -33,146 +37,87 @@ class Puppet::Resource
   PCORE_TYPE_KEY = '__pcore_type__'.freeze
   VALUE_KEY = 'value'.freeze
 
-  def self.from_data_hash(data, rich_data_enabled = false)
-    raise ArgumentError, "No resource type provided in serialized data" unless type = data['type']
-    raise ArgumentError, "No resource title provided in serialized data" unless title = data['title']
+  def self.from_data_hash(data)
+    resource = self.allocate
+    resource.initialize_from_hash(data)
+    resource
+  end
 
-    resource = new(type, title)
+  def initialize_from_hash(data)
+    raise ArgumentError, _('No resource type provided in serialized data') unless type = data['type']
+    raise ArgumentError, _('No resource title provided in serialized data') unless title = data['title']
+    @type, @title = self.class.type_and_title(type, title)
 
     if params = data['parameters']
-      params.each do |param, value|
-        value = convert_rich_data_hash(value, rich_data_enabled) if value.is_a?(Hash) && value.include?(PCORE_TYPE_KEY)
-        resource[param] = value
-      end
+      params = Puppet::Pops::Serialization::FromDataConverter.convert(params)
+      @parameters = {}
+      params.each { |param, value| self[param] = value }
+    else
+      @parameters = EMPTY_HASH
     end
 
-    if sensitive_parameters = data['sensitive_parameters']
-      resource.sensitive_parameters = sensitive_parameters.map(&:to_sym)
+    if sensitives = data['sensitive_parameters']
+      @sensitive_parameters = sensitives.map(&:to_sym)
+    else
+      @sensitive_parameters = EMPTY_ARRAY
     end
 
     if tags = data['tags']
-      tags.each { |tag| resource.tag(tag) }
+      tags.each { |t| tag(t) }
     end
 
     ATTRIBUTES.each do |a|
-      if value = data[a.to_s]
-        resource.send(a.to_s + "=", value)
-      end
+      value = data[a.to_s]
+      send("#{a}=", value) unless value.nil?
     end
-
-    resource
   end
 
-  def self.convert_rich_data_hash(rich_data_hash, rich_data_enabled)
-    if rich_data_enabled
-      value = rich_data_hash[VALUE_KEY]
-      if value.is_a?(Array)
-        json_deserializer ||= Puppet::Pops::Serialization::Deserializer.new(Puppet::Pops::Serialization::JSON::Reader.new([]), nil)
-        reader = json_deserializer.reader
-        reader.re_initialize(value)
-        json_deserializer.read
-      else
-        pcore_type =  Puppet::Pops::Types::TypeParser.singleton.parse(rich_data_hash[PCORE_TYPE_KEY])
-        pcore_type.create(value)
-      end
-    else
-      strict = Puppet[:strict]
-      unless strict == :off
-        msg = _('Unable to deserialize non-Data value for parameter %{param} unless rich data is enabled') % { :param => "#{resource.name}.#{param}" }
-        raise Puppet::Error, msg if strict == :error
-        Puppet.warn(msg)
-      end
-      rich_data_hash
-    end
-  end
-  private_class_method :convert_rich_data_hash
-
   def inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
 
-  def to_data_hash(rich_data_enabled = false)
-    data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
-      next hash unless value = self.send(param)
-      hash[param.to_s] = value
-      hash
+  def to_data_hash
+    data = {
+      'type' => type,
+      'title' => title.to_s,
+      'tags' => tags.to_data_hash
+    }
+    ATTRIBUTES.each do |param|
+      value = send(param)
+      data[param.to_s] = value unless value.nil?
     end
 
-    data["exported"] ||= false
+    data['exported'] ||= false
 
-    ext_params = {}
     params = {}
     self.to_hash.each_pair do |param, value|
       # Don't duplicate the title as the namevar
       unless param == namevar && value == title
-        value = Puppet::Resource.value_to_pson_data(value)
-        if is_json_type?(value)
-          params[param] = value
-        elsif !rich_data_enabled
-          Puppet.warning("Resource '#{to_s}' contains a #{value.class.name} value. It will be converted to the String '#{value}'")
-          params[param] = value
-        else
-          ext_params[param] = value
-        end
+        params[param.to_s] = Puppet::Resource.value_to_json_data(value)
       end
     end
 
-    unless ext_params.empty?
-      tc = Puppet::Pops::Types::TypeCalculator.singleton
-      sc = Puppet::Pops::Types::StringConverter.singleton
-      ext_params.each_pair do |key, value|
-        pcore_type = tc.infer(value)
-
-        # Don't allow unknown runtime types to leak into the catalog
-        raise Puppet::Error, _('No Puppet Type found for %{type_name}') % { :type_name => value.class.name } if pcore_type.is_a?(Puppet::Pops::Types::PRuntimeType)
-
-        if value.is_a?(Hash) || value.is_a?(Array) || value.is_a?(Puppet::Pops::Types::PuppetObject)
-          # Non scalars and Objects are serialized into an array using Pcore
-          json_serializer ||= Puppet::Pops::Serialization::Serializer.new(Puppet::Pops::Serialization::JSON::Writer.new(''), :type_by_reference => true)
-          writer = json_serializer.writer
-          writer.clear_io
-          json_serializer.write(value)
-          writer.finish
-          value = writer.to_a
-        else
-          # Scalar values are stored using their default string representation
-          value = sc.convert(value)
-        end
-        params[key] = {
-          PCORE_TYPE_KEY => pcore_type.name,
-          VALUE_KEY => value
-        }
-      end
+    unless params.empty?
+      data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, {
+        :rich_data => environment.rich_data?,
+        :symbol_as_string => true,
+        :local_reference => false,
+        :type_by_reference => true,
+        :message_prefix => ref,
+        :semantic => self
+      })
     end
 
-    data['parameters'] = params unless params.empty?
-    data["sensitive_parameters"] = sensitive_parameters unless sensitive_parameters.empty?
-
+    data['sensitive_parameters'] = sensitive_parameters.map(&:to_s) unless sensitive_parameters.empty?
     data
   end
 
-  # @param [Object] value The value to test
-  # @return [Boolean] `true` if the value can be represented as JSON
-  # @api private
-  def is_json_type?(value)
-    case value
-    when NilClass, TrueClass, FalseClass, Integer, Float, String
-      true
-    when Array
-      value.all? { |elem| is_json_type?(elem) }
-    when Hash
-      value.all? { |key, val| key.is_a?(String) && is_json_type?(val) }
-    else
-      false
-    end
-  end
-
-  def self.value_to_pson_data(value)
+  def self.value_to_json_data(value)
     if value.is_a?(Array)
-      value.map{|v| value_to_pson_data(v) }
+      value.map{|v| value_to_json_data(v) }
     elsif value.is_a?(Hash)
       result = {}
-      value.each_pair { |k, v| result[value_to_pson_data(k)] = value_to_pson_data(v) }
+      value.each_pair { |k, v| result[value_to_json_data(k)] = value_to_json_data(v) }
       result
     elsif value.is_a?(Puppet::Resource)
       value.to_s
@@ -184,19 +129,7 @@ class Puppet::Resource
   end
 
   def yaml_property_munge(x)
-    self.value.to_pson_data(x)
-  end
-
-  YAML_ATTRIBUTES = [:@file, :@line, :@exported, :@type, :@title, :@tags, :@parameters]
-
-  # Explicitly list the instance variables that should be serialized when
-  # converting to YAML.
-  #
-  # @api private
-  # @return [Array<Symbol>] The intersection of our explicit variable list and
-  #   all of the instance variables defined on this class.
-  def to_yaml_properties
-    YAML_ATTRIBUTES & super
+    self.value.to_json_data(x)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
@@ -285,7 +218,7 @@ class Puppet::Resource
   #   be the full resource name in the form of `"Type[Title]"`.
   #
   # @api public
-  def initialize(type, title = nil, attributes = {})
+  def initialize(type, title = nil, attributes = EMPTY_HASH)
     @parameters = {}
     @sensitive_parameters = []
     if type.is_a?(Puppet::Resource)
@@ -342,6 +275,7 @@ class Puppet::Resource
         # set the type name to the symbolic name
         type = type.name
       end
+      @exported = false
 
       # Set things like strictness first.
       attributes.each do |attr, value|
@@ -450,7 +384,9 @@ class Puppet::Resource
     @environment = environment
   end
 
-  # Produce a simple hash of our parameters.
+  # Produces a hash of attribute to value mappings where the title parsed into its components
+  # acts as the default values overridden by any parameter values explicitly given as parameters.
+  #
   def to_hash
     parse_title.merge parameters
   end
@@ -542,12 +478,12 @@ class Puppet::Resource
   # @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.')
+    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)
-      fail Puppet::DevError, "Cannot evaluate default parameters for #{self} - not a parser resource"
+      fail Puppet::DevError, _("Cannot evaluate default parameters for %{resource} - not a parser resource") % { resource: self }
     end
 
     missing_arguments.collect do |param, default|
@@ -587,13 +523,13 @@ class Puppet::Resource
   # @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.')
+    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|
       param = param.to_sym
-      fail Puppet::ParseError, "Must pass #{param} to #{self}" unless parameters.include?(param)
+      fail Puppet::ParseError, _("Must pass %{param} to %{resource}") % { param: param, resource: self } unless parameters.include?(param)
     end
 
     # Perform optional type checking
@@ -604,16 +540,22 @@ class Puppet::Resource
       unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
         inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
         actual = inferred_type.generalize()
-        fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
+        fail Puppet::ParseError, _("Expected parameter '%{name}' of '%{value0}' to have type %{value1}, got %{value2}") % { name: name, value0: self, value1: t.to_s, value2: actual.to_s }
       end
     end
   end
 
   def validate_parameter(name)
-    raise Puppet::ParseError.new("no parameter named '#{name}'", file, line) unless valid_parameter?(name)
+    raise Puppet::ParseError.new(_("no parameter named '%{name}'") % { name: name }, file, line) unless valid_parameter?(name)
   end
 
-  def prune_parameters(options = {})
+  # This method, together with #file and #line, makes it possible for a Resource to be a 'source_pos' in a reported issue.
+  # @return [Integer] Instances of this class will always return `nil`.
+  def pos
+    nil
+  end
+
+  def prune_parameters(options = EMPTY_HASH)
     properties = resource_type.properties.map(&:name)
 
     dup.collect do |attribute, value|
@@ -686,6 +628,11 @@ class Puppet::Resource
     end
   end
 
+  # Produces a hash with { :key => part_of_title } for each entry in title_patterns
+  # for the resource type. A typical result for a title of 'example' is {:name => 'example'}.
+  # A resource type with a complex title to attribute mapping returns one entry in the hash
+  # per part.
+  #
   def parse_title
     h = {}
     type = resource_type
@@ -714,15 +661,9 @@ class Puppet::Resource
       # If we've gotten this far, then none of the provided title patterns
       # matched. Since there's no way to determine the title then the
       # resource should fail here.
-      raise Puppet::Error, "No set of title patterns matched the title \"#{title}\"."
+      raise Puppet::Error, _("No set of title patterns matched the title \"%{title}\".") % { title: title }
     else
       return { :name => title.to_s }
     end
   end
-
-  def parameters
-    # @parameters could have been loaded from YAML, causing it to be nil (by
-    # bypassing initialize).
-    @parameters ||= {}
-  end
 end

data/lib/puppet/resource/capability_finder.rb

@@ -74,7 +74,7 @@ module Puppet::Resource::CapabilityFinder
             ['=', 'code_id', code_id]]]]
     end
 
-    Puppet.notice "Looking up capability #{cap} in PuppetDB: #{query_terms}"
+    Puppet.notice _("Looking up capability %{cap} in PuppetDB: %{query_terms}") % { cap: cap, query_terms: query_terms }
 
     query_puppetdb(query_terms)
   end

data/lib/puppet/resource/catalog.rb

@@ -82,6 +82,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     tag(*classes)
   end
 
+  # Returns [typename, title] when given a String with "Type[title]".
+  # Returns [nil, nil] if '[' ']' not detected.
+  #
   def title_key_for_ref( ref )
     s = ref.index('[')
     e = ref.rindex(']')
@@ -154,7 +157,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   private :add_resource_to_graph
 
   def create_resource_aliases(resource)
-    # Skip creating aliases and checking collisions for non-isomorphic resources.
+    # Explicit aliases must always be processed
+    # The alias setting logic checks, and does not error if the alias is set to an already set alias
+    # for the same resource (i.e. it is ok if alias == title
+    explicit_aliases = [resource[:alias]].flatten.compact
+    explicit_aliases.each {| given_alias | self.alias(resource, given_alias) }
+
+    # Skip creating uniqueness key alias 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.
@@ -186,7 +195,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       return if existing == resource
       resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
       existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
-      msg = "Cannot alias #{ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
+      #TRANSLATORS "resource" here is a Puppet type and should not be translated
+      msg = _("Cannot alias %{ref} to %{key}%{resource_declaration}; resource %{newref} already declared%{existing_declaration}") % { ref: ref, key: key.inspect, resource_declaration: resource_declaration, newref: newref.inspect, existing_declaration: existing_declaration }
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
@@ -200,13 +210,6 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   #   The report object to log this transaction to. This is optional,
   #   and the resulting transaction will create a report if not
   #   supplied.
-  # @option options [Array[String]] :tags
-  #   Tags used to filter the transaction. If supplied then only
-  #   resources tagged with any of these tags will be evaluated.
-  # @option options [Boolean] :ignoreschedules
-  #   Ignore schedules when evaluating resources
-  # @option options [Boolean] :for_network_device
-  #   Whether this catalog is for a network device
   #
   # @return [Puppet::Transaction] the transaction created for this
   #   application
@@ -360,16 +363,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       # an instance has to be created in order to construct the unique key used when
       # searching for aliases, or when app_management is active and nothing is found in
       # which case it is needed by the CapabilityFinder.
-      res = nil
-      app_mgnt = Puppet[:app_management]
-      if app_mgnt || !@aliases.empty?
-        res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
+      res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
 
-        # No need to build the uniqueness key unless there are aliases
-        result = @resource_table[[type_name, res.uniqueness_key].flatten] unless @aliases.empty?
-      end
+      # Must check with uniqueness key because of aliases or if resource transforms title in title
+      # to attribute mappings.
+      result = @resource_table[[type_name, res.uniqueness_key].flatten]
 
-      if result.nil? && app_mgnt
+      if result.nil?
         resource_type = res.resource_type
         if resource_type && resource_type.is_capability?
           # @todo lutter 2015-03-10: this assumes that it is legal to just
@@ -424,9 +424,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     end
 
     if resources = data['resources']
-      rich_data_enabled = Puppet[:rich_data] || result.environment_instance && result.environment_instance.rich_data?
       result.add_resource(*resources.collect do |res|
-        Puppet::Resource.from_data_hash(res, rich_data_enabled)
+        Puppet::Resource.from_data_hash(res)
       end)
     end
 
@@ -478,27 +477,20 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       h
     end
 
-    resources = if @resources.empty?
-        []
-      elsif environment_instance.rich_data?
-        @resources.collect { |v| @resource_table[v].to_data_hash(true) }
-      else
-        @resources.collect { |v| @resource_table[v].to_data_hash }
-      end
-
     {
-      'tags'      => tags,
+      'tags'      => tags.to_a,
       'name'      => name,
       'version'   => version,
       'code_id'   => code_id,
       'catalog_uuid' => catalog_uuid,
       'catalog_format' => catalog_format,
       'environment'  => environment.to_s,
-      'resources' => resources,
-      'edges'     => edges.   collect { |e| e.to_data_hash },
+      'resources' => @resources.map { |v| @resource_table[v].to_data_hash },
+      'edges'     => edges.map { |e| e.to_data_hash },
       'classes'   => classes,
-    }.merge(metadata_hash.empty? ? {} : {'metadata' => metadata_hash})
-     .merge(recursive_metadata_hash.empty? ? {} : {'recursive_metadata' => recursive_metadata_hash})
+    }.merge(metadata_hash.empty? ?
+      {} : {'metadata' => metadata_hash}).merge(recursive_metadata_hash.empty? ?
+        {} : {'recursive_metadata' => recursive_metadata_hash})
   end
 
   # Convert our catalog into a RAL catalog.
@@ -538,7 +530,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       f.puts classes.join("\n")
     end
   rescue => detail
-    Puppet.err "Could not create class file #{Puppet[:classfile]}: #{detail}"
+    Puppet.err _("Could not create class file %{file}: %{detail}") % { file: Puppet[:classfile], detail: detail }
   end
 
   # Store the list of resources we manage
@@ -558,7 +550,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       f.puts to_print.join("\n")
     end
   rescue => detail
-    Puppet.err "Could not create resource file #{Puppet[:resourcefile]}: #{detail}"
+    Puppet.err _("Could not create resource file %{file}: %{detail}") % { file: Puppet[:resourcefile], detail: detail }
   end
 
   # Produce the graph files if requested.