puppet 4.10.0 → 5.0.0

data/lib/puppet/generate/type.rb

@@ -37,7 +37,7 @@ module Puppet
         # @return [Symbol] Returns the new format.
         def format=(format)
           format = format.to_sym
-          raise "unsupported format '#{format}'." unless self.class.supported_format?(format)
+          raise _("unsupported format '%{format}'.") % { format: format } unless self.class.supported_format?(format)
           @format = format
         end
 
@@ -57,7 +57,7 @@ module Puppet
             when :pcore
               "#{File.basename(@path, '.rb')}.pp"
             else
-              raise "unsupported format '#{@format}'."
+              raise _("unsupported format '%{format}'.") % { format: @format }
             end
         end
 
@@ -69,7 +69,7 @@ module Puppet
             when :pcore
               File.join(@base, 'pcore', 'types', output_name)
             else
-              raise "unsupported format '#{@format}'."
+              raise _("unsupported format '%{format}'.") % { format: @format }
             end
         end
 
@@ -153,24 +153,24 @@ module Puppet
           files_to_remove.each do |f|
             Puppet::FileSystem.unlink(File.join(outputdir, f))
           end
-          Puppet.notice("Removed output '#{files_to_remove}' for non existing inputs") unless files_to_remove.empty?
+          Puppet.notice(_("Removed output '%{files_to_remove}' for non existing inputs") % { files_to_remove: files_to_remove }) unless files_to_remove.empty?
         end
 
         if inputs.empty?
-          Puppet.notice 'No custom types were found.'
+          Puppet.notice _('No custom types were found.')
           return nil
         end
 
         templates = {}
         templates.default_proc = lambda { |hash, key|
-          raise "template was not found at '#{key}'." unless Puppet::FileSystem.file?(key)
+          raise _("template was not found at '%{key}'.") % { key: key } unless Puppet::FileSystem.file?(key)
           template = ERB.new(File.read(key), nil, '-')
           template.filename = key
           template
         }
 
         up_to_date = true
-        Puppet.notice 'Generating Puppet resource types.'
+        Puppet.notice _('Generating Puppet resource types.')
         inputs.each do |input|
           if !force && input.up_to_date?(outputdir)
             Puppet.debug "Skipping '#{input}' because it is up-to-date."
@@ -187,7 +187,7 @@ module Puppet
             raise
           rescue Exception => e
             # Log the exception and move on to the next input
-            Puppet.log_exception(e, "Failed to load custom type '#{type_name}' from '#{input}': #{e.message}")
+            Puppet.log_exception(e, _("Failed to load custom type '%{type_name}' from '%{input}': %{message}") % { type_name: type_name, input: input, message: e.message })
             next
           end
 
@@ -196,7 +196,7 @@ module Puppet
 
           # Assume the type follows the naming convention
           unless type = types[type_name]
-            Puppet.err "Custom type '#{type_name}' was not defined in '#{input}'."
+            Puppet.err _("Custom type '%{type_name}' was not defined in '%{input}'.") % { type_name: type_name, input: input }
             next
           end
 
@@ -220,19 +220,19 @@ module Puppet
           # Write the output file
           begin
             effective_output_path = input.effective_output_path(outputdir)
-            Puppet.notice "Generating '#{effective_output_path}' using '#{input.format}' format."
+            Puppet.notice _("Generating '%{effective_output_path}' using '%{format}' format.") % { effective_output_path: effective_output_path, format: input.format }
             FileUtils.mkdir_p(File.dirname(effective_output_path))
             Puppet::FileSystem.open(effective_output_path, nil, 'w:UTF-8') do |file|
               file.write(result)
             end
           rescue Exception => e
-            Puppet.log_exception(e, "Failed to generate '#{effective_output_path}': #{e.message}")
+            Puppet.log_exception(e, _("Failed to generate '%{effective_output_path}': %{message}") % { effective_output_path: effective_output_path, message: e.message })
             # Move on to the next input
             next
           end
         end
 
-        Puppet.notice 'No files were generated because all inputs were up-to-date.' if up_to_date
+        Puppet.notice _('No files were generated because all inputs were up-to-date.') if up_to_date
       end
     end
   end

data/lib/puppet/graph/relationship_graph.rb

@@ -102,8 +102,11 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     overly_deferred_resource_handler = options[:overly_deferred_resource_handler] || lambda { |resource| }
     canceled_resource_handler = options[:canceled_resource_handler] || lambda { |resource| }
     teardown = options[:teardown] || lambda {}
