puppet 4.10.12 → 5.0.0

data/lib/puppet/network/authconfig.rb

@@ -51,7 +51,7 @@ module Puppet
     def insert_default_acl
       self.class.default_acl.each do |acl|
         unless rights[acl[:acl]]
-          Puppet.info "Inserting default '#{acl[:acl]}' (auth #{acl[:authenticated]}) ACL"
+          Puppet.info _("Inserting default '%{acl}' (auth %{auth}) ACL") % { acl: acl[:acl], auth: acl[:authenticated] }
           mk_acl(acl)
         end
       end
@@ -79,7 +79,7 @@ module Puppet
     # is denied.
     def check_authorization(method, path, params)
       if authorization_failure_exception = @rights.is_request_forbidden_and_why?(method, path, params)
-        Puppet.warning("Denying access: #{authorization_failure_exception}")
+        Puppet.warning(_("Denying access: %{authorization_failure_exception}") % { authorization_failure_exception: authorization_failure_exception })
         raise authorization_failure_exception
       end
     end

data/lib/puppet/network/authstore.rb

@@ -33,7 +33,7 @@ module Puppet
         return decl.result
       end
 
-      info "defaulting to no access for #{name}"
+      info _("defaulting to no access for %{name}") % { name: name }
       false
     end
 
@@ -254,7 +254,7 @@ module Puppet
           bits = 8*segments.length
           [:inexact, bits, IPAddr.new((segments+[0,0,0])[0,4].join(".") + "/#{bits}")]
         else
-          raise AuthStoreError, "Invalid IP pattern #{value}"
+          raise AuthStoreError, _("Invalid IP pattern %{value}") % { value: value }
         end
       end
 

data/lib/puppet/network/format.rb

@@ -6,14 +6,12 @@ class Puppet::Network::Format
   include Puppet::Confiner
 
   attr_reader :name, :mime
-  attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods, :extension
+  attr_accessor :intern_method, :render_method, :intern_multiple_method, :render_multiple_method, :weight, :required_methods, :extension, :charset
 
   def init_attribute(name, default)
-    if value = @options[name]
-      @options.delete(name)
-    else
-      value = default
-    end
+    value = @options.delete(name)
+    value = default if value.nil?
+
     self.send(name.to_s + "=", value)
   end
 
@@ -36,6 +34,7 @@ class Puppet::Network::Format
     init_attribute(:weight, 5)
     init_attribute(:required_methods, method_list.keys)
     init_attribute(:extension, name.to_s)
+    init_attribute(:charset, nil)
 
     method_list.each do |method, value|
       init_attribute(method, value)
@@ -70,7 +69,8 @@ class Puppet::Network::Format
   def render_multiple(instances)
     # This method implicitly assumes that all instances are of the same type.
     return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
-    raise NotImplementedError, "#{instances[0].class} does not respond to #{render_multiple_method}; can not intern multiple instances to #{mime}"
+    raise NotImplementedError, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") \
+                               % { klass: instances[0].class, method: render_multiple_method, mime: mime }
   end
 
   def required_methods_present?(klass)

data/lib/puppet/network/format_handler.rb

@@ -62,7 +62,11 @@ module Puppet::Network::FormatHandler
     else
       out = format(format)
     end
-    raise ArgumentError, "No format match the given format name or mime-type (#{format})" if out.nil?
+
+    if out.nil?
+      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % {format: format}
+    end
+
     out.name
   end
 
@@ -74,10 +78,11 @@ module Puppet::Network::FormatHandler
   #   (most preferred is first)
   # @param supported [Array<Symbol>] the names of the supported formats (the
   #   most preferred format is first)
-  # @return [Puppet::Network::Format, nil] the most suitable format
+  # @return [Array<Puppet::Network::Format>] the most suitable formats that
+  #   are both accepted and supported
   # @api private
