puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/lib/puppet/network/http.rb

@@ -13,8 +13,6 @@ module Puppet::Network::HTTP
   require 'puppet/network/http/error'
   require 'puppet/network/http/route'
   require 'puppet/network/http/api'
-  require 'puppet/network/http/api/ca'
-  require 'puppet/network/http/api/ca/v1'
   require 'puppet/network/http/api/master'
   require 'puppet/network/http/api/master/v3'
   require 'puppet/network/http/handler'

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

@@ -20,8 +20,7 @@ class Puppet::Network::HTTP::API
                                                                       "or point them to a server running Puppet 3.\n\n" +
                                                                       "Master Info:\n" +
                                                                       "  Puppet version: #{Puppet.version}\n" +
-                                                                      "  Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}\n" +
-                                                                      "  Supported /puppet-ca API versions: #{Puppet::Network::HTTP::CA_URL_VERSIONS}",
+                                                                      "  Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}\n",
                                                                   Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
       end)
   end
@@ -33,12 +32,4 @@ class Puppet::Network::HTTP::API
       chain(Puppet::Network::HTTP::API::Master::V3.routes,
             Puppet::Network::HTTP::API.not_found)
   end
-
-  def self.ca_routes
-    ca_prefix = Regexp.new("^#{Puppet::Network::HTTP::CA_URL_PREFIX}/")
-    Puppet::Network::HTTP::Route.path(ca_prefix).
-      any.
-      chain(Puppet::Network::HTTP::API::CA::V1.routes,
-            Puppet::Network::HTTP::API.not_found)
-  end
 end

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

@@ -43,8 +43,14 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       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)
-    Puppet.override(:trusted_information => trusted) do
+    overrides = {
+      trusted_information: Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate),
+    }
+    if params[:environment]
+      overrides[:current_environment] = params[:environment]
+    end
+
+    Puppet.override(overrides) do
       send("do_#{method}", indirection, key, params, request, response)
     end
   end
@@ -114,17 +120,6 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     [indirection, method, key, params]
   end
 
-  def self.request_to_uri(request)
-    uri, body = request_to_uri_and_body(request)
-    "#{uri}?#{body}"
-  end
-
-  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}/#{Puppet::Util.uri_encode(request.key)}", "environment=#{request.environment.name}&#{request.query_string}"]
-  end
-
   private
 
   # Execute our find.
@@ -202,7 +197,8 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       begin
         yield format
         true
-      rescue Puppet::Network::FormatHandler::FormatError
+      rescue Puppet::Network::FormatHandler::FormatError => err
+        Puppet.log_exception(err, err.message, level: :debug)
         false
       end
     end
@@ -210,7 +206,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     return formatter if formatter
 
     raise Puppet::Network::HTTP::Error::HTTPNotAcceptableError.new(
-            _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats.map(&:mime).join(', ') },
+            _("No supported formats are acceptable (Accept: %{accepted_formats})") % { accepted_formats: formats },
             Puppet::Network::HTTP::Issues::UNSUPPORTED_FORMAT)
   end
 
@@ -257,10 +253,20 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
     method
   end
 
+  def self.request_to_uri(request)
+    uri, body = request_to_uri_and_body(request)
+    "#{uri}?#{body}"
+  end
+
+  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}/#{Puppet::Util.uri_encode(request.key)}", "environment=#{request.environment.name}&#{request.query_string}"]
+  end
+
   def self.pluralize(indirection)
     return(indirection == "status" ? "statuses" : indirection + "s")
   end
-  private_class_method :pluralize
 
   def plurality(indirection)
     # NOTE These specific hooks for paths are ridiculous, but it's a *many*-line

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

@@ -1,11 +1,8 @@
 require 'puppet/util/json'
 require 'puppet/parser/environment_compiler'
 
-# @deprecated application orchestration will be removed in puppet 7
 class Puppet::Network::HTTP::API::Master::V3::Environment
   def call(request, response)
-    Puppet.deprecation_warning("Application orchestration is deprecated. See https://puppet.com/docs/puppet/5.5/deprecated_language.html")
-
     env_name = request.routing_path.split('/').last
     env = Puppet.lookup(:environments).get(env_name)
     code_id = request.params[:code_id]

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

@@ -1,6 +1,5 @@
 require 'net/https'
 require 'puppet/ssl/host'
-require 'puppet/ssl/configuration'
 require 'puppet/ssl/validator'
 require 'puppet/network/http'
 require 'uri'
@@ -131,26 +130,20 @@ module Puppet::Network::HTTP
     # future we may want to refactor these so that they are funneled through
     # that method and do inherit the error handling.
     def request_get(*args, &block)
