puppet 5.0.0 → 6.0.0

data/lib/puppet/resource/catalog.rb

@@ -100,7 +100,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     resources.each do |resource|
       other_title_key = title_key_for_ref(other.ref)
       idx = @resources.index(other_title_key)
-      raise ArgumentError, "Cannot add resource #{resource.ref} before #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      if idx.nil?
+        raise ArgumentError, _("Cannot add resource %{resource_1} before %{resource_2} because %{resource_2} is not yet in the catalog") %
+            { resource_1: resource.ref, resource_2: other.ref }
+      end
       add_one_resource(resource, idx)
     end
   end
@@ -112,7 +115,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     resources.each do |resource|
       other_title_key = title_key_for_ref(other.ref)
       idx = @resources.index(other_title_key)
-      raise ArgumentError, "Cannot add resource #{resource.ref} after #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      if idx.nil?
+        raise ArgumentError, _("Cannot add resource %{resource_1} after %{resource_2} because %{resource_2} is not yet in the catalog") %
+            { resource_1: resource.ref, resource_2: other.ref }
+      end
       add_one_resource(resource, idx+1)
     end
   end
@@ -193,10 +199,17 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     # isn't sufficient.
     if existing = @resource_table[newref]
       return if existing == resource
-      resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
-      existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
-      #TRANSLATORS "resource" here is a Puppet type and should not be translated
-      msg = _("Cannot alias %{ref} to %{key}%{resource_declaration}; resource %{newref} already declared%{existing_declaration}") % { ref: ref, key: key.inspect, resource_declaration: resource_declaration, newref: newref.inspect, existing_declaration: existing_declaration }
+      resource_declaration = Puppet::Util::Errors.error_location(resource.file, resource.line)
+      msg = if resource_declaration.empty?
+              #TRANSLATORS 'alias' should not be translated
+              _("Cannot alias %{resource} to %{key}; resource %{newref} already declared") %
+                  { resource: ref, key: key.inspect, newref: newref.inspect }
+            else
+              #TRANSLATORS 'alias' should not be translated
+              _("Cannot alias %{resource} to %{key} at %{resource_declaration}; resource %{newref} already declared") %
+                  { resource: ref, key: key.inspect, resource_declaration: resource_declaration, newref: newref.inspect }
+            end
+      msg += Puppet::Util::Errors.error_location_with_space(existing.file, existing.line)
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
@@ -222,7 +235,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
     begin
       transaction.report.as_logging_destination do
-        transaction.evaluate
+        transaction_evaluate_time = Puppet::Util.thinmark do
+          transaction.evaluate
+        end
+        transaction.report.add_times(:transaction_evaluation, transaction_evaluate_time)
       end
     ensure
       # Don't try to store state unless we're a host config
@@ -271,7 +287,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Create a new resource and register it in the catalog.
   def create_resource(type, options)
     unless klass = Puppet::Type.type(type)
-      raise ArgumentError, "Unknown resource type #{type}"
+      raise ArgumentError, _("Unknown resource type %{type}") % { type: type }
     end
     return unless resource = klass.new(options)
 
@@ -361,8 +377,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     result = @resource_table[title_key]
     if result.nil?
       # an instance has to be created in order to construct the unique key used when
-      # searching for aliases, or when app_management is active and nothing is found in
-      # which case it is needed by the CapabilityFinder.
+      # searching for aliases, or nothing is found as it is needed by the CapabilityFinder.
       res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
 
       # Must check with uniqueness key because of aliases or if resource transforms title in title
@@ -433,12 +448,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       edges.each do |edge_hash|
         edge = Puppet::Relationship.from_data_hash(edge_hash)
         unless source = result.resource(edge.source)
-          raise ArgumentError, "Could not intern from data: Could not find relationship source #{edge.source.inspect} for #{edge.target.to_s}"
+          raise ArgumentError, _("Could not intern from data: Could not find relationship source %{source} for %{target}") %
+              { source: edge.source.inspect, target: edge.target.to_s }
         end
         edge.source = source
 
         unless target = result.resource(edge.target)
