puppet 6.12.0-universal-darwin → 6.17.0-universal-darwin

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

@@ -0,0 +1,206 @@
+require 'puppet/file_serving/metadata'
+
+#
+# @api private
+#
+# The FileServer service is used to retrieve file metadata and content
+#
+class Puppet::HTTP::Service::FileServer < Puppet::HTTP::Service
+  # @api private
+  # @return [String] Default API for the FileServer service
+  API = '/puppet/v3'.freeze
+
+  # @api private
+  # @return [RegEx] RegEx used to determine if a path contains a leading slash
+  PATH_REGEX = /^\//
+
+  #
+  # @api private
+  #
+  # @param [Puppet::HTTP::Client] client
+  # @param [Puppet::HTTP::Session] session
+  # @param [String] server (Puppet[:ca_server]) If an explicit server is given,
+  #   create a service using that server. If server is nil, the default value
+  #   is used to create the service.
+  # @param [Integer] port (Puppet[:ca_port]) If an explicit port is given, create
+  #   a service using that port. If port is nil, the default value is used to
+  #   create the service.
+  #
+  def initialize(client, session, server, port)
+    url = build_url(API, server || Puppet[:server], port || Puppet[:masterport])
+    super(client, session, url)
+  end
+
+  #
+  # @api private
+  #
+  # Submit a GET request to the server to retrieve the metadata for a specified
+  # file
+  #
+  # @param [String] path path to the file to retrieve data from
+  # @param [String] environment the name of the environment we are operating in
+  # @param [Symbol] links Can be one of either `:follow` or `:manage`, defines
+  #   how links are handled.
+  # @param [String] checksum_type The digest algorithm used to verify the file.
+  #   Currently if fips is enabled, this defaults to `sha256`. Otherwise, it
+  #   defaults to `md5`.
+  # @param [Symbol] source_permissions Can be one of `:use`, `:use_when_creating`,
+  #   or `:ignore`. This parameter tells the server if it should include the
+  #   file permissions in the response. If set to `:ignore`, the server will
+  #   return default permissions.
+  #
+  # @return [Array<Puppet::HTTP::Response, Puppet::FileServing::Metadata>] An
+  #   array with the request response and the deserialized metadata for the
+  #   file returned from the server
+  #
+  def get_file_metadata(path:, environment:, links: :manage, checksum_type: Puppet[:digest_algorithm], source_permissions: :ignore)
+    validate_path(path)
+
+    headers = add_puppet_headers('Accept' => get_mime_types(Puppet::FileServing::Metadata).join(', '))
+
+    response = @client.get(
+      with_base_url("/file_metadata#{path}"),
+      headers: headers,
+      params: {
+        links: links,
+        checksum_type: checksum_type,
+        source_permissions: source_permissions,
+        environment: environment
+      }
+    )
+
+    process_response(response)
+
+    [response, deserialize(response, Puppet::FileServing::Metadata)]
+  end
+
+  #
+  # @api private
+  #
+  # Submit a GET request to the server to retrieve the metadata for multiple files
+  #
+  # @param [String] path path to the file(s) to retrieve data from
+  # @param [String] environment the name of the environment we are operating in
+  # @param [Symbol] recurse  Can be `:true`, `:false`, or `:remote`. Defines if
+  #   we recursively return the contents of the directory. Used in conjunction
+  #   with `:recurselimit`. See the reference documentation for the file type
+  #   for more details.
+  # @param [Integer] recurselimit When `recurse` is set, `recurselimit` defines
+  #   how far Puppet should descend into subdirectories. `0` is effectively the
+  #   same as `recurse => false`, `1` will return files and directories directly
+  #   inside the defined directory, `2` will return the direct content of the
+  #   directory as well as the contents of the _first_ level of subdirectories.
+  #   The pattern continues for each incremental value. See the reference
+  #   documentation for the file type for more details.
+  # @param [Array<String>] ignore An optional array of files to ignore, ie `['CVS', '.git', '.hg']`
+  # @param [Symbol] links Can be one of either `:follow` or `:manage`, defines
+  #   how links are handled.
+  # @param [String] checksum_type The digest algorithm used to verify the file.
+  #   Currently if fips is enabled, this defaults to `sha256`. Otherwise, it's `md5`.
+  # @param [Symbol] source_permissions Can be one of `:use`, `:use_when_creating`,
+  #   or `:ignore`. This parameter tells the server if it should include the
+  #   file permissions in the report. If set to `:ignore`, the server will return
+  #   default permissions.
+  #
+  # @return [Array<Puppet::HTTP::Response, Array<Puppet::FileServing::Metadata>>]
+  #   An array with the request response and an array of the deserialized
+  #   metadata for each file returned from the server
+  #
+  def get_file_metadatas(path: nil, environment:, recurse: :false, recurselimit: nil, ignore: nil, links: :manage, checksum_type: Puppet[:digest_algorithm], source_permissions: :ignore)
+    validate_path(path)
+
+    headers = add_puppet_headers('Accept' => get_mime_types(Puppet::FileServing::Metadata).join(', '))
+
+    response = @client.get(
+      with_base_url("/file_metadatas#{path}"),
+      headers: headers,
+      params: {
+        recurse: recurse,
+        recurselimit: recurselimit,
+        ignore: ignore,
+        links: links,
+        checksum_type: checksum_type,
+        source_permissions: source_permissions,
+        environment: environment,
+      }
+    )
+
+    process_response(response)
+
+    [response, deserialize_multiple(response, Puppet::FileServing::Metadata)]
+  end
+
+  #
+  # @api private
+  #
+  # Submit a GET request to the server to retrieve content of a file
+  #
+  # @param [String] path path to the file to retrieve data from
+  # @param [String] environment the name of the environment we are operating in
+  #
+  # @yield [Sting] Yields the body of the response returned from the server
+  #
+  # @return [Puppet::HTTP::Response] The request response
+  #
+  def get_file_content(path:, environment:, &block)
+    validate_path(path)
+
+    headers = add_puppet_headers('Accept' => 'application/octet-stream')
+    response = @client.get(
+      with_base_url("/file_content#{path}"),
+      headers: headers,
+      params: {
+        environment: environment
+      }
+    ) do |res|
+      if res.success?
+        res.read_body(&block)
+      end
+    end
+
+    process_response(response)
+
+    response
+  end
+
+  #
+  # @api private
+  #
+  # Submit a GET request to
+  #
+  # @param [String] path path to the file to retrieve data from
+  # @param [String] environment the name of the environment we are operating in
+  # @param [String] code_id Defines the version of the resource to return
+  #
+  # @yield [String] Yields the body of the response returned
+  #
+  # @return [Puppet::HTTP::Response] The request response
+  #
+  def get_static_file_content(path:, environment:, code_id:, &block)
+    validate_path(path)
+
+    headers = add_puppet_headers('Accept' => 'application/octet-stream')
+    response = @client.get(
+      with_base_url("/static_file_content#{path}"),
+      headers: headers,
+      params: {
+        environment: environment,
+        code_id: code_id,
+      }
+    ) do |res|
+      if res.success?
+        res.read_body(&block)
+      end
+    end
+
+    process_response(response)
+
+    response
+  end
+
+  private
+
+  def validate_path(path)
+    raise ArgumentError, "Path must start with a slash" unless path =~ PATH_REGEX
+  end
+end

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

