puppet 4.10.0 → 5.0.0

data/lib/puppet/provider/user/ldap.rb

@@ -46,7 +46,7 @@ Puppet::Type.type(:user).provide :ldap, :parent => Puppet::Provider::Ldap do
 
   # Convert our gid to a group name, if necessary.
   def gid=(value)
-    value = group2id(value) unless [Fixnum, Bignum].include?(value.class)
+    value = group2id(value) unless value.is_a?(Integer)
 
     @property_hash[:gid] = value
   end

data/lib/puppet/provider/user/useradd.rb

@@ -203,7 +203,7 @@ Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameServ
   [:expiry, :password_min_age, :password_max_age, :password].each do |shadow_property|
     define_method(shadow_property) do
       if Puppet.features.libshadow?
-        if ent = Shadow::Passwd.getspnam(@resource.name)
+        if ent = Shadow::Passwd.getspnam(@canonical_name)
           method = self.class.option(shadow_property, :method)
           return unmunge(shadow_property, ent.send(method))
         end

data/lib/puppet/provider/yumrepo/inifile.rb

@@ -181,7 +181,7 @@ Puppet::Type.type(:yumrepo).provide(:inifile) do
   # Save all yum repository files and force the mode to 0644
   # @api private
   # @return [void]
-  def self.store
+  def self.store(resource)
     inifile = self.virtual_inifile
     inifile.store
 
@@ -189,7 +189,7 @@ Puppet::Type.type(:yumrepo).provide(:inifile) do
     inifile.each_file do |file|
       current_mode = Puppet::FileSystem.stat(file).mode & 0777
       unless current_mode == target_mode
-        Puppet.info "changing mode of #{file} from %03o to %03o" % [current_mode, target_mode]
+        resource.info "changing mode of #{file} from %03o to %03o" % [current_mode, target_mode]
         Puppet::FileSystem.chmod(target_mode, file)
       end
     end
@@ -245,7 +245,7 @@ Puppet::Type.type(:yumrepo).provide(:inifile) do
   # @api public
   # @return [void]
   def flush
-    self.class.store
+    self.class.store(self)
   end
 
   # Generate setters and getters for our INI properties.

data/lib/puppet/provider.rb

@@ -119,11 +119,13 @@ class Puppet::Provider
 
   # Convenience methods - see class method with the same name.
   # @return (see self.execfail)
+  # @deprecated
   def execfail(*args)
     Puppet::Util::Execution.execfail(*args)
   end
 
   # (see Puppet::Util::Execution.execfail)
+  # @deprecated
   def self.execfail(*args)
     Puppet::Util::Execution.execfail(*args)
   end

data/lib/puppet/reference/configuration.rb

@@ -32,7 +32,7 @@ config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc
       val = 'Unix/Linux: /var/run/puppetlabs -- Windows: C:\ProgramData\PuppetLabs\puppet\var\run -- Non-root user: ~/.puppetlabs/var/run'
     elsif name.to_s == 'logdir'
       val = 'Unix/Linux: /var/log/puppetlabs/puppet -- Windows: C:\ProgramData\PuppetLabs\puppet\var\log -- Non-root user: ~/.puppetlabs/var/log'
-    elsif name.to_s == 'hiera.yaml'
+    elsif name.to_s == 'hiera_config'
       val = '$confdir/hiera.yaml. However, if a file exists at $codedir/hiera.yaml, Puppet uses that instead.'
     end
 

data/lib/puppet/reference/indirection.rb

@@ -19,7 +19,7 @@ reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirect
         terminus_doc = Puppet::Util::Docs.scrub(term_class.doc)
         text << markdown_header("`#{terminus_name}` terminus", 3) << terminus_doc << "\n\n"
       else