-      with_connection(@site) do |http|
-        resp = http.request_get(*args, &block)
-        Puppet.debug("HTTP GET #{@site}#{args.first.split('?').first} returned #{resp.code} #{resp.message}")
-        resp
+      with_connection(@site) do |connection|
+        connection.request_get(*args, &block)
       end
     end
 
     def request_head(*args, &block)
-      with_connection(@site) do |http|
-        resp = http.request_head(*args, &block)
-        Puppet.debug("HTTP HEAD #{@site}#{args.first.split('?').first} returned #{resp.code} #{resp.message}")
-        resp
+      with_connection(@site) do |connection|
+        connection.request_head(*args, &block)
       end
     end
 
     def request_post(*args, &block)
-      with_connection(@site) do |http|
-        resp = http.request_post(*args, &block)
-        Puppet.debug("HTTP POST #{@site}#{args.first.split('?').first} returned #{resp.code} #{resp.message}")
-        resp
+      with_connection(@site) do |connection|
+        connection.request_post(*args, &block)
       end
     end
     # end of Net::HTTP#request_* proxies
@@ -198,10 +191,6 @@ module Puppet::Network::HTTP
               current_request[header] = value
             end
           when 429, 503
-            if connection.started?
-              Puppet.debug("Closing connection for #{current_site}")
-              connection.finish
-            end
             response = handle_retry_after(current_response)
           else
             response = current_response
@@ -236,8 +225,7 @@ module Puppet::Network::HTTP
       # Recover remote hostname if Net::HTTPResponse was generated by a
       # method that fills in the uri attribute.
       #
-      # TODO: Drop the respond_to? check when support for Ruby 1.9.3 is dropped.
-      server_hostname = if response.respond_to?(:uri) && response.uri.is_a?(URI)
+      server_hostname = if response.uri.is_a?(URI)
                           response.uri.host
                         else
                           # TRANSLATORS: Used in the phrase:
@@ -309,23 +297,13 @@ module Puppet::Network::HTTP
 
     def execute_request(connection, request)
       start = Time.now
-      resp = connection.request(request)
-      Puppet.debug("HTTP #{request.method.upcase} #{@site}#{request.path.split('?').first} returned #{resp.code} #{resp.message}")
-      resp
-    rescue => exception
+      connection.request(request)
+    rescue EOFError => e
       elapsed = (Time.now - start).to_f.round(3)