-  def self.most_suitable_format_for(accepted, supported)
-    format_name = accepted.collect do |format|
+  def self.most_suitable_formats_for(accepted, supported)
+    accepted.collect do |format|
       format.to_s.sub(/;q=.*$/, '')
     end.collect do |format|
       if format == ALL_MEDIA_TYPES
@@ -85,12 +90,10 @@ module Puppet::Network::FormatHandler
       else
         format_to_canonical_name_or_nil(format)
       end
-    end.find do |format|
+    end.compact.find_all do |format|
       supported.include?(format)
-    end
-
-    if format_name
-      format_for(format_name)
+    end.collect do |format|
+      format_for(format)
     end
   end
 

data/lib/puppet/network/format_support.rb

@@ -11,19 +11,22 @@ module Puppet::Network::FormatSupport
     def convert_from(format, data)
       get_format(format).intern(self, data)
     rescue => err
-      raise Puppet::Network::FormatHandler::FormatError, "Could not intern from #{format}: #{err}", err.backtrace
+      #TRANSLATORS "intern" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def convert_from_multiple(format, data)
       get_format(format).intern_multiple(self, data)
     rescue => err
-      raise Puppet::Network::FormatHandler::FormatError, "Could not intern_multiple from #{format}: #{err}", err.backtrace
+      #TRANSLATORS "intern_multiple" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern_multiple from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def render_multiple(format, instances)
       get_format(format).render_multiple(instances)
     rescue => err
-      raise Puppet::Network::FormatHandler::FormatError, "Could not render_multiple to #{format}: #{err}", err.backtrace
+      #TRANSLATORS "render_multiple" is a function name and should not be translated
+      raise Puppet::Network::FormatHandler::FormatError, _("Could not render_multiple to %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def default_format
@@ -88,6 +91,7 @@ module Puppet::Network::FormatSupport
     to_data_hash.to_msgpack(*args)
   end
 
+  # @deprecated, use to_json
   def to_pson(*args)
     to_data_hash.to_pson(*args)
   end
@@ -101,7 +105,8 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).render(self)
   rescue => err
-    raise Puppet::Network::FormatHandler::FormatError, "Could not render to #{format}: #{err}", err.backtrace
+    #TRANSLATORS "render" is a function name and should not be translated
+    raise Puppet::Network::FormatHandler::FormatError, _("Could not render to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
   def mime(format = nil)
@@ -109,7 +114,8 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).mime
   rescue => err
-    raise Puppet::Network::FormatHandler::FormatError, "Could not mime to #{format}: #{err}", err.backtrace
+    #TRANSLATORS "mime" is a function name and should not be translated
+    raise Puppet::Network::FormatHandler::FormatError, _("Could not mime to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
   def support_format?(name)

data/lib/puppet/network/formats.rb

@@ -1,4 +1,5 @@
 require 'puppet/network/format_handler'
+require 'json'
 
 Puppet::Network::FormatHandler.create_serialized_formats(:msgpack, :weight => 20, :mime => "application/x-msgpack", :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
 
@@ -30,7 +31,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
   def intern_multiple(klass, text)
     data = YAML.load(text)
     unless data.respond_to?(:collect)
-      raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a collection of instances when calling intern_multiple"
+      raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a collection of instances when calling intern_multiple")
     end
 
     data.collect do |datum|
@@ -42,7 +43,7 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
     return data if data.is_a?(klass)
 
     unless data.is_a? Hash
-      raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a valid instance of #{klass}"
+      raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}") % { klass: klass }
     end
 
     klass.from_data_hash(data)
@@ -62,28 +63,15 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
   end
 end
 
-Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :extension => "txt")
+Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :charset => Encoding::UTF_8, :extension => "txt")
 
-Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1) do
-  def intern_multiple(klass, text)
-    raise NotImplementedError
-  end
-
-  def render_multiple(instances)
-    raise NotImplementedError
-  end
-
-  # LAK:NOTE The format system isn't currently flexible enough to handle
-  # what I need to support raw formats just for individual instances (rather
-  # than both individual and collections), but we don't yet have enough data
-  # to make a "correct" design.
-  #   So, we hack it so it works for singular but fail if someone tries it
-  # on plurals.
-  def supported?(klass)
-    true
-  end
+# By default, to_binary is called to render and from_binary called to intern. Note unlike
+# text-based formats (json, yaml, etc), we don't use to_data_hash for binary.
+Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1,
+                                      :required_methods => [:render_method, :intern_method]) do
 end
 
+# PSON is deprecated
 Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
   def intern(klass, text)
     data_to_instance(klass, PSON.parse(text))
@@ -111,6 +99,31 @@ Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :
   end
 end
 
+Puppet::Network::FormatHandler.create_serialized_formats(:json, :mime => 'application/json', :charset => Encoding::UTF_8, :weight => 15, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
+  def intern(klass, text)
+    data_to_instance(klass, JSON.parse(text))
+  end
+
+  def intern_multiple(klass, text)
+    JSON.parse(text).collect do |data|
+      data_to_instance(klass, data)
+    end
+  end
+
+  # JSON monkey-patches Array, so this works.
+  # https://github.com/ruby/ruby/blob/ruby_1_9_3/ext/json/generator/generator.c#L1416
+  def render_multiple(instances)
+    instances.to_json
+  end
+
+  # Unlike PSON, we do not need to unwrap the data envelope, because legacy 3.x agents
+  # have never supported JSON
+  def data_to_instance(klass, data)
+    return data if data.is_a?(klass)
+    klass.from_data_hash(data)
+  end
+end
+
 # This is really only ever going to be used for Catalogs.
 Puppet::Network::FormatHandler.create_serialized_formats(:dot, :required_methods => [:render_method])
 
@@ -119,16 +132,14 @@ Puppet::Network::FormatHandler.create(:console,
                                       :mime   => 'text/x-console-text',
                                       :weight => 0) do
   def json
-    @json ||= Puppet::Network::FormatHandler.format(:pson)
+    @json ||= Puppet::Network::FormatHandler.format(:json)
   end
 
   def render(datum)
-    # String to String
-    return datum if datum.is_a? String
-    return datum if datum.is_a? Numeric
+    return datum if datum.is_a?(String) || datum.is_a?(Numeric)
 
     # Simple hash to table
-    if datum.is_a? Hash and datum.keys.all? { |x| x.is_a? String or x.is_a? Numeric }
+    if datum.is_a?(Hash) && datum.keys.all? { |x| x.is_a?(String) || x.is_a?(Numeric) }
       output = ''
       column_a = datum.empty? ? 2 : datum.map{ |k,v| k.to_s.length }.max + 2
       datum.sort_by { |k,v| k.to_s } .each do |key, value|
@@ -151,7 +162,7 @@ Puppet::Network::FormatHandler.create(:console,
     end
 
     # ...or pretty-print the inspect outcome.
-    return PSON.pretty_generate(datum)
+    JSON.pretty_generate(datum, :quirks_mode => true)
   end
 
   def render_multiple(data)

data/lib/puppet/network/http/api/indirected_routes.rb

@@ -40,7 +40,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       # TODO: should we tell the user we found an indirection but it doesn't
       # allow remote requests, or just pretend there's no handler at all? what
       # are the security implications for the former?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("No handler for #{indirection.name}", :NO_INDIRECTION_REMOTE_REQUESTS)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("No handler for %{indirection}") % { indirection: indirection.name }, :NO_INDIRECTION_REMOTE_REQUESTS)
     end
 
     trusted = Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate)
@@ -57,7 +57,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
 
     if indirection_name !~ /^\w+$/
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        "The indirection name must be purely alphanumeric, not '#{indirection_name}'")
+        _("The indirection name must be purely alphanumeric, not '%{indirection_name}'") % { indirection_name: indirection_name })
     end
 
     # this also depluralizes the indirection_name if it is a search
