puppet 5.3.4 → 6.29.0

data/lib/puppet/resource/type.rb

@@ -11,6 +11,7 @@ class Puppet::Resource::Type
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
+  # @deprecated application orchestration will be removed in puppet 7 (capability_mapping, application, site)
   RESOURCE_KINDS = [:hostclass, :node, :definition, :capability_mapping, :application, :site]
 
   # Map the names used in our documentation to the names used internally
@@ -33,7 +34,7 @@ class Puppet::Resource::Type
   DOUBLE_COLON = '::'.freeze
   EMPTY_ARRAY = [].freeze
 
-  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
+  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection, :override
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
   # The attributes 'produces' and 'consumes' are arrays of the blueprints
@@ -43,7 +44,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
@@ -62,6 +63,7 @@ class Puppet::Resource::Type
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
+    return true if override
     return false unless parent
 
     return(klass == parent_type ? true : parent_type.child_of?(klass))
@@ -69,6 +71,8 @@ class Puppet::Resource::Type
 
   # Evaluate the resources produced by the given resource. These resources are
   # evaluated in a separate but identical scope from the rest of the resource.
+  #
+  # @deprecated application orchestration will be removed in puppet 7
   def evaluate_produces(resource, scope)
     # Only defined types and classes can produce capabilities
     return unless definition? || hostclass?
@@ -89,7 +93,8 @@ class Puppet::Resource::Type
       produced_resource.resource_type.parameters.each do |name|
         next if name == :name
 
-        if expr = blueprint[:mappings][name.to_s]
+        expr = blueprint[:mappings][name.to_s]
+        if expr
           produced_resource[name] = expr.safeevaluate(scope)
         else
           produced_resource[name] = scope[name.to_s]
@@ -147,7 +152,8 @@ class Puppet::Resource::Type
     set_name_and_namespace(name)
 
     [:code, :doc, :line, :file, :parent].each do |param|
-      next unless value = options[param]
+      value = options[param]
+      next unless value
       send(param.to_s + '=', value)
     end
 
@@ -159,19 +165,23 @@ class Puppet::Resource::Type
     @module_name = options[:module_name]
   end
 
+  # @deprecated application orchestration will be removed in puppet 7
   def produces
     @produces || EMPTY_ARRAY
   end
 
+  # @deprecated application orchestration will be removed in puppet 7
   def consumes
     @consumes || EMPTY_ARRAY
   end
 
+  # @deprecated application orchestration will be removed in puppet 7
   def add_produces(blueprint)
     @produces ||= []
     @produces << blueprint
   end
 
+  # @deprecated application orchestration will be removed in puppet 7
   def add_consumes(blueprint)
     @consumes ||= []
     @consumes << blueprint
@@ -189,8 +199,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
@@ -229,6 +243,7 @@ class Puppet::Resource::Type
     when :node
       :node
     when :site
+      # @deprecated application orchestration will be removed in puppet 7
       :site
     end
 
@@ -258,7 +273,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
 
@@ -442,14 +457,16 @@ 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
 
   def evaluate_parent_type(resource)
-    return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
+    klass = parent_type(resource.scope)
+    parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name) if klass
+    return unless klass && parent_resource
     parent_resource.evaluate unless parent_resource.evaluated?
     parent_scope(resource.scope, klass)
   end
@@ -476,7 +493,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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
 require 'puppet/parser/type_loader'
 require 'puppet/util/file_watcher'
 require 'puppet/util/warnings'
+require 'puppet/concurrent/lock'
 
 # @api private
 class Puppet::Resource::TypeCollection
@@ -28,6 +30,7 @@ class Puppet::Resource::TypeCollection
     @nodes = {}
     @notfound = {}
     @sites = []
+    @lock = Puppet::Concurrent::Lock.new
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
@@ -58,7 +61,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
@@ -124,7 +127,8 @@ class Puppet::Resource::TypeCollection
   def node(name)
     name = munge_name(name)
 
-    if node = @nodes[name]
+    node = @nodes[name]
+    if node
       return node
     end
 
@@ -208,7 +212,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
 
@@ -224,25 +228,27 @@ class Puppet::Resource::TypeCollection
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
   def find_or_load(name, type)