-        Puppet.warning "Could not build docs for indirector #{name.inspect}, terminus #{terminus_name.inspect}: could not locate terminus."
+        Puppet.warning _("Could not build docs for indirector %{name}, terminus %{terminus}: could not locate terminus.") % { name: name.inspect, terminus: terminus_name.inspect }
       end
     end
   end

data/lib/puppet/reference/metaparameter.rb

@@ -27,7 +27,7 @@ etc.), prevent Puppet from making changes (`noop`), and change logging verbosity
       str << "\n\n"
     }
   rescue => detail
-    Puppet.log_exception(detail, "incorrect metaparams: #{detail}")
+    Puppet.log_exception(detail, _("incorrect metaparams: %{detail}") % { detail: detail })
     exit(1)
   end
 

data/lib/puppet/reference/providers.rb

@@ -56,21 +56,21 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
         missing.each do |test, values|
           case test
           when :exists
-            details << "  - Missing files #{values.join(", ")}\n"
+            details << _("  - Missing files %{files}\n") % { files: values.join(", ") }
           when :variable
             values.each do |name, facts|
               if Puppet.settings.valid?(name)
-                details << "  - Setting #{name} (currently #{Puppet.settings.value(name).inspect}) not in list #{facts.join(", ")}\n"
+                details << _("  - Setting %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Puppet.settings.value(name).inspect, facts: facts.join(", ") }
               else
-                details << "  - Fact #{name} (currently #{Facter.value(name).inspect}) not in list #{facts.join(", ")}\n"
+                details << _("  - Fact %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Facter.value(name).inspect, facts: facts.join(", ") }
               end
             end
           when :true
-            details << "  - Got #{values} true tests that should have been false\n"
+            details << _("  - Got %{values} true tests that should have been false\n") % { values: values }
           when :false
-            details << "  - Got #{values} false tests that should have been true\n"
+            details << _("  - Got %{values} false tests that should have been true\n") % { values: values }
           when :feature
-            details << "  - Missing features #{values.collect { |f| f.to_s }.join(",")}\n"
+            details << _("  - Missing features %{values}\n") % { values: values.collect { |f| f.to_s }.join(",") }
           end
         end
         notes << details

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

@@ -14,7 +14,11 @@ Puppet::Reports.register_report(:http) do
   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,
@@ -25,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/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
@@ -87,7 +87,7 @@ module Puppet::Resource::CapabilityFinder
         Puppet::Util::Puppetdb.query_puppetdb(["from", "resources", query])
       # For PuppetDB < 4, use the old internal method action()
       else
-        url = "/pdb/query/v4/resource?query=#{CGI.escape(query.to_json)}"
+        url = "/pdb/query/v4/resource?query=#{Puppet::Util.uri_query_encode(query.to_json)}"
         response = Puppet::Util::Puppetdb::Http.action(url) do |conn, uri|
           conn.get(uri, { 'Accept' => 'application/json'})
         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,15 +424,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     end
 
     if resources = data['resources']
-      # TODO: The deserializer needs a loader in order to deserialize types defined using the puppet language.
-      json_deserializer = nil
-      if resources.any? { |res| res.has_key?('ext_parameters') }
-        json_deserializer = Puppet::Pops::Serialization::Deserializer.new(
-            Puppet::Pops::Serialization::JSON::Reader.new([]),
-            Puppet::Pops::Loaders.catalog_loader)
-      end
       result.add_resource(*resources.collect do |res|
-        Puppet::Resource.from_data_hash(res, json_deserializer)
+        Puppet::Resource.from_data_hash(res)
       end)
     end
 
@@ -484,28 +477,20 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       h
     end
 
-    resources = if @resources.empty?
-        []
-      elsif environment_instance.rich_data?
-        json_serializer = Puppet::Pops::Serialization::Serializer.new(Puppet::Pops::Serialization::JSON::Writer.new(''))
-        @resources.collect { |v| @resource_table[v].to_data_hash(json_serializer) }
-      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.
@@ -545,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
@@ -565,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.

data/lib/puppet/resource/status.rb

@@ -96,14 +96,6 @@ module Puppet
         failed_dependencies && !failed_dependencies.empty?
       end
 
-      # 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)
@@ -140,13 +132,20 @@ module Puppet
       end
 
       def failed_because(detail)
-        @real_resource.log_exception(detail, "Could not evaluate: #{detail}")
-        failed = true
+        @real_resource.log_exception(detail, _("Could not evaluate: %{detail}") % { detail: detail })
         # 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(:name => :resource_error, :status => "failure", :message => detail.to_s))
+        fail_with_event(detail.to_s)
+      end
+
+      # Both set the status state to failed and generate a corresponding
+      # Puppet::Transaction::Event failure with the given message.
+      # @param message [String] the reason for a status failure
+      def fail_with_event(message)
+        failed = true
+        add_event(@real_resource.event(:name => :resource_error, :status => "failure", :message => message))
       end
 
       def initialize(resource)
@@ -191,14 +190,8 @@ module Puppet
         @failed = data['failed']
         @corrective_change = data['corrective_change']
         @events = data['events'].map do |event|
-          # in YAML (for reports) we serialize this as an object, but
-          # in PSON it becomes a hash. Depending on where we came from
-          # we might not need to deserialize it.
-          if event.class == Puppet::Transaction::Event
-            event
-          else
-            Puppet::Transaction::Event.from_data_hash(event)
-          end
+          # Older versions contain tags that causes Psych to create instances directly
+          event.is_a?(Puppet::Transaction::Event) ? event : Puppet::Transaction::Event.from_data_hash(event)
         end
       end
 
@@ -219,14 +212,10 @@ module Puppet
           'skipped' => @skipped,
           'change_count' => @change_count,
           'out_of_sync_count' => @out_of_sync_count,
-          'events' => @events,
+          'events' => @events.map { |event| event.to_data_hash },
           'corrective_change' => @corrective_change,
         }
       end
-
-      def to_yaml_properties
-        YAML_ATTRIBUTES & super
-      end
     end
   end
 end

data/lib/puppet/resource/type.rb

@@ -5,11 +5,6 @@ require 'puppet/parser/ast/leaf'
 
 # 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
@@ -64,49 +59,6 @@ class Puppet::Resource::Type
     define_method("#{t}?") { self.type == t }
   end
 
-  require 'puppet/indirector'
-  extend Puppet::Indirector
-  indirects :resource_type, :terminus_class => :parser
-
-  def self.from_data_hash(data)
-    name = data.delete(NAME) or raise ArgumentError, 'Resource Type names must be specified'
-    kind = data.delete(KIND) || 'definition'
-
-    unless type = RESOURCE_EXTERNAL_NAMES_TO_KINDS[kind]
-      raise ArgumentError, "Unsupported resource kind '#{kind}'"
-    end
-
-    data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
-
-    # External documentation uses "parameters" but the internal name
-    # is "arguments"
-    data[:arguments] = data.delete(:parameters)
-
-    new(type, name, data)
-  end
-
-  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
-
-    # 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[NAME] = name
-
-    unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
-      raise ArgumentError, "Unsupported resource kind '#{type}'"
-    end
-    data[KIND] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
-    data
-  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)
@@ -123,12 +75,12 @@ class Puppet::Resource::Type
 
     resource.export.map do |ex|
       # Assert that the ref really is a resource reference
