puppet 5.0.0 → 6.0.0

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

@@ -18,10 +18,10 @@ class Puppet::Node::Facts::NetworkDevice < 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 a remote device"
+    raise Puppet::DevError, _("You cannot destroy facts in the code store; it is only used for getting facts from a remote device")
   end
 
   def save(facts)
-    raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from a remote device"
+    raise Puppet::DevError, _("You cannot save facts to the code store; it is only used for getting facts from a remote device")
   end
 end

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

@@ -0,0 +1,21 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/rest'
+
+class Puppet::Node::Facts::Rest < Puppet::Indirector::REST
+  desc "Find and save facts about nodes over HTTP via REST."
+
+  def save(request)
+    raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
+
+    response = do_request(request) do |req|
+      http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
+    end
+
+    if is_http_200?(response)
+      content_type, body = parse_response(response)
+      deserialize_save(content_type, body)
+    else
+      raise convert_to_http_error(response)
+    end
+  end
+end

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

@@ -5,15 +5,13 @@ class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
   desc "Store client facts as flat files, serialized using YAML, or
     return deserialized facts from disk."
 
-  def allow_remote_requests?
-    false
-  end
-
   def search(request)
     node_names = []
     Dir.glob(yaml_dir_path).each do |file|
-      facts = YAML.load_file(file)
-      node_names << facts.name if node_matches?(facts, request.options)
+      facts = load_file(file)
+      if facts && node_matches?(facts, request.options)
+        node_names << facts.name
+      end
     end
     node_names
   end

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

@@ -29,6 +29,7 @@ module Puppet::FileBucketFile
           raise _("Unable to diff on this platform") unless Puppet[:diff] != ""
           return diff(Puppet::FileSystem.path_string(contents_file), Puppet::FileSystem.path_string(other_contents_file))
         else
+          #TRANSLATORS "FileBucket" should not be translated
           Puppet.info _("FileBucket read %{checksum}") % { checksum: checksum }
           model.new(Puppet::FileSystem.binread(contents_file))
         end
@@ -158,8 +159,13 @@ module Puppet::FileBucketFile
         Puppet::FileSystem.exclusive_open(paths_file, 0640, 'a+:external') do |f|
           if Puppet::FileSystem.exist?(contents_file)
             if verify_identical_file(contents_file, bucket_file)
-              Puppet.info "FileBucket got a duplicate file #{bucket_file.checksum}"
-              Puppet::FileSystem.touch(contents_file)
+              #TRANSLATORS "FileBucket" should not be translated
+              Puppet.info _("FileBucket got a duplicate file %{file_checksum}") % { file_checksum: bucket_file.checksum }
+              # Don't touch the contents file on Windows, since we can't update the
+              # mtime of read-only files there.
+              if !Puppet::Util::Platform.windows?
+                Puppet::FileSystem.touch(contents_file)
+              end
             elsif contents_file_matches_checksum?(contents_file, bucket_file.checksum_data, bucket_file.checksum_type)
               # If the contents or sizes don't match, but the checksum does,
               # then we've found a conflict (potential hash collision).
@@ -167,6 +173,7 @@ module Puppet::FileBucketFile
               # needed, but ask the user to validate.
               # Note: Don't print the full path to the bucket file in the
               # exception to avoid disclosing file system layout on server.
+              #TRANSLATORS "FileBucket" should not be translated
               Puppet.err(_("Unable to verify existing FileBucket backup at '%{path}'.") % { path: contents_file.to_path })
               raise Puppet::FileBucket::BucketError, _("Existing backup and new file have different content but same checksum, %{value}. Verify existing backup and remove if incorrect.") %
                 { value: bucket_file.checksum }
@@ -219,7 +226,7 @@ module Puppet::FileBucketFile
     #   and content as that in the bucket_file
     # @api private
     def verify_identical_file(contents_file, bucket_file)
-      (bucket_file.size == Puppet::FileSystem.size(contents_file)) &&
+      (bucket_file.to_binary.bytesize == Puppet::FileSystem.size(contents_file)) &&
         (bucket_file.stream() {|s| Puppet::FileSystem.compare_stream(contents_file, s) })
     end
 
@@ -243,7 +250,7 @@ module Puppet::FileBucketFile
     # @return [void]
     # @api private
     def copy_bucket_file_to_contents_file(contents_file, bucket_file)