@@ -1,40 +1,66 @@
+#
+# @api private
+#
+# The Report service is used to submit run reports to the report server
+#
 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
+  # @api private
+  # @return [String] Default API for the report service
+  API = '/puppet/v3'.freeze
 
-  def initialize(client, server, port)
+  #
+  # @api private
+  #
+  # @param [Puppet::HTTP::Client] client
+  # @param [Puppet::HTTP::Session] session
+  # @param [String] server (Puppet[:ca_server]) If an explicit server is given,
+  #   create a service using that server. If server is nil, the default value
+  #   is used to create the service.
+  # @param [Integer] port (Puppet[:ca_port]) If an explicit port is given, create
+  #   a service using that port. If port is nil, the default value is used to
+  #   create the service.
+  #
+  def initialize(client, session, server, port)
     url = build_url(API, server || Puppet[:report_server], port || Puppet[:report_port])
-    super(client, url)
+    super(client, session, url)
   end
 
-  def put_report(name, report, environment:, ssl_context: nil)
+  #
+  # @api private
+  #
+  # Submit a report to the report server
+  #
+  # @param [String] name the name of the report being submitted
+  # @param [Puppet::Transaction::Report] report run report to be submitted
+  # @param [String] environment name of the agent environment
+  #
+  # @return [Puppet::HTTP::Response] response returned by the server
+  #
+  def put_report(name, report, environment:)
     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 }
