puppet 4.10.12 → 5.0.0

data/lib/puppet/network/http/api/master/v3/environment.rb

@@ -8,45 +8,64 @@ class Puppet::Network::HTTP::API::Master::V3::Environment
     code_id = request.params[:code_id]
 
     if env.nil?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("#{env_name} is not a known environment", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("%{env_name} is not a known environment") % { env_name: env_name }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
     end
 
     catalog = Puppet::Parser::EnvironmentCompiler.compile(env, code_id).to_resource
 
-    # This reads code_id off the catalog rather than using the one from the
-    # request. There shouldn't really be a case where the two differ, but if
-    # they do, the one from the catalog itself is authoritative.
-    env_graph = {:environment => env.name, :applications => {}, :code_id => catalog.code_id}
+    env_graph = build_environment_graph(catalog)
+
+    response.respond_with(200, "application/json", JSON.dump(env_graph))
+  end
+
+  def build_environment_graph(catalog)
+    # This reads catalog and code_id off the catalog rather than using the one
+    # from the request. There shouldn't really be a case where the two differ,
+    # but if they do, the one from the catalog itself is authoritative.
+    env_graph = {:environment => catalog.environment, :applications => {}, :code_id => catalog.code_id}
     applications = catalog.resources.select do |res|
       type = res.resource_type
       type.is_a?(Puppet::Resource::Type) && type.application?
     end
     applications.each do |app|
-      app_components = {}
+      file, line = app.file, app.line
+      nodes = app['nodes']
+
+      required_components = catalog.direct_dependents_of(app).map {|comp| comp.ref}
+      mapped_components = nodes.values.flatten.map {|comp| comp.ref}
+
+      nonexistent_components = mapped_components - required_components
+      if nonexistent_components.any?
+        raise Puppet::ParseError.new("Application #{app} assigns nodes to non-existent components: #{nonexistent_components.join(', ')}", file, line)
+      end
+
+      missing_components = required_components - mapped_components
+      if missing_components.any?
+        raise Puppet::ParseError.new("Application #{app} has components without assigned nodes: #{missing_components.join(', ')}", file, line)
+      end
+
       # Turn the 'nodes' hash into a map component ref => node name
       node_mapping = {}
-      app['nodes'].each do |node, comps|
+      nodes.each do |node, comps|
         comps = [comps] unless comps.is_a?(Array)
         comps.each do |comp|
-          raise Puppet::ParseError, "Application #{app} maps component #{comp} to multiple nodes" if node_mapping.include?(comp.ref)
+          raise Puppet::ParseError.new(_("Application %{app} assigns multiple nodes to component %{comp}") % { app: app, comp: comp }, file, line) if node_mapping.include?(comp.ref)
           node_mapping[comp.ref] = node.title
         end
       end
 
+      app_components = {}
       catalog.direct_dependents_of(app).each do |comp|
-        mapped_node = node_mapping[comp.ref]
-        if mapped_node.nil?
-          raise Puppet::ParseError, "Component #{comp} is not mapped to any node"
-        end
         app_components[comp.ref] = {
           :produces => comp.export.map(&:ref),
           :consumes => prerequisites(comp).map(&:ref),
-          :node => mapped_node
+          :node => node_mapping[comp.ref]
         }
       end
       env_graph[:applications][app.ref] = app_components
     end
-    response.respond_with(200, "application/json", JSON.dump(env_graph))
+
+    env_graph
   end
 
   private

data/lib/puppet/network/http/compression.rb

@@ -27,7 +27,7 @@ module Puppet::Network::HTTP::Compression
       when nil, 'identity'
         return response.body
       else
-        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
+        raise Net::HTTPError.new(_("Unknown content encoding - %{encoding}") % { encoding: response['content-encoding'] }, response)
       end
     end
 
@@ -40,12 +40,14 @@ module Puppet::Network::HTTP::Compression
       when nil, 'identity'
         uncompressor = IdentityAdapter.new
       else
-        raise Net::HTTPError.new("Unknown content encoding - #{response['content-encoding']}", response)
+        raise Net::HTTPError.new(_("Unknown content encoding - %{encoding}") % { encoding: response['content-encoding'] }, response)
       end
 
-      yield uncompressor
-
-      uncompressor.close
+      begin
+        yield uncompressor
+      ensure
+        uncompressor.close
+      end
     end
 
     def add_accept_encoding(headers={})
@@ -56,7 +58,7 @@ module Puppet::Network::HTTP::Compression
     # This adapters knows how to uncompress both 'zlib' stream (the deflate algorithm from Content-Encoding)
     # and GZip streams.
     class ZlibAdapter
-      def initialize
+      def initialize(uncompressor = Zlib::Inflate.new(15 + 32))
         # Create an inflater that knows to parse GZip streams and zlib streams.
         # This uses a property of the C Zlib library, documented as follow:
         #   windowBits can also be greater than 15 for optional gzip decoding. Add
@@ -64,7 +66,7 @@ module Puppet::Network::HTTP::Compression
         #   detection, or add 16 to decode only the gzip format (the zlib format will
         #   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
         #   a crc32 instead of an adler32.
-        @uncompressor = Zlib::Inflate.new(15 + 32)
+        @uncompressor = uncompressor
         @first = true
       end
 
@@ -87,6 +89,7 @@ module Puppet::Network::HTTP::Compression
 
       def close
         @uncompressor.finish
+      ensure
         @uncompressor.close
       end
     end

data/lib/puppet/network/http/connection.rb

@@ -4,7 +4,6 @@ require 'puppet/ssl/configuration'
 require 'puppet/ssl/validator'
 require 'puppet/network/http'
 require 'uri'
-require 'time'
 
 module Puppet::Network::HTTP
 
@@ -31,14 +30,14 @@ module Puppet::Network::HTTP
 
     # Creates a new HTTP client connection to `host`:`port`.
     # @param host [String] the host to which this client will connect to
-    # @param port [Fixnum] the port to which this client will connect to
+    # @param port [Integer] the port to which this client will connect to
     # @param options [Hash] options influencing the properties of the created
     #   connection,
     # @option options [Boolean] :use_ssl true to connect with SSL, false
     #   otherwise, defaults to true
     # @option options [#setup_connection] :verify An object that will configure
     #   any verification to do on the connection
-    # @option options [Fixnum] :redirect_limit the number of allowed
+    # @option options [Integer] :redirect_limit the number of allowed
     #   redirections, defaults to 10 passing any other option in the options
     #   hash results in a Puppet::Error exception
     #
@@ -52,7 +51,7 @@ module Puppet::Network::HTTP
       @port = port
 
       unknown_options = options.keys - OPTION_DEFAULTS.keys
-      raise Puppet::Error, "Unrecognized option(s): #{unknown_options.map(&:inspect).sort.join(', ')}" unless unknown_options.empty?
+      raise Puppet::Error, _("Unrecognized option(s): %{opts}") % { opts: unknown_options.map(&:inspect).sort.join(', ') } unless unknown_options.empty?
 
       options = OPTION_DEFAULTS.merge(options)
       @use_ssl = options[:use_ssl]
@@ -63,9 +62,13 @@ module Puppet::Network::HTTP
     end
 
     # @!macro [new] common_options
-    #   @param options [Hash] options influencing the request made
+    #   @param options [Hash] options influencing the request made. Any
+    #   options not recognized by this class will be ignored - no error will
+    #   be thrown.
     #   @option options [Hash{Symbol => String}] :basic_auth The basic auth
-    #     :username and :password to use for the request
+    #     :username and :password to use for the request, :metric_id Ignored
+    #     by this class - used by Puppet Server only. The metric id by which
+    #     to track metrics on requests.
 
     # @param path [String]
     # @param headers [Hash{String => String}]
@@ -194,7 +197,7 @@ module Puppet::Network::HTTP
         # and try again...
       end
 
-      raise RedirectionLimitExceededException, "Too many HTTP redirections for #{@host}:#{@port}"
+      raise RedirectionLimitExceededException, _("Too many HTTP redirections for %{host}:%{port}") % { host: @host, port: @port }
     end
 
     def apply_options_to(request, options)
@@ -206,14 +209,7 @@ module Puppet::Network::HTTP
     end
 
     def execute_request(connection, request)
-      start = Time.now
       connection.request(request)
-    rescue EOFError => e
-      elapsed = (Time.now - start).to_f.round(3)
-      uri = @site.addr + request.path.split('?')[0]
-      eof = EOFError.new(_('request %{uri} interrupted after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
-      eof.set_backtrace(e.backtrace) unless e.backtrace.empty?
-      raise eof
     end
 
     def with_connection(site, &block)
@@ -223,17 +219,17 @@ module Puppet::Network::HTTP
       end
       response
     rescue OpenSSL::SSL::SSLError => error
-      if error.message.include? "certificate verify failed"
+      # can be nil
+      peer_cert = @verify.peer_certs.last
+
+      if peer_cert && !OpenSSL::SSL.verify_certificate_identity(peer_cert.content, site.host)
+        valid_certnames = [peer_cert.name, *peer_cert.subject_alt_names].uniq
+        msg = valid_certnames.length > 1 ? _("one of %{certnames}") % { certnames: valid_certnames.join(', ') } : valid_certnames.first
+        msg += _("Server hostname '%{host}' did not match server certificate; expected %{msg}") % { host: site.host, msg: msg }
+        raise Puppet::Error, msg, error.backtrace
+      elsif error.message.include? "certificate verify failed"
         msg = error.message
         msg << ": [" + @verify.verify_errors.join('; ') + "]"
-        raise Puppet::Error, msg, error.backtrace
-      elsif error.message =~ /hostname.*not match.*server certificate/
-        leaf_ssl_cert = @verify.peer_certs.last
-
-        valid_certnames = [leaf_ssl_cert.name, *leaf_ssl_cert.subject_alt_names].uniq
-        msg = valid_certnames.length > 1 ? "one of #{valid_certnames.join(', ')}" : valid_certnames.first
-        msg = "Server hostname '#{site.host}' did not match server certificate; expected #{msg}"
-
         raise Puppet::Error, msg, error.backtrace
       else
         raise

data/lib/puppet/network/http/error.rb

@@ -20,50 +20,54 @@ module Puppet::Network::HTTP::Error
   class HTTPNotAcceptableError < HTTPError
     CODE = 406
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Not Acceptable: " + message, CODE, issue_kind)
+      super(_("Not Acceptable: ") + message, CODE, issue_kind)
     end
   end
 
   class HTTPNotFoundError < HTTPError
     CODE = 404
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Not Found: " + message, CODE, issue_kind)
+      super(_("Not Found: ") + message, CODE, issue_kind)
     end
   end
 
   class HTTPNotAuthorizedError < HTTPError
     CODE = 403
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Not Authorized: " + message, CODE, issue_kind)
+      super(_("Not Authorized: ") + message, CODE, issue_kind)
     end
   end
 
   class HTTPBadRequestError < HTTPError
     CODE = 400
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Bad Request: " + message, CODE, issue_kind)
+      super(_("Bad Request: ") + message, CODE, issue_kind)
     end
   end
 
   class HTTPMethodNotAllowedError < HTTPError
     CODE = 405
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super("Method Not Allowed: " + message, CODE, issue_kind)
+      super(_("Method Not Allowed: ") + message, CODE, issue_kind)
+    end
+  end
+
+  class HTTPUnsupportedMediaTypeError < HTTPError
+    CODE = 415
+    def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
+      super(_("Unsupported Media Type: ") + message, CODE, issue_kind)
     end
   end
 
   class HTTPServerError < HTTPError
     CODE = 500
 
-    attr_reader :backtrace
-
     def initialize(original_error, issue_kind = Issues::RUNTIME_ERROR)
-      super("Server Error: " + original_error.message, CODE, issue_kind)
-      @backtrace = ["Warning: The 'stacktrace' property is deprecated and will be removed in a future version of Puppet. For security reasons, stacktraces are not returned with Puppet HTTP Error responses."]
+      super(_("Server Error: ") + original_error.message, CODE, issue_kind)
     end
 
     def to_json
-      JSON({:message => message, :issue_kind => @issue_kind, :stacktrace => self.backtrace})
+      JSON({:message => message, :issue_kind => @issue_kind})
     end
   end
 end

data/lib/puppet/network/http/factory.rb

@@ -12,8 +12,6 @@ require 'puppet/util/http_proxy'
 class Puppet::Network::HTTP::Factory
   @@openssl_initialized = false
 
-  KEEP_ALIVE_TIMEOUT = 2**31 - 1
-
   def initialize
     # PUP-1411, make sure that openssl is initialized before we try to connect
     if ! @@openssl_initialized
@@ -39,16 +37,6 @@ class Puppet::Network::HTTP::Factory
     http.use_ssl = site.use_ssl?
     http.read_timeout = Puppet[:http_read_timeout]
     http.open_timeout = Puppet[:http_connect_timeout]
-    http.keep_alive_timeout = KEEP_ALIVE_TIMEOUT if http.respond_to?(:keep_alive_timeout=)
-
-    if Puppet[:sourceaddress]
-      if http.respond_to?(:local_host)
-        Puppet.debug("Using source IP #{Puppet[:sourceaddress]}")
-        http.local_host = Puppet[:sourceaddress]
-      else
-        raise ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP."
-      end
-    end
 
     if Puppet[:http_debug]
       http.set_debug_output($stderr)

data/lib/puppet/network/http/handler.rb

@@ -20,7 +20,7 @@ module Puppet::Network::HTTP::Handler
     routes.each { |r| dupes[r.path_matcher] = (dupes[r.path_matcher] || 0) + 1 }
     dupes = dupes.collect { |pm, count| pm if count > 1 }.compact
     if dupes.count > 0
-      raise ArgumentError, "Given multiple routes with identical path regexes: #{dupes.map{ |rgx| rgx.inspect }.join(', ')}"
+      raise ArgumentError, _("Given multiple routes with identical path regexes: %{regexes}") % { regexes: dupes.map{ |rgx| rgx.inspect }.join(', ') }
     end
 
     @routes = routes
@@ -36,6 +36,10 @@ module Puppet::Network::HTTP::Handler
     raise NotImplementedError
   end
 
+  # The mime type is always passed to the `set_content_type` method, so
+  # it is no longer necessary to retrieve the Format's mime type.
+  #
+  # @deprecated
   def format_to_mime(format)
     format.is_a?(Puppet::Network::Format) ? format.mime : format
   end
@@ -55,11 +59,11 @@ module Puppet::Network::HTTP::Handler
 
     profiler = configure_profiler(request_headers, request_params)
 
-    Puppet::Util::Profiler.profile("Processed request #{request_method} #{request_path}", [:http, request_method, request_path]) do
+    Puppet::Util::Profiler.profile(_("Processed request %{request_method} %{request_path}") % { request_method: request_method, request_path: request_path }, [:http, request_method, request_path]) do
       if route = @routes.find { |r| r.matches?(new_request) }
         route.process(new_request, new_response)
       else
-        raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No route for #{new_request.method} #{new_request.path}", HANDLER_NOT_FOUND)
+        raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("No route for %{request} %{path}") % { request: new_request.method, path: new_request.path }, HANDLER_NOT_FOUND)
       end
     end
 
@@ -94,7 +98,7 @@ module Puppet::Network::HTTP::Handler
     begin
       return Resolv.getname(result[:ip])
     rescue => detail
-      Puppet.err "Could not resolve #{result[:ip]}: #{detail}"
+      Puppet.err _("Could not resolve %{ip}: %{detail}") % { ip: result[:ip], detail: detail }
     end
     result[:ip]
   end

data/lib/puppet/network/http/issues.rb

@@ -8,4 +8,5 @@ module Puppet::Network::HTTP::Issues
   UNSUPPORTED_FORMAT = :UNSUPPORTED_FORMAT
   UNSUPPORTED_METHOD = :UNSUPPORTED_METHOD
   FAILED_AUTHORIZATION = :FAILED_AUTHORIZATION
+  UNSUPPORTED_MEDIA_TYPE = :UNSUPPORTED_MEDIA_TYPE
 end

data/lib/puppet/network/http/pool.rb

@@ -62,7 +62,7 @@ class Puppet::Network::HTTP::Pool
     Puppet.debug("Closing connection for #{site}")
     http.finish
   rescue => detail
-    Puppet.log_exception(detail, "Failed to close connection for #{site}: #{detail}")
+    Puppet.log_exception(detail, _("Failed to close connection for %{site}: %{detail}") % { site: site, detail: detail })
   end
 
   # Borrow and take ownership of a persistent connection. If a new

data/lib/puppet/network/http/rack.rb

@@ -23,9 +23,9 @@ class Puppet::Network::HTTP::Rack
       # Send a Status 500 Error on unhandled exceptions.
       response.status = 500
       response['Content-Type'] = 'text/plain'
-      response.write 'Internal Server Error: "%s"' % detail.message
+      response.write _('Internal Server Error: "%s"') % detail.message
       # log what happened
-      Puppet.log_exception(detail, "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message)
+      Puppet.log_exception(detail, _("Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"") % detail.message)
     end
     response.finish
   end

data/lib/puppet/network/http/rack/rest.rb

@@ -35,7 +35,7 @@ class Puppet::Network::HTTP::RackREST
   end
 
   def set_content_type(response, format)
-    response[ContentType] = format_to_mime(format)
+    response[ContentType] = format
   end
 
   # produce the body of the response

data/lib/puppet/network/http/request.rb

@@ -11,7 +11,7 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
           hash[:client_cert],
           hash[:body])
     else
-      raise ArgumentError, "Unknown arguments: #{unknown.collect(&:inspect).join(', ')}"
+      raise ArgumentError, _("Unknown arguments: %{args}") % { args: unknown.collect(&:inspect).join(', ') }
     end
   end
 
@@ -19,38 +19,52 @@ Puppet::Network::HTTP::Request = Struct.new(:headers, :params, :method, :path, :
     self.class.new(headers, params, method, path, routing_path.sub(prefix, ''), client_cert, body)
   end
 
-  def format
+  def formatter
     if header = headers['content-type']
       header.gsub!(/\s*;.*$/,'') # strip any charset
       format = Puppet::Network::FormatHandler.mime(header)
-      if format.nil?
-        raise "Client sent a mime-type (#{header}) that doesn't correspond to a format we support"
-      else
-        assert_supported_format(format)
-        return format.name.to_s if format.suitable?
-      end
+
+      return format if valid_network_format?(format)
+
+      #TRANSLATORS "mime-type" is a keyword and should not be translated
+      raise Puppet::Network::HTTP::Error::HTTPUnsupportedMediaTypeError.new(
+              _("Client sent a mime-type (%{header}) that doesn't correspond to a format we support") % { header: headers['content-type'] },
+              Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE)
     end
 
-    raise "No Content-Type header was received, it isn't possible to unserialize the request"
+    raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+            _("No Content-Type header was received, it isn't possible to unserialize the request"),
+            Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
   end
 
-  def response_formatter_for(supported_formats, accepted_formats = headers['accept'])
-    formatter = Puppet::Network::FormatHandler.most_suitable_format_for(
+  def response_formatters_for(supported_formats, default_accepted_formats = nil)
+    accepted_formats = headers['accept'] || default_accepted_formats
+
+    if accepted_formats.nil?
+      raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(_("Missing required Accept header"), Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
+    end
+
+    formats = Puppet::Network::FormatHandler.most_suitable_formats_for(
       accepted_formats.split(/\s*,\s*/),
       supported_formats)
 
-      if formatter.nil?
-        raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new("No supported formats are acceptable (Accept: #{accepted_formats})", Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
-      end
+    formats.find_all do |format|
+      # we are only passed supported_formats that are suitable
+      # and whose klass implements the required_methods
+      valid_network_format?(format)
+    end
 
-      assert_supported_format(formatter)
+    return formats unless formats.empty?
 
-      formatter
+    raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
+      _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: accepted_formats },
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
   end
 
-  def assert_supported_format(format)
-    if format.name == :yaml || format.name == :b64_zlib_yaml
-      raise Puppet::Error, "YAML in network requests is not supported. See http://links.puppetlabs.com/deprecate_yaml_on_network"
-    end
+  private
+
+  def valid_network_format?(format)
+    # YAML in network requests is not supported. See http://links.puppet.com/deprecate_yaml_on_network
+    format != nil && format.name != :yaml && format.name != :b64_zlib_yaml
   end
 end