-      Puppet::FileSystem.open(contents_file, 0440, 'wb') do |of|
+      Puppet::Util.replace_file(contents_file, 0440) do |of|
         # PUP-1044 writes all of the contents
         bucket_file.stream() do |src|
           FileUtils.copy_stream(src, of)

data/lib/puppet/indirector/file_content/http.rb

@@ -1,15 +1,17 @@
 require 'puppet/file_serving/metadata'
 require 'puppet/indirector/generic_http'
+require 'puppet/network/http'
 
 class Puppet::Indirector::FileContent::Http < Puppet::Indirector::GenericHttp
   desc "Retrieve file contents from a remote HTTP server."
 
   include Puppet::FileServing::TerminusHelper
+  include Puppet::Network::HTTP::Compression.module
 
   @http_method = :get
 
   def find(request)
     response = super
-    model.from_binary(response.body)
+    model.from_binary(uncompress_body(response))
   end
 end

data/lib/puppet/indirector/file_server.rb

@@ -11,7 +11,7 @@ class Puppet::Indirector::FileServer < Puppet::Indirector::Terminus
   def authorized?(request)
     return false unless [:find, :search].include?(request.method)
 
-    mount, file_path = configuration.split_path(request)
+    mount, _ = configuration.split_path(request)
 
     # If we're not serving this mount, then access is denied.
     return false unless mount

data/lib/puppet/indirector/indirection.rb

@@ -1,6 +1,5 @@
 require 'puppet/util/docs'
 require 'puppet/util/profiler'
-require 'puppet/util/methodhelper'
 require 'puppet/indirector/envelope'
 require 'puppet/indirector/request'
 
@@ -8,7 +7,6 @@ require 'puppet/indirector/request'
 # back-ends.  Each indirection has a set of associated terminus classes,
 # each of which is a subclass of Puppet::Indirector::Terminus.
 class Puppet::Indirector::Indirection
-  include Puppet::Util::MethodHelper
   include Puppet::Util::Docs
 
   attr_accessor :name, :model
@@ -37,7 +35,7 @@ class Puppet::Indirector::Indirection
 
   # Create and return our cache terminus.
   def cache
-    raise(Puppet::DevError, "Tried to cache when no cache class was set") unless cache_class
+    raise Puppet::DevError, _("Tried to cache when no cache class was set") unless cache_class
     terminus(cache_class)
   end
 
@@ -89,25 +87,23 @@ class Puppet::Indirector::Indirection
     text
   end
 
-  def initialize(model, name, options = {})
+  def initialize(model, name, doc: nil, indirected_class: nil, cache_class: nil, terminus_class: nil, terminus_setting: nil, extend: nil)
     @model = model
     @name = name
     @termini = {}
 
-    @cache_class = nil
-    @terminus_class = nil
+    @doc = doc
 
-    raise(ArgumentError, "Indirection #{@name} is already defined") if @@indirections.find { |i| i.name == @name }
+    raise(ArgumentError, _("Indirection %{name} is already defined") % { name: @name }) if @@indirections.find { |i| i.name == @name }
     @@indirections << self
 
-    @indirected_class = options.delete(:indirected_class)
-    if mod = options[:extend]
-      extend(mod)
-      options.delete(:extend)
-    end
+    @indirected_class = indirected_class
+    self.extend(extend) if extend
 
-    # This is currently only used for cache_class and terminus_class.
-    set_options(options)
+    # These setters depend on the indirection already being installed so they have to be at the end
+    self.cache_class = cache_class if cache_class
+    self.terminus_class = terminus_class if terminus_class
+    self.terminus_setting = terminus_setting if terminus_setting
   end
 
   # Set up our request object.
@@ -118,7 +114,7 @@ class Puppet::Indirector::Indirection
   # Return the singleton terminus for this indirection.
   def terminus(terminus_name = nil)
     # Get the name of the terminus.
-    raise Puppet::DevError, "No terminus specified for #{self.name}; cannot redirect" unless terminus_name ||= terminus_class
+    raise Puppet::DevError, _("No terminus specified for %{name}; cannot redirect") % { name: self.name } unless terminus_name ||= terminus_class
 
     termini[terminus_name] ||= make_terminus(terminus_name)
   end