-      uri = [@site.addr, request.path.split('?')[0]].join('/')
-
-      case exception
-      when EOFError
-        Puppet.log_exception(exception, _('request %{uri} interrupted after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
-      when Timeout::Error
-        Puppet.log_exception(exception, _('request %{uri} timed out after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
-      else
-        Puppet.log_exception(exception, _('request %{uri} failed: %{msg}') % {uri: uri, msg: exception.message})
-      end
-
-      raise exception
+      uri = @site.addr + request.path.split('?')[0]
+      eof = EOFError.new(_('request %{uri} interrupted after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
+      eof.set_backtrace(e.backtrace) unless e.backtrace.empty?
+      raise eof
     end
 
     def with_connection(site, &block)
@@ -335,28 +313,7 @@ module Puppet::Network::HTTP
       end
       response
     rescue OpenSSL::SSL::SSLError => error
-      raise @verify.last_error if @verify.last_error
-
-      # can be nil
-      peer_cert = @verify.peer_certs.last
-
-      if error.message.include? "certificate verify failed"
-        msg = error.message
-        msg << ": [" + @verify.verify_errors.join('; ') + "]"
-        raise Puppet::Error, msg, error.backtrace
-      elsif peer_cert && !OpenSSL::SSL.verify_certificate_identity(peer_cert.content, site.host)
-        valid_certnames = [peer_cert.name, *peer_cert.subject_alt_names].uniq
-        if valid_certnames.size > 1
-          expected_certnames = _("expected one of %{certnames}") % { certnames: valid_certnames.join(', ') }
-        else
-          expected_certnames = _("expected %{certname}") % { certname: valid_certnames.first }
-        end
-
-        msg = _("Server hostname '%{host}' did not match server certificate; %{expected_certnames}") % { host: site.host, expected_certnames: expected_certnames }
-        raise Puppet::Error, msg, error.backtrace
-      else
-        raise
-      end
+      Puppet::Util::SSL.handle_connection_error(error, @verify, site.host)
     end
   end
 end

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

@@ -25,19 +25,25 @@ class Puppet::Network::HTTP::Factory
   def create_connection(site)
     Puppet.debug("Creating new connection for #{site}")
 
-    http = Puppet::Util::HttpProxy.proxy(URI(site.addr))
+    args = [site.host, site.port]
+
+    unless Puppet::Util::HttpProxy.no_proxy?(site)
+      if Puppet[:http_proxy_host] == "none"
+        args << nil << nil
+      else
+        args << Puppet[:http_proxy_host] << Puppet[:http_proxy_port]
+      end
+    end
+
+    http = Net::HTTP.new(*args)
     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
+      Puppet.debug("Using source IP #{Puppet[:sourceaddress]}")
+      http.local_host = Puppet[:sourceaddress]
     end
 
     if Puppet[:http_debug]

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

@@ -44,42 +44,78 @@ module Puppet::Network::HTTP::Handler
     format.is_a?(Puppet::Network::Format) ? format.mime : format
   end
 
-  # handle an HTTP request
-  def process(request, response)
-    new_response = Puppet::Network::HTTP::Response.new(self, response)
-
-    request_headers = headers(request)
-    request_params = params(request)
-    request_method = http_method(request)
+  # Create a generic puppet request from the implementation-specific request
+  # created by the web server
+  def make_generic_request(request)
     request_path = path(request)
 
-    new_request = Puppet::Network::HTTP::Request.new(request_headers, request_params, request_method, request_path, request_path, client_cert(request), body(request))
+    Puppet::Network::HTTP::Request.new(
+      headers(request),
+      params(request),
+      http_method(request),
+      request_path, # path
+      request_path, # routing_path
+      client_cert(request),
+      body(request)
+    )
+  end
+
+  def with_request_profiling(request)
+    profiler = configure_profiler(request.headers, request.params)
+
+    Puppet::Util::Profiler.profile(
+      _("Processed request %{request_method} %{request_path}") % { request_method: request.method, request_path: request.path },
+      [:http, request.method, request.path]
+    ) do
+      yield
+    end
+  ensure
+    remove_profiler(profiler) if profiler
+  end
 
-    response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] = Puppet.version
+  # handle an HTTP request
+  def process(external_request, response)
+    # The response_wrapper stores the response and modifies it as a side effect.
+    # The caller will use the original response
+    response_wrapper = Puppet::Network::HTTP::Response.new(self, response)
+    request = make_generic_request(external_request)
 
-    profiler = configure_profiler(request_headers, request_params)
+    set_puppet_version_header(response)
 
-    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 %{request} %{path}") % { request: new_request.method, path: new_request.path }, HANDLER_NOT_FOUND)
+    respond_to_errors(response_wrapper) do
+      with_request_profiling(request) do
+        find_route_or_raise(request).process(request, response_wrapper)
       end
     end
+  end
 
+  def respond_to_errors(response)
+    yield
   rescue Puppet::Network::HTTP::Error::HTTPError => e
     Puppet.info(e.message)
-    new_response.respond_with(e.status, "application/json", e.to_json)
+    respond_with_http_error(response, e)
   rescue StandardError => e
     http_e = Puppet::Network::HTTP::Error::HTTPServerError.new(e)
-    log_msg = [http_e.message, *e.backtrace].join("\n")
-    Puppet.err(log_msg)
-    new_response.respond_with(http_e.status, "application/json", http_e.to_json)
-  ensure
-    if profiler
-      remove_profiler(profiler)
+    Puppet.err([http_e.message, *e.backtrace].join("\n"))
+    respond_with_http_error(response, http_e)
+  end
+
+  def respond_with_http_error(response, exception)
+    response.respond_with(exception.status, "application/json", exception.to_json)
+  end
+
+  def find_route_or_raise(request)
+    if route = @routes.find { |r| r.matches?(request) }
+      return route
+    else
+      raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(
+              _("No route for %{request} %{path}") % { request: request.method, path: request.path },
+              HANDLER_NOT_FOUND)
     end
-    cleanup(request)
+  end
+
+  def set_puppet_version_header(response)
+    response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] = Puppet.version
   end
 
   # Set the response up, with the body and status.
@@ -131,10 +167,6 @@ module Puppet::Network::HTTP::Handler
     raise NotImplementedError
   end
 
-  def cleanup(request)
-    # By default, there is nothing to cleanup.
-  end
-
   def decode_params(params)
     params.select { |key, _| allowed_parameter?(key) }.inject({}) do |result, ary|
       param, value = ary

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

@@ -33,7 +33,7 @@ class Puppet::Network::HTTP::Pool
       reuse = false
       raise detail
     ensure
-      if reuse && http.started?
+      if reuse
         release(site, http)
       else
         close_connection(site, http)
@@ -56,17 +56,13 @@ class Puppet::Network::HTTP::Pool
   end
 
   # Safely close a persistent connection.
-  # Don't try to close a connection that's already closed.
   #
   # @api private
   def close_connection(site, http)
-    return false unless http.started?
     Puppet.debug("Closing connection for #{site}")
     http.finish
-    true
   rescue => detail
     Puppet.log_exception(detail, _("Failed to close connection for %{site}: %{detail}") % { site: site, detail: detail })
-    nil
   end
 
   # Borrow and take ownership of a persistent connection. If a new
@@ -94,8 +90,6 @@ class Puppet::Network::HTTP::Pool
   #
   # @api private
   def setsockopts(netio)
-    return unless netio
-
     socket = netio.io
     socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
   end

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

@@ -15,7 +15,7 @@ class Puppet::Network::HTTP::Site
   end
 
   def addr
-    "#{@scheme}://#{@host}:#{@port}"
+    "#{@scheme}://#{@host}:#{@port.to_s}"
   end
   alias to_s addr
 

data/lib/puppet/network/resolver.rb

@@ -1,85 +1,158 @@
 require 'resolv'
-module Puppet::Network; end
-
-module Puppet::Network::Resolver
-  # Iterate through the list of servers that service this hostname
-  # and yield each server/port since SRV records have ports in them
-  # It will override whatever masterport setting is already set.
-  def self.each_srv_record(domain, service_name = :puppet, &block)
-    if (domain.nil? or domain.empty?)
-      Puppet.debug "Domain not known; skipping SRV lookup"
-      return
+
+module Puppet::Network
+  class Resolver
+
+    class CacheEntry
+      attr_reader :records, :ttl, :resolution_time
+
+      def initialize(records)
+        @records = records
+        @resolution_time = Time.now
+        @ttl = choose_lowest_ttl(records)
+      end
+
+      def choose_lowest_ttl(records)
+        ttl = records.first.ttl
+        records.each do |rec|
+          if rec.ttl < ttl
+            ttl = rec.ttl
+          end
+        end
+        ttl
+      end
     end
 
-    Puppet.debug "Searching for SRV records for domain: #{domain}"
+    def initialize
+      @resolver = Resolv::DNS.new
 
-    case service_name
-      when :puppet then service = '_x-puppet'
-      when :ca     then service = '_x-puppet-ca'
-      when :report then service = '_x-puppet-report'
-      when :file   then service = '_x-puppet-fileserver'
-      else              service = "_x-puppet-#{service_name}"
+      # Stores DNS records per service, along with their TTL
+      # and the time at which they were resolved, for cache
+      # eviction.
+      @record_cache = {}
     end
-    srv_record = "#{service}._tcp.#{domain}"
-
-    resolver = Resolv::DNS.new
-    records = resolver.getresources(srv_record, Resolv::DNS::Resource::IN::SRV)
-    Puppet.debug "Found #{records.size} SRV records for: #{srv_record}"
-
-    if records.size == 0 && service_name != :puppet
-      # Try the generic :puppet service if no SRV records were found
-      # for the specific service.
-      each_srv_record(domain, :puppet, &block)
-    else
-      each_priority(records) do |priority, recs|
-        while next_rr = recs.delete(find_weighted_server(recs))
-          Puppet.debug "Yielding next server of #{next_rr.target}:#{next_rr.port}"
-          yield next_rr.target.to_s, next_rr.port
+
+    # Iterate through the list of records for this service
+    # and yield each server and port pair. Records are only fetched
+    # via DNS query the first time and cached for the duration of their
+    # service's TTL thereafter.
+    # @param [String] domain the domain to search for
+    # @param [Symbol] service_name the key of the service we are querying
+    # @yields [String, Integer] server and port of selected record
+    def each_srv_record(domain, service_name = :puppet, &block)
+      if (domain.nil? or domain.empty?)
+        Puppet.debug "Domain not known; skipping SRV lookup"
+        return
+      end
+
+      Puppet.debug "Searching for SRV records for domain: #{domain}"
+
+      case service_name
+        when :puppet then service = '_x-puppet'
+        when :file   then service = '_x-puppet-fileserver'
+        else              service = "_x-puppet-#{service_name.to_s}"
+      end
+      record_name = "#{service}._tcp.#{domain}"
+
+      if @record_cache.has_key?(service_name) && !expired?(service_name)
+        records = @record_cache[service_name].records
+        Puppet.debug "Using cached record for #{record_name}"
+      else
+        records = @resolver.getresources(record_name, Resolv::DNS::Resource::IN::SRV)
+        if records.size > 0
+          @record_cache[service_name] = CacheEntry.new(records)
+        end
+        Puppet.debug "Found #{records.size} SRV records for: #{record_name}"
+      end
+
+      if records.size == 0 && service_name != :puppet
+        # Try the generic :puppet service if no SRV records were found
+        # for the specific service.
+        each_srv_record(domain, :puppet, &block)
+      else
+        each_priority(records) do |recs|
+          while next_rr = recs.delete(find_weighted_server(recs))
+            Puppet.debug "Yielding next server of #{next_rr.target.to_s}:#{next_rr.port}"
+            yield next_rr.target.to_s, next_rr.port
+          end
         end
       end
     end
-  end
 
-  def self.each_priority(records)
-    pri_hash = records.inject({}) do |groups, element|
-      groups[element.priority] ||= []
-      groups[element.priority] << element
-      groups
+    # Given a list of records of the same priority, chooses a random one
+    # from among them, favoring those with higher weights.
+    # @param [[Resolv::DNS::Resource::IN::SRV]] records a list of records
+    #        of the same priority
+    # @return [Resolv::DNS::Resource::IN:SRV] the chosen record
+    def find_weighted_server(records)
+      return nil if records.nil? || records.empty?
+      return records.first if records.size == 1
+
+      # Calculate the sum of all weights in the list of resource records,
+      # This is used to then select hosts until the weight exceeds what
+      # random number we selected.  For example, if we have weights of 1 8 and 3:
+      #
+      # |-|--------|---|
+      #        ^
+      # We generate a random number 5, and iterate through the records, adding
+      # the current record's weight to the accumulator until the weight of the
+      # current record plus previous records is greater than the random number.
+      total_weight = records.inject(0) { |sum,record|
+        sum + weight(record)
+      }
+      current_weight = 0
+      chosen_weight  = 1 + Kernel.rand(total_weight)
+
+      records.each do |record|
+        current_weight += weight(record)
+        return record if current_weight >= chosen_weight
+      end
     end
 
-    pri_hash.keys.sort.each do |key|
-      yield key, pri_hash[key]
+    def weight(record)
+      record.weight == 0 ? 1 : record.weight * 10
     end
-  end
-  private_class_method :each_priority
 
-  def self.find_weighted_server(records)
-    return nil if records.nil? || records.empty?
-    return records.first if records.size == 1
+    # Returns TTL for the cached records for this service.
+    # @param [String] service_name the service whose TTL we want
+    # @return [Integer] the TTL for this service, in seconds
+    def ttl(service_name)
+      return @record_cache[service_name].ttl
+    end
 
-    # Calculate the sum of all weights in the list of resource records,
-    # This is used to then select hosts until the weight exceeds what
-    # random number we selected.  For example, if we have weights of 1 8 and 3:
-    #
-    # |-|---|--------|
-    #        ^
-    # We generate a random number 5, and iterate through the records, adding
-    # the current record's weight to the accumulator until the weight of the
-    # current record plus previous records is greater than the random number.
-
-    total_weight = records.inject(0) { |sum,record|
-      sum + weight(record)
-    }
-    current_weight = 0
-    chosen_weight  = 1 + Kernel.rand(total_weight)
-
-    records.each do |record|
-      current_weight += weight(record)
-      return record if current_weight >= chosen_weight
+    # Checks if the cached entry for the given service has expired.
+    # @param [String] service_name the name of the service to check
+    # @return [Boolean] true if the entry has expired, false otherwise.
+    #                  Always returns true if the record had no TTL.
+    def expired?(service_name)
+      if entry = @record_cache[service_name]
+        return Time.now > (entry.resolution_time + entry.ttl)
+      else
+        return true
+      end
     end
-  end
 
-  def self.weight(record)
-    record.weight == 0 ? 1 : record.weight * 10
+    private
+
+    # Groups the records by their priority and yields the groups
+    # in order of highest to lowest priority (lowest to highest numbers),
+    # one at a time.
+    # { 1 => [records], 2 => [records], etc. }
+    #
+    # @param [[Resolv::DNS::Resource::IN::SRV]] records the list of
+    #        records for a given service
+    # @yields [[Resolv::DNS::Resource::IN::SRV]] a group of records of
+    #         the same priority
+    def each_priority(records)
+      pri_hash = records.inject({}) do |groups, element|
+        groups[element.priority] ||= []
+        groups[element.priority] << element
+        groups
+      end
+
+      pri_hash.keys.sort.each do |key|
+        yield pri_hash[key]
+      end
+    end
   end
 end