puppet 6.25.0-x64-mingw32 → 7.0.0-x64-mingw32

data/lib/puppet/resource/type_collection.rb

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 require 'puppet/parser/type_loader'
 require 'puppet/util/file_watcher'
 require 'puppet/util/warnings'
@@ -14,22 +13,16 @@ class Puppet::Resource::TypeCollection
   def clear
     @hostclasses.clear
     @definitions.clear
-    @applications.clear
     @nodes.clear
     @notfound.clear
-    @capability_mappings.clear
-    @sites.clear
   end
 
   def initialize(env)
     @environment = env
     @hostclasses = {}
     @definitions = {}
-    @capability_mappings = {}
-    @applications = {}
     @nodes = {}
     @notfound = {}
-    @sites = []
     @lock = Puppet::Concurrent::Lock.new
 
     # So we can keep a list and match the first-defined regex
@@ -46,10 +39,7 @@ class Puppet::Resource::TypeCollection
     "TypeCollection" + {
       :hostclasses => @hostclasses.keys,
       :definitions => @definitions.keys,
-      :nodes => @nodes.keys,
-      :capability_mappings => @capability_mappings.keys,
-      :applications => @applications.keys,
-      :site => @sites[0] # todo, could be just a binary, this dumps the entire body (good while developing)
+      :nodes => @nodes.keys
     }.inspect
   end
 