+    graph_cycle_handler = options[:graph_cycle_handler] || lambda { [] }
 
-    report_cycles_in_graph
+    if cycles = report_cycles_in_graph
+      graph_cycle_handler.call(cycles)
+    end
 
     enqueue_roots
 

data/lib/puppet/graph/simple_graph.rb

@@ -4,6 +4,8 @@ require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::Graph::SimpleGraph
+  include Puppet::Util::PsychSupport
+
   #
   # All public methods of this class must maintain (assume ^ ensure) the following invariants, where "=~=" means
   # equiv. up to order:
@@ -61,7 +63,7 @@ class Puppet::Graph::SimpleGraph
     source = base || event.resource
 
     unless vertex?(source)
-      Puppet.warning "Got an event from invalid vertex #{source.ref}"
+      Puppet.warning _("Got an event from invalid vertex %{source}") % { source: source.ref }
       return []
     end
     # Get all of the edges that this vertex should forward events
@@ -193,7 +195,8 @@ class Puppet::Graph::SimpleGraph
   # through the graph first, which are more likely to be interesting to the
   # user.  I think; it would be interesting to verify that. --daniel 2011-01-23
   def paths_in_cycle(cycle, max_paths = 1)
-    raise ArgumentError, "negative or zero max_paths" if max_paths < 1
+    #TRANSLATORS "negative or zero" refers to the count of paths
+    raise ArgumentError, _("negative or zero max_paths") if max_paths < 1
 
     # Calculate our filtered outbound vertex lists...
     adj = {}
@@ -219,13 +222,13 @@ class Puppet::Graph::SimpleGraph
     return found.sort
   end
 
+  # @return [Array] array of dependency cycles (arrays)
   def report_cycles_in_graph
     cycles = find_cycles_in_graph
-    n = cycles.length           # where is "pluralize"? --daniel 2011-01-22
-    return if n == 0
-    s = n == 1 ? '' : 's'
+    number_of_cycles = cycles.length
+    return if number_of_cycles == 0
 
-    message = "Found #{n} dependency cycle#{s}:\n"
+    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"
@@ -233,13 +236,14 @@ class Puppet::Graph::SimpleGraph
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
-      message += "Cycle graph written to #{filename}."
+      message += _("Cycle graph written to %{filename}.") % { filename: filename }
     else
-      message += "Try the '--graph' option and opening the "
-      message += "resulting '.dot' file in OmniGraffle or GraphViz"
+      #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
+      message += _("Try the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz")
     end
-
-    raise Puppet::Error, message
+    Puppet.err(message)
+    cycles
   end
 
   def write_cycles_to_graph(cycles)
@@ -293,6 +297,7 @@ class Puppet::Graph::SimpleGraph
   # since they have to specify what kind of edge it is.
   def add_edge(e,*a)
     return add_relationship(e,*a) unless a.empty?
+    e = Puppet::Relationship.from_data_hash(e) if e.is_a?(Hash)
     @upstream_from.clear
     @downstream_from.clear
     add_vertex(e.source)
@@ -479,68 +484,42 @@ class Puppet::Graph::SimpleGraph
   end
   self.use_new_yaml_format = false
 
-  # Stub class to allow graphs to be represented in YAML using the old
-  # (version 2.6) format.
-  class VertexWrapper
-    attr_reader :vertex, :adjacencies
-    def initialize(vertex, adjacencies)
-      @vertex = vertex
-      @adjacencies = adjacencies
-    end
-
-    def inspect
-      { :@adjacencies => @adjacencies, :@vertex => @vertex.to_s }.inspect
+  def initialize_from_hash(hash)
+    initialize
+    vertices = hash['vertices']
+    edges = hash['edges']
+    if vertices.is_a?(Hash)
+      # Support old (2.6) format
+      vertices = vertices.keys
     end
+    vertices.each { |v| add_vertex(v) } unless vertices.nil?
+    edges.each { |e| add_edge(e) } unless edges.nil?
   end
 