-    # Name is always absolute, but may start with :: which must be removed
-    fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
-
-    result = send(type, fqname)
-    unless result
-      if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
-        # do not try to autoload if we already tried and it wasn't conclusive
-        # as this is a time consuming operation. Warn the user.
-        # Check first if debugging is on since the call to debug_once is expensive
-        if Puppet[:debug]
-          debug_once _("Not attempting to load %{type} %{fqname} as this object was missing during a prior compilation") % { type: type, fqname: fqname }
+    @lock.synchronize do
+      # Name is always absolute, but may start with :: which must be removed
+      fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
+
+      result = send(type, fqname)
+      unless result
+        if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
+          # do not try to autoload if we already tried and it wasn't conclusive
+          # as this is a time consuming operation. Warn the user.
+          # Check first if debugging is on since the call to debug_once is expensive
+          if Puppet[:debug]
+            debug_once _("Not attempting to load %{type} %{fqname} as this object was missing during a prior compilation") % { type: type, fqname: fqname }
+          end
+        else
+          fqname = munge_name(fqname)
+          result = loader.try_load_fqname(type, fqname)
+          @notfound[ fqname ] = result.nil?
         end
-      else
-        fqname = munge_name(fqname)
-        result = loader.try_load_fqname(type, fqname)
-        @notfound[ fqname ] = result.nil?
       end
+      result
     end
-    result
   end
 
   def munge_name(name)
@@ -250,7 +256,8 @@ class Puppet::Resource::TypeCollection
   end
 
   def dupe_check(instance, hash)
-    return unless dupe = hash[instance.name]
+    dupe = hash[instance.name]
+    return unless dupe
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end

data/lib/puppet/resource.rb

@@ -11,8 +11,8 @@ class Puppet::Resource
   include Puppet::Util::PsychSupport
 
   include Enumerable
-  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
-  attr_reader :type, :title, :parameters, :rich_data_enabled
+  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict, :kind
+  attr_reader :type, :title, :parameters
 
   # @!attribute [rw] sensitive_parameters
   #   @api private
@@ -29,12 +29,17 @@ class Puppet::Resource
   EMPTY_ARRAY = [].freeze
   EMPTY_HASH = {}.freeze
 
-  ATTRIBUTES = [:file, :line, :exported].freeze
+  ATTRIBUTES = [:file, :line, :exported, :kind].freeze
   TYPE_CLASS = 'Class'.freeze
   TYPE_NODE  = 'Node'.freeze
   TYPE_SITE  = 'Site'.freeze
 
-  PCORE_TYPE_KEY = '__pcore_type__'.freeze
+  CLASS_STRING = 'class'.freeze
+  DEFINED_TYPE_STRING = 'defined_type'.freeze
+  COMPILABLE_TYPE_STRING = 'compilable_type'.freeze
+  UNKNOWN_TYPE_STRING  = 'unknown'.freeze
+
+  PCORE_TYPE_KEY = '__ptype'.freeze
   VALUE_KEY = 'value'.freeze
 
   def self.from_data_hash(data)
@@ -44,11 +49,14 @@ class Puppet::Resource
   end
 
   def initialize_from_hash(data)
-    raise ArgumentError, _('No resource type provided in serialized data') unless type = data['type']
-    raise ArgumentError, _('No resource title provided in serialized data') unless title = data['title']
+    type = data['type']
+    raise ArgumentError, _('No resource type provided in serialized data') unless type
+    title = data['title']
+    raise ArgumentError, _('No resource title provided in serialized data') unless title
     @type, @title = self.class.type_and_title(type, title)
 
-    if params = data['parameters']
+    params = data['parameters']
+    if params
       params = Puppet::Pops::Serialization::FromDataConverter.convert(params)
       @parameters = {}
       params.each { |param, value| self[param] = value }
@@ -56,14 +64,16 @@ class Puppet::Resource
       @parameters = EMPTY_HASH
     end
 
-    if sensitives = data['sensitive_parameters']
+    sensitives = data['sensitive_parameters']
+    if sensitives
       @sensitive_parameters = sensitives.map(&:to_sym)
     else
       @sensitive_parameters = EMPTY_ARRAY
     end
 
-    if tags = data['tags']
-      tags.each { |t| tag(t) }
+    tags = data['tags']
+    if tags
+      tag(*tags)
     end
 
     ATTRIBUTES.each do |a|
@@ -76,6 +86,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 +106,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,
@@ -172,6 +199,18 @@ class Puppet::Resource
     resource_type.is_a?(Puppet::CompilableResourceType)
   end
 