-      raise Puppet::Error, "Invalid export in #{resource.ref}: #{ex} is not a resource" unless ex.is_a?(Puppet::Resource)
-      raise Puppet::Error, "Invalid export in #{resource.ref}: #{ex} is not a capability resource" if ex.resource_type.nil? || !ex.resource_type.is_capability?
+      raise Puppet::Error, _("Invalid export in %{reference}: %{ex} is not a resource") % { reference: resource.ref, ex: ex } unless ex.is_a?(Puppet::Resource)
+      raise Puppet::Error, _("Invalid export in %{reference}: %{ex} is not a capability resource") % { reference: resource.ref, ex: ex } if ex.resource_type.nil? || !ex.resource_type.is_capability?
 
       blueprint = produces.find { |pr| pr[:capability] == ex.type }
       if blueprint.nil?
-        raise Puppet::ParseError, "Resource type #{resource.type} does not produce #{ex.type}"
+        raise Puppet::ParseError, _("Resource type %{res_type} does not produce %{ex_type}") % { res_type: resource.type, ex_type: ex.type }
       end
       t = ex.type
       t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
@@ -165,7 +117,7 @@ class Puppet::Resource::Type
     static_parent = evaluate_parent_type(resource)
     scope = static_parent || resource.scope
 
-    scope = scope.newscope(:namespace => namespace, :source => self, :resource => resource) unless resource.title == :main
+    scope = scope.newscope(:source => self, :resource => resource) unless resource.title == :main
     scope.compiler.add_class(name) unless definition?
 
     set_resource_parameters(resource, scope)