+    headers = add_puppet_headers(
+      'Accept' => get_mime_types(Puppet::Transaction::Report).join(', '),
+      'Content-Type' => formatter.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
+      serialize(formatter, report),
+      headers: headers,
+      params: { environment: environment },
     )
 
-    return response.body.to_s if response.success?
+    # override parent's process_response handling
+    @session.process_response(response)
 
-    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'
+    if response.success?
+      response
+    elsif !@session.supports?(:report, 'json') && 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 })
+      raise Puppet::HTTP::ProtocolError.new(_("To submit reports to a server running puppetserver %{server_version}, set preferred_serialization_format to pson") % { server_version: response[Puppet::HTTP::HEADER_PUPPET_VERSION]})
+    else
+      raise Puppet::HTTP::ResponseError.new(response)
     end
-
-    raise Puppet::HTTP::ResponseError.new(response)
   end
 end

data/lib/puppet/http/session.rb

@@ -1,22 +1,75 @@
+#
+# @api private
+#
+# The session is the mechanism by which services may be connected to and accessed.
+#
 class Puppet::HTTP::Session
+  # capabilities for a site
+  CAP_LOCALES = 'locales'.freeze
+  CAP_JSON = 'json'.freeze
+
+  # puppet version where locales mount was added
+  SUPPORTED_LOCALES_MOUNT_AGENT_VERSION = Gem::Version.new("5.3.4")
+
+  # puppet version where JSON was enabled by default
+  SUPPORTED_JSON_DEFAULT = Gem::Version.new("5.0.0")
+
+  #
+  # @api private
+  #
+  # Create a new HTTP session. The session is the mechanism by which services
+  # may be connected to and accessed.
+  #
+  # @param [Puppet::HTTP::Client] client the container for this session
+  # @param [Array<Puppet::HTTP::Resolver>] resolvers array of resolver strategies
+  #   to implement.
+  #
   def initialize(client, resolvers)
     @client = client
     @resolvers = resolvers
     @resolved_services = {}
-    @resolution_exceptions = []
+    @server_versions = {}
   end
 
-  def route_to(name, ssl_context: nil)
+  #
+  # @api private
+  #
+  # If an explicit server and port are specified on the command line or
+  # configuration file, this method always returns a Service with that host and
+  # port. Otherwise, we walk the list of resolvers in priority order:
+  #     - DNS SRV
+  #     - Server List
+  #     - Puppet server/port settings
+  # If a given resolver fails to connect, it tries the next available resolver
+  # until a successful connection is found and returned. The successful service
+  # is cached and returned if `route_to` is called again.
+  #
+  # @param [Symbol] name the service to resolve
+  # @param [URI] url (nil) optional explicit url to use, if it is already known
+  # @param [Puppet::SSL::SSLContext] ssl_context ssl_context ssl context to be
+  #   used for connections
+  #
+  # @return [Puppet::HTTP::Service] the resolved service
+  #
+  def route_to(name, url: nil, ssl_context: nil)
     raise ArgumentError, "Unknown service #{name}" unless Puppet::HTTP::Service.valid_name?(name)
 
+    # short circuit if explicit URL host & port given
+    if url && url.host != nil && !url.host.empty?
+      service = Puppet::HTTP::Service.create_service(@client, self, name, url.host, url.port)
+      service.connect(ssl_context: ssl_context)
+      return service
+    end
+
     cached = @resolved_services[name]
     return cached if cached
 