+  def self.to_kind(resource_type)
+    if resource_type == CLASS_STRING
+      CLASS_STRING
+    elsif resource_type.is_a?(Puppet::Resource::Type) && resource_type.type == :definition
+      DEFINED_TYPE_STRING
+    elsif resource_type.is_a?(Puppet::CompilableResourceType)
+      COMPILABLE_TYPE_STRING
+    else
+      UNKNOWN_TYPE_STRING
+    end
+  end
+
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     parameters.each { |p,v| yield p, v }
@@ -192,7 +231,7 @@ class Puppet::Resource
   end
 
   def stage?
-    @is_stage ||= @type.to_s.downcase == "stage"
+    @is_stage ||= @type.to_s.casecmp("stage").zero?
   end
 
   # Construct a resource from data.
@@ -226,6 +265,7 @@ class Puppet::Resource
       src = type
       self.file = src.file
       self.line = src.line
+      self.kind = src.kind
       self.exported = src.exported
       self.virtual = src.virtual
       self.set_tags(src)
@@ -257,7 +297,6 @@ class Puppet::Resource
               { 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):
@@ -279,7 +318,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,6 +328,7 @@ class Puppet::Resource
 
       rt = resource_type
 
+      self.kind = self.class.to_kind(rt) unless kind
       if strict? && rt.nil?
         if self.class?
           raise ArgumentError, _("Could not find declared class %{title}") % { title: title }
@@ -411,6 +451,8 @@ class Puppet::Resource
   end
 
   # Convert our resource to yaml for Hiera purposes.
+  #
+  # @deprecated Use {to_hiera_hash} instead.
   def to_hierayaml
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
@@ -430,6 +472,21 @@ class Puppet::Resource
     "  %s:\n%s" % [self.title, attributes]
   end
 
+  # Convert our resource to a hiera hash suitable for serialization.
+  def to_hiera_hash
+    # to_data_hash converts to safe Data types, e.g. no symbols, unicode replacement character
+    h = to_data_hash
+
+    params = h['parameters'] || {}
+    value = params.delete('ensure')
+
+    res = {}
+    res['ensure'] = value if value
+    res.merge!(Hash[params.sort])
+
+    return { h['title'] => res }
+  end
+
   # Convert our resource to Puppet code.
   def to_manifest
     # Collect list of attributes to align => and move ensure first
@@ -455,10 +512,24 @@ class Puppet::Resource
     ref
   end
 
-  # Convert our resource to a RAL resource instance.  Creates component
-  # instances for resource types that don't exist.
+  # Convert our resource to a RAL resource instance. Creates component
+  # instances for resource types that are not of a compilable_type kind. In case
+  # the resource doesn’t exist and it’s compilable_type kind, raise an error.
+  # There are certain cases where a resource won't be in a catalog, such as 
+  # when we create a resource directly by using Puppet::Resource.new(...), so we 
+  # must check its kind before deciding whether the catalog format is of an older
+  # version or not.
   def to_ral
-    typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
+    if self.kind == COMPILABLE_TYPE_STRING
+      typeklass = Puppet::Type.type(self.type)
+    elsif self.catalog && self.catalog.catalog_format >= 2
+      typeklass = Puppet::Type.type(:component)
+    else
+      typeklass =  Puppet::Type.type(self.type) || Puppet::Type.type(:component)
+    end
+
+    raise(Puppet::Error, "Resource type '#{self.type}' was not found") unless typeklass
+
     typeklass.new(self)
   end
 
@@ -538,7 +609,8 @@ class Puppet::Resource
     arg_types = resource_type.argument_types
     # Parameters is a map from name, to parameter, and the parameter again has name and value
     parameters.each do |name, value|
-      next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
+      t = arg_types[name.to_s] # untyped, and parameters are symbols here (aargh, strings in the type)
+      next unless t
       unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
         inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
         actual = inferred_type.generalize()
@@ -567,7 +639,9 @@ class Puppet::Resource
         delete(attribute)
       end
 
-      parameters_to_include = options[:parameters_to_include] || []
+      parameters_to_include = resource_type.parameters_to_include
+      parameters_to_include += options[:parameters_to_include] || []
+
       delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute)
     end
     self
@@ -587,7 +661,8 @@ class Puppet::Resource
   def self.extract_type_and_title(argtype, argtitle)
     if (argtype.nil? || argtype == :component || argtype == :whit) &&
           argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [ $1,                 $2            ]