@@ -132,7 +128,7 @@ class Puppet::Indirector::Indirection
       if setting = self.terminus_setting
         self.terminus_class = Puppet.settings[setting]
       else
-        raise Puppet::DevError, "No terminus class nor terminus setting was provided for indirection #{self.name}"
+        raise Puppet::DevError, _("No terminus class nor terminus setting was provided for indirection %{name}") % { name: self.name}
       end
     end
     @terminus_class
@@ -150,9 +146,12 @@ class Puppet::Indirector::Indirection
 
   # This is used by terminus_class= and cache=.
   def validate_terminus_class(terminus_class)
-    raise ArgumentError, "Invalid terminus name #{terminus_class.inspect}" unless terminus_class and terminus_class.to_s != ""
+    unless terminus_class and terminus_class.to_s != ""
+      raise ArgumentError, _("Invalid terminus name %{terminus_class}") % { terminus_class: terminus_class.inspect }
+    end
     unless Puppet::Indirector::Terminus.terminus_class(self.name, terminus_class)
-      raise ArgumentError, "Could not find terminus #{terminus_class} for indirection #{self.name}"
+      raise ArgumentError, _("Could not find terminus %{terminus_class} for indirection %{name}") %
+          { terminus_class: terminus_class, name: self.name }
     end
   end
 
@@ -162,7 +161,7 @@ class Puppet::Indirector::Indirection
   def expire(key, options={})
     request = request(:expire, key, nil, options)
 
-    return nil unless cache?
+    return nil unless cache? && !request.ignore_cache_save?
 
     return nil unless instance = cache.find(request(:find, key, nil, options))
 
@@ -195,7 +194,7 @@ class Puppet::Indirector::Indirection
       result = terminus.find(request)
       if not result.nil?
         result.expiration ||= self.expiration if result.respond_to?(:expiration)
-        if cache?
+        if cache? && !request.ignore_cache_save?
           Puppet.info _("Caching %{indirection} for %{request}") % { indirection: self.name, request: request.key }
           begin
             cache.save request(:save, key, result, options)
@@ -268,7 +267,7 @@ class Puppet::Indirector::Indirection
     terminus = prepare(request)
 
     if result = terminus.search(request)
-      raise Puppet::DevError, "Search results from terminus #{terminus.name} are not an array" unless result.is_a?(Array)
+      raise Puppet::DevError, _("Search results from terminus %{terminus_name} are not an array") % { terminus_name: terminus.name } unless result.is_a?(Array)
       result.each do |instance|
         next unless instance.respond_to? :expiration
         instance.expiration ||= self.expiration
@@ -286,7 +285,7 @@ class Puppet::Indirector::Indirection
     result = terminus.save(request)
 
     # If caching is enabled, save our document there
-    cache.save(request) if cache?
+    cache.save(request) if cache? && !request.ignore_cache_save?
 
     result
   end
@@ -304,8 +303,13 @@ class Puppet::Indirector::Indirection
     return unless terminus.respond_to?(:authorized?)
 
     unless terminus.authorized?(request)
-      msg = "Not authorized to call #{request.method} on #{request.description}"
-      msg += " with #{request.options.inspect}" unless request.options.empty?
+      msg = if request.options.empty?
+              _("Not authorized to call %{method} on %{description}") %
+                  { method: request.method, description: request.description }
+            else
+              _("Not authorized to call %{method} on %{description} with %{option}") %
+                  { method: request.method, description: request.description, option: request.options.inspect }
+            end
       raise ArgumentError, msg
     end
   end

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

@@ -5,7 +5,6 @@ class Puppet::SSL::Key::File < Puppet::Indirector::SslFile
   desc "Manage SSL private and public keys on disk."
 
   store_in :privatekeydir
-  store_ca_at :cakey
 
   def allow_remote_requests?
     false
@@ -13,11 +12,7 @@ class Puppet::SSL::Key::File < Puppet::Indirector::SslFile
 
   # Where should we store the public key?
   def public_key_path(name)
-    if ca?(name)
-      Puppet[:capub]
-    else
-      File.join(Puppet[:publickeydir], name.to_s + ".pem")
-    end
+    File.join(Puppet[:publickeydir], name.to_s + ".pem")
   end
 
   # Remove the public key, in addition to the private key