-    @resolution_exceptions = []
+    resolution_exceptions = []
+    error_handler = proc { |e| resolution_exceptions << e }
 
     @resolvers.each do |resolver|
       Puppet.debug("Resolving service '#{name}' using #{resolver.class}")
-      service = resolver.resolve(self, name, ssl_context: ssl_context)
+      service = resolver.resolve(self, name, ssl_context: ssl_context, error_handler: error_handler)
       if service
         @resolved_services[name] = service
         Puppet.debug("Resolved service '#{name}' to #{service.url}")
@@ -24,11 +77,54 @@ class Puppet::HTTP::Session
       end
     end
 
-    @resolution_exceptions.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 add_exception(exception)
-    @resolution_exceptions << exception
+  #
+  # @api private
+  #
+  # Collect per-site server versions. This will allow us to modify future
+  # requests based on the version of puppetserver we are talking to.
+  #
+  # @param [Puppet::HTTP::Response] response the request response containing headers
+  #
+  def process_response(response)
+    version = response[Puppet::HTTP::HEADER_PUPPET_VERSION]
+    if version
+      site = Puppet::Network::HTTP::Site.from_uri(response.url)
+      @server_versions[site] = version
+    end
+  end
+
+  #
+  # @api private
+  #
+  # Determine if a session supports a capability. Depending on the server version
+  # we are talking to, we know certain features are available or not. These
+  # specifications are defined here so we can modify our requests appropriately.
+  #
+  # @param [Symbol] name name of the service to check
+  # @param [String] capability the capability, ie `locales` or `json`
+  #
+  # @return [Boolean]
+  #
+  def supports?(name, capability)
+    raise ArgumentError, "Unknown service #{name}" unless Puppet::HTTP::Service.valid_name?(name)
+
+    service = @resolved_services[name]
+    return false unless service
+
+    site = Puppet::Network::HTTP::Site.from_uri(service.url)
+    server_version = @server_versions[site]
+
+    case capability
+    when CAP_LOCALES
+      !server_version.nil? && Gem::Version.new(server_version) >= SUPPORTED_LOCALES_MOUNT_AGENT_VERSION
+    when CAP_JSON
+      server_version.nil? || Gem::Version.new(server_version) >= SUPPORTED_JSON_DEFAULT
+    else
+      false
+    end
   end
 end

data/lib/puppet/indirector.rb

@@ -46,7 +46,7 @@ module Puppet::Indirector
 
     # instantiate the actual Terminus for that type and this name (:ldap, w/ args :node)
     # & hook the instantiated Terminus into this class (Node: @indirection = terminus)
-    @indirection = Puppet::Indirector::Indirection.new(self, indirection, options)
+    @indirection = Puppet::Indirector::Indirection.new(self, indirection, **options)
   end
 
   module ClassMethods

data/lib/puppet/indirector/catalog/compiler.rb

@@ -1,3 +1,4 @@
+require 'puppet/environments'
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/code'
@@ -173,6 +174,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # Initially restricted to files sourced from codedir via puppet:/// uri.
   def inline_metadata(catalog, checksum_type)
     environment_path = Pathname.new File.join(Puppet[:environmentpath], catalog.environment, "")
+    environment_path = Puppet::Environments::Directories.real_path(environment_path)
     list_of_resources = catalog.resources.find_all { |res| res.type == "File" }
 
     # TODO: get property/parameter defaults if entries are nil in the resource
@@ -393,9 +395,17 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   # Initialize our server fact hash; we add these to each client, and they
   # won't change while we're running, so it's safe to cache the values.
+  #
+  # See also set_server_facts in Puppet::Server::Compiler in puppetserver.
   def set_server_facts
     @server_facts = {}
 
+    # Add our server Puppet Enterprise version, if available.
+    pe_version_file = '/opt/puppetlabs/server/pe_version'
+    if File.readable?(pe_version_file) and !File.zero?(pe_version_file)
+      @server_facts['pe_serverversion'] = File.read(pe_version_file).chomp
+    end
+
     # Add our server version to the fact list
     @server_facts["serverversion"] = Puppet.version.to_s