diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index a67753f68..0b3452b41 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,312 +1,317 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
 require 'puppet/util/pson'
 require 'puppet/network/resolver'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
   attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
   attr_accessor :server, :port, :uri, :protocol
 
   attr_reader :indirection_name
 
   # 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]
 
   ::PSON.register_document_type('IndirectorRequest',self)
 
   def self.from_data_hash(data)
     raise ArgumentError, "No indirection name provided in data" unless indirection_name = data['type']
     raise ArgumentError, "No method name provided in data" unless method = data['method']
     raise ArgumentError, "No key provided in data" unless key = data['key']
 
     request = new(indirection_name, method, key, nil, data['attributes'])
 
     if instance = data['instance']
       klass = Puppet::Indirector::Indirection.instance(request.indirection_name).model
       if instance.is_a?(klass)
         request.instance = instance
       else
         request.instance = klass.from_data_hash(instance)
       end
     end
 
     request
   end
 
   def self.from_pson(json)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(json)
   end
 
   def to_data_hash
     result = {
       'type' => indirection_name,
       'method' => method,
       'key' => key
     }
     attributes = {}
     OPTION_ATTRIBUTES.each do |key|
       next unless value = send(key)
       attributes[key] = value
     end
 
     options.each do |opt, value|
       attributes[opt] = value
     end
 
     result['attributes'] = attributes unless attributes.empty?
     result['instance'] = instance if instance
     result
   end
 
   def to_pson_data_hash
     {
       'document_type' => 'IndirectorRequest',
       'data' => to_data_hash,
     }
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Is this an authenticated request?
   def authenticated?
     # Double negative, so we just get true or false
     ! ! authenticated
   end
 
   def environment
