puppet 6.16.0-x64-mingw32 → 7.0.0-x64-mingw32

data/lib/puppet/parser/compiler/catalog_validator/site_validator.rb

@@ -1,20 +0,0 @@
-class Puppet::Parser::Compiler
-  # Validator that asserts that only application components can appear inside a site.
-  class CatalogValidator::SiteValidator < CatalogValidator
-    def self.validation_stage?(stage)
-      PRE_FINISH.equal?(stage)
-    end
-
-    def validate
-      the_site_resource = catalog.resource('Site', 'site')
-      return unless the_site_resource
-
-      catalog.downstream_from_vertex(the_site_resource).keys.each do |r|
-        unless r.is_application_component? || r.resource_type.application?
-          raise CatalogValidationError.new(_("Only application components can appear inside a site - %{res} is not allowed") % { res: r }, r.file, r.line)
-        end
-      end
-    end
-  end
-end
-

data/lib/puppet/parser/environment_compiler.rb

@@ -1,199 +0,0 @@
-require 'puppet/parser/compiler'
-
-class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
-  def self.compile(env, code_id=nil)
-    begin
-      env.check_for_reparse
-
-      node = Puppet::Node.new(env)
-      node.environment = env
-      new(node, :code_id => code_id).compile
-    rescue => detail
-      message = _("%{detail} in environment %{env}") % { detail: detail, env: env.name }
-      Puppet.log_exception(detail, message)
-      raise Puppet::Error, message, detail.backtrace
-    end
-  end
-
-  def initialize(node, options = {})
-    super
-    @overridden_functions = {}
-  end
-
-  def add_function_overrides
-    add_function_override('hiera_include', proc { Puppet.debug "Ignoring hiera_include() during environment catalog compilation" })
-  end
-
-  def add_function_override(func_name, override)
-    typed_name = Puppet::Pops::Loader::TypedName.new(:function, func_name)
-    loader = loaders.puppet_system_loader
-
-    # Remove and preserve existing entry. A `nil` is also preserved to indicate
-    # an override that didn't replace a loaded function.
-    entry = loader.get_entry(typed_name)
-    existing = entry.nil? ? nil : entry.value
-    loader.remove_entry(typed_name) unless existing.nil?
-    @overridden_functions[typed_name] = existing
-
-    # Add the override to the loader
-    loader.set_entry(typed_name, override)
-  end
-
-  def remove_function_overrides
-    loader = loaders.puppet_system_loader
-    @overridden_functions.each_pair do |typed_name, overridden|
-      loader.remove_entry(typed_name)
-      loader.set_entry(typed_name, overridden) unless overridden.nil?
-    end
-  end
-
-  def add_catalog_validators
-    super
-    add_catalog_validator(CatalogValidator::SiteValidator)
-    add_catalog_validator(CatalogValidator::EnvironmentRelationshipValidator)
-  end
-
-  def compile
-    add_function_overrides
-    begin
-      Puppet.override(@context_overrides, _("For compiling environment catalog %{env}") % { env: environment.name }) do
-        @catalog.environment_instance = environment
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
-          validate_catalog(CatalogValidator::PRE_FINISH)
-        end
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
-
-        fail_on_unevaluated
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog final"), [:compiler, :validate_final]) do
-          validate_catalog(CatalogValidator::FINAL)
-        end
-
-        if block_given?
-          yield @catalog
-        else
-          @catalog
-        end
-      end
-    ensure
-      remove_function_overrides
-    end
-  end
-
-  # @api private
-  def prune_catalog
-    prune_env_catalog
-  end
-
-  # Prunes the catalog by dropping all resources that are not contained under the Site (if a site expression is used).
-  # As a consequence all edges to/from dropped resources are also dropped.
-  # Once the pruning is performed, this compiler returns the pruned list when calling the #resources method.
-  # The pruning does not alter the order of resources in the resources list.
-  #
-  def prune_env_catalog
-    # Everything under Class[main], that is not under (inclusive of) Site[site] should be pruned as those resources
-    # are intended for nodes in a node catalog.
-    #
-    the_main_class_resource = @catalog.resource('Class', '')
-    the_site_resource = @catalog.resource('Site', 'site')
-
-    # Get downstream vertexes returns a hash where the keys are the resources and values nesting level
-    rooted_in_main = @catalog.downstream_from_vertex(the_main_class_resource).keys
-
-    to_be_removed =
-    if the_site_resource
-      keep_from_site = @catalog.downstream_from_vertex(the_site_resource).keys
-      keep_from_site << the_site_resource
-      rooted_in_main - keep_from_site
-    else
-      rooted_in_main
-    end
-
-    @catalog.remove_resource(*to_be_removed)
-    # The compiler keeps a list of added resources, this shadows that list with the now pruned result
-    @pruned_resources = @catalog.resources
-  end
-
-  def add_resource(scope, resource)
-    @resources << resource
-    @catalog.add_resource(resource)
-
-    if !resource.class? && resource[:stage]
-      raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
-    end
-
-    # Stages should not be inside of classes.  They are always a
-    # top-level container, regardless of where they appear in the
-    # manifest.
-    return if resource.stage?
-
-    # This adds a resource to the class it lexically appears in in the
-    # manifest.
-    unless resource.class?
-      @catalog.add_edge(scope.resource, resource)
-    end
-    resource.mark_unevaluated_consumer if is_capability_consumer?(resource)
-    assert_app_in_site(scope, resource)
-  end
-
-  def evaluate_ast_node()
-    # Do nothing, the environment catalog is not built for a particular node.
-  end
-
-  def on_empty_site
-    Puppet.warning(_("Environment Compiler: Could not find a site definition to evaluate"))
-  end
-
-  def evaluate_applications
-    exceptwrap do
-      resources.select { |resource| type = resource.resource_type; type.is_a?(Puppet::Resource::Type) && type.application? }.each do |resource|
-        Puppet::Util::Profiler.profile(_("Evaluated application %{resource}") % { resource: resource }, [:compiler, :evaluate_resource, resource]) do
-          resource.evaluate
-        end
-      end
-    end
-  end
-
-  def evaluate_classes(titles, scope, lazy)
-    # Always lazy in an Environment compilation
-    super(titles, scope, true)
-  end
-
-  # Overrides the regular compiler to be able to return the list of resources after a prune
-  # has taken place in the graph representation. Before a prune, the list is the same as in the regular
-  # compiler
-  #
-  def resources
-    @pruned_resources || super
-  end
-
-  def is_capability?(value)
-    if value.is_a?(Array)
-      value.find { |ev| is_capability?(ev) }
-    elsif value.is_a?(Puppet::Resource)
-      rstype = value.resource_type
-      rstype.nil? ? false : rstype.is_capability?
-    else
-      false
-    end
-  end
-  private :is_capability?
-
-  def is_capability_consumer?(resource)
-    resource.eachparam { |param| return true if (param.name == :consume || param.name == :require) && is_capability?(param.value) }
-    false
-  end
-  private :is_capability_consumer?
-end

