bolt 0.20.3 → 0.20.5

data/vendored/puppet/lib/puppet/network/format_support.rb

@@ -97,7 +97,7 @@ module Puppet::Network::FormatSupport
   end
 
   def to_json(*args)
-    to_data_hash.to_json(*args)
+    Puppet::Util::Json.dump(to_data_hash, *args)
   end
 
   def render(format = nil)

data/vendored/puppet/lib/puppet/network/formats.rb

@@ -1,5 +1,5 @@
 require 'puppet/network/format_handler'
-require 'json'
+require 'puppet/util/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
 
@@ -101,19 +101,17 @@ 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))
+    data_to_instance(klass, Puppet::Util::Json.load(text))
   end
 
   def intern_multiple(klass, text)
-    JSON.parse(text).collect do |data|
+    Puppet::Util::Json.load(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
+    Puppet::Util::Json.dump(instances)
   end
 
   # Unlike PSON, we do not need to unwrap the data envelope, because legacy 3.x agents
@@ -162,7 +160,7 @@ Puppet::Network::FormatHandler.create(:console,
     end
 
     # ...or pretty-print the inspect outcome.
-    JSON.pretty_generate(datum, :quirks_mode => true)
+    Puppet::Util::Json.dump(datum, :pretty => true, :quirks_mode => true)
   end
 
   def render_multiple(data)

data/vendored/puppet/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/vendored/puppet/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/vendored/puppet/lib/puppet/network/http/api/master/v3/environment.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 require 'puppet/parser/environment_compiler'
 
 class Puppet::Network::HTTP::API::Master::V3::Environment
@@ -15,7 +15,7 @@ class Puppet::Network::HTTP::API::Master::V3::Environment
 
     env_graph = build_environment_graph(catalog)
 
-    response.respond_with(200, "application/json", JSON.dump(env_graph))
+    response.respond_with(200, "application/json", Puppet::Util::Json.dump(env_graph))
   end
 
   def build_environment_graph(catalog)

data/vendored/puppet/lib/puppet/network/http/api/master/v3/environments.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 class Puppet::Network::HTTP::API::Master::V3::Environments
   def initialize(env_loader)
@@ -6,7 +6,7 @@ class Puppet::Network::HTTP::API::Master::V3::Environments
   end
 
   def call(request, response)
-    response.respond_with(200, "application/json", JSON.dump({
+    response.respond_with(200, "application/json", Puppet::Util::Json.dump({
       "search_paths" => @env_loader.search_paths,
       "environments" => Hash[@env_loader.list.collect do |env|
         [env.name, {

data/vendored/puppet/lib/puppet/network/http/compression.rb

@@ -32,7 +32,7 @@ module Puppet::Network::HTTP::Compression
     end
 
     def uncompress(response)
-      raise Net::HTTPError.new("No block passed") unless block_given?
+      raise Net::HTTPError.new("No block passed", response) unless block_given?
 
       case response['content-encoding']
       when 'gzip','deflate'

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

@@ -1,10 +1,10 @@
 require 'net/https'
 require 'puppet/ssl/host'
-require 'puppet/ssl/configuration'
 require 'puppet/ssl/validator'
 require 'puppet/network/http'
 require 'uri'
 require 'date'
+require 'time'
 
 module Puppet::Network::HTTP
 
@@ -297,7 +297,14 @@ module Puppet::Network::HTTP
     end
 
     def execute_request(connection, request)
+      start = Time.now
       connection.request(request)
+    rescue EOFError => e
+      elapsed = (Time.now - start).to_f.round(3)
+      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)
@@ -314,8 +321,9 @@ module Puppet::Network::HTTP
         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
+      elsif peer_cert && !OpenSSL::SSL.verify_certificate_identity(peer_cert, site.host)
+        valid_certnames = [peer_cert.subject.to_s.sub(/.*=/, ''),
+                           *Puppet::SSL::Certificate.subject_alt_names_for(peer_cert)].uniq
         if valid_certnames.size > 1
           expected_certnames = _("expected one of %{certnames}") % { certnames: valid_certnames.join(', ') }
         else

data/vendored/puppet/lib/puppet/network/http/error.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 module Puppet::Network::HTTP::Error
   Issues = Puppet::Network::HTTP::Issues
@@ -13,7 +13,7 @@ module Puppet::Network::HTTP::Error
     end
 
     def to_json
-      JSON({:message => message, :issue_kind => @issue_kind})
+      Puppet::Util::Json.dump({:message => message, :issue_kind => @issue_kind})
     end
   end
 
@@ -67,7 +67,7 @@ module Puppet::Network::HTTP::Error
     end
 
     def to_json
-      JSON({:message => message, :issue_kind => @issue_kind})
+      Puppet::Util::Json.dump({:message => message, :issue_kind => @issue_kind})
     end
   end
 end

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

@@ -12,6 +12,8 @@ require 'puppet/util/http_proxy'
 class Puppet::Network::HTTP::Factory
   @@openssl_initialized = false
 
+  KEEP_ALIVE_TIMEOUT = 2**31 - 1
+
   def initialize
     # PUP-1411, make sure that openssl is initialized before we try to connect
     if ! @@openssl_initialized
@@ -37,6 +39,7 @@ class Puppet::Network::HTTP::Factory
     http.use_ssl = site.use_ssl?
     http.read_timeout = Puppet[:http_read_timeout]
     http.open_timeout = Puppet[:http_connect_timeout]
+    http.keep_alive_timeout = KEEP_ALIVE_TIMEOUT if http.respond_to?(:keep_alive_timeout=)
 
     if Puppet[:sourceaddress]
       if http.respond_to?(:local_host)

data/vendored/puppet/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/vendored/puppet/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.to_s}"
+      # 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.to_s}:#{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