@@ -67,24 +67,24 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     # request
     if url_prefix != IndirectionType.url_prefix_for(indirection_name)
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        "Indirection '#{indirection_name}' does not match url prefix '#{url_prefix}'")
+        _("Indirection '%{indirection_name}' does not match url prefix '%{url_prefix}'") % { indirection_name: indirection_name, url_prefix: url_prefix })
     end
 
     indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
     if !indirection
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-        "Could not find indirection '#{indirection_name}'",
+        _("Could not find indirection '%{indirection_name}'") % { indirection_name: indirection_name },
         Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
     end
 
     if !environment
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        "An environment parameter must be specified")
+        _("An environment parameter must be specified"))
     end
 
     if ! Puppet::Node::Environment.valid_name?(environment)
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        "The environment must be purely alphanumeric, not '#{environment}'")
+        _("The environment must be purely alphanumeric, not '%{environment}'") % { environment: environment })
     end
 
     configured_environment = Puppet.lookup(:environments).get(environment)
@@ -101,14 +101,14 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
 
     if configured_environment.nil?
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
-        "Could not find environment '#{environment}'")
+        _("Could not find environment '%{environment}'") % { environment: environment })
     end
 
     params.delete(:bucket_path)
 
     if key == "" or key.nil?
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        "No request key specified in #{uri}")
+        _("No request key specified in %{uri}") % { uri: uri })
     end
 
     [indirection, method, key, params]
@@ -119,27 +119,28 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
   # Execute our find.
   def do_find(indirection, key, params, request, response)
     unless result = indirection.find(key, params)
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{indirection.name} #{key}", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("Could not find %{value0} %{key}") % { value0: indirection.name, key: key }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
     end
 
-    format = accepted_response_formatter_for(indirection.model, request)
-
     rendered_result = result
-    if result.respond_to?(:render)
-      Puppet::Util::Profiler.profile("Rendered result in #{format}", [:http, :v3_render, format]) do
-        rendered_result = result.render(format)
+
+    rendered_format = first_response_formatter_for(indirection.model, request) do |format|
+      if result.respond_to?(:render)
+        Puppet::Util::Profiler.profile(_("Rendered result in %{format}") % { format: format }, [:http, :v3_render, format]) do
+          rendered_result = result.render(format)
+        end
       end
     end
 
-    Puppet::Util::Profiler.profile("Sent response", [:http, :v3_response]) do
-      response.respond_with(200, format, rendered_result)
+    Puppet::Util::Profiler.profile(_("Sent response"), [:http, :v3_response]) do
+      response.respond_with(200, rendered_format, rendered_result)
     end
   end
 
   # Execute our head.
   def do_head(indirection, key, params, request, response)
     unless indirection.head(key, params)
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find #{indirection.name} #{key}", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("Could not find %{indirection} %{key}") % { indirection: indirection.name, key: key }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
     end
 
     # No need to set a response because no response is expected from a
@@ -151,17 +152,21 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     result = indirection.search(key, params)
 
     if result.nil?