-  # instance_variable_get is used by YAML.dump to get instance
-  # variables.  Override it so that we can simulate the presence of
-  # instance variables @edges and @vertices for serialization.
-  def instance_variable_get(v)
-    case v.to_s
-    when '@edges' then
-      edges
-    when '@vertices' then
-      if self.class.use_new_yaml_format
-        vertices
-      else
-        result = {}
-        vertices.each do |vertex|
-          adjacencies = {}
-          [:in, :out].each do |direction|
-            adjacencies[direction] = {}
-            adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
-              other_vertex = direction == :in ? edge.source : edge.target
-              (adjacencies[direction][other_vertex] ||= Set.new).add(edge)
-            end
+  def to_data_hash
+    hash = { 'edges' => edges.map(&:to_data_hash) }
+    hash['vertices'] = if self.class.use_new_yaml_format
+      vertices
+    else
+      # Represented in YAML using the old (version 2.6) format.
+      result = {}
+      vertices.each do |vertex|
+        adjacencies = {}
+        [:in, :out].each do |direction|
+          direction_hash = {}
+          adjacencies[direction.to_s] = direction_hash
+          adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
+            other_vertex = direction == :in ? edge.source : edge.target
+            (direction_hash[other_vertex.to_s] ||= []) << edge
           end
-          result[vertex] = Puppet::Graph::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
+          direction_hash.each_pair { |key, edges| direction_hash[key] = edges.uniq.map(&:to_data_hash) }
         end
-        result
+        vname = vertex.to_s
+        result[vname] = { 'adjacencies' => adjacencies, 'vertex' => vname }
       end
-    else
-      super(v)
-    end
-  end
-
-  def to_yaml_properties
-    (super + [:@vertices, :@edges] -
-     [:@in_to, :@out_from, :@upstream_from, :@downstream_from]).uniq
-  end
-
-  def yaml_initialize(tag, var)
-    initialize()
-    vertices = var.delete('vertices')
-    edges = var.delete('edges')
-    if vertices.is_a?(Hash)
-      # Support old (2.6) format
-      vertices = vertices.keys
-    end
-    vertices.each { |v| add_vertex(v) }
-    edges.each { |e| add_edge(e) }
-    var.each do |varname, value|
-      instance_variable_set("@#{varname}", value)
+      result
     end
+    hash
   end
 
   def multi_vertex_component?(component)

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

@@ -14,40 +14,39 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   attr_accessor :code
 
+  # @param request [Puppet::Indirector::Request] an indirection request
+  #   (possibly) containing facts
+  # @return [Puppet::Node::Facts] facts object corresponding to facts in request
   def extract_facts_from_request(request)
     return unless text_facts = request.options[:facts]
     unless format = request.options[:facts_format]
-      raise ArgumentError, "Facts but no fact format provided for #{request.key}"
+      raise ArgumentError, _("Facts but no fact format provided for %{request}") % { request: request.key }
     end
 
-    Puppet::Util::Profiler.profile("Found facts", [:compiler, :find_facts]) do
-      # If the facts were encoded as yaml, then the param reconstitution system
-      # in Network::HTTP::Handler will automagically deserialize the value.
-      if text_facts.is_a?(Puppet::Node::Facts)
-        facts = text_facts
-      else
-        # We unescape here because the corresponding code in Puppet::Configurer::FactHandler escapes
-        facts = Puppet::Node::Facts.convert_from(format, CGI.unescape(text_facts))
-      end
+    Puppet::Util::Profiler.profile(_("Found facts"), [:compiler, :find_facts]) do
+      facts = text_facts.is_a?(Puppet::Node::Facts) ? text_facts :
+                                                      convert_wire_facts(text_facts, format)
 
       unless facts.name == request.key
-        raise Puppet::Error, "Catalog for #{request.key.inspect} was requested with fact definition for the wrong node (#{facts.name.inspect})."
+        raise Puppet::Error, _("Catalog for %{request} was requested with fact definition for the wrong node (%{fact_name}).") % { request: request.key.inspect, fact_name: facts.name.inspect }
       end
-
-      options = {
-        :environment => request.environment,
-        :transaction_uuid => request.options[:transaction_uuid],
-      }
-
-      Puppet::Node::Facts.indirection.save(facts, nil, options)
+      return facts
     end
   end
 
+  def save_facts_from_request(facts, request)
+    Puppet::Node::Facts.indirection.save(facts, nil,
+                                         :environment => request.environment,
+                                         :transaction_uuid => request.options[:transaction_uuid])
+  end
+
   # Compile a node's catalog.
   def find(request)
-    extract_facts_from_request(request)
+    facts = extract_facts_from_request(request)
 