data/lib/puppet/pops/types/enumeration.rb

@@ -1,16 +0,0 @@
-# The Enumeration class provides default Enumerable::Enumerator creation for Puppet Programming Language
-# runtime objects that supports the concept of enumeration.
-#
-module Puppet::Pops::Types
-  class Enumeration
-    def self.enumerator(o)
-      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
-      Iterable.on(o)
-    end
-
-    def enumerator(o)
-      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
-      Iterable.on(o)
-    end
-  end
-end

data/lib/puppet/resource/capability_finder.rb

@@ -1,154 +0,0 @@
-#
-# A helper module to look a capability up from PuppetDB
-#
-# @todo lutter 2015-03-10: determine whether this should be based on
-# Puppet::Pops::Evaluator::Collectors, or at least use
-# Puppet::Util::Puppetdb::Http
-
-require 'net/http'
-require 'cgi'
-require 'puppet/util/json'
-
-# @api private
-module Puppet::Resource::CapabilityFinder
-
-  # Looks up a capability resource from PuppetDB. Capability resources are
-  # required to be unique per environment and code id. If multiple copies of a
-  # capability resource are found, the one matching the current code id is
-  # used.
-  #
-  # @param environment [String] environment name
-  # @param code_id [String,nil] code_id of the catalog
-  # @param cap [Puppet::Resource] the capability resource type instance
-  # @return [Puppet::Resource,nil] The found capability resource or `nil` if it could not be found
-  def self.find(environment, code_id, cap)
-    unless Puppet::Util.const_defined?('Puppetdb')
-      #TRANSLATOR PuppetDB is a product name and should not be translated
-      raise Puppet::DevError, _('PuppetDB is not available')
-    end
-
-    resources = search(nil, nil, cap)
-
-    if resources.size > 1
-      Puppet.debug "Found multiple resources when looking up capability #{cap}, filtering by environment #{environment}"
-      resources = resources.select { |r| r['tags'].any? { |t| t == "producer:#{environment}" } }
-    end
-
-    if resources.empty?
-      Puppet.debug "Could not find capability resource #{cap} in PuppetDB"
-    elsif resources.size == 1
-      resource_hash = resources.first
-    else
-      code_id_resource = disambiguate_by_code_id(environment, code_id, cap)
-      if code_id_resource
-        resource_hash = code_id_resource
-      else
-        #TRANSLATOR PuppetDB is a product name and should not be translated
-        message = _("Unexpected response from PuppetDB when looking up %{capability}:") % { capability: cap }
-        message += "\n" + _("expected exactly one resource but got %{count};") % { count: resources.size }
-        message += "\n" + _("returned data is:\n%{resources}") % { resources: resources.inspect }
-        raise Puppet::DevError, message
-      end
-    end
-
-    if resource_hash
-      resource_hash['type'] = cap.resource_type
-      instantiate_resource(resource_hash)
-    end
-  end
-
-  def self.search(environment, code_id, cap)
-    query_terms = [
-      'and',
-      ['=', 'type', cap.type.capitalize],
-      ['=', 'title', cap.title.to_s],
-    ]
-
-    if environment.nil?
-      query_terms << ['~', 'tag', "^producer:"]
-    else
-      query_terms << ['=', 'tag', "producer:#{environment}"]
-    end
-
-    unless code_id.nil?
-      query_terms << ['in', 'certname',
-        ['extract', 'certname',
-          ['select_catalogs',
-            ['=', 'code_id', code_id]]]]
-    end
-
-    #TRANSLATOR PuppetDB is a product name and should not be translated
-    Puppet.notice _("Looking up capability %{capability} in PuppetDB: %{query_terms}") % { capability: cap, query_terms: query_terms }
-
-    query_puppetdb(query_terms)
-  end
-
-  def self.query_puppetdb(query)
-    begin
-      # If using PuppetDB >= 4, use the API method query_puppetdb()
-      result = if Puppet::Util::Puppetdb.respond_to?(:query_puppetdb)
-        # PuppetDB 4 uses a unified query endpoint, so we have to specify what we're querying
-        Puppet::Util::Puppetdb.query_puppetdb(["from", "resources", query])
-      # For PuppetDB < 4, use the old internal method action()
-      else
-        url = "/pdb/query/v4/resource?query=#{Puppet::Util.uri_query_encode(query.to_json)}"
-        response = Puppet::Util::Puppetdb::Http.action(url) do |conn, uri|
-          conn.get(uri, { 'Accept' => 'application/json'})
-        end
-        Puppet::Util::Json.load(response.body)
-      end
-
-      # The format of the response body is documented at
-      #   https://puppet.com/docs/puppetdb/3.0/api/query/v4/resources.html#response-format
-      unless result.is_a?(Array)
-        #TRANSLATOR PuppetDB is a product name and should not be translated
-        raise Puppet::DevError, _("Unexpected response from PuppetDB when looking up %{capability}: expected an Array but got %{result}") %
-            { capability: cap, result: result.inspect }
-      end
-
-      result
-    rescue Puppet::Util::Json::ParseError => e
-      #TRANSLATOR PuppetDB is a product name and should not be translated
-      raise Puppet::DevError, _("Invalid JSON from PuppetDB when looking up %{capability}\n%{detail}") % { capability: cap, detail: e }
-    end
-  end
-
-  # Find a distinct copy of the given capability resource by searching for only
-  # resources matching the given code_id. Returns `nil` if no code_id is
-  # supplied or if there isn't exactly one matching resource.
-  #
-  # @param environment [String] environment name
-  # @param code_id [String,nil] code_id of the catalog
-  # @param cap [Puppet::Resource] the capability resource type instance
-  def self.disambiguate_by_code_id(environment, code_id, cap)
-    if code_id
-      Puppet.debug "Found multiple resources when looking up capability #{cap}, filtering by code id #{code_id}"
-      resources = search(environment, code_id, cap)
-
-      if resources.size > 1
-        Puppet.debug "Found multiple resources matching code id #{code_id} when looking up #{cap}"
-        nil
-      else
-        resources.first
-      end
-    end
-  end
-  private_class_method :disambiguate_by_code_id
-
-  def self.instantiate_resource(resource_hash)
-    real_type = resource_hash['type']
-    resource = Puppet::Resource.new(real_type, resource_hash['title'])
-    real_type.parameters.each do |param|
-      param = param.to_s
-      next if param == 'name'
-      value = resource_hash['parameters'][param]
-      if value
-        resource[param] = value
-      else
-        Puppet.debug "No capability value for #{resource}->#{param}"
-      end
-    end
-    return resource
-  end
-  private_class_method :instantiate_resource
-end

data/lib/puppet/rest/errors.rb

@@ -1,15 +0,0 @@
-# @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

@@ -1,35 +0,0 @@
-# @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

@@ -1,85 +0,0 @@
-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 speical
-    #                  port configuration
-    # @param [Symbol] srv_service the name of the service when using SRV
-    #                 records
-    def initialize(api:, server_setting: :server, port_setting: :masterport, 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