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

data/lib/puppet/resource/type_collection.rb

@@ -13,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
@@ -45,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
 
@@ -71,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
@@ -109,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
@@ -149,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
@@ -189,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/runtime.rb

@@ -11,8 +11,7 @@ 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)

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'
@@ -44,7 +46,7 @@ class Puppet::Settings
   REQUIRED_APP_SETTINGS = [:logdir, :confdir, :vardir, :codedir]
 
   # The acceptable sections of the puppet.conf configuration file.
-  ALLOWED_SECTION_NAMES = ['main', 'master', 'agent', 'user'].freeze
+  ALLOWED_SECTION_NAMES = ['main', 'server', 'master', 'agent', 'user'].freeze
 
   NONE = 'none'.freeze
 
@@ -52,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
 
@@ -330,7 +333,7 @@ class Puppet::Settings
     end
 
     option_parser.on('--run_mode',
-                     "The effective 'run mode' of the application: master, agent, or user.",
+                     "The effective 'run mode' of the application: server, agent, or user.",
                      :REQUIRED) do |arg|
       Puppet.settings.preferred_run_mode = arg
     end
@@ -385,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
@@ -564,7 +580,7 @@ class Puppet::Settings
   # @api private
   def preferred_run_mode=(mode)
     mode = mode.to_s.downcase.intern
-    raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
+    raise ValidationError, "Invalid run mode '#{mode}'" unless [:server, :master, :agent, :user].include?(mode)
     @preferred_run_mode_name = mode
     # Changing the run mode has far-reaching consequences. Flush any cached
     # settings so they will be re-generated.
@@ -659,7 +675,7 @@ class Puppet::Settings
     if explicit_config_file?
       return self[:config]
     else
-      return File.join(Puppet::Util::RunMode[:master].conf_dir, config_file_name)
+      return File.join(Puppet::Util::RunMode[:server].conf_dir, config_file_name)
     end
   end
   private :main_config_file
@@ -719,6 +735,8 @@ class Puppet::Settings
       :file_or_directory => FileOrDirectorySetting,
       :path       => PathSetting,
       :boolean    => BooleanSetting,
+      :integer    => IntegerSetting,
+      :port       => PortSetting,
       :terminus   => TerminusSetting,
       :duration   => DurationSetting,
       :ttl        => TTLSetting,
@@ -829,7 +847,16 @@ class Puppet::Settings
       SearchPathElement.new(:cli, :values),
     ]
     searchpath << SearchPathElement.new(environment.intern, :environment) if environment
-    searchpath << SearchPathElement.new(run_mode, :section) if run_mode
+
+    if run_mode
+      if [:master, :server].include?(run_mode)
+        searchpath << SearchPathElement.new(:server, :section)
+        searchpath << SearchPathElement.new(:master, :section)
+      else
+        searchpath << SearchPathElement.new(run_mode, :section)
+      end
+    end
+
     searchpath << SearchPathElement.new(:main, :section)
   end
 
@@ -907,6 +934,16 @@ class Puppet::Settings
     end
   end
 
+  # 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
+      vals.lookup(param)
+    end
+  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.
@@ -1053,36 +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)
-    sections = sections.collect { |s| s.to_sym }
-    sections = sections.reject { |s| @used.include?(s) }
+    if Puppet[:settings_catalog]
+      sections = sections.collect { |s| s.to_sym }
+      sections = sections.reject { |s| @used.include?(s) }
 
-    return if sections.empty?
+      Puppet.warning(":master section deprecated in favor of :server section") if sections.include?(:master)
 
-    Puppet.debug("Applying settings catalog for sections #{sections.join(', ')}")
+      # add :server if sections include :master or :master if sections include :server
+      sections |= [:master, :server] if (sections & [:master, :server]).any?
 
-    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
+      sections = sections.collect { |s| s.to_sym }
+      sections = sections.reject { |s| @used.include?(s) }
 
-    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("; ")
+      return if sections.empty?
 
-        raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}"
+      Puppet.debug { "Applying settings catalog for sections #{sections.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
+
+      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)

data/lib/puppet/settings/base_setting.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'puppet/settings/errors'
 
 # The base setting type
@@ -5,27 +6,50 @@ class Puppet::Settings::BaseSetting
   attr_accessor :name, :desc, :section, :default, :call_hook
   attr_reader :short, :deprecated
 
+  # Hooks are called during different parts of the settings lifecycle:
+  #
+  # * :on_write_only - This is the default hook type. The hook will be called
+  #   if its value is set in `main` or programmatically. If its value is set in
+  #   a section that doesn't match the application's run mode, it will be
+  #   ignored entirely. If the section does match the run mode, the value will
+  #   be used, but the hook will not be called!
+  #
+  # * :on_define_and_write - The hook behaves the same as above, except it is
+  #   also called immediately when the setting is defined in
+  #   {Puppet::Settings.define_settings}. In that case, the hook receives the
+  #   default value as specified.
+  #
+  # * :on_initialize_and_write - The hook will be called if the value is set in
+  #   `main`, the section that matches the run mode, or programmatically.
+  #
+  HOOK_TYPES = Set.new([:on_define_and_write, :on_initialize_and_write, :on_write_only]).freeze
+
   def self.available_call_hook_values
-    [:on_define_and_write, :on_initialize_and_write, :on_write_only]
+    HOOK_TYPES.to_a
   end
 
+  # Registers a hook to be called later based on the type of hook specified in `value`.
+  #
+  # @param value [Symbol] One of {HOOK_TYPES}
   def call_hook=(value)
     if value.nil?
       #TRANSLATORS ':%{name}', ':call_hook', and ':on_write_only' should not be translated
       Puppet.warning _("Setting :%{name} :call_hook is nil, defaulting to :on_write_only") % { name: name }
       value = :on_write_only
     end
-    unless self.class.available_call_hook_values.include?(value)
+    unless HOOK_TYPES.include?(value)
       #TRANSLATORS 'call_hook' is a Puppet option name and should not be translated
       raise ArgumentError, _("Invalid option %{value} for call_hook") % { value: value }
     end
     @call_hook = value
   end
 
+  # @see {HOOK_TYPES}
   def call_hook_on_define?
     call_hook == :on_define_and_write
   end
 
+  # @see {HOOK_TYPES}
   def call_hook_on_initialize?
     call_hook == :on_initialize_and_write
   end

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/ssl.rb

@@ -2,18 +2,22 @@
 require 'puppet'
 require 'puppet/ssl/openssl_loader'
 
+# Responsible for bootstrapping an agent's certificate and private key, generating
+# SSLContexts for use in making HTTPS connections, and handling CSR attributes and
+# certificate extensions.
+#
+# @see Puppet::SSL::SSLProvider
 # @api private
-module Puppet::SSL # :nodoc:
+module Puppet::SSL
   CA_NAME = "ca".freeze
-  require 'puppet/ssl/host'
+
   require 'puppet/ssl/oids'
-  require 'puppet/ssl/validator'
-  require 'puppet/ssl/validator/no_validator'
-  require 'puppet/ssl/validator/default_validator'
   require 'puppet/ssl/error'
   require 'puppet/ssl/ssl_context'
   require 'puppet/ssl/verifier'
-  require 'puppet/ssl/verifier_adapter'
   require 'puppet/ssl/ssl_provider'
   require 'puppet/ssl/state_machine'
+  require 'puppet/ssl/certificate'
+  require 'puppet/ssl/certificate_request'
+  require 'puppet/ssl/certificate_request_attributes'
 end