-    node = node_from_request(request)
+    save_facts_from_request(facts, request) if !facts.nil?
+
+    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)
@@ -66,7 +65,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   end
 
   def initialize
-    Puppet::Util::Profiler.profile("Setup server facts for compiling", [:compiler, :init_server_facts]) do
+    Puppet::Util::Profiler.profile(_("Setup server facts for compiling"), [:compiler, :init_server_facts]) do
       set_server_facts
     end
   end
@@ -78,6 +77,22 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   private
 
+  # @param facts [String] facts in a wire format for decoding
+  # @param format [String] a content-type string
+  # @return [Puppet::Node::Facts] facts object deserialized from supplied string
+  # @api private
+  def convert_wire_facts(facts, format)
+    if format == 'pson'
+      # We unescape here because the corresponding code in Puppet::Configurer::FactHandler encodes with Puppet::Util.uri_query_encode
+      # PSON is deprecated, but continue to accept from older agents
+      return Puppet::Node::Facts.convert_from('pson', CGI.unescape(facts))
+    elsif format == 'application/json'
+      return Puppet::Node::Facts.convert_from('json', CGI.unescape(facts))
+    else
+      raise ArgumentError, "Unsupported facts format"
+    end
+  end
+
   # Add any extra data necessary to the node.
   def add_node_data(node)
     # Merge in our server-side facts, so they can be used during compilation.
@@ -103,7 +118,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     # This does that, while preserving any user-specified server or port.
     source_path = Pathname.new(metadata.full_path)
     path = source_path.relative_path_from(environment_path).to_s
-    source_as_uri = URI.parse(URI.escape(source))
+    source_as_uri = URI.parse(Puppet::Util.uri_encode(source))
     server = source_as_uri.host
     port = ":#{source_as_uri.port}" if source_as_uri.port
     return "puppet://#{server}#{port}/#{path}"
@@ -114,11 +129,11 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   def inlineable?(resource, sources)
     case
       when resource[:ensure] == 'absent'