@@ -72,7 +62,6 @@ class Puppet::Resource::TypeCollection
     handle_hostclass_merge(instance)
     dupe_check(instance, @hostclasses) { |dupe| _("Class '%{klass}' is already defined%{error}; cannot redefine") % { klass: instance.name, error: dupe.error_context } }
     dupe_check(instance, @definitions) { |dupe| _("Definition '%{klass}' is already defined%{error}; cannot be redefined as a class") % { klass: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @applications) { |dupe| _("Application '%{klass}' is already defined%{error}; cannot be redefined as a class") % { klass: instance.name, error: dupe.error_context } }
 
     @hostclasses[instance.name] = instance
     instance
@@ -110,16 +99,6 @@ class Puppet::Resource::TypeCollection
     instance
   end
 
-  def add_site(instance)
-    dupe_check_singleton(instance, @sites) { |dupe| _("Site is already defined%{error}; cannot redefine") % { error: dupe.error_context } }
-    @sites << instance
-    instance
-  end
-
-  def site(_)
-    @sites[0]
-  end
-
   def loader
     @loader ||= Puppet::Parser::TypeLoader.new(environment)
   end
@@ -150,38 +129,18 @@ class Puppet::Resource::TypeCollection
   def add_definition(instance)
     dupe_check(instance, @hostclasses) { |dupe| _("'%{name}' is already defined%{error} as a class; cannot redefine as a definition") % { name: instance.name, error: dupe.error_context } }
     dupe_check(instance, @definitions) { |dupe| _("Definition '%{name}' is already defined%{error}; cannot be redefined") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @applications) { |dupe| _("'%{name}' is already defined%{error} as an application; cannot be redefined") % { name: instance.name, error: dupe.error_context } }
-    @definitions[instance.name] = instance
-  end
 
-  def add_capability_mapping(instance)
-    dupe_check(instance, @capability_mappings) { |dupe| _("'%{name}' is already defined%{error} as a class; cannot redefine as a mapping") % { name: instance.name, error: dupe.error_context } }
-    @capability_mappings[instance.name] = instance
+    @definitions[instance.name] = instance
   end
 
   def definition(name)
     @definitions[munge_name(name)]
   end
 
-  def add_application(instance)
-    dupe_check(instance, @hostclasses) { |dupe| _("'%{name}' is already defined%{error} as a class; cannot redefine as an application") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @definitions) { |dupe| _("'%{name}' is already defined%{error} as a definition; cannot redefine as an application") % { name: instance.name, error: dupe.error_context } }
-    dupe_check(instance, @applications) { |dupe| _("'%{name}' is already defined%{error} as an application; cannot be redefined") % { name: instance.name, error: dupe.error_context } }
-    @applications[instance.name] = instance
-  end
-
-  def application(name)
-    @applications[munge_name(name)]
-  end
-
   def find_node(name)
     @nodes[munge_name(name)]
   end
 
-  def find_site()
-    @sites[0]
-  end
-
   def find_hostclass(name)
     find_or_load(name, :hostclass)
   end
@@ -190,14 +149,9 @@ class Puppet::Resource::TypeCollection
     find_or_load(name, :definition)
   end
 
-  def find_application(name)
-    find_or_load(name, :application)
-  end
-
   # TODO: This implementation is wasteful as it creates a copy on each request
   #
-  [:hostclasses, :nodes, :definitions, :capability_mappings,
-   :applications].each do |m|
+  [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end

data/lib/puppet/resource.rb

@@ -32,7 +32,6 @@ class Puppet::Resource
   ATTRIBUTES = [:file, :line, :exported].freeze
   TYPE_CLASS = 'Class'.freeze
   TYPE_NODE  = 'Node'.freeze
-  TYPE_SITE  = 'Site'.freeze
 
   PCORE_TYPE_KEY = '__ptype'.freeze
   VALUE_KEY = 'value'.freeze
@@ -340,29 +339,6 @@ class Puppet::Resource
     catalog ? catalog.resource(to_s) : nil
   end
 
-  # A resource is an application component if it exports or consumes
-  # one or more capabilities, or if it requires a capability resource
-  def is_application_component?
-    return true if ! export.empty? || self[:consume]
-    # Array(self[:require]) does not work for Puppet::Resource instances
-    req = self[:require] || []
-    req = [ req ] unless req.is_a?(Array)
-    req.any? { |r| r.is_capability? }
-  end
-
-  # A resource is a capability (instance) if its underlying type is a
-  # capability type
-  def is_capability?
-    !resource_type.nil? && resource_type.is_capability?
-  end
-
-  # Returns the value of the 'export' metaparam as an Array
-  # @api private
-  def export
-    v = self[:export] || []
-    v.is_a?(Array) ? v : [ v ]
-  end
-
   # The resource's type implementation
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
@@ -377,12 +353,11 @@ class Puppet::Resource
     case type
     when TYPE_CLASS; environment.known_resource_types.hostclass(title == :main ? "" : title)
     when TYPE_NODE; environment.known_resource_types.node(title)
-    when TYPE_SITE; environment.known_resource_types.site(nil)
     else
       result = Puppet::Type.type(type)
       if !result
         krt = environment.known_resource_types
-        result = krt.definition(type) || krt.application(type)
+        result = krt.definition(type)
       end
       result
     end
@@ -515,38 +490,6 @@ class Puppet::Resource
   end
   private :missing_arguments
 
-  # @deprecated Not used by Puppet
-  # @api private
-  def set_default_parameters(scope)
-    Puppet.deprecation_warning(_('The method Puppet::Resource.set_default_parameters is deprecated and will be removed in the next major release of Puppet.'))
-
-    return [] unless resource_type and resource_type.respond_to?(:arguments)
-
-    unless is_a?(Puppet::Parser::Resource)
-      fail Puppet::DevError, _("Cannot evaluate default parameters for %{resource} - not a parser resource") % { resource: self }
-    end
-
-    missing_arguments.collect do |param, default|
-      rtype = resource_type
-      if rtype.type == :hostclass
-        using_bound_value = false
-        catch(:no_such_key) do
-          bound_value = Puppet::Pops::Lookup.search_and_merge("#{rtype.name}::#{param}", Puppet::Pops::Lookup::Invocation.new(scope), nil)
-          # Assign bound value but don't let an undef trump a default expression
-          unless bound_value.nil? && !default.nil?
-            self[param.to_sym] = bound_value
-            using_bound_value = true
-          end
-        end
-      end
-      unless using_bound_value
-        next if default.nil?
-        self[param.to_sym] = default.safeevaluate(scope)
-      end
-      param
-    end.compact
-  end
-
   def copy_as_resource
     Puppet::Resource.new(self)
   end
@@ -555,37 +498,6 @@ class Puppet::Resource
     resource_type.valid_parameter?(name)
   end
 
-  # Verify that all required arguments are either present or
-  # have been provided with defaults.
-  # Must be called after 'set_default_parameters'.  We can't join the methods
-  # because Type#set_parameters needs specifically ordered behavior.
-  #
-  # @deprecated Not used by Puppet
-  # @api private
-  def validate_complete
-    Puppet.deprecation_warning(_('The method Puppet::Resource.validate_complete is deprecated and will be removed in the next major release of Puppet.'))
-
-    return unless resource_type and resource_type.respond_to?(:arguments)
-
-    resource_type.arguments.each do |param, default|
-      param = param.to_sym
-      fail Puppet::ParseError, _("Must pass %{param} to %{resource}") % { param: param, resource: self } unless parameters.include?(param)
-    end
-
-    # Perform optional type checking
-    arg_types = resource_type.argument_types
-    # Parameters is a map from name, to parameter, and the parameter again has name and value
-    parameters.each do |name, value|
-      t = arg_types[name.to_s] # untyped, and parameters are symbols here (aargh, strings in the type)
-      next unless t
-      unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
-        inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
-        actual = inferred_type.generalize()
-        fail Puppet::ParseError, _("Expected parameter '%{name}' of '%{value0}' to have type %{value1}, got %{value2}") % { name: name, value0: self, value1: t.to_s, value2: actual.to_s }
-      end
-    end
-  end
-
   def validate_parameter(name)
     raise Puppet::ParseError.new(_("no parameter named '%{name}'") % { name: name }, file, line) unless valid_parameter?(name)
   end

data/lib/puppet/runtime.rb

@@ -1,5 +1,4 @@
 require 'puppet/http'
-require 'puppet/facter_impl'
 require 'singleton'
 
 # Provides access to runtime implementations.
@@ -12,26 +11,16 @@ class Puppet::Runtime
     @runtime_services = {
       http: proc do
         klass = Puppet::Network::HttpPool.http_client_class
-        if klass == Puppet::Network::HTTP::Connection ||
-           klass == Puppet::Network::HTTP::ConnectionAdapter
+        if klass == Puppet::Network::HTTP::Connection
           Puppet::HTTP::Client.new
         else
           Puppet::HTTP::ExternalClient.new(klass)
         end
-      end,
-      facter: proc { Puppet::FacterImpl.new }
+      end
     }
   end
   private :initialize
 
-  # Loads all runtime implementations.
-  #
-  # @return Array[Symbol] the names of loaded implementations
-  # @api private
-  def load_services
-    @runtime_services.keys.each { |key| self[key] }
-  end
-
   # Get a runtime implementation.
   #
   # @param name [Symbol] the name of the implementation

data/lib/puppet/settings/environment_conf.rb

@@ -29,7 +29,6 @@ class Puppet::Settings::EnvironmentConf
       section = config.sections[:main]
     rescue Errno::ENOENT
       # environment.conf is an optional file
-      Puppet.debug { "Path to #{path_to_env} does not exist, using default environment.conf" }
     end
 
     new(path_to_env, section, global_module_path)

data/lib/puppet/settings/integer_setting.rb

@@ -0,0 +1,17 @@
+class Puppet::Settings::IntegerSetting < Puppet::Settings::BaseSetting
+  def munge(value)
+    return value if Integer === value
+
+    begin
+      value = Integer(value)
+    rescue ArgumentError, TypeError
+      raise Puppet::Settings::ValidationError, _("Cannot convert '%{value}' to an integer for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+
+    value
+  end
+
+  def type
+    :integer
+  end
+end

data/lib/puppet/settings/port_setting.rb

@@ -0,0 +1,15 @@
+class Puppet::Settings::PortSetting < Puppet::Settings::IntegerSetting
+  def munge(value)
+    value = super
+
+    if value < 0 || value > 65535
+      raise Puppet::Settings::ValidationError, _("Value '%{value}' is not a valid port number for parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+
+    value
+  end
+
+  def type
+    :port
+  end
+end

data/lib/puppet/settings/priority_setting.rb

@@ -6,11 +6,12 @@ class Puppet::Settings::PrioritySetting < Puppet::Settings::BaseSetting
   PRIORITY_MAP =
     if Puppet::Util::Platform.windows?
       require 'puppet/util/windows/process'
+      require 'puppet/ffi/windows/constants'
       {
-        :high    => Puppet::Util::Windows::Process::HIGH_PRIORITY_CLASS,
-        :normal  => Puppet::Util::Windows::Process::NORMAL_PRIORITY_CLASS,
-        :low     => Puppet::Util::Windows::Process::BELOW_NORMAL_PRIORITY_CLASS,
-        :idle    => Puppet::Util::Windows::Process::IDLE_PRIORITY_CLASS
+        :high    => Puppet::FFI::Windows::Constants::HIGH_PRIORITY_CLASS,
+        :normal  => Puppet::FFI::Windows::Constants::NORMAL_PRIORITY_CLASS,
+        :low     => Puppet::FFI::Windows::Constants::BELOW_NORMAL_PRIORITY_CLASS,
+        :idle    => Puppet::FFI::Windows::Constants::IDLE_PRIORITY_CLASS
       }
     else
       {

data/lib/puppet/settings.rb

@@ -21,6 +21,8 @@ class Puppet::Settings
   require 'puppet/settings/file_or_directory_setting'
   require 'puppet/settings/path_setting'
   require 'puppet/settings/boolean_setting'
+  require 'puppet/settings/integer_setting'
+  require 'puppet/settings/port_setting'
   require 'puppet/settings/terminus_setting'
   require 'puppet/settings/duration_setting'
   require 'puppet/settings/ttl_setting'
@@ -32,7 +34,6 @@ class Puppet::Settings
   require 'puppet/settings/server_list_setting'
   require 'puppet/settings/http_extra_headers_setting'
   require 'puppet/settings/certificate_revocation_setting'
-  require 'puppet/settings/alias_setting'
 
   # local reference for convenience
   PuppetOptionParser = Puppet::Util::CommandLine::PuppetOptionParser
@@ -53,13 +54,14 @@ class Puppet::Settings
   # returns reasonable application default settings values for a given run_mode.
   def self.app_defaults_for_run_mode(run_mode)
     {
-        :name     => run_mode.to_s,
-        :run_mode => run_mode.name,
-        :confdir  => run_mode.conf_dir,
-        :codedir  => run_mode.code_dir,
-        :vardir   => run_mode.var_dir,
-        :rundir   => run_mode.run_dir,
-        :logdir   => run_mode.log_dir,
+        :name      => run_mode.to_s,
+        :run_mode  => run_mode.name,
+        :confdir   => run_mode.conf_dir,
+        :codedir   => run_mode.code_dir,
+        :vardir    => run_mode.var_dir,
+        :publicdir => run_mode.public_dir,
+        :rundir    => run_mode.run_dir,
+        :logdir    => run_mode.log_dir,
     }
   end
 
@@ -75,11 +77,11 @@ class Puppet::Settings
   end
 
   def self.hostname_fact()
-    Puppet.runtime[:facter].value :hostname
+    Facter.value :hostname
   end
 
   def self.domain_fact()
-    Puppet.runtime[:facter].value :domain
+    Facter.value :domain
   end
 
   def self.default_config_file_name
@@ -386,6 +388,19 @@ class Puppet::Settings
     call_hooks_deferred_to_application_initialization
     issue_deprecations
 
+    run_mode = Puppet::Util::RunMode[self.preferred_run_mode]
+    if run_mode.agent? || run_mode.server?
+      if self.set_in_section?(:masterport, run_mode.name) && !self.set_in_section?(:serverport, run_mode.name)
+        self[:serverport] = self[:masterport]
+      elsif self.set_by_config?(:masterport) && !self.set_by_config?(:serverport)
+        self[:serverport] = self[:masterport]
+      elsif self.set_in_section?(:serverport, run_mode.name) && !self.set_in_section?(:masterport, run_mode.name)
+        self[:masterport] = self[:serverport]
+      elsif self.set_by_config?(:serverport) && !self.set_by_config?(:masterport)
+        self[:masterport] = self[:serverport]
+      end
+    end
+
     REQUIRED_APP_SETTINGS.each do |key|
       create_ancestors(Puppet[key])
     end
@@ -720,6 +735,8 @@ class Puppet::Settings
       :file_or_directory => FileOrDirectorySetting,
       :path       => PathSetting,
       :boolean    => BooleanSetting,
+      :integer    => IntegerSetting,
+      :port       => PortSetting,
       :terminus   => TerminusSetting,
       :duration   => DurationSetting,
       :ttl        => TTLSetting,
@@ -730,8 +747,7 @@ class Puppet::Settings
       :autosign   => AutosignSetting,
       :server_list => ServerListSetting,
       :http_extra_headers => HttpExtraHeadersSetting,
-      :certificate_revocation => CertificateRevocationSetting,
-      :alias => AliasSetting
+      :certificate_revocation => CertificateRevocationSetting
   }
 
   # Create a new setting.  The value is passed in because it's used to determine
@@ -862,11 +878,7 @@ class Puppet::Settings
     if self[:user]
       user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
 
-      if user.suitable?
-        @service_user_available = user.exists?
-      else
-        raise Puppet::Error, (_("Cannot manage owner permissions, because the provider for '%{name}' is not functional") % { name: user })
-      end
+      @service_user_available = user.exists?
     else
       @service_user_available = false
     end
@@ -878,11 +890,7 @@ class Puppet::Settings
     if self[:group]
       group = Puppet::Type.type(:group).new :name => self[:group], :audit => :ensure
 
-      if group.suitable?
-        @service_group_available = group.exists?
-      else
-        raise Puppet::Error, (_("Cannot manage group permissions, because the provider for '%{name}' is not functional") % { name: group })
-      end
+      @service_group_available = group.exists?
     else
       @service_group_available = false
     end
@@ -891,16 +899,9 @@ class Puppet::Settings
   # Allow later inspection to determine if the setting was set on the
   # command line, or through some other code path.  Used for the
   # `dns_alt_names` option during cert generate. --daniel 2011-10-18
-  #
-  # @param param [String, Symbol] the setting to look up
-  # @return [Object, nil] the value of the setting or nil if unset
-  def set_by_cli(param)
-    param = param.to_sym
-    @value_sets[:cli].lookup(param)
-  end
-
   def set_by_cli?(param)
-    !!set_by_cli(param)
+    param = param.to_sym
+    !@value_sets[:cli].lookup(param).nil?
   end
 
   # Get values from a search path entry.
@@ -933,13 +934,9 @@ class Puppet::Settings
     end
   end
 
-  # Allow later inspection to determine if the setting was set in a specific
-  # section
-  #
-  # @param param [String, Symbol] the setting to look up
-  # @param section [Symbol] the section in which to look up the setting
-  # @return [Object, nil] the value of the setting or nil if unset
-  def set_in_section(param, section)
+  # Allow later inspection to determine if the setting was set by user
+  # config, rather than a default setting.
+  def set_in_section?(param, section)
     param = param.to_sym
     vals = searchpath_values(SearchPathElement.new(section, :section))
     if vals
@@ -947,10 +944,6 @@ class Puppet::Settings
     end
   end
 
-  def set_in_section?(param, section)
-    !!set_in_section(param, section)
-  end
-
   # Patches the value for a param in a section.
   # This method is required to support the use case of unifying --dns-alt-names and
   # --dns_alt_names in the certificate face. Ideally this should be cleaned up.
@@ -1097,41 +1090,48 @@ Generated on #{Time.now}.
   # Create the necessary objects to use a section.  This is idempotent;
   # you can 'use' a section as many times as you want.
   def use(*sections)
-    Puppet.warning(":master section deprecated in favor of :server section") if sections.include?(:master)
+    if Puppet[:settings_catalog]
+      sections = sections.collect { |s| s.to_sym }
+      sections = sections.reject { |s| @used.include?(s) }
 
-    # add :server if sections include :master or :master if sections include :server
-    sections |= [:master, :server] if (sections & [:master, :server]).any?
+      Puppet.warning(":master section deprecated in favor of :server section") if sections.include?(:master)
 
-    sections = sections.collect { |s| s.to_sym }
-    sections = sections.reject { |s| @used.include?(s) }
+      # add :server if sections include :master or :master if sections include :server
+      sections |= [:master, :server] if (sections & [:master, :server]).any?
 
-    return if sections.empty?
+      sections = sections.collect { |s| s.to_sym }
+      sections = sections.reject { |s| @used.include?(s) }
 
-    Puppet.debug { "Applying settings catalog for sections #{sections.join(', ')}" }
+      return if sections.empty?
 
-    begin
-      catalog = to_catalog(*sections).to_ral
-    rescue => detail
-      Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
-    end
+      Puppet.debug { "Applying settings catalog for sections #{sections.join(', ')}" }
 
-    catalog.host_config = false
-    catalog.apply do |transaction|
-      if transaction.any_failed?
-        report = transaction.report
-        status_failures = report.resource_statuses.values.select { |r| r.failed? }
-        status_fail_msg = status_failures.
-          collect(&:events).
-          flatten.
-          select { |event| event.status == 'failure' }.
-          collect { |event| "#{event.resource}: #{event.message}" }.join("; ")
+      begin
+        catalog = to_catalog(*sections).to_ral
+      rescue => detail
+        Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
+      end
 
-        raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}"
+      catalog.host_config = false
+      catalog.apply do |transaction|
+        if transaction.any_failed?
+          report = transaction.report
+          status_failures = report.resource_statuses.values.select { |r| r.failed? }
+          status_fail_msg = status_failures.
+            collect(&:events).
+            flatten.
+            select { |event| event.status == 'failure' }.
+            collect { |event| "#{event.resource}: #{event.message}" }.join("; ")
+
+          raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}"
+        end
       end
-    end
 
-    sections.each { |s| @used << s }
-    @used.uniq!
+      sections.each { |s| @used << s }
+      @used.uniq!
+    else
+      Puppet.debug("Skipping settings catalog for sections #{sections.join(', ')}")
+    end
   end
 
   def valid?(param)
@@ -1285,37 +1285,27 @@ Generated on #{Time.now}.
   end
 
   def add_environment_resources(catalog, sections)
+    path = self[:environmentpath]
+    envdir = path.split(File::PATH_SEPARATOR).first if path
     configured_environment = self[:environment]
-
-    if configured_environment == "production" && !production_environment_exists?
-      environment_path = self[:environmentpath]
-      first_environment_path = environment_path.split(File::PATH_SEPARATOR).first
-
-      if Puppet::FileSystem.exist?(first_environment_path)
-        production_environment_path = File.join(first_environment_path, configured_environment)
+    if configured_environment == "production" && envdir && Puppet::FileSystem.exist?(envdir)
+      configured_environment_path = File.join(envdir, configured_environment)
+      # If configured_environment_path is a symlink, assume the source path is being managed
+      # elsewhere, so don't do any of this configuration
+      if !Puppet::FileSystem.symlink?(configured_environment_path)
         parameters = { :ensure => 'directory' }
-        parameters[:mode] = '0750'
-        if Puppet.features.root?
-          parameters[:owner] = Puppet[:user] if service_user_available?
-          parameters[:group] = Puppet[:group] if service_group_available?
+        unless Puppet::FileSystem.exist?(configured_environment_path)
+          parameters[:mode] = '0750'
+          if Puppet.features.root?
+            parameters[:owner] = Puppet[:user] if service_user_available?
+            parameters[:group] = Puppet[:group] if service_group_available?
+          end
         end
-        catalog.add_resource(Puppet::Resource.new(:file, production_environment_path, :parameters => parameters))
+        catalog.add_resource(Puppet::Resource.new(:file, configured_environment_path, :parameters => parameters))
       end
     end
   end
 
-  def production_environment_exists?
-    environment_path = self[:environmentpath]
-    paths = environment_path.split(File::PATH_SEPARATOR)
-
-    paths.any? do |path|
-      # If expected_path is a symlink, assume the source path is being managed
-      # elsewhere, so accept it also as a valid production environment path
-      expected_path = File.join(path, 'production')
-      Puppet::FileSystem.directory?(expected_path) || Puppet::FileSystem.symlink?(expected_path)
-    end
-  end
-
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet::Util::Platform.windows?
@@ -1416,12 +1406,6 @@ Generated on #{Time.now}.
         end
       end
 
-      setting  = @defaults[name]
-      if setting.respond_to?(:alias_name)
-        val  = lookup(setting.alias_name)
-        return val if val
-      end
-
       @defaults[name].default
     end
 

data/lib/puppet/ssl/base.rb

@@ -1,7 +1,6 @@
 require 'puppet/ssl/openssl_loader'
 require 'puppet/ssl'
 require 'puppet/ssl/digest'
-require 'puppet/util/ssl'
 
 # The base class for wrapping SSL instances.
 class Puppet::SSL::Base
@@ -54,7 +53,9 @@ class Puppet::SSL::Base
   #
   # @return [String] the name (CN) extracted from the subject.
   def self.name_from_subject(subject)
-    Puppet::Util::SSL.cn_from_subject(subject)
+    if subject.respond_to? :to_a
+      (subject.to_a.assoc('CN') || [])[1]
+    end
   end
 
   # Create an instance of our Puppet::SSL::* class using a given instance of the wrapped class
@@ -82,15 +83,12 @@ class Puppet::SSL::Base
   # Read content from disk appropriately.
   def read(path)
     # applies to Puppet::SSL::Certificate, Puppet::SSL::CertificateRequest
-    # Puppet::SSL::Key uses this, but also provides its own override
     # nothing derives from Puppet::SSL::Certificate, but it is called by a number of other SSL Indirectors:
     # Puppet::Indirector::CertificateStatus::File (.indirection.find)
     # Puppet::Network::HTTP::WEBrick (.indirection.find)
     # Puppet::Network::HTTP::RackREST (.from_instance)
     # Puppet::Network::HTTP::WEBrickREST (.from_instance)
-    # Puppet::SSL::Host (.indirection.find)
     # Puppet::SSL::Inventory (.indirection.search, implements its own add / rebuild / serials with encoding UTF8)
-    # Puppet::SSL::Validator::DefaultValidator (.from_instance) / Puppet::SSL::Validator::NoValidator does nothing
     @content = wrapped_class.new(Puppet::FileSystem.read(path, :encoding => Encoding::ASCII))
   end