@@ -235,12 +187,12 @@ class Puppet::Resource::Type
 
   # Add code from a new instance to our code.
   def merge(other)
-    fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
-    fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
-    fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
+    fail _("%{name} is not a class; cannot add code to it") % { name: name } unless type == :hostclass
+    fail _("%{name} is not a class; cannot add code from it") % { name: other.name } unless other.type == :hostclass
+    fail _("Cannot have code outside of a class/node/define because 'freeze_main' is enabled") if name == "" and Puppet.settings[:freeze_main]
 
     if parent and other.parent and parent != other.parent
-      fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
+      fail _("Cannot merge classes with different parent classes (%{name} => %{parent} vs. %{other_name} => %{other_parent})") % { name: name, parent: parent, other_name: other.name, other_parent: other.parent }
     end
 
     # We know they're either equal or only one is set, so keep whichever parent is specified.
@@ -325,7 +277,7 @@ class Puppet::Resource::Type
   # @deprecated Not used by Puppet
   # @api private
   def assign_parameter_values(parameters, resource)
-    Puppet.deprecation_warning('The method Puppet::Resource::Type.assign_parameter_values is deprecated and will be removed in the next major release of Puppet.')
+    Puppet.deprecation_warning(_('The method Puppet::Resource::Type.assign_parameter_values is deprecated and will be removed in the next major release of Puppet.'))
 
     return unless parameters
 
@@ -341,7 +293,7 @@ class Puppet::Resource::Type
     return nil unless parent
 
     @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}")
+      fail(Puppet::ParseError, _("Could not find parent resource type '%{parent}' of type %{parent_type} in %{env}") % { parent: parent, parent_type: type, env: scope.environment })
   end
 
   # Validate and set any arguments passed by the resource as variables in the scope.
@@ -532,9 +484,9 @@ class Puppet::Resource::Type
     return unless Puppet::Type.metaparamclass(param)
 
     if default
-      warnonce "#{param} is a metaparam; this value will inherit to all contained resources in the #{self.name} definition"
+      warnonce _("%{param} is a metaparam; this value will inherit to all contained resources in the %{name} definition") % { param: param, name: self.name }
     else
-      raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
+      raise Puppet::ParseError, _("%{param} is a metaparameter; please choose another parameter name in the %{name} definition") % { param: param, name: self.name }
     end
   end
 
@@ -549,7 +501,7 @@ class Puppet::Resource::Type
 
     if application?
       resource_type = type_factory.type_type(type_factory.resource)
-      members[type_factory.optional(type_factory.string(NODES))] = type_factory.hash_of(type_factory.variant(
+      members[type_factory.string(NODES)] = type_factory.hash_of(type_factory.variant(
           resource_type, type_factory.array_of(resource_type)), type_factory.type_type(type_factory.resource('node')))
     end