data/lib/puppet/indirector/node/exec.rb

@@ -3,7 +3,7 @@ require 'puppet/indirector/exec'
 
 class Puppet::Node::Exec < Puppet::Indirector::Exec
   desc "Call an external program to get node information.  See
-  the [External Nodes](https://docs.puppetlabs.com/guides/external_nodes.html) page for more information."
+  the [External Nodes](https://puppet.com/docs/puppet/latest/lang_write_functions_in_puppet.html) page for more information."
   include Puppet::Util
 
   def command
@@ -38,11 +38,9 @@ class Puppet::Node::Exec < Puppet::Indirector::Exec
   # Turn our outputted objects into a Puppet::Node instance.
   def create_node(name, result, facts = nil)
     node = Puppet::Node.new(name)
-    set = false
     [:parameters, :classes, :environment].each do |param|
       if value = result[param]
         node.send(param.to_s + "=", value)
-        set = true
       end
     end
 
@@ -52,7 +50,7 @@ class Puppet::Node::Exec < Puppet::Indirector::Exec
 
   # Translate the yaml string into Ruby objects.
   def translate(name, output)
-    YAML.load(output).inject({}) do |hash, data|
+    Puppet::Util::Yaml.safe_load(output, [Symbol]).inject({}) do |hash, data|
       case data[0]
       when String
         hash[data[0].intern] = data[1]

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

@@ -4,10 +4,4 @@ require 'puppet/indirector/yaml'
 class Puppet::Node::Yaml < Puppet::Indirector::Yaml
   desc "Store node information as flat files, serialized using YAML,
     or deserialize stored YAML nodes."
-
-  protected
-
-  def fix(object)
-    object
-  end
 end

data/lib/puppet/indirector/request.rb

@@ -10,7 +10,7 @@ require 'puppet/util/psych_support'
 class Puppet::Indirector::Request
   include Puppet::Util::PsychSupport
 
-  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
+  attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_cache_save, :ignore_terminus
 
   attr_accessor :server, :port, :uri, :protocol
 
@@ -18,7 +18,7 @@ class Puppet::Indirector::Request
 
   # trusted_information is specifically left out because we can't serialize it
   # and keep it "trusted"
-  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
+  OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :ignore_cache_save, :instance, :environment]
 
   # Is this an authenticated request?
   def authenticated?
@@ -50,6 +50,10 @@ class Puppet::Indirector::Request
     ignore_cache
   end
 
+  def ignore_cache_save?
+    ignore_cache_save
+  end
+
   def ignore_terminus?
     ignore_terminus
   end
@@ -181,7 +185,11 @@ class Puppet::Indirector::Request
     return yield(self) if !self.server.nil?
 
     if Puppet.settings[:use_srv_records]
-      Puppet::Network::Resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
+      # We may want to consider not creating a new resolver here
+      # every request eventually, to take advantage of the resolver's
+      # caching behavior.
+      resolver = Puppet::Network::Resolver.new
+      resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
         begin
           self.server = srv_server
           self.port   = srv_port
@@ -193,27 +201,23 @@ class Puppet::Indirector::Request
     end
 
     # ... Fall back onto the default server.
-    begin
-      bound_server = Puppet.lookup(:server)
-    rescue
+    bound_server = Puppet.lookup(:server) do
       if primary_server = Puppet.settings[:server_list][0]
-        bound_server = primary_server[0]
+        primary_server[0]
       else
-        bound_server = nil
+        Puppet.settings[:server]
       end
     end
 
-    begin
-      bound_port = Puppet.lookup(:serverport)
-    rescue
+    bound_port = Puppet.lookup(:serverport) do
       if primary_server = Puppet.settings[:server_list][0]
-        bound_port = primary_server[1]
+        primary_server[1]
       else
-        bound_port = nil
+        Puppet.settings[:masterport]
       end
     end
-    self.server = default_server || bound_server || Puppet.settings[:server]
-    self.port   = default_port || bound_port || Puppet.settings[:masterport]
+    self.server = default_server || bound_server
+    self.port   = default_port || bound_port
 
     Puppet.debug "No more servers left, falling back to #{self.server}:#{self.port}" if Puppet.settings[:use_srv_records]
 

data/lib/puppet/indirector/rest.rb

@@ -1,6 +1,7 @@
 require 'net/http'
 require 'uri'
-require 'json'
+require 'puppet/util/json'
+require 'puppet/util/connection'
 require 'semantic_puppet'
 
 require 'puppet/network/http'
@@ -39,68 +40,16 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     @srv_service || :puppet
   end
 
-  # The logic for server and port is kind of gross. In summary:
-  # IF an endpoint-specific setting is requested AND that setting has been set by the user
-  #    Use that setting.
-  #         The defaults for these settings are the "normal" server/masterport settings, so
-  #         when they are unset we instead want to "fall back" to the failover-selected
-  #         host/port pair.
-  # ELSE IF we have a failover-selected host/port
-  #    Use what the failover logic came up with
-  # ELSE IF the server_list setting is in use
-  #    Use the first entry - failover hasn't happened yet, but that
-  #    setting is still authoritative
-  # ELSE
-  #    Go for the legacy server/masterport settings, and hope for the best
+  # Select the server to use based on the settings configuration
+  # for this indirection, taking into account the HA server list.
   def self.server
-    setting = server_setting()
-    if setting && setting != :server && Puppet.settings.set_by_config?(setting)
-      Puppet.settings[setting]
-    else
-      begin
-        Puppet.lookup(:server)
-      rescue
-        if primary_server = Puppet.settings[:server_list][0]
-          Puppet.debug "Dynamically-bound server lookup failed; using first entry"
-          primary_server[0]
-        else
-          setting ||= :server
-          Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
-          Puppet.settings[setting]
-        end
-      end
-    end
+    Puppet::Util::Connection.determine_server(server_setting)
   end
 
-  # For port there's a little bit of an extra snag: setting a specific
-  # server setting and relying on the default port for that server is
-  # common, so we also want to check if the assocaited SERVER setting
-  # has been set by the user. If either of those are set we ignore the
-  # failover-selected port.
+  # Select the port to use based on the settings configuration
+  # for this indirection, taking into account the HA server list.
   def self.port
-    setting = port_setting()
-    srv_setting = server_setting()
-    if (setting && setting != :masterport && Puppet.settings.set_by_config?(setting)) ||
-       (srv_setting && srv_setting != :server && Puppet.settings.set_by_config?(srv_setting))
-      Puppet.settings[setting].to_i
-    else
-      begin
-        Puppet.lookup(:serverport).to_i
-      rescue
-        if primary_server = Puppet.settings[:server_list][0]
-          Puppet.debug "Dynamically-bound port lookup failed; using first entry"
-
-          # Port might not be set, so we want to fallback in that
-          # case. We know we don't need to use `setting` here, since
-          # the default value of every port setting is `masterport`
-          (primary_server[1] || Puppet.settings[:masterport]).to_i
-        else
-          setting ||= :masterport
-          Puppet.debug "Dynamically-bound port lookup failed; falling back to #{setting} setting"
-          Puppet.settings[setting].to_i
-        end
-      end
-    end
+    Puppet::Util::Connection.determine_port(port_setting, server_setting)
   end
 
   # Provide appropriate headers.
@@ -183,7 +132,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
       # While this way of handling the issue is not perfect, there is at least an error
       # that makes a user aware of the reason for the failure.
       #
-      content_type, body = parse_response(response)
+      _, body = parse_response(response)
       msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(uri_with_query_string, 100), body: body }
       raise Puppet::Error, msg
     else