-        return Puppet::Util::Profiler.profile("Not inlining absent resource", [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
+        return Puppet::Util::Profiler.profile(_("Not inlining absent resource"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :absent]) { false }
       when sources.empty?
-        return Puppet::Util::Profiler.profile("Not inlining resource without sources", [:compiler, :static_compile_inlining, :skipped_file_metadata, :no_sources]) { false }
+        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:/}))
-        return Puppet::Util::Profiler.profile("Not inlining unsupported source scheme", [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
+        return Puppet::Util::Profiler.profile(_("Not inlining unsupported source scheme"), [:compiler, :static_compile_inlining, :skipped_file_metadata, :unsupported_scheme]) { false }
       else
         return true
     end
@@ -128,7 +143,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # for the 'modules' mount and the resolved path is of the form:
   #   $codedir/environments/$environment/*/*/files/**
   def inlineable_metadata?(metadata, source, environment_path)
-    source_as_uri = URI.parse(URI.escape(source))
+    source_as_uri = URI.parse(Puppet::Util.uri_encode(source))
+
     location = Puppet::Module::FILETYPES['files']
 
     !!(source_as_uri.path =~ /^\/modules\// &&
@@ -138,12 +154,12 @@ 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
-    Puppet::Util::Profiler.profile("Not inlining file outside environment", [:compiler, :static_compile_inlining, :skipped_file_metadata, :file_outside_environment]) { true }
+    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
-    Puppet::Util::Profiler.profile("Inlining file metadata", [:compiler, :static_compile_inlining, :inlined_file_metadata]) { true }
+    Puppet::Util::Profiler.profile(_("Inlining file metadata"), [:compiler, :static_compile_inlining, :inlined_file_metadata]) { true }
   end
 
   # Inline file metadata for static catalogs
@@ -230,7 +246,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
           end
         end
 
-        raise "Could not get metadata for #{resource[:source]}" unless metadata
+        raise _("Could not get metadata for %{resource}") % { resource: resource[:source] } unless metadata
 
         if inlineable_metadata?(metadata, metadata.source,  environment_path)
           metadata.content_uri = get_content_uri(metadata, metadata.source, environment_path)
@@ -251,12 +267,12 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     if node.environment && node.environment.static_catalogs? && options[:static_catalog] && options[:code_id]
       # Check for errors before compiling the catalog
       checksum_type = common_checksum_type(options[:checksum_type])
-      raise Puppet::Error, "Unable to find a common checksum type between agent '#{options[:checksum_type]}' and master '#{known_checksum_types}'." unless checksum_type
+      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 = _("Compiled %s for ") % (checksum_type ? _('static catalog') : _('catalog'))
     str += node.name
-    str += " in environment #{node.environment}" if node.environment
+    str += _(" in environment %{env}") % { env: node.environment } if node.environment
     config = nil
 
     benchmark(:notice, str) do
@@ -272,8 +288,8 @@ 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.name}"
-          str += " in environment #{node.environment}" if node.environment
+          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
               inline_metadata(config, checksum_type)
@@ -287,16 +303,17 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     config
   end
 
-  # Turn our host name into a node object.
-  def find_node(name, environment, transaction_uuid, configured_environment)
-    Puppet::Util::Profiler.profile("Found node information", [:compiler, :find_node]) do
+  # Use indirection to find the node associated with a given request
+  def find_node(name, environment, transaction_uuid, configured_environment, facts)
+    Puppet::Util::Profiler.profile(_("Found node information"), [:compiler, :find_node]) do
       node = nil
       begin
         node = Puppet::Node.indirection.find(name, :environment => environment,
                                              :transaction_uuid => transaction_uuid,
-                                             :configured_environment => configured_environment)
+                                             :configured_environment => configured_environment,
+                                             :facts => facts)
       rescue => detail
-        message = "Failed when searching for node #{name}: #{detail}"
+        message = _("Failed when searching for node %{name}: %{detail}") % { name: name, detail: detail }
         Puppet.log_exception(detail, message)
         raise Puppet::Error, message, detail.backtrace
       end
@@ -312,10 +329,10 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   # Extract the node from the request, or use the request
   # to find the node.
-  def node_from_request(request)
+  def node_from_request(facts, request)
     if node = request.options[:use_node]
       if request.remote?
-        raise Puppet::Error, "Invalid option use_node for a remote request"
+        raise Puppet::Error, _("Invalid option use_node for a remote request")
       else
         return node
       end
@@ -329,11 +346,11 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     # node's catalog with only one certificate and a modification to auth.conf
     # If no key is provided we can only compile the currently connected node.
     name = request.key || request.node
-    if node = find_node(name, request.environment, request.options[:transaction_uuid], request.options[:configured_environment])
+    if node = find_node(name, request.environment, request.options[:transaction_uuid], request.options[:configured_environment], facts)
       return node
     end
 
-    raise ArgumentError, "Could not find node '#{name}'; cannot compile"
+    raise ArgumentError, _("Could not find node '%{name}'; cannot compile") % { name: name }
   end
 
   # Initialize our server fact hash; we add these to each client, and they
@@ -351,7 +368,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       if value = Facter.value(fact)
         @server_facts[var] = value
       else
-        Puppet.warning "Could not retrieve fact #{fact}"
+        Puppet.warning _("Could not retrieve fact %{fact}") % { fact: fact }
       end
     end
 

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

@@ -3,4 +3,22 @@ require 'puppet/indirector/json'
 
 class Puppet::Resource::Catalog::Json < Puppet::Indirector::JSON
   desc "Store catalogs as flat files, serialized using JSON."
+
+  def from_json(text)
+    utf8 = text.force_encoding(Encoding::UTF_8)
+
+    if utf8.valid_encoding?
+      model.convert_from('json', utf8)
+    else
+      Puppet.info(_("Unable to deserialize catalog from json, retrying with pson"))
+      model.convert_from('pson', text.force_encoding(Encoding::BINARY))
+    end
+  end
+
+  def to_json(object)
+    object.render('json')
+  rescue Puppet::Network::FormatHandler::FormatError
+    Puppet.info(_("Unable to serialize catalog to json, retrying with pson"))
+    object.render('pson').force_encoding(Encoding::BINARY)
+  end
 end

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

@@ -13,7 +13,7 @@ CA to prevent clients getting confusing 'success' behaviour."
   [:find, :head, :search, :save, :destroy].each do |name|
     define_method(name) do |request|
       if request.remote?
-        raise Puppet::Error, "this master is not a CA"
+        raise Puppet::Error, _("this master is not a CA")
       else
         @file.send(name, request)
       end

data/lib/puppet/indirector/certificate_request/ca.rb

@@ -9,14 +9,14 @@ class Puppet::SSL::CertificateRequest::Ca < Puppet::Indirector::SslFile
   def save(request)
     if host = Puppet::SSL::Host.indirection.find(request.key)
       if Puppet[:allow_duplicate_certs]
-        Puppet.notice "#{request.key} already has a #{host.state} certificate; new certificate will overwrite it"
+        Puppet.notice _("%{request} already has a %{host} certificate; new certificate will overwrite it") % { request: request.key, host: host.state }
       else
-        raise "#{request.key} already has a #{host.state} certificate; ignoring certificate request"
+        raise _("%{request} already has a %{host} certificate; ignoring certificate request") % { request: request.key, host: host.state }
       end
     end
 
     result = super
-    Puppet.notice "#{request.key} has a waiting certificate request"
+    Puppet.notice _("%{request} has a waiting certificate request") % { request: request.key }
     result
   end
 end

data/lib/puppet/indirector/certificate_request/disabled_ca.rb

@@ -13,7 +13,7 @@ prevent clients getting confusing 'success' behaviour."
   [:find, :head, :search, :save, :destroy].each do |name|
     define_method(name) do |request|
       if request.remote?
-        raise Puppet::Error, "this master is not a CA"
+        raise Puppet::Error, _("this master is not a CA")
       else
         @file.send(name, request)
       end

data/lib/puppet/indirector/certificate_revocation_list/disabled_ca.rb

@@ -13,7 +13,7 @@ prevent clients getting confusing 'success' behaviour."
   [:find, :head, :search, :save, :destroy].each do |name|
     define_method(name) do |request|
       if request.remote?
-        raise Puppet::Error, "this master is not a CA"
+        raise Puppet::Error, _("this master is not a CA")
       else
         @file.send(name, request)
       end

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

@@ -12,7 +12,7 @@ class Puppet::Indirector::CertificateStatus::File < Puppet::Indirector::Code
     on the CA."
 
   def ca
-    raise ArgumentError, "This process is not configured as a certificate authority" unless Puppet::SSL::CertificateAuthority.ca?
+    raise ArgumentError, _("This process is not configured as a certificate authority") unless Puppet::SSL::CertificateAuthority.ca?
     Puppet::SSL::CertificateAuthority.new
   end
 
@@ -28,21 +28,21 @@ class Puppet::Indirector::CertificateStatus::File < Puppet::Indirector::Code
       end
     end
 
-    return "Nothing was deleted" if deleted.empty?
-    "Deleted for #{request.key}: #{deleted.join(", ")}"
+    return _("Nothing was deleted") if deleted.empty?
+    _("Deleted for %{request}: %{deleted}") % { request: request.key, deleted: deleted.join(", ") }
   end
 
   def save(request)
     if request.instance.desired_state == "signed"
       certificate_request = Puppet::SSL::CertificateRequest.indirection.find(request.key)
-      raise Puppet::Error, "Cannot sign for host #{request.key} without a certificate request" unless certificate_request
+      raise Puppet::Error, _("Cannot sign for host %{request} without a certificate request") % { request: request.key } unless certificate_request
       ca.sign(request.key)
     elsif request.instance.desired_state == "revoked"
       certificate = Puppet::SSL::Certificate.indirection.find(request.key)
-      raise Puppet::Error, "Cannot revoke host #{request.key} because has it doesn't have a signed certificate" unless certificate
+      raise Puppet::Error, _("Cannot revoke host %{request} because has it doesn't have a signed certificate") % { request: request.key } unless certificate
       ca.revoke(request.key)
     else
-      raise Puppet::Error, "State #{request.instance.desired_state} invalid; Must specify desired state of 'signed' or 'revoked' for host #{request.key}"
+      raise Puppet::Error, _("State %{state} invalid; Must specify desired state of 'signed' or 'revoked' for host %{request}") % { state: request.instance.desired_state, request: request.key }
     end
 
   end

data/lib/puppet/indirector/exec.rb

@@ -11,14 +11,14 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
     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])
+    raise ArgumentError, _("You must set the exec parameter to a fully qualified command") unless Puppet::Util.absolute_path?(external_command[0])
 
     # Add our name to it.
     external_command << name
     begin
       output = execute(external_command, :failonfail => true, :combine => false)
     rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, "Failed to find #{name} via exec: #{detail}", detail.backtrace
+      raise Puppet::Error, _("Failed to find %{name} via exec: %{detail}") % { name: name, detail: detail }, detail.backtrace
     end
 
     if output =~ /\A\s*\Z/ # all whitespace