+    # The lookup of the environment from the configuration is correct here
+    # as this is used to establish the environment to use for a request.
+    # If some other environment should be in effect, it should already
+    # have been set with #environment=
+    #
     @environment ||= Puppet.lookup(:environments).get(Puppet[:environment])
   end
 
   def environment=(env)
     @environment = if env.is_a?(Puppet::Node::Environment)
       env
     else
       Puppet.lookup(:environments).get(env)
     end
   end
 
   def escaped_key
     URI.escape(key)
   end
 
   # LAK:NOTE This is a messy interface to the cache, and it's only
   # used by the Configurer class.  I decided it was better to implement
   # it now and refactor later, when we have a better design, than
   # to spend another month coming up with a design now that might
   # not be any better.
   def ignore_cache?
     ignore_cache
   end
 
   def ignore_terminus?
     ignore_terminus
   end
 
   def initialize(indirection_name, method, key, instance, options = {})
     @instance = instance
     options ||= {}
 
     self.indirection_name = indirection_name
     self.method = method
 
     options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
 
     set_attributes(options)
 
     @options = options
 
     if key
       # If the request key is a URI, then we need to treat it specially,
       # because it rewrites the key.  We could otherwise strip server/port/etc
       # info out in the REST class, but it seemed bad design for the REST
       # class to rewrite the key.
 
       if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
         set_uri_key(key)
       else
         @key = key
       end
     end
 
     @key = @instance.name if ! @key and @instance
   end
 
   # Look up the indirection based on the name provided.
   def indirection
     Puppet::Indirector::Indirection.instance(indirection_name)
   end
 
   def indirection_name=(name)
     @indirection_name = name.to_sym
   end
 
   def model
     raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
     i.model
   end
 
   # Are we trying to interact with multiple resources, or just one?
   def plural?
     method == :search
   end
 
   # Create the query string, if options are present.
   def query_string
     return "" if options.nil? || options.empty?
 
     # For backward compatibility with older (pre-3.3) masters,
     # this puppet option allows serialization of query parameter
     # arrays as yaml.  This can be removed when we remove yaml
     # support entirely.
     if Puppet.settings[:legacy_query_parameter_serialization]
       replace_arrays_with_yaml
     end
 
     "?" + encode_params(expand_into_parameters(options.to_a))
   end
 
   def replace_arrays_with_yaml
     options.each do |key, value|
       case value
         when Array
           options[key] = YAML.dump(value)
       end
     end
   end
 
   def expand_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
 
       expanded_value = case value
                        when Array
                          value.collect { |val| [key, val] }
                        else
                          [key_value]
                        end
 
       params.concat(expand_primitive_types_into_parameters(expanded_value))
     end
   end
 
   def expand_primitive_types_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
       case value
       when nil
         params
       when true, false, String, Symbol, Fixnum, Bignum, Float
         params << [key, value]
       else
         raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
       end
     end
   end
 
   def encode_params(params)
     params.collect do |key, value|
       "#{key}=#{CGI.escape(value.to_s)}"
     end.join("&")
   end
 
   def to_hash
     result = options.dup
 
     OPTION_ATTRIBUTES.each do |attribute|
       if value = send(attribute)
         result[attribute] = value
       end
     end
     result
   end
 
   def to_s
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
   def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
     # We were given a specific server to use, so just use that one.
     # This happens if someone does something like specifying a file
     # source using a puppet:// URI with a specific server.
     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|
         begin
           self.server = srv_server
           self.port   = srv_port
           return yield(self)
         rescue SystemCallError => e
           Puppet.warning "Error connecting to #{srv_server}:#{srv_port}: #{e.message}"
         end
       end
     end
 
     # ... Fall back onto the default server.
     Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
     self.server = default_server
     self.port   = default_port
     return yield(self)
   end
 
   def remote?
     self.node or self.ip
   end
 
   private
 
   def set_attributes(options)
     OPTION_ATTRIBUTES.each do |attribute|
       if options.include?(attribute.to_sym)
         send(attribute.to_s + "=", options[attribute])
         options.delete(attribute)
       end
     end
   end
 
   # Parse the key as a URI, setting attributes appropriately.
   def set_uri_key(key)
     @uri = key
     begin
       uri = URI.parse(URI.escape(key))
     rescue => detail
       raise ArgumentError, "Could not understand URL #{key}: #{detail}", detail.backtrace
     end
 
     # Just short-circuit these to full paths
     if uri.scheme == "file"
       @key = Puppet::Util.uri_to_path(uri)
       return
     end
 
     @server = uri.host if uri.host
 
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
       @port = Puppet.settings[:masterport].to_i
     else
       @port = uri.port.to_i
     end
 
     @protocol = uri.scheme
 
     if uri.scheme == 'puppet'
       @key = URI.unescape(uri.path.sub(/^\//, ''))
       return
     end
 
     env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
     @key ||= ''
     self.environment = env unless env == ''
   end
 end
diff --git a/lib/puppet/indirector/rest.rb b/lib/puppet/indirector/rest.rb
index 1697aa55f..30136de29 100644
--- a/lib/puppet/indirector/rest.rb
+++ b/lib/puppet/indirector/rest.rb
@@ -1,264 +1,267 @@
 require 'net/http'
 require 'uri'
 
 require 'puppet/network/http'
 require 'puppet/network/http_pool'
 require 'puppet/network/http/api/v1'
 require 'puppet/network/http/compression'
 
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   include Puppet::Network::HTTP::Compression.module
 
   class << self
     attr_reader :server_setting, :port_setting
   end
 
   # Specify the setting that we should use to get the server name.
   def self.use_server_setting(setting)
     @server_setting = setting
   end
 
   # Specify the setting that we should use to get the port.
   def self.use_port_setting(setting)
     @port_setting = setting
   end
 
   # Specify the service to use when doing SRV record lookup
   def self.use_srv_service(service)
     @srv_service = service
   end
 
   def self.srv_service
     @srv_service || :puppet
   end
 
   def self.server
     Puppet.settings[server_setting || :server]
   end
 
   def self.port
     Puppet.settings[port_setting || :masterport].to_i
   end
 
   # Provide appropriate headers.
   def headers
     add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
   end
 
   def add_profiling_header(headers)
     if (Puppet[:profile])
       headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
     end
     headers
   end
 
   def network(request)
     Puppet::Network::HttpPool.http_instance(request.server || self.class.server,
                                             request.port || self.class.port)
   end
 
   def http_get(request, path, headers = nil, *args)
     http_request(:get, request, path, add_profiling_header(headers), *args)
   end
 
   def http_post(request, path, data, headers = nil, *args)
     http_request(:post, request, path, data, add_profiling_header(headers), *args)
   end
 
   def http_head(request, path, headers = nil, *args)
     http_request(:head, request, path, add_profiling_header(headers), *args)
   end
 
   def http_delete(request, path, headers = nil, *args)
     http_request(:delete, request, path, add_profiling_header(headers), *args)
   end
 
   def http_put(request, path, data, headers = nil, *args)
     http_request(:put, request, path, data, add_profiling_header(headers), *args)
   end
 
   def http_request(method, request, *args)
     conn = network(request)
     conn.send(method, *args)
   end
 
   def find(request)
     uri, body = Puppet::Network::HTTP::API::V1.request_to_uri_and_body(request)
     uri_with_query_string = "#{uri}?#{body}"
 
     response = do_request(request) do |request|
       # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
       # http://redmine.ruby-lang.org/issues/show/3991
       if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
         http_post(request, uri, body, headers)
       else
         http_get(request, uri_with_query_string, headers)
       end
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       result = deserialize_find(content_type, body)
       result.name = request.key if result.respond_to?(:name=)
       result
 
     elsif is_http_404?(response)
       # 404 gets special treatment as the indirector API can not produce a meaningful
       # reason to why something is not found - it may not be the thing the user is
       # expecting to find that is missing, but something else (like the environment).
       # While this way of handling the issue is not perfect, there is at least a warning
       # that makes a user aware of the reason for the failure.
       #
       content_type, body = parse_response(response)
       msg = "Find #{uri_with_query_string} resulted in 404 with the message: #{body}"
       # warn_once
       Puppet::Util::Warnings.maybe_log(msg, self.class){ Puppet.warning msg }
       nil
 
     else
       nil
     end
   end
 
   def head(request)
     response = do_request(request) do |request|
       http_head(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
     end
 
     if is_http_200?(response)
       check_master_version(response)
       true
     else
       false
     end
   end
 
   def search(request)
     response = do_request(request) do |request|
       http_get(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       deserialize_search(content_type, body) || []
     else
       []
     end
   end
 
   def destroy(request)
     raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
 
     response = do_request(request) do |request|
       http_delete(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       deserialize_destroy(content_type, body)
     else
       nil
     end
   end
 
   def save(request)
     raise ArgumentError, "PUT does not accept options" unless request.options.empty?
 
     response = do_request(request) do |request|
       http_put(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       deserialize_save(content_type, body)
     else
       nil
     end
   end
 
   # Encapsulate call to request.do_request with the arguments from this class
   # Then yield to the code block that was called in
   # We certainly could have retained the full request.do_request(...) { |r| ... }
   # but this makes the code much cleaner and we only then actually make the call
   # to request.do_request from here, thus if we change what we pass or how we
   # get it, we only need to change it here.
   def do_request(request)
     request.do_request(self.class.srv_service, self.class.server, self.class.port) { |request| yield(request) }
   end
 
   def validate_key(request)
     # Validation happens on the remote end
   end
 
   private
 
   def is_http_200?(response)
     case response.code
     when "404"
       false
     when /^2/
       true
     else
       # Raise the http error if we didn't get a 'success' of some kind.
       raise convert_to_http_error(response)
     end
   end
 
   def is_http_404?(response)
     response.code == "404"
   end
 
   def convert_to_http_error(response)
     message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
     Net::HTTPError.new(message, response)
   end
 
   def check_master_version response
     if !response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] &&
        (Puppet[:legacy_query_parameter_serialization] == false || Puppet[:report_serialization_format] != "yaml")
       Puppet.notice "Using less secure serialization of reports and query parameters for compatibility"
       Puppet.notice "with older puppet master. To remove this notice, please upgrade your master(s) "
       Puppet.notice "to Puppet 3.3 or newer."
       Puppet.notice "See http://links.puppetlabs.com/deprecate_yaml_on_network for more information."
       Puppet[:legacy_query_parameter_serialization] = true
       Puppet[:report_serialization_format] = "yaml"
     end
   end
 
   # Returns the content_type, stripping any appended charset, and the
   # body, decompressed if necessary (content-encoding is checked inside
   # uncompress_body)
   def parse_response(response)
     if response['content-type']
       [ response['content-type'].gsub(/\s*;.*$/,''),
         body = uncompress_body(response) ]
     else
       raise "No content type in http response; cannot parse"
     end
   end
 
   def deserialize_find(content_type, body)
     model.convert_from(content_type, body)
   end
 
   def deserialize_search(content_type, body)
     model.convert_from_multiple(content_type, body)
   end
 
   def deserialize_destroy(content_type, body)
     model.convert_from(content_type, body)
   end
 
   def deserialize_save(content_type, body)
     nil
   end
 
   def environment
+    # The lookup of the environment from the configuration is correct here
+    # as this is used to establish the environment to use for a rest request in general.
+    #
     Puppet.lookup(:environments).get(Puppet[:environment])
   end
 end