@@ -262,11 +211,16 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
   def handle_response(request, response)
     server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
-    if server_version &&
-       SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
-       Puppet[:preferred_serialization_format] != 'pson'
-      Puppet.warning("Downgrading to PSON for future requests")
-      Puppet[:preferred_serialization_format] = 'pson'
+    if server_version
+      Puppet.lookup(:server_agent_version) do
+        Puppet.push_context(:server_agent_version => server_version)
+      end
+      if SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
+          Puppet[:preferred_serialization_format] != 'pson'
+        #TRANSLATORS "PSON" should not be translated
+        Puppet.warning(_("Downgrading to PSON for future requests"))
+        Puppet[:preferred_serialization_format] = 'pson'
+      end
     end
   end
 
@@ -298,7 +252,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     elsif response['content-type'].is_a?(String)
       content_type, body = parse_response(response)
       if content_type =~ /[pj]son/
-        returned_message = JSON.parse(body)["message"]
+        returned_message = Puppet::Util::Json.load(body)["message"]
       else
         returned_message = uncompress_body(response)
       end
@@ -315,8 +269,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   # uncompress_body)
   def parse_response(response)
     if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''),
-        body = uncompress_body(response) ]
+      [ response['content-type'].gsub(/\s*;.*$/,''), uncompress_body(response) ]
     else
       raise _("No content type in http response; cannot parse")
     end

