puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/lib/puppet/generate/models/type/property.rb

@@ -40,7 +40,7 @@ module Puppet
             values = property.value_collection.instance_variable_get('@values') || {}
             values.each do |_, value|
               if value.regex?
-                regexes << Puppet::Pops::Types::StringConverter.convert(value.name, '%p')
+                regexes << "/#{value.name.source.gsub(/\//, '\/')}/"
                 next
               end
 

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
 
@@ -244,12 +247,6 @@ 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

@@ -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.rb

@@ -22,7 +22,7 @@ module Puppet::Indirector
       Puppet::Indirector::Terminus.terminus_class(indirection_name, terminus_name || cache_name)
 
       indirection = Puppet::Indirector::Indirection.instance(indirection_name)
-      raise "Indirection #{indirection_name} does not exist" unless indirection
+      raise _("Indirection %{indirection_name} does not exist") % { indirection_name: indirection_name } unless indirection
 
       indirection.terminus_class = terminus_name if terminus_name
       indirection.cache_class = cache_name if cache_name
@@ -35,7 +35,7 @@ module Puppet::Indirector
   # evaluated at parse time, which is before the user has had a chance
   # to override it.
   def indirects(indirection, options = {})
-    raise(ArgumentError, "Already handling indirection for #{@indirection.name}; cannot also handle #{indirection}") if @indirection
+    raise(ArgumentError, _("Already handling indirection for %{current}; cannot also handle %{next}") % { current: @indirection.name, next: indirection }) if @indirection
     # populate this class with the various new methods
     extend ClassMethods
     include Puppet::Indirector::Envelope

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

@@ -14,42 +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
-      elsif format == 'pson'
-        # We unescape here because the corresponding code in Puppet::Configurer::FactHandler encodes with Puppet::Util.uri_query_encode
-        facts = Puppet::Node::Facts.convert_from('pson', CGI.unescape(text_facts))
-      else
-        raise ArgumentError, "Unsupported facts format"
-      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)
@@ -68,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
@@ -80,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.
@@ -116,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
@@ -141,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
@@ -233,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)
@@ -254,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
@@ -275,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)
@@ -290,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
@@ -315,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
@@ -332,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
@@ -354,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