-      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("Could not find instances in #{indirection.name} with '#{key}'", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("Could not find instances in %{indirection} with '%{key}'") % { indirection: indirection.name, key: key }, Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
     end
 
-    format = accepted_response_formatter_for(indirection.model, request)
+    rendered_result = nil
+
+    rendered_format = first_response_formatter_for(indirection.model, request) do |format|
+      rendered_result = indirection.model.render_multiple(format, result)
+    end
 
-    response.respond_with(200, format, indirection.model.render_multiple(format, result))
+    response.respond_with(200, rendered_format, rendered_result)
   end
 
   # Execute our destroy.
   def do_destroy(indirection, key, params, request, response)
-    formatter = accepted_response_formatter_or_pson_for(indirection.model, request)
+    formatter = accepted_response_formatter_or_json_for(indirection.model, request)
 
     result = indirection.destroy(key, params)
 
@@ -170,7 +175,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
 
   # Execute our save.
   def do_save(indirection, key, params, request, response)
-    formatter = accepted_response_formatter_or_pson_for(indirection.model, request)
+    formatter = accepted_response_formatter_or_json_for(indirection.model, request)
     sent_object = read_body_into_model(indirection.model, request)
 
     result = indirection.save(sent_object, key)
@@ -178,30 +183,64 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     response.respond_with(200, formatter, formatter.render(result))
   end
 
-  def accepted_response_formatter_for(model_class, request)
-    accepted_formats = request.headers['accept'] or raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new("Missing required Accept header", Puppet::Network::HTTP::Issues::MISSING_HEADER_FIELD)
-    request.response_formatter_for(model_class.supported_formats, accepted_formats)
+  # Return the first response formatter that didn't cause the yielded
+  # block to raise a FormatError.
+  def first_response_formatter_for(model, request, &block)
+    formats = accepted_response_formatters_for(model, request)
+    formatter = formats.find do |format|
+      begin
+        yield format
+        true
+      rescue Puppet::Network::FormatHandler::FormatError => e
+        false
+      end
+    end
+
+    return formatter if formatter
+
+    raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
+            _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats },
+            Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
+  end
+
+  # Return an array of response formatters that the client accepts and
+  # the server supports.
+  def accepted_response_formatters_for(model_class, request)
+    request.response_formatters_for(model_class.supported_formats)
   end
 
-  def accepted_response_formatter_or_pson_for(model_class, request)
-    accepted_formats = request.headers['accept'] || "text/pson"
-    request.response_formatter_for(model_class.supported_formats, accepted_formats)
+  # Return the first response formatter that the client accepts and
+  # the server supports, or default to 'application/json'.
+  def accepted_response_formatter_or_json_for(model_class, request)
+    request.response_formatters_for(model_class.supported_formats, "application/json").first
   end
 
   def read_body_into_model(model_class, request)
     data = request.body.to_s
+    formatter = request.formatter
+
+    if formatter.supported?(model_class)
+      begin
+        return model_class.convert_from(formatter.name.to_s, data)
+      rescue => e
+        raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
+          _("The request body is invalid: %{message}") % { message: e.message })
+      end
+    end
 
-    format = request.format
-    model_class.convert_from(format, data)
+    #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: request.headers['content-type'] },
+      Puppet::Network::HTTP::Issues::UNSUPPORTED_MEDIA_TYPE)
   end
 
   def indirection_method(http_method, indirection)
     raise Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError.new(
-      "No support for http method #{http_method}") unless METHOD_MAP[http_method]
+      _("No support for http method %{http_method}") % { http_method: http_method }) unless METHOD_MAP[http_method]
 
     unless method = METHOD_MAP[http_method][plurality(indirection)]
       raise Puppet::Network::HTTP::Error::HTTPBadRequestError.new(
-        "No support for plurality #{plurality(indirection)} for #{http_method} operations")
+        _("No support for plurality %{indirection} for %{http_method} operations") % { indirection: plurality(indirection), http_method: http_method })
     end
 
     method
@@ -215,7 +254,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
   def self.request_to_uri_and_body(request)
     url_prefix = IndirectionType.url_prefix_for(request.indirection_name.to_s)
     indirection = request.method == :search ? pluralize(request.indirection_name.to_s) : request.indirection_name.to_s
-    ["#{url_prefix}/#{indirection}/#{request.escaped_key}", "environment=#{request.environment.name}&#{request.query_string}"]
+    ["#{url_prefix}/#{indirection}/#{Puppet::Util.uri_encode(request.key)}", "environment=#{request.environment.name}&#{request.query_string}"]
   end
 
   def self.pluralize(indirection)