data/lib/puppet/indirector/ssl_file.rb

@@ -12,13 +12,8 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     @file_setting = setting
   end
 
-  # Specify where a specific ca file should be stored.
-  def self.store_ca_at(setting)
-    @ca_setting = setting
-  end
-
   class << self
-    attr_reader :directory_setting, :file_setting, :ca_setting
+    attr_reader :directory_setting, :file_setting
   end
 
   # The full path to where we should store our files.
@@ -33,23 +28,10 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     Puppet.settings[file_setting]
   end
 
-  # The full path to a ca file we would be managing.
-  def self.ca_location
-    return nil unless ca_setting
-    Puppet.settings[ca_setting]
-  end
-
-  # We assume that all files named 'ca' are pointing to individual ca files,
-  # rather than normal host files.  It's a bit hackish, but all the other
-  # solutions seemed even more hackish.
-  def ca?(name)
-    name == Puppet::SSL::Host.ca_name
-  end
-
   def initialize
     Puppet.settings.use(:main, :ssl)
 
-    (collection_directory || file_location) or raise Puppet::DevError, "No file or directory setting provided; terminus #{self.class.name} cannot function"
+    (collection_directory || file_location) or raise Puppet::DevError, _("No file or directory setting provided; terminus %{class_name} cannot function") % { class_name: self.class.name }
   end
 
   def path(name)
@@ -58,9 +40,7 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    if ca?(name) and ca_location
-      ca_location
-    elsif collection_directory
+    if collection_directory
       File.join(collection_directory, name.to_s + ".pem")
     else
       file_location
@@ -127,10 +107,6 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     self.class.file_location
   end
 
-  def ca_location
-    self.class.ca_location
-  end
-
   # A hack method to deal with files that exist with a different case.
   # Just renames it; doesn't read it in or anything.
   # LAK:NOTE This is a copy of the method in sslcertificates/support.rb,
@@ -164,25 +140,8 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     # * SSL::Key may be a .export(OpenSSL::Cipher::DES.new(:EDE3, :CBC), pass) or .to_pem
     # * All other classes are translated to strings by calling .to_pem
 
-    # Serialization of:
-    # Puppet::SSL::Certificate by Puppet::SSL::Certificate::Ca, Puppet::SSL::Certificate::File
-    # -----BEGIN CERTIFICATE-----
-    # Puppet::SSL::Key by Puppet::SSL::Key::Ca, Puppet::SSL::Key::File
-    # -----BEGIN RSA PRIVATE KEY-----
-    if ca?(name) and ca_location
-      Puppet.settings.setting(self.class.ca_setting).open('w:ASCII') { |f| yield f }
-    # Serialization of:
-    # Puppet::SSL::CertificateRevocationList by Puppet::SSL::CertificateRevocationList::Ca, Puppet::SSL::CertificateRevocationList::File
-    # -----BEGIN X509 CRL-----
-    elsif file_location
+    if file_location
       Puppet.settings.setting(self.class.file_setting).open('w:ASCII') { |f| yield f }
-    # Serialization of:
-    # Puppet::SSL::Certificate by Puppet::SSL::Certificate::Ca, Puppet::SSL::Certificate::File
-    # -----BEGIN CERTIFICATE-----
-    # Puppet::SSL::CertificateRequest by Puppet::SSL::CertificateRequest::Ca, Puppet::SSL::CertificateRequest::File
-    # -----BEGIN CERTIFICATE REQUEST-----
-    # Puppet::SSL::Key by Puppet::SSL::Key::Ca, Puppet::SSL::Key::File
-    # -----BEGIN RSA PRIVATE KEY-----
     elsif setting = self.class.directory_setting
       begin
         Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
@@ -190,7 +149,7 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
         raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
       end
     else
-      raise Puppet::DevError, "You must provide a setting to determine where the files are stored"
+      raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
     end
   end
 end