-          raise ArgumentError, "Could not intern from data: Could not find relationship target #{edge.target.inspect} for #{edge.source.to_s}"
+          raise ArgumentError, _("Could not intern from data: Could not find relationship target %{target} for %{source}") %
+              { target: edge.target.inspect, source: edge.source.to_s }
         end
         edge.target = target
 
@@ -524,7 +541,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Store the classes in the classfile.
   def write_class_file
     # classfile paths may contain UTF-8
-    # https://docs.puppet.com/puppet/latest/reference/configuration.html#classfile
+    # https://puppet.com/docs/puppet/latest/configuration.html#classfile
     classfile = Puppet.settings.setting(:classfile)
     Puppet::FileSystem.open(classfile.value, classfile.mode.to_i(8), "w:UTF-8") do |f|
       f.puts classes.join("\n")
@@ -536,7 +553,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Store the list of resources we manage
   def write_resource_file
     # resourcefile contains resources that may be UTF-8 names
-    # https://docs.puppet.com/puppet/latest/reference/configuration.html#resourcefile
+    # https://puppet.com/docs/puppet/latest/configuration.html#resourcefile
     resourcefile = Puppet.settings.setting(:resourcefile)
     Puppet::FileSystem.open(resourcefile.value, resourcefile.mode.to_i(8), "w:UTF-8") do |f|
       to_print = resources.map do |resource|
@@ -564,23 +581,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   private
 
   def prioritizer
-    @prioritizer ||= case Puppet[:ordering]
-                     when "title-hash"
-                       Puppet::Graph::TitleHashPrioritizer.new
-                     when "manifest"
-                       Puppet::Graph::SequentialPrioritizer.new
-                     when "random"
-                       Puppet::Graph::RandomPrioritizer.new
-                     else
-                       raise Puppet::DevError, "Unknown ordering type #{Puppet[:ordering]}"
-                     end
+    @prioritizer = Puppet::Graph::SequentialPrioritizer.new
   end
 
   def create_transaction(options)
     transaction = Puppet::Transaction.new(self, options[:report], prioritizer)
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
-    transaction.for_network_device = options[:network_device]
+    transaction.for_network_device = Puppet.lookup(:network_device) { nil } || options[:network_device]
 
     transaction
   end
@@ -591,12 +599,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     return unless existing_resource = @resource_table[title_key]
 
     # If we've gotten this far, it's a real conflict
-    msg = "Duplicate declaration: #{resource.ref} is already declared"
-
-    msg << " in file #{existing_resource.file}:#{existing_resource.line}" if existing_resource.file and existing_resource.line
-
-    msg << "; cannot redeclare"
-
+    error_location_str = Puppet::Util::Errors.error_location(existing_resource.file, existing_resource.line)
+    msg = if error_location_str.empty?
+            _("Duplicate declaration: %{resource} is already declared; cannot redeclare") % { resource: resource.ref }
+          else
+            _("Duplicate declaration: %{resource} is already declared at %{error_location}; cannot redeclare") % { resource: resource.ref, error_location: error_location_str }
+          end
     raise DuplicateResourceError.new(msg, resource.file, resource.line)
   end
 
@@ -643,11 +651,11 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       next if block_given? and yield edge.target
 
       unless source = map[edge.source.ref]
-        raise Puppet::DevError, "Could not find resource #{edge.source.ref} when converting #{message} resources"
+        raise Puppet::DevError, _("Could not find resource %{resource} when converting %{message} resources") % { resource: edge.source.ref, message: message }
       end
 
       unless target = map[edge.target.ref]
-        raise Puppet::DevError, "Could not find resource #{edge.target.ref} when converting #{message} resources"
+        raise Puppet::DevError, _("Could not find resource %{resource} when converting %{message} resources") % { resource: edge.target.ref, message: message }
       end
 
       result.add_edge(source, target, edge.label)
@@ -656,7 +664,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     map.clear
 
     result.add_class(*self.classes)
-    result.tag(*self.tags)
+    result.merge_tags_from(self)
 
     result
   end

data/lib/puppet/resource/status.rb

@@ -31,7 +31,7 @@ module Puppet
 
       # Boolean status types set while evaluating `@real_resource`.
       STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled, :corrective_change]
-      attr_accessor *STATES
+      attr_accessor(*STATES)
 
       # @!attribute [r] source_description
       #   @return [String] The textual description of the path to `@real_resource`
@@ -74,6 +74,10 @@ module Puppet
       #   @return [String] The class name of `@real_resource`
       attr_reader :resource_type
 
+      # @!attribute [rw] provider_used
+      #   @return [String] The class name of the provider used for the resource
+      attr_accessor :provider_used
+
       # @!attribute [r] title
       #   @return [String] The title of `@real_resource`
       attr_reader :title
@@ -144,7 +148,6 @@ module Puppet
       # Puppet::Transaction::Event failure with the given message.
       # @param message [String] the reason for a status failure
       def fail_with_event(message)
-        failed = true
         add_event(@real_resource.event(:name => :resource_error, :status => "failure", :message => message))
       end
 
@@ -164,15 +167,17 @@ module Puppet
         @file = resource.file
         @line = resource.line
 
-        tag(*resource.tags)
+        merge_tags_from(resource)
         @time = Time.now
         @events = []
         @resource_type = resource.type.to_s.capitalize
+        @provider_used = resource.provider.class.name.to_s unless resource.provider.nil?
         @title = resource.title
       end
 
       def initialize_from_hash(data)
         @resource_type = data['resource_type']
+        @provider_used = data['provider_used']
         @title = data['title']
         @resource = data['resource']
         @containment_path = data['containment_path']
@@ -188,6 +193,7 @@ module Puppet
         @changed = data['changed']
         @skipped = data['skipped']
         @failed = data['failed']
+        @failed_to_restart = data['failed_to_restart']
         @corrective_change = data['corrective_change']
         @events = data['events'].map do |event|
           # Older versions contain tags that causes Psych to create instances directly
@@ -202,11 +208,13 @@ module Puppet
           'line' => @line,
           'resource' => @resource,
           'resource_type' => @resource_type,
+          'provider_used' => @provider_used,
           'containment_path' => @containment_path,
           'evaluation_time' => @evaluation_time,
           'tags' => @tags.to_a,
           'time' => @time.iso8601(9),
           'failed' => @failed,
+          'failed_to_restart' => self.failed_to_restart?,
           'changed' => @changed,
           'out_of_sync' => @out_of_sync,
           'skipped' => @skipped,

data/lib/puppet/resource/type.rb

@@ -43,7 +43,7 @@ class Puppet::Resource::Type
   #   :capability  - the type name of the capres produced/consumed
   #   :mappings    - a hash of attribute_name => Expression
   # These two attributes are populated in
-  # PopsBridge::instantiate_CapabilityMaping
+  # PopsBridge::instantiate_CapabilityMapping
 
   # Map from argument (aka parameter) names to Puppet Type
   # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
@@ -140,7 +140,7 @@ class Puppet::Resource::Type
 
   def initialize(type, name, options = {})
     @type = type.to_s.downcase.to_sym
-    raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_KINDS.include?(@type)
+    raise ArgumentError, _("Invalid resource supertype '%{type}'") % { type: type } unless RESOURCE_KINDS.include?(@type)
 
     name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
 
@@ -189,8 +189,12 @@ class Puppet::Resource::Type
   def merge(other)
     fail _("%{name} is not a class; cannot add code to it") % { name: name } unless type == :hostclass
     fail _("%{name} is not a class; cannot add code from it") % { name: other.name } unless other.type == :hostclass
-    fail _("Cannot have code outside of a class/node/define because 'freeze_main' is enabled") if name == "" and Puppet.settings[:freeze_main]
-
+    if name == "" && Puppet.settings[:freeze_main]
+      # It is ok to merge definitions into main even if freeze is on (definitions are nodes, classes, defines, functions, and types)
+      unless other.code.is_definitions_only?
+        fail _("Cannot have code outside of a class/node/define because 'freeze_main' is enabled")
+      end
+    end
     if parent and other.parent and parent != other.parent
       fail _("Cannot merge classes with different parent classes (%{name} => %{parent} vs. %{other_name} => %{other_parent})") % { name: name, parent: parent, other_name: other.name, other_parent: other.parent }
     end
@@ -223,7 +227,7 @@ class Puppet::Resource::Type
     resource_type =
     case type
     when :definition
-      raise ArgumentError, 'Cannot create resources for defined resource types'
+      raise ArgumentError, _('Cannot create resources for defined resource types')
     when :hostclass
       :class
     when :node
@@ -258,7 +262,7 @@ class Puppet::Resource::Type
     end
 
     if ['Class', 'Node'].include? resource.type
-      scope.catalog.tag(*resource.tags)
+      scope.catalog.merge_tags_from(resource)
     end
   end
 
@@ -420,10 +424,10 @@ class Puppet::Resource::Type
     name_to_type_hash.each do |name, t|
       # catch internal errors
       unless @arguments.include?(name)
-        raise Puppet::DevError, "Parameter '#{name}' is given a type, but is not a valid parameter."
+        raise Puppet::DevError, _("Parameter '%{name}' is given a type, but is not a valid parameter.") % { name: name }
       end
       unless t.is_a? Puppet::Pops::Types::PAnyType
-        raise Puppet::DevError, "Parameter '#{name}' is given a type that is not a Puppet Type, got #{t.class}"
+        raise Puppet::DevError, _("Parameter '%{name}' is given a type that is not a Puppet Type, got %{class_name}") % { name: name, class_name: t.class }
       end
       @argument_types[name] = t
     end
@@ -442,9 +446,9 @@ class Puppet::Resource::Type
   def convert_from_ast(name)
     value = name.value
     if value.is_a?(Puppet::Parser::AST::Regex)
-      name = value.value
+      value.value
     else
-      name = value
+      value
     end
   end
 
@@ -463,7 +467,7 @@ class Puppet::Resource::Type
   end
 
   def parent_scope(scope, klass)
-    scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
+    scope.class_scope(klass) || raise(Puppet::DevError, _("Could not find scope for %{class_name}") % { class_name: klass.name })
   end
 
   def set_name_and_namespace(name)
@@ -476,7 +480,7 @@ class Puppet::Resource::Type
       # Note we're doing something somewhat weird here -- we're setting
       # the class's namespace to its fully qualified name.  This means
       # anything inside that class starts looking in that namespace first.
-      @namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
+      @namespace, _ = @type == :hostclass ? [@name, ''] : namesplit(@name)
     end
   end
 

data/lib/puppet/resource/type_collection.rb

@@ -58,7 +58,7 @@ class Puppet::Resource::TypeCollection
 
   def add(instance)
     # return a merged instance, or the given
-    result = catch(:merged) {
+    catch(:merged) {
       send("add_#{instance.type}", instance)
       instance.resource_type_collection = self
       instance
@@ -208,7 +208,7 @@ class Puppet::Resource::TypeCollection
       if environment.config_version.nil? || environment.config_version == ""
         @version = Time.now.to_i
       else
-        @version = Puppet::Util::Execution.execute([environment.config_version]).strip
+        @version = Puppet::Util::Execution.execute([environment.config_version]).to_s.strip
       end
     end
 

data/lib/puppet/resource.rb

@@ -12,7 +12,7 @@ class Puppet::Resource
 
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
-  attr_reader :type, :title, :parameters, :rich_data_enabled
+  attr_reader :type, :title, :parameters
 
   # @!attribute [rw] sensitive_parameters
   #   @api private
@@ -34,7 +34,7 @@ class Puppet::Resource
   TYPE_NODE  = 'Node'.freeze
   TYPE_SITE  = 'Site'.freeze
 
-  PCORE_TYPE_KEY = '__pcore_type__'.freeze
+  PCORE_TYPE_KEY = '__ptype'.freeze
   VALUE_KEY = 'value'.freeze
 
   def self.from_data_hash(data)
@@ -63,7 +63,7 @@ class Puppet::Resource
     end
 
     if tags = data['tags']
-      tags.each { |t| tag(t) }
+      tag(*tags)
     end
 
     ATTRIBUTES.each do |a|
@@ -76,6 +76,13 @@ class Puppet::Resource
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
 
+  # Produces a Data compliant hash of the resource.
+  # The result depends on the --rich_data setting, and the context value
+  # for Puppet.lookup(:stringify_rich), that if it is `true` will use the
+  # ToStringifiedConverter to produce the value per parameter.
+  # (Note that the ToStringifiedConverter output is lossy and should not
+  # be used when producing a catalog serialization).
+  #
   def to_data_hash
     data = {
       'type' => type,
@@ -89,17 +96,27 @@ class Puppet::Resource
 
     data['exported'] ||= false
 
+    # To get stringified parameter values the flag :stringify_rich can be set
+    # in the puppet context.
+    #
+    stringify = Puppet.lookup(:stringify_rich) { false }
+    converter = stringify ? Puppet::Pops::Serialization::ToStringifiedConverter.new : nil
+
     params = {}
     self.to_hash.each_pair do |param, value|
       # Don't duplicate the title as the namevar
       unless param == namevar && value == title
-        params[param.to_s] = Puppet::Resource.value_to_json_data(value)
+        if stringify
+          params[param.to_s] = converter.convert(value)
+        else
+          params[param.to_s] = Puppet::Resource.value_to_json_data(value)
+        end
       end
     end
 
     unless params.empty?
       data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, {
-        :rich_data => environment.rich_data?,
+        :rich_data => Puppet.lookup(:rich_data),
         :symbol_as_string => true,
         :local_reference => false,
         :type_by_reference => true,
@@ -251,11 +268,12 @@ class Puppet::Resource
       @sensitive_parameters.replace(type.sensitive_parameters)
     else
       if type.is_a?(Hash)
-        raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
-          "Did you mean (#{(type[:type] || type["type"]).inspect}, #{(type[:title] || type["title"]).inspect }) ?"
+        #TRANSLATORS 'Puppet::Resource.new' should not be translated
+        raise ArgumentError, _("Puppet::Resource.new does not take a hash as the first argument.") + ' ' +
+          _("Did you mean (%{type}, %{title}) ?") %
+              { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect }
       end
 
-      environment = attributes[:environment]
       # In order to avoid an expensive search of 'known_resource_types" and
       # to obey/preserve the implementation of the resource's type - if the
       # given type is a resource type implementation (one of):
@@ -277,7 +295,7 @@ class Puppet::Resource
       end
       @exported = false
 
-      # Set things like strictness first.
+      # Set things like environment, strictness first.
       attributes.each do |attr, value|
         next if attr == :parameters
         send(attr.to_s + "=", value)
@@ -289,9 +307,9 @@ class Puppet::Resource
 
       if strict? && rt.nil?
         if self.class?
-          raise ArgumentError, "Could not find declared class #{title}"
+          raise ArgumentError, _("Could not find declared class %{title}") % { title: title }
         else
-          raise ArgumentError, "Invalid resource type #{type}"
+          raise ArgumentError, _("Invalid resource type %{type}") % { type: type }
         end
       end
 
@@ -588,7 +606,7 @@ class Puppet::Resource
     elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
     elsif argtitle                                             then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
-    else  raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
+    else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect }
     end
   end
   private_class_method :extract_type_and_title

data/lib/puppet/rest/client.rb

@@ -0,0 +1,83 @@
+require 'httpclient'
+
+require 'puppet'
+require 'puppet/rest/response'
+require 'puppet/rest/errors'
+require 'puppet/util/ssl'
+
+module Puppet::Rest
+  class Client
+    attr_reader :dns_resolver
+
+    # Create a new HTTP client for querying the given API.
+    # @param [Puppet::Rest::SSLContext] ssl_context the SSL configuration for this client
+    # @param [Integer] receive_timeout how long in seconds this client will wait
+    #                  for a response after making a request
+    # @param [HTTPClient] client the third-party HTTP client wrapped by this
+    #                     class. This param is only used for testing.
+    def initialize(ssl_context:,
+                   receive_timeout: Puppet[:http_read_timeout],
+                   client: HTTPClient.new(agent_name: nil,
+                                          default_header: {
+                                            'User-Agent' => Puppet[:http_user_agent],
+                                            'X-PUPPET-VERSION' => Puppet::PUPPETVERSION
+                                          }))
+      @client = client
+      @client.tcp_keepalive = true
+      @client.connect_timeout = Puppet[:http_connect_timeout]
+      @client.receive_timeout = receive_timeout
+      @client.transparent_gzip_decompression = true
+
+      if Puppet[:http_debug]
+        @client.debug_dev = $stderr
+      end
+
+      @ca_path = Puppet[:ssl_client_ca_auth] || Puppet[:localcacert]
+      @verifier = Puppet::SSL::Validator::DefaultValidator.new(@ca_path)
+      configure_verify_mode(ssl_context)
+
+      @dns_resolver = Puppet::Network::Resolver.new
+    end
+
+    # Make a GET request to the specified URL with the specified params.
+    # @param [URI::HTTPS] url the full path to query
+    # @param [Hash] query any URL params to add to send to the endpoint
+    # @param [Hash] header any additional entries to add to the default header
+    # @yields [String] chunks of the response body
+    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
+    def get(url, query: nil, header: nil, &block)
+      begin
+        @client.get_content(url.to_s, { query: query, header: header }) do |chunk|
+          block.call(chunk)
+        end
+      rescue HTTPClient::BadResponseError => e
+        raise Puppet::Rest::ResponseError.new(e.message, Puppet::Rest::Response.new(e.res))
+      rescue OpenSSL::OpenSSLError => e
+        Puppet::Util::SSL.handle_connection_error(e, @verifier, url.host)
+      end
+    end
+
+    # Make a PUT request to the specified URL with the specified params.
+    # @param [URI::HTTPS] url the full path to query
+    # @param [String/Hash] body the contents of the PUT request
+    # @param [Hash] query any URL params to add to send to the endpoint
+    # @param [Hash] header any additional entries to add to the default header
+    # @return [Puppet::Rest::Response]
+    def put(url, body:, query: nil, header: nil)
+      begin
+        response = @client.put(url.to_s, body: body, query: query, header: header)
+        Puppet::Rest::Response.new(response)
+      rescue OpenSSL::OpenSSLError => e
+        Puppet::Util::SSL.handle_connection_error(e, @verifier, url.host)
+      end
+    end
+
+    private
+
+    def configure_verify_mode(ssl_context)
+      @client.ssl_config.verify_callback = @verifier
+      @client.ssl_config.cert_store = ssl_context.cert_store
+      @client.ssl_config.verify_mode = ssl_context.verify_mode
+    end
+  end
+end

data/lib/puppet/rest/errors.rb

@@ -0,0 +1,14 @@
+module Puppet::Rest
+  class ResponseError < Puppet::Error
+    attr_reader :response
+
+    # Error thrown when request status is not OK.
+    # @param [String] msg the error message
+    # @param [Puppet::Rest::Response] response the response from the failed
+    #                                 request
+    def initialize(msg, response = nil)
+      super(msg)
+      @response = response
+    end
+  end
+end

data/lib/puppet/rest/response.rb

@@ -0,0 +1,34 @@
+module Puppet::Rest
+  # This is a wrapper for the HTTP::Message class of the HTTPClient
+  # gem. It is designed to wrap a message sent as an HTTP response.
+  class Response
+    def initialize(message)
+      @message = message
+    end
+
+    def body
+      @message.body
+    end
+
+    def content_type
+      @message.content_type
+    end
+
+    def content_encoding
+      @message.headers['Content-Encoding']
+    end
+
+    def status_code
+      @message.status
+    end
+
+    def ok?
+      @message.ok?
+    end
+
+    def to_exception
+      message = _("Error %{code} on SERVER: %{returned_message}") % { code: status_code, returned_message: body }
+      Puppet::Rest::ResponseError.new(message, self)
+    end
+  end
+end