-    elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
+    elsif argtitle.nil? && argtype.is_a?(String) &&
+          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 %{type} is not a valid resource reference") % { type: argtype.inspect }
@@ -639,8 +714,9 @@ class Puppet::Resource
     h = {}
     type = resource_type
     if type.respond_to?(:title_patterns) && !type.title_patterns.nil?
-      type.title_patterns.each { |regexp, symbols_and_lambdas|
-        if captures = regexp.match(title.to_s)
+      type.title_patterns.each do |regexp, symbols_and_lambdas|
+        captures = regexp.match(title.to_s)  
+        if captures
           symbols_and_lambdas.zip(captures[1..-1]).each do |symbol_and_lambda,capture|
             symbol, proc = symbol_and_lambda
             # Many types pass "identity" as the proc; we might as well give
@@ -659,7 +735,7 @@ class Puppet::Resource
           end
           return h
         end
-      }
+      end
       # If we've gotten this far, then none of the provided title patterns
       # matched. Since there's no way to determine the title then the
       # resource should fail here.

data/lib/puppet/rest/errors.rb

@@ -0,0 +1,15 @@
+# @deprecated Use {Puppet::HTTP::Client} instead.
+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,35 @@
+# @deprecated Use {Puppet::HTTP::Client} instead.
+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

data/lib/puppet/rest/route.rb

@@ -0,0 +1,85 @@
+require 'uri'
+require 'puppet/util/connection'
+
+# @deprecated Use {Puppet::HTTP::Client} instead.
+module Puppet::Rest
+  class Route
+    attr_reader :server
+
+    # Create a Route containing information for querying the given API,
+    # hosted at a server determined either by SRV service or by the
+    # fallback server on the fallback port.
+    # @param [String] api the path leading to the root of the API. Must
+    #                 contain a trailing slash for proper endpoint path
+    #                 construction
+    # @param [Symbol] server_setting the setting to check for special
+    #                 server configuration
+    # @param [Symbol] port_setting the setting to check for special
+    #                  port configuration
+    # @param [Symbol] srv_service the name of the service when using SRV
+    #                 records
+    def initialize(api:, server_setting: :server, port_setting: :serverport, srv_service: :puppet)
+      @api = api
+      @default_server = Puppet::Util::Connection.determine_server(server_setting)
+      @default_port = Puppet::Util::Connection.determine_port(port_setting, server_setting)
+      @srv_service = srv_service
+    end
+
+    # Select a server and port to create a base URL for the API specified by this
+    # route. If the connection fails and SRV records are in use, the next suitable
+    # server will be tried. If SRV records are not in use or no successful connection
+    # could be made, fall back to the configured server and port for this API, taking
+    # into account failover settings.
+    # @parma [Puppet::Network::Resolver] dns_resolver the DNS resolver to use to check
+    #                                    SRV records
+    # @yield [URI] supply a base URL to make a request with
+    # @raise [Puppet::Error] if connection to selected server and port fails, and SRV
+    #                        records are not in use
+    def with_base_url(dns_resolver)
+      if @server && @port
+        # First try connecting to the previously selected server and port.
+        begin
+          return yield(base_url)
+        rescue SystemCallError => e
+          if Puppet[:use_srv_records]
+            Puppet.debug "Connection to cached server and port #{@server}:#{@port} failed, reselecting."
+          else
+            raise Puppet::Error, _("Connection to cached server and port %{server}:%{port} failed: %{message}") %
+              { server: @server, port: @port, message: e.message }
+          end
+        end
+      end
+
+      if Puppet[:use_srv_records]
+        dns_resolver.each_srv_record(Puppet[:srv_domain], @srv_service) do |srv_server, srv_port|
+          # Try each of the servers for this service in weighted order
+          # until a working one is found.
+          begin
+            @server = srv_server
+            @port = srv_port
+            return yield(base_url)
+          rescue SystemCallError
+            Puppet.debug "Connection to selected server and port #{@server}:#{@port} failed. Trying next cached SRV record."
+            @server = nil
+            @port = nil
+          end
+        end
+      end
+
+      # If not using SRV records, fall back to the defaults calculated above
+      @server = @default_server
+      @port = @default_port
+
+      Puppet.debug "No more servers in SRV record, falling back to #{@server}:#{@port}" if Puppet[:use_srv_records]
+      return yield(base_url)
+    end
+
+    private
+
+    # Returns a URI built from the information stored by this route,
+    # e.g. 'https://myserver.com:555/myapi/v1/'
+    def base_url
+      URI::HTTPS.build(host: @server, port: @port, path: @api)
+    end
+  end
+end