puppet 5.0.0 → 6.0.0

data/lib/puppet/gettext/config.rb

@@ -0,0 +1,275 @@
+require 'puppet/util/platform'
+require 'puppet/file_system'
+
+module Puppet::GettextConfig
+  LOCAL_PATH = File.absolute_path('../../../locales', File.dirname(__FILE__))
+  POSIX_PATH = File.absolute_path('../../../../../share/locale', File.dirname(__FILE__))
+  WINDOWS_PATH = File.absolute_path('../../../../../../puppet/share/locale', File.dirname(__FILE__))
+
+  # This is the only domain name that won't be a symbol, making it unique from environments.
+  DEFAULT_TEXT_DOMAIN = 'default-text-domain'
+
+  # Load gettext helpers and track whether they're available.
+  # Used instead of features because we initialize gettext before features is available.
+  begin
+    require 'fast_gettext'
+    require 'locale'
+
+    # Make translation methods (e.g. `_()` and `n_()`) available everywhere.
+    class ::Object
+      include FastGettext::Translation
+    end
+
+    @gettext_loaded = true
+  rescue LoadError
+    # Stub out gettext's `_` and `n_()` methods, which attempt to load translations,
+    # with versions that do nothing
+    require 'puppet/gettext/stubs'
+    @gettext_loaded = false
+  end
+
+  # @api private
+  # Whether we were able to require fast_gettext and locale
+  # @return [Boolean] true if translation gems were successfully loaded
+  def self.gettext_loaded?
+    @gettext_loaded
+  end
+
+  # @api private
+  # Returns the currently selected locale from FastGettext,
+  # or 'en' of gettext has not been loaded
+  # @return [String] the active locale
+  def self.current_locale
+    if gettext_loaded?
+      return FastGettext.default_locale
+    else
+      return 'en'
+    end
+  end
+
+  # @api private
+  # Returns a list of the names of the loaded text domains
+  # @return [[String]] the names of the loaded text domains
+  def self.loaded_text_domains
+    return [] if @gettext_disabled || !gettext_loaded?
+
+    return FastGettext.translation_repositories.keys
+  end
+
+  # @api private
+  # Clears the translation repository for the given text domain,
+  # creating it if it doesn't exist, then adds default translations
+  # and switches to using this domain.
+  # @param [String, Symbol] domain_name the name of the domain to create
+  def self.reset_text_domain(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+    domain_name = domain_name.to_sym
+
+    Puppet.debug "Reset text domain to #{domain_name.inspect}"
+    FastGettext.add_text_domain(domain_name,
+                                type: :chain,
+                                chain: [],
+                                report_warning: false)
+    copy_default_translations(domain_name)
+    FastGettext.text_domain = domain_name
+  end
+
+  # @api private
+  # Resets the thread's configured text_domain to the default text domain.
+  # In Puppet Server, thread A may process a compile request that configures
+  # a domain, while thread B may invalidate that environment and delete the
+  # domain. That leaves thread A with an invalid text_domain selected.
+  # To avoid that, clear_text_domain after any processing that needs the
+  # non-default text domain.
+  def self.clear_text_domain
+    return if @gettext_disabled || !gettext_loaded?
+    FastGettext.text_domain = nil
+  end
+
+  # @api private
+  # Creates a default text domain containing the translations for
+  # Puppet as the start of chain. When semantic_puppet gets initialized,
+  # its translations are added to this chain. This is used as a cache
+  # so that all non-module translations only need to be loaded once as
+  # we create and reset environment-specific text domains.
+  #
+  # @return true if Puppet translations were successfully loaded, false
+  # otherwise
+  def self.create_default_text_domain
+    return if @gettext_disabled || !gettext_loaded?
+
+    FastGettext.add_text_domain(DEFAULT_TEXT_DOMAIN,
+                                type: :chain,
+                                chain: [],
+                                report_warning: false)
+    FastGettext.default_text_domain = DEFAULT_TEXT_DOMAIN
+
+    load_translations('puppet', puppet_locale_path, translation_mode(puppet_locale_path), DEFAULT_TEXT_DOMAIN)
+  end
+
+  # @api private
+  # Switches the active text domain, if the requested domain exists.
+  # @param [String, Symbol] domain_name the name of the domain to switch to
+  def self.use_text_domain(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+    domain_name = domain_name.to_sym
+
+    if FastGettext.translation_repositories.include?(domain_name)
+      Puppet.debug "Use text domain #{domain_name.inspect}"
+      FastGettext.text_domain = domain_name
+    else
+      Puppet.debug "Requested unknown text domain #{domain_name.inspect}"
+    end
+  end
+
+  # @api private
+  # Delete all text domains.
+  def self.delete_all_text_domains
+    FastGettext.translation_repositories.clear
+    FastGettext.default_text_domain = nil
+    FastGettext.text_domain = nil
+  end
+
+  # @api private
+  # Deletes the text domain with the given name
+  # @param [String, Symbol] domain_name the name of the domain to delete
+  def self.delete_text_domain(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+    domain_name = domain_name.to_sym
+
+    deleted = FastGettext.translation_repositories.delete(domain_name)
+    if FastGettext.text_domain == domain_name
+      Puppet.debug "Deleted current text domain #{domain_name.inspect}: #{!deleted.nil?}"
+      FastGettext.text_domain = nil
+    else
+      Puppet.debug "Deleted text domain #{domain_name.inspect}: #{!deleted.nil?}"
+    end
+  end
+
+  # @api private
+  # Deletes all text domains except the default one
+  def self.delete_environment_text_domains
+    return if @gettext_disabled || !gettext_loaded?
+
+    FastGettext.translation_repositories.keys.each do |key|
+      # do not clear default translations
+      next if key == DEFAULT_TEXT_DOMAIN
+
+      FastGettext.translation_repositories.delete(key)
+    end
+    FastGettext.text_domain = nil
+  end
+
+  # @api private
+  # Adds translations from the default text domain to the specified
+  # text domain. Creates the default text domain if one does not exist
+  # (this will load Puppet's translations).
+  #
+  # Since we are currently (Nov 2017) vendoring semantic_puppet, in normal
+  # flows these translations will be copied along with Puppet's.
+  #
+  # @param [Symbol] domain_name the name of the domain to add translations to
+  def self.copy_default_translations(domain_name)
+    return if @gettext_disabled || !gettext_loaded?
+
+    if FastGettext.default_text_domain.nil?
+      create_default_text_domain
+    end
+
+    puppet_translations = FastGettext.translation_repositories[FastGettext.default_text_domain].chain
+    FastGettext.translation_repositories[domain_name].chain.push(*puppet_translations)
+  end
+
+  # @api private
+  # Search for puppet gettext config files
+  # @return [String] path to the config, or nil if not found
+  def self.puppet_locale_path
+    if Puppet::FileSystem.exist?(LOCAL_PATH)
+      return LOCAL_PATH
+    elsif Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(WINDOWS_PATH)
+      return WINDOWS_PATH
+    elsif !Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(POSIX_PATH)
+      return POSIX_PATH
+    else
+      nil
+    end
+  end
+
+  # @api private
+  # Determine which translation file format to use
+  # @param [String] conf_path the path to the gettext config file
+  # @return [Symbol] :mo if in a package structure, :po otherwise
+  def self.translation_mode(conf_path)
+    if WINDOWS_PATH == conf_path || POSIX_PATH == conf_path
+      return :mo
+    else
+      return :po
+    end
+  end
+
+  # @api private
+  # Prevent future gettext initializations
+  def self.disable_gettext
+    @gettext_disabled = true
+  end
+
+  # @api private
+  # Attempt to load translations for the given project.
+  # @param [String] project_name the project whose translations we want to load
+  # @param [String] locale_dir the path to the directory containing translations
+  # @param [Symbol] file_format translation file format to use, either :po or :mo
+  # @return true if initialization succeeded, false otherwise
+  def self.load_translations(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
+    if project_name.nil? || project_name.empty?
+      raise Puppet::Error, "A project name must be specified in order to initialize translations."
+    end
+
+    return false if @gettext_disabled || !@gettext_loaded
+
+    return false unless locale_dir && Puppet::FileSystem.exist?(locale_dir)
+
+    unless file_format == :po || file_format == :mo
+      raise Puppet::Error, "Unsupported translation file format #{file_format}; please use :po or :mo"
+    end
+
+    add_repository_to_domain(project_name, locale_dir, file_format, text_domain)
+    return true
+  end
+
+  # @api private
+  # Add the translations for this project to the domain's repository chain
+  # chain for the currently selected text domain, if needed.
+  # @param [String] project_name the name of the project for which to load translations
+  # @param [String] locale_dir the path to the directory containing translations
+  # @param [Symbol] file_format the format of the translations files, :po or :mo
+  def self.add_repository_to_domain(project_name, locale_dir, file_format, text_domain = FastGettext.text_domain)
+    return if @gettext_disabled || !gettext_loaded?
+
+    current_chain = FastGettext.translation_repositories[text_domain].chain
+
+    repository = FastGettext::TranslationRepository.build(project_name,
+                                                          path: locale_dir,
+                                                          type: file_format,
+                                                          report_warning: false)
+    current_chain << repository
+  end
+
+  # @api private
+  # Sets FastGettext's locale to the current system locale
+  def self.setup_locale
+    return if @gettext_disabled || !gettext_loaded?
+
+    set_locale(Locale.current.language)
+  end
+
+  # @api private
+  # Sets the language in which to display strings.
+  # @param [String] locale the language portion of a locale string (e.g. "ja")
+  def self.set_locale(locale)
+    return if @gettext_disabled || !gettext_loaded?
+    # make sure we're not using the `available_locales` machinery
+    FastGettext.default_available_locales = nil
+
+    FastGettext.default_locale = locale
+  end
+end

data/lib/puppet/gettext/module_translations.rb

@@ -0,0 +1,42 @@
+require 'puppet/gettext/config'
+
+module Puppet::ModuleTranslations
+
+  # @api private
+  # Loads translation files for each of the specified modules,
+  # if present. Requires the modules to have `forge_name` specified.
+  # @param [[Module]] modules a list of modules for which to
+  #        load translations
+  def self.load_from_modulepath(modules)
+    modules.each do |mod|
+      next unless mod.forge_name && mod.has_translations?(Puppet::GettextConfig.current_locale)
+
+      module_name = mod.forge_name.gsub('/', '-')
+      if Puppet::GettextConfig.load_translations(module_name, mod.locale_directory, :po)
+        Puppet.debug "Loaded translations for #{module_name}."
+      elsif Puppet::GettextConfig.gettext_loaded?
+        Puppet.debug "Could not find translation files for #{module_name} at #{mod.locale_directory}. Skipping translation initialization."
+      else
+        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
+      end
+    end
+  end
+
+  # @api private
+  # Loads translation files that have been pluginsync'd for modules
+  # from the $vardir.
+  # @param [String] vardir the path to Puppet's vardir
+  def self.load_from_vardir(vardir)
+    locale = Puppet::GettextConfig.current_locale
+    Dir.glob("#{vardir}/locales/#{locale}/*.po") do |f|
+      module_name = File.basename(f, ".po")
+      if Puppet::GettextConfig.load_translations(module_name, File.join(vardir, "locales"), :po)
+        Puppet.debug "Loaded translations for #{module_name}."
+      elsif Puppet::GettextConfig.gettext_loaded?
+        Puppet.debug "Could not load translations for #{module_name}."
+      else
+        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
+      end
+    end
+  end
+end

data/lib/puppet/gettext/stubs.rb

@@ -0,0 +1,11 @@
+# These stub the translation methods normally brought in
+# by FastGettext. Used when Gettext could not be properly
+# initialized.
+def _(msg)
+  msg
+end
+
+def n_(*args, &block)
+  plural = args[2] == 1 ? args[0] : args[1]
+  block ? block.call : plural
+end

data/lib/puppet/graph/relationship_graph.rb

@@ -70,7 +70,7 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     if @blockers[resource] > 0
       @blockers[resource] -= 1
     else
-      resource.warning "appears to have a negative number of dependencies"
+      resource.warning _("appears to have a negative number of dependencies")
     end
     @blockers[resource] <= 0
   end
@@ -247,6 +247,12 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     containers.each { |x|
       admissible[x] = whit_class.new(:name => "admissible_#{x.ref}", :catalog => catalog)
       completed[x]  = whit_class.new(:name => "completed_#{x.ref}",  :catalog => catalog)
+
+      # This copies the original container's tags over to the two anchor whits.
+      # Without this, tags are not propagated to the container's resources.
+      admissible[x].set_tags(x)
+      completed[x].set_tags(x)
+
       priority = @prioritizer.priority_of(x)
       add_vertex(admissible[x], priority)
       add_vertex(completed[x], priority)

data/lib/puppet/graph/simple_graph.rb

@@ -229,17 +229,17 @@ class Puppet::Graph::SimpleGraph
     return if number_of_cycles == 0
 
     message = n_("Found %{num} dependency cycle:\n", "Found %{num} dependency cycles:\n", number_of_cycles) % { num: number_of_cycles }
+
     cycles.each do |cycle|
       paths = paths_in_cycle(cycle)
-      message += paths.map{ |path| '(' + path.join(" => ") + ')'}.join("\n") + "\n"
+      message += paths.map{ |path| '(' + path.join(' => ') + ')'}.join('\n') + '\n'
     end
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
       message += _("Cycle graph written to %{filename}.") % { filename: filename }
     else
-      #TRANSLATORS "graph" refers to a command line option and should not be translated
-      #TRANSLATORS OmniGraffle and GraphViz and program names and should not be translated
+      #TRANSLATORS '--graph' refers to a command line option and OmniGraffle and GraphViz are program names and should not be translated
       message += _("Try the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz")
     end
     Puppet.err(message)
@@ -436,14 +436,14 @@ class Puppet::Graph::SimpleGraph
   # undirected Graph.  _params_ can contain any graph property specified in
   # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
   # which match +dot+ properties will be used as well.
-  def to_dot_graph (params = {})
+  def to_dot_graph(params = {})
     params['name'] ||= self.class.name.gsub(/:/,'_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
       name = v.ref
-      params = {'name'     => '"'+name+'"',
+      params = {'name'     => stringify(name),
         'fontsize' => fontsize,
         'label'    => name}
       v_label = v.ref
@@ -451,8 +451,8 @@ class Puppet::Graph::SimpleGraph
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
-      params = {'from'     => '"'+ e.source.ref + '"',
-        'to'       => '"'+ e.target.ref + '"',
+      params = {'from'     => stringify(e.source.ref),
+        'to'       => stringify(e.target.ref),
         'fontsize' => fontsize }
       e_label = e.ref
       params.merge!(e_label) if e_label and e_label.kind_of? Hash
@@ -461,8 +461,12 @@ class Puppet::Graph::SimpleGraph
     graph
   end
 
+  def stringify(s)
+    %("#{s.gsub('"', '\\"')}")
+  end
+
   # Output the dot format as a string
-  def to_dot (params={}) to_dot_graph(params).to_s; end
+  def to_dot(params={}) to_dot_graph(params).to_s; end
 
   # Produce the graph files if requested.
   def write_graph(name)

data/lib/puppet/graph.rb

@@ -1,8 +1,6 @@
 module Puppet::Graph
   require 'puppet/graph/prioritizer'
   require 'puppet/graph/sequential_prioritizer'
-  require 'puppet/graph/title_hash_prioritizer'
-  require 'puppet/graph/random_prioritizer'
 
   require 'puppet/graph/simple_graph'
   require 'puppet/graph/rb_tree_map'

data/lib/puppet/indirector/catalog/compiler.rb

@@ -49,12 +49,12 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     node = node_from_request(facts, request)
     node.trusted_data = Puppet.lookup(:trusted_information) { Puppet::Context::TrustedInformation.local(node) }.to_h
 
-    if catalog = compile(node, request.options)
-      return catalog
+    if node.environment
+      node.environment.with_text_domain do
+        compile(node, request.options)
+      end
     else
-      # This shouldn't actually happen; we should either return
-      # a config or raise an exception.
-      return nil
+      compile(node, request.options)
     end
   end
 
@@ -89,7 +89,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     elsif format == 'application/json'
       return Puppet::Node::Facts.convert_from('json', CGI.unescape(facts))
     else
-      raise ArgumentError, "Unsupported facts format"
+      raise ArgumentError, _("Unsupported facts format")
     end
   end
 
@@ -129,10 +129,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   def inlineable?(resource, sources)
     case
       when resource[:ensure] == 'absent'
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining absent resource"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
       when sources.empty?
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining resource without sources"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
       when (not (sources.all? {|source| source =~ /^puppet:/}))
+        #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
         return Puppet::Util::Profiler.profile(_("Not inlining unsupported source scheme"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
       else
         return true
@@ -154,11 +157,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # Helper method to log file resources that could not be inlined because they
   # fall outside of an environment.
   def log_file_outside_environment
+    #TRANSLATORS Inlining refers to adding additional metadata (in this case we are not inlining)
     Puppet::Util::Profiler.profile(_("Not inlining file outside environment"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :file_outside_environment]) { true }
   end
 
   # Helper method to log file resources that were successfully inlined.
   def log_metadata_inlining
+    #TRANSLATORS Inlining refers to adding additional metadata
     Puppet::Util::Profiler.profile(_("Inlining file metadata"), [:compiler, :static_compile_inlining, :inlined_file_metadata]) { true }
   end
 
@@ -171,7 +176,6 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     # TODO: get property/parameter defaults if entries are nil in the resource
     # For now they're hard-coded to match the File type.
 
-    file_metadata = {}
     list_of_resources.each do |resource|
       sources = [resource[:source]].flatten.compact
       next unless inlineable?(resource, sources)
@@ -270,14 +274,31 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       raise Puppet::Error, _("Unable to find a common checksum type between agent '%{agent_type}' and master '%{master_type}'.") % { agent_type: options[:checksum_type], master_type: known_checksum_types } unless checksum_type
     end
 
-    str = _("Compiled %s for ") % (checksum_type ? _('static catalog') : _('catalog'))
-    str += node.name
-    str += _(" in environment %{env}") % { env: node.environment } if node.environment
+    escaped_node_name = node.name.gsub(/%/, '%%')
+    if checksum_type
+      if node.environment
+        escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+        benchmark_str = _("Compiled static catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+        profile_str   = _("Compiled static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+      else
+        benchmark_str = _("Compiled static catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+        profile_str   = _("Compiled static catalog for %{node}") % { node: node.name }
+      end
+    else
+      if node.environment
+        escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+        benchmark_str = _("Compiled catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+        profile_str   = _("Compiled catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+      else
+        benchmark_str = _("Compiled catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+        profile_str   = _("Compiled catalog for %{node}") % { node: node.name }
+      end
+    end
     config = nil
 
-    benchmark(:notice, str) do
+    benchmark(:notice, benchmark_str) do
       compile_type = checksum_type ? :static_compile : :compile
-      Puppet::Util::Profiler.profile(str, [:compiler, compile_type, node.environment, node.name]) do
+      Puppet::Util::Profiler.profile(profile_str, [:compiler, compile_type, node.environment, node.name]) do
         begin
           config = Puppet::Parser::Compiler.compile(node, options[:code_id])
         rescue Puppet::Error => detail
@@ -288,10 +309,21 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         end
 
         if checksum_type && config.is_a?(model)
-          str = _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
-          str += _(" in environment %{env}") % { env: node.environment } if node.environment
-          benchmark(:notice, str) do
-            Puppet::Util::Profiler.profile(str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
+          escaped_node_name = node.name.gsub(/%/, '%%')
+          if node.environment
+            escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+            #TRANSLATORS Inlined refers to adding additional metadata
+            benchmark_str = _("Inlined resource metadata into static catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+            #TRANSLATORS Inlined refers to adding additional metadata
+            profile_str   = _("Inlined resource metadata into static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+          else
+            #TRANSLATORS Inlined refers to adding additional metadata
+            benchmark_str = _("Inlined resource metadata into static catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+            #TRANSLATORS Inlined refers to adding additional metadata
+            profile_str   = _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
+          end
+          benchmark(:notice, benchmark_str) do
+            Puppet::Util::Profiler.profile(profile_str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
               inline_metadata(config, checksum_type)
             end
           end

data/lib/puppet/indirector/catalog/json.rb

@@ -8,7 +8,7 @@ class Puppet::Resource::Catalog::Json < Puppet::Indirector::JSON
     utf8 = text.force_encoding(Encoding::UTF_8)
 
     if utf8.valid_encoding?
-      model.convert_from('json', utf8)
+      model.convert_from(json_format, utf8)
     else
       Puppet.info(_("Unable to deserialize catalog from json, retrying with pson"))
       model.convert_from('pson', text.force_encoding(Encoding::BINARY))
@@ -16,9 +16,20 @@ class Puppet::Resource::Catalog::Json < Puppet::Indirector::JSON
   end
 
   def to_json(object)
-    object.render('json')
-  rescue Puppet::Network::FormatHandler::FormatError
+    object.render(json_format)
+  rescue Puppet::Network::FormatHandler::FormatError => err
     Puppet.info(_("Unable to serialize catalog to json, retrying with pson"))
+    Puppet.log_exception(err, err.message, level: :debug)
     object.render('pson').force_encoding(Encoding::BINARY)
   end
+
+  private
+
+  def json_format
+    if Puppet[:rich_data]
+      'rich_data_json'
+    else
+      'json'
+    end
+  end
 end

data/lib/puppet/indirector/catalog/yaml.rb

@@ -3,20 +3,4 @@ require 'puppet/indirector/yaml'
 
 class Puppet::Resource::Catalog::Yaml < Puppet::Indirector::Yaml
   desc "Store catalogs as flat files, serialized using YAML."
-
-  private
-
-  # Override these, because yaml doesn't want to convert our self-referential
-  # objects.  This is hackish, but eh.
-  def from_yaml(text)
-    if config = YAML.load(text)
-      return config
-    end
-  end
-
-  def to_yaml(config)
-    # We can't yaml-dump classes.
-    #config.edgelist_class = nil
-    YAML.dump(config)
-  end
 end

data/lib/puppet/indirector/certificate/file.rb

@@ -5,5 +5,4 @@ class Puppet::SSL::Certificate::File < Puppet::Indirector::SslFile
   desc "Manage SSL certificates on disk."
 
   store_in :certdir
-  store_ca_at :localcacert
 end

data/lib/puppet/indirector/exec.rb

@@ -8,7 +8,7 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     external_command = command
 
     # Make sure it's an array
-    raise Puppet::DevError, "Exec commands must be an array" unless external_command.is_a?(Array)
+    raise Puppet::DevError, _("Exec commands must be an array") unless external_command.is_a?(Array)
 
     # Make sure it's fully qualified.
     raise ArgumentError, _("You must set the exec parameter to a fully qualified command") unless Puppet::Util.absolute_path?(external_command[0])

data/lib/puppet/indirector/facts/facter.rb

@@ -11,11 +11,11 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
   end
 
   def destroy(facts)
-    raise Puppet::DevError, 'You cannot destroy facts in the code store; it is only used for getting facts from Facter'
+    raise Puppet::DevError, _('You cannot destroy facts in the code store; it is only used for getting facts from Facter')
   end
 
   def save(facts)
-    raise Puppet::DevError, 'You cannot save facts to the code store; it is only used for getting facts from Facter'
+    raise Puppet::DevError, _('You cannot save facts to the code store; it is only used for getting facts from Facter')
   end
 
   # Lookup a host's facts up in Facter.
@@ -38,8 +38,6 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     result
   end
 
-  private
-
   def self.setup_search_paths(request)
     # Add any per-module fact directories to facter's search path
     dirs = request.environment.modulepath.collect do |dir|
@@ -55,7 +53,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
       # print out each .rb in the facts directory as module
       # developers may find that information useful for debugging purposes
       if Puppet::Util::Log.sendlevel?(:info)
-        Puppet.info "Loading facts"
+        Puppet.info _("Loading facts")
         Dir.glob("#{dir}/*.rb").each do |file|
           Puppet.debug "Loading facts from #{file}"
         end
@@ -64,7 +62,7 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
       true
     end
 
-    Facter.search *dirs
+    Facter.search(*dirs)
   end
 
   def self.setup_external_search_paths(request)