puppet 6.11.1-x86-mingw32 → 6.12.0-x86-mingw32

data/lib/puppet/http/resolver.rb

@@ -1,5 +1,18 @@
 class Puppet::HTTP::Resolver
-  def resolve(session, name, &block)
+  def initialize(client)
+    @client = client
+  end
+
+  def resolve(session, name, ssl_context: nil)
     raise NotImplementedError
   end
+
+  def check_connection?(session, service, ssl_context: nil)
+    service.connect(ssl_context: ssl_context)
+    return true
+  rescue Puppet::HTTP::ConnectionError => e
+    session.add_exception(e)
+    Puppet.debug("Connection to #{service.url} failed, trying next route: #{e.message}")
+    return false
+  end
 end

data/lib/puppet/http/resolver/server_list.rb

@@ -0,0 +1,38 @@
+class Puppet::HTTP::Resolver::ServerList < Puppet::HTTP::Resolver
+  def initialize(client, server_list_setting:, default_port:, services: )
+    @client = client
+    @server_list_setting = server_list_setting
+    @default_port = default_port
+    @services = services
+  end
+
+  def resolve(session, name, ssl_context: nil)
+    if @services.include?(name)
+      @server_list_setting.value.each do |server|
+        host = server[0]
+        port = server[1] || @default_port
+        uri = URI("https://#{host}:#{port}/status/v1/simple/master")
+        if get_success?(uri, session, ssl_context: ssl_context)
+          return Puppet::HTTP::Service.create_service(@client, name, host, port)
+        end
+      end
+      raise Puppet::Error, _("Could not select a functional puppet master from server_list: '%{server_list}'") % { server_list: @server_list_setting.print(@server_list_setting.value) }
+    else
+      return nil
+    end
+  end
+
+  def get_success?(uri, session, ssl_context: nil)
+    response = @client.get(uri, ssl_context: ssl_context)
+    return true if response.success?
+
+    Puppet.debug(_("Puppet server %{host}:%{port} is unavailable: %{code} %{reason}") %
+                 { host: host, port: port, code: response.code, reason: response.message })
+    return false
+  rescue => detail
+    session.add_exception(detail)
+    #TRANSLATORS 'server_list' is the name of a setting and should not be translated
+    Puppet.debug _("Unable to connect to server from server_list setting: %{detail}") % {detail: detail}
+    return false
+  end
+end

data/lib/puppet/http/resolver/settings.rb

@@ -1,5 +1,6 @@
 class Puppet::HTTP::Resolver::Settings < Puppet::HTTP::Resolver
-  def resolve(session, name, &block)
-    yield session.create_service(name)
+  def resolve(session, name, ssl_context: nil)
+    service = Puppet::HTTP::Service.create_service(@client, name)
+    check_connection?(session, service, ssl_context: ssl_context) ? service : nil
   end
 end

data/lib/puppet/http/resolver/srv.rb

@@ -1,13 +1,19 @@
 class Puppet::HTTP::Resolver::SRV < Puppet::HTTP::Resolver
-  def initialize(domain: srv_domain, dns: Resolv::DNS.new)
+  def initialize(client, domain:, dns: Resolv::DNS.new)
+    @client = client
     @srv_domain = domain
     @delegate = Puppet::Network::Resolver.new(dns)
   end
 
-  def resolve(session, name, &block)
-    # This assumes the route name is the same as the DNS SRV name
+  def resolve(session, name, ssl_context: nil)
+    # Here we pass our HTTP service name as the DNS SRV service name
+    # This is fine for :ca, but note that :puppet and :file are handled
+    # specially in `each_srv_record`.
     @delegate.each_srv_record(@srv_domain, name) do |server, port|
-      yield session.create_service(name, server, port)
+      service = Puppet::HTTP::Service.create_service(@client, name, server, port)
+      return service if check_connection?(session, service, ssl_context: ssl_context)
     end
+
+    return nil
   end
 end

data/lib/puppet/http/service.rb

@@ -1,6 +1,23 @@
 class Puppet::HTTP::Service
   attr_reader :url
 
+  SERVICE_NAMES = [:ca, :report].freeze
+
+  def self.create_service(client, name, server = nil, port = nil)
+    case name
+    when :ca
+      Puppet::HTTP::Service::Ca.new(client, server, port)
+    when :report
+      Puppet::HTTP::Service::Report.new(client, server, port)
+    else
+      raise ArgumentError, "Unknown service #{name}"
+    end
+  end
+
+  def self.valid_name?(name)
+    SERVICE_NAMES.include?(name)
+  end
+
   def initialize(client, url)
     @client = client
     @url = url
@@ -15,4 +32,19 @@ class Puppet::HTTP::Service
   def connect(ssl_context: nil)
     @client.connect(@url, ssl_context: ssl_context)
   end
+
+  protected
+
+  def add_puppet_headers(headers)
+    modified_headers = headers.dup
+    modified_headers['X-Puppet-Profiling'] = 'true' if Puppet[:profile]
+    modified_headers
+  end
+
+  def build_url(api, server, port)
+    URI::HTTPS.build(host: server,
+                     port: port,
+                     path: api
+                    ).freeze
+  end
 end

data/lib/puppet/http/service/ca.rb

@@ -1,10 +1,16 @@
 class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
   HEADERS = { 'Accept' => 'text/plain' }.freeze
+  API = '/puppet-ca/v1'.freeze
+
+  def initialize(client, server, port)
+    url = build_url(API, server || Puppet[:ca_server], port || Puppet[:ca_port])
+    super(client, url)
+  end
 
   def get_certificate(name, ssl_context: nil)
     response = @client.get(
       with_base_url("/certificate/#{name}"),
-      headers: HEADERS,
+      headers: add_puppet_headers(HEADERS),
       ssl_context: ssl_context
     )
 
@@ -14,17 +20,12 @@ class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
   end
 
   def get_certificate_revocation_list(if_modified_since: nil, ssl_context: nil)
-    request_headers = if if_modified_since
-                        h = HEADERS.dup
-                        h['If-Modified-Since'] = if_modified_since.httpdate
-                        h
-                      else
-                        HEADERS
-                      end
+    headers = add_puppet_headers(HEADERS)
+    headers['If-Modified-Since'] = if_modified_since.httpdate if if_modified_since
 
     response = @client.get(
       with_base_url("/certificate_revocation_list/ca"),
-      headers: request_headers,
+      headers: headers,
       ssl_context: ssl_context
     )
 
@@ -36,7 +37,7 @@ class Puppet::HTTP::Service::Ca < Puppet::HTTP::Service
   def put_certificate_request(name, csr, ssl_context: nil)
     response = @client.put(
       with_base_url("/certificate_request/#{name}"),
-      headers: HEADERS,
+      headers: add_puppet_headers(HEADERS),
       content_type: 'text/plain',
       body: csr.to_pem,
       ssl_context: ssl_context

data/lib/puppet/http/service/report.rb

@@ -0,0 +1,40 @@
+class Puppet::HTTP::Service::Report < Puppet::HTTP::Service
+  API = '/puppet/v3'.freeze
+  EXCLUDED_FORMATS = [:yaml, :b64_zlib_yaml, :dot]
+
+  # puppet major version where JSON is enabled by default
+  MAJOR_VERSION_JSON_DEFAULT = 5
+
+  def initialize(client, server, port)
+    url = build_url(API, server || Puppet[:report_server], port || Puppet[:report_port])
+    super(client, url)
+  end
+
+  def put_report(name, report, environment:, ssl_context: nil)
+    formatter = Puppet::Network::FormatHandler.format_for(Puppet[:preferred_serialization_format])
+
+    model = Puppet::Transaction::Report
+    network_formats = model.supported_formats - EXCLUDED_FORMATS
+    mime_types = network_formats.map { |f| model.get_format(f).mime }
+
+    response = @client.put(
+      with_base_url("/report/#{name}"),
+      headers: add_puppet_headers('ACCEPT' => mime_types.join(', ')),
+      params: { :environment => environment },
+      content_type: formatter.mime,
+      body: formatter.render(report),
+      ssl_context: ssl_context
+    )
+
+    return response.body.to_s if response.success?
+
+    server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
+    if server_version && SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
+        Puppet[:preferred_serialization_format] != 'pson'
+      #TRANSLATORS "pson", "preferred_serialization_format", and "puppetserver" should not be translated
+      raise Puppet::HTTP::ProtocolError.new(_("To submit reports to a server running puppetserver %{server_version}, set preferred_serialization_format to pson") % { server_version: server_version })
+    end
+
+    raise Puppet::HTTP::ResponseError.new(response)
+  end
+end

data/lib/puppet/http/session.rb

@@ -1,55 +1,34 @@
 class Puppet::HTTP::Session
-  Route = Struct.new(:service_class, :api, :server_setting, :port_setting)
-
-  ROUTES = {
-    ca: Route.new(Puppet::HTTP::Service::Ca, '/puppet-ca/v1', :ca_server, :ca_port),
-  }.freeze
-
   def initialize(client, resolvers)
     @client = client
     @resolvers = resolvers
     @resolved_services = {}
+    @resolution_exceptions = []
   end
 
   def route_to(name, ssl_context: nil)
-    route = ROUTES[name]
-    raise ArgumentError, "Unknown service #{name}" unless route
+    raise ArgumentError, "Unknown service #{name}" unless Puppet::HTTP::Service.valid_name?(name)
 
     cached = @resolved_services[name]
     return cached if cached
 
-    errors = []
+    @resolution_exceptions = []
 
     @resolvers.each do |resolver|
       Puppet.debug("Resolving service '#{name}' using #{resolver.class}")
-      resolver.resolve(self, name) do |service|
-        begin
-          service.connect(ssl_context: ssl_context)
-          @resolved_services[name] = service
-          Puppet.debug("Resolved service '#{name}' to #{service.url}")
-          return service
-        rescue Puppet::HTTP::ConnectionError => e
-          errors << e
-          Puppet.debug("Connection to #{service.url} failed, trying next route: #{e.message}")
-        end
+      service = resolver.resolve(self, name, ssl_context: ssl_context)
+      if service
+        @resolved_services[name] = service
+        Puppet.debug("Resolved service '#{name}' to #{service.url}")
+        return service
       end
     end
 
-    errors.each { |e| Puppet.log_exception(e) }
-
+    @resolution_exceptions.each { |e| Puppet.log_exception(e) }
     raise Puppet::HTTP::RouteError, "No more routes to #{name}"
   end
 
-  def create_service(name, server = nil, port = nil)
-    route = ROUTES[name]
-    raise ArgumentError, "Unknown service #{name}" unless route
-
-    server ||= Puppet[route.server_setting]
-    port   ||= Puppet[route.port_setting]
-    url = URI::HTTPS.build(host: server,
-                           port: port,
-                           path: route.api
-                          ).freeze
-    route.service_class.new(@client, url)
+  def add_exception(exception)
+    @resolution_exceptions << exception
   end
 end

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

@@ -8,6 +8,7 @@ class Puppet::Network::HTTP::BasePool
       verifier.setup_connection(http)
       begin
         http.start
+        print_ssl_info(http) if Puppet::Util::Log.sendlevel?(:debug)
       rescue OpenSSL::SSL::SSLError => error
         verifier.handle_connection_error(http, error)
       end
@@ -15,4 +16,16 @@ class Puppet::Network::HTTP::BasePool
       http.start
     end
   end
+
+  private
+
+  def print_ssl_info(http)
+    buffered_io = http.instance_variable_get(:@socket)
+    return unless buffered_io
+
+    socket = buffered_io.io
+    return unless socket
+
+    Puppet.debug("Using #{socket.ssl_version} with cipher #{socket.cipher.first}")
+  end
 end

data/lib/puppet/node/environment.rb

@@ -1,6 +1,7 @@
 require 'puppet/util'
 require 'monitor'
 require 'puppet/parser/parser_factory'
+require 'puppet/concurrent/lock'
 
 # Just define it, so this class has fewer load dependencies.
 class Puppet::Node
@@ -70,6 +71,7 @@ class Puppet::Node::Environment
   #
   # @param name [Symbol] The environment name
   def initialize(name, modulepath, manifest, config_version)
+    @lock = Puppet::Concurrent::Lock.new
     @name = name.intern
     @modulepath = self.class.expand_dirs(self.class.extralibs() + modulepath)
     @manifest = manifest == NO_MANIFEST ? manifest : Puppet::FileSystem.expand_path(manifest)
@@ -232,11 +234,13 @@ class Puppet::Node::Environment
   # @api public
   # @return [Puppet::Resource::TypeCollection] The current global TypeCollection
   def known_resource_types
-    if @known_resource_types.nil?
-      @known_resource_types = Puppet::Resource::TypeCollection.new(self)
-      @known_resource_types.import_ast(perform_initial_import(), '')
+    @lock.synchronize do
+      if @known_resource_types.nil?
+        @known_resource_types = Puppet::Resource::TypeCollection.new(self)
+        @known_resource_types.import_ast(perform_initial_import(), '')
+      end
+      @known_resource_types
     end
-    @known_resource_types
   end
 
   # Yields each modules' plugin directory if the plugin directory (modulename/lib)
@@ -429,9 +433,11 @@ class Puppet::Node::Environment
   # Checks if a reparse is required (cache of files is stale).
   #
   def check_for_reparse
-    if (Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?)
-      @parsed_code = nil
-      @known_resource_types = nil
+    @lock.synchronize do
+      if (Puppet[:code] != @parsed_code || @known_resource_types.parse_failed?)
+        @parsed_code = nil
+        @known_resource_types = nil
+      end
     end
   end
 

data/lib/puppet/pal/pal_impl.rb

@@ -83,6 +83,8 @@ module Pal
       end
     end
 
+    previous_tasks_value = Puppet[:tasks]
+    previous_code_value = Puppet[:code]
     Puppet[:tasks] = true
     # After the assertions, if code_string is non nil - it has the highest precedence
     Puppet[:code] = code_string unless code_string.nil?
@@ -90,6 +92,9 @@ module Pal
     # If manifest_file is nil, the #main method will use the env configured manifest
     # to do things in the block while a Script Compiler is in effect
     main(manifest_file, facts, variables, :script, &block)
+  ensure
+    Puppet[:tasks] = previous_tasks_value
+    Puppet[:code] = previous_code_value
   end
 
   # Evaluates a Puppet Language script string.

data/lib/puppet/parser/functions/epp.rb

@@ -7,12 +7,12 @@ result as a String.
 The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
 reference, which loads `<TEMPLATE FILE>` from `<MODULE NAME>`'s `templates`
 directory. In most cases, the last argument is optional; if used, it should be a
-[hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+[hash](https://puppet.com/docs/puppet/latest/lang_data_hash.html) that contains parameters to
 pass to the template.
 
-- See the [template](/puppet/latest/reference/lang_template.html) documentation
+- See the [template](https://puppet.com/docs/puppet/latest/lang_template.html) documentation
 for general template usage information.
-- See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+- See the [EPP syntax](https://puppet.com/docs/puppet/latest/lang_template_epp.html)
 documentation for examples of EPP.
 
 For example, to call the apache module's `templates/vhost/_docroot.epp`

data/lib/puppet/parser/functions/inline_epp.rb

@@ -6,12 +6,12 @@ text result as a String.
 
 The first argument to this function should be a string containing an EPP
 template. In most cases, the last argument is optional; if used, it should be a
-[hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+[hash](https://puppet.com/docs/puppet/latest/lang_data_hash.html) that contains parameters to
 pass to the template.
 
-- See the [template](/puppet/latest/reference/lang_template.html) documentation
+- See the [template](https://puppet.com/docs/puppet/latest/lang_template.html) documentation
 for general template usage information.
-- See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+- See the [EPP syntax](https://puppet.com/docs/puppet/latest/lang_template_epp.html)
 documentation for examples of EPP.
 
 For example, to evaluate an inline EPP template and pass it the `docroot` and
@@ -29,7 +29,7 @@ parameter tag without default values. Puppet produces an error if the
 `inline_epp` function fails to pass any required parameter.
 
 An inline EPP template should be written as a single-quoted string or
-[heredoc](/puppet/latest/reference/lang_data_string.html#heredocs).
+[heredoc](https://puppet.com/docs/puppet/latest/lang_data_string.html#heredocs).
 A double-quoted string is subject to expression interpolation before the string
 is parsed as an EPP template.
 
@@ -45,7 +45,7 @@ END
 ~~~
 
 - Since 3.5
-- Requires [future parser](/puppet/3.8/reference/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
+- Requires [future parser](https://puppet.com/docs/puppet/3.8/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
 
   Puppet::Parser::Functions::Error.is4x('inline_epp')
 end

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -33,7 +33,7 @@ module Runtime3Support
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def optionally_fail(issue, semantic, options={}, except=nil)
-    if except.nil?
+    if except.nil? && diagnostic_producer.severity_producer[issue] == :error
       # Want a stacktrace, and it must be passed as an exception
       begin
        raise EvaluationError.new()