puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

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

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

@@ -5,7 +5,19 @@ class Puppet::Network::HTTP::Response
   end
 
   def respond_with(code, type, body)
-    @handler.set_content_type(@response, type)
+    format = Puppet::Network::FormatHandler.format_for(type)
+    mime = format.mime
+    charset = format.charset
+
+    if charset
+      if body.is_a?(String) && body.encoding != charset
+        body.encode!(charset)
+      end
+
+      mime += "; charset=#{charset.name.downcase}"
+    end
+
+    @handler.set_content_type(@response, mime)
     @handler.set_response(@response, body, code)
   end
 end

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

@@ -17,15 +17,17 @@ class Puppet::Network::HTTP::WEBrick
   def listen(address, port)
     @server = create_server(address, port)
 
+    @server.listeners.each { |l| l.start_immediately = false }
+
     @server.mount('/', Puppet::Network::HTTP::WEBrickREST)
 
-    raise "WEBrick server is already listening" if @listening
+    raise _("WEBrick server is already listening") if @listening
     @listening = true
     @thread = Thread.new do
       @server.start do |sock|
         timeout = 10.0
         if ! IO.select([sock],nil,nil,timeout)
-          raise "Client did not send data within %.1f seconds of connecting" % timeout
+          raise _("Client did not send data within %.1f seconds of connecting") % timeout
         end
         sock.accept
         @server.run(sock)
@@ -35,7 +37,7 @@ class Puppet::Network::HTTP::WEBrick
   end
 
   def unlisten
-    raise "WEBrick server is not listening" unless @listening
+    raise _("WEBrick server is not listening") unless @listening
     @server.shutdown
     wait_for_shutdown
     @server = nil
@@ -95,15 +97,15 @@ class Puppet::Network::HTTP::WEBrick
     # Get the cached copy.  We know it's been generated, too.
     host = Puppet::SSL::Host.localhost
 
-    raise Puppet::Error, "Could not retrieve certificate for #{host.name} and not running on a valid certificate authority" unless host.certificate
+    raise Puppet::Error, _("Could not retrieve certificate for %{host} and not running on a valid certificate authority") % { value0: host.name } unless host.certificate
 
     results[:SSLPrivateKey] = host.key.content
     results[:SSLCertificate] = host.certificate.content
-    results[:SSLStartImmediately] = false
+    results[:SSLStartImmediately] = true
     results[:SSLEnable] = true
     results[:SSLOptions] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
 
-    raise Puppet::Error, "Could not find CA certificate" unless Puppet::SSL::Certificate.indirection.find(Puppet::SSL::CA_NAME)
+    raise Puppet::Error, _("Could not find CA certificate") unless Puppet::SSL::Certificate.indirection.find(Puppet::SSL::CA_NAME)
 
     results[:SSLCACertificateFile] = ssl_configuration.ca_auth_file
     results[:SSLVerifyClient] = OpenSSL::SSL::VERIFY_PEER

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

@@ -13,7 +13,7 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def initialize(server)
-    raise ArgumentError, "server is required" unless server
+    raise ArgumentError, _("server is required") unless server
     register([Puppet::Network::HTTP::API.master_routes,
               Puppet::Network::HTTP::API.ca_routes,
               Puppet::Network::HTTP::API.not_found_upgrade])
@@ -80,7 +80,7 @@ class Puppet::Network::HTTP::WEBrickREST < WEBrick::HTTPServlet::AbstractServlet
 
   # Set the specified format as the content type of the response.
   def set_content_type(response, format)
-    response["content-type"] = format_to_mime(format)
+    response["content-type"] = format
   end
 
   def set_response(response, result, status = 200)

data/lib/puppet/network/rights.rb

@@ -55,7 +55,7 @@ class Rights
     # case will return an error to the outside world
     msg = "#{name} [#{args[:method]}]"
 
-    AuthorizationError.new("Forbidden request: #{msg}")
+    AuthorizationError.new(_("Forbidden request: %{msg}") % { msg: msg })
   end
 
   def initialize
@@ -123,7 +123,7 @@ class Rights
         @name = name.gsub(/^~\s+/,'')
         @key = Regexp.new(@name)
       else
-        raise ArgumentError, "Unknown right type '#{name}'"
+        raise ArgumentError, _("Unknown right type '%{name}'") % { name: name }
       end
 
       super()
@@ -165,21 +165,21 @@ class Rights
     def restrict_method(m)
       m = m.intern if m.is_a?(String)
 
-      raise ArgumentError, "'#{m}' is not an allowed value for method directive" unless ALL.include?(m)
+      raise ArgumentError, _("'%{m}' is not an allowed value for method directive") % { m: m } unless ALL.include?(m)
 
       # if we were allowing all methods, then starts from scratch
       if @methods === ALL
         @methods = []
       end
 
-      raise ArgumentError, "'#{m}' is already in the '#{name}' ACL" if @methods.include?(m)
+      raise ArgumentError, _("'%{m}' is already in the '%{name}' ACL") % { m: m, name: name } if @methods.include?(m)
 
       @methods << m
     end
 
     def restrict_environment(environment)
       env = Puppet.lookup(:environments).get(environment)
-      raise ArgumentError, "'#{env}' is already in the '#{name}' ACL" if @environment.include?(env)
+      raise ArgumentError, _("'%{env}' is already in the '%{name}' ACL") % { env: env, name: name } if @environment.include?(env)
 
       @environment << env
     end
@@ -191,7 +191,7 @@ class Rights
       when "no", "off", "false", false, "all" ,"any", :all, :any
         authentication = false
       else
-        raise ArgumentError, "'#{name}' incorrect authenticated value: #{authentication}"
+        raise ArgumentError, _("'%{name}' incorrect authenticated value: %{authentication}") % { name: name, authentication: authentication }
       end
       @authentication = authentication
     end

data/lib/puppet/network/server.rb

@@ -22,13 +22,13 @@ class Puppet::Network::Server
   end
 
   def start
-    raise "Cannot listen -- already listening." if listening?
+    raise _("Cannot listen -- already listening.") if listening?
     @listening = true
     @http_server.listen(address, port)
   end
 
   def stop
-    raise "Cannot unlisten -- not currently listening." unless listening?
+    raise _("Cannot unlisten -- not currently listening.") unless listening?
     @http_server.unlisten
     @listening = false
   end

data/lib/puppet/node.rb

@@ -24,10 +24,13 @@ class Puppet::Node
   ENVIRONMENT = 'environment'.freeze
 
   def initialize_from_hash(data)
-    @name       = data['name']       || (raise ArgumentError, "No name provided in serialized data")
+    @name       = data['name']       || (raise ArgumentError, _("No name provided in serialized data"))
     @classes    = data['classes']    || []
     @parameters = data['parameters'] || {}
-    @environment_name = data['environment']
+    env_name = data['environment']
+    env_name = env_name.intern unless env_name.nil?
+    @environment_name = env_name
+    environment = env_name
   end
 
   def self.from_data_hash(data)
@@ -39,7 +42,7 @@ class Puppet::Node
   def to_data_hash
     result = {
       'name' => name,
-      'environment' => environment.name,
+      'environment' => environment.name.to_s,
     }
     result['classes'] = classes unless classes.empty?
     result['parameters'] = parameters unless parameters.empty?
@@ -86,7 +89,7 @@ class Puppet::Node
   end
 
   def initialize(name, options = {})
-    raise ArgumentError, "Node names cannot be nil" unless name
+    raise ArgumentError, _("Node names cannot be nil") unless name
     @name = name
 
     if classes = options[:classes]
@@ -113,22 +116,31 @@ class Puppet::Node
   end
 
   # Merge the node facts with parameters from the node source.
-  def fact_merge
-    if @facts = Puppet::Node::Facts.indirection.find(name, :environment => environment)
+  # @api public
+  # @param facts [optional, Puppet::Node::Facts] facts to merge into node parameters.
+  #   Will query Facts indirection if not supplied.
+  # @raise [Puppet::Error] Raise on failure to retrieve facts if not supplied
+  # @return [nil]
+  def fact_merge(facts = nil)
+    begin
+      @facts = facts.nil? ? Puppet::Node::Facts.indirection.find(name, :environment => environment) : facts
+    rescue => detail
+      error = Puppet::Error.new(_("Could not retrieve facts for %{name}: %{detail}") % { name: name, detail: detail }, detail)
+      error.set_backtrace(detail.backtrace)
+      raise error
+    end
+
+    if !@facts.nil?
       @facts.sanitize
       merge(@facts.values)
     end
-  rescue => detail
-    error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
-    error.set_backtrace(detail.backtrace)
-    raise error
   end
 
   # Merge any random parameters into our parameter list.
   def merge(params)
     params.each do |name, value|
       if @parameters.include?(name)
-        Puppet::Util::Warnings.warnonce("The node parameter '#{name}' for node '#{@name}' was already set to '#{@parameters[name]}'. It could not be set to '#{value}'")
+        Puppet::Util::Warnings.warnonce(_("The node parameter '%{param_name}' for node '%{node_name}' was already set to '%{value}'. It could not be set to '%{desired_value}'") % { param_name: name, node_name: @name, value: @parameters[name], desired_value: value })
       else
         @parameters[name] = value
       end
@@ -137,16 +149,6 @@ class Puppet::Node
     @parameters[ENVIRONMENT] ||= self.environment.name.to_s
   end
 
-  # Add extra facts, such as facts given to lookup on the command line The
-  # extra facts will override existing ones.
-  # @param extra_facts [Hash{String=>Object}] the facts to tadd
-  # @api private
-  def add_extra_facts(extra_facts)
-    @facts.add_extra_values(extra_facts)
-    @parameters.merge!(extra_facts)
-    nil
-  end
-
   def add_server_facts(facts)
     # Append the current environment to the list of server facts
     @server_facts = facts.merge({ "environment" => self.environment.name.to_s})
@@ -169,7 +171,7 @@ class Puppet::Node
       if parameters["hostname"] and parameters["domain"]
         fqdn = parameters["hostname"] + "." + parameters["domain"]
       else
-        Puppet.warning "Host is missing hostname and/or domain: #{name}"
+        Puppet.warning _("Host is missing hostname and/or domain: %{name}") % { name: name }
       end
     end
 
@@ -201,7 +203,7 @@ class Puppet::Node
   # Ensures the data is frozen
   #
   def trusted_data=(data)
-    Puppet.warning("Trusted node data modified for node #{name}") unless @trusted_data.nil?
+    Puppet.warning(_("Trusted node data modified for node %{name}") % { name: name }) unless @trusted_data.nil?
     @trusted_data = data.freeze
   end
 end