puppet 6.18.0-x86-mingw32 → 6.19.0-x86-mingw32

data/lib/puppet/http/session.rb

@@ -64,20 +64,21 @@ class Puppet::HTTP::Session
     cached = @resolved_services[name]
     return cached if cached
 
-    resolution_exceptions = []
-    error_handler = proc { |e| resolution_exceptions << e }
+    canceled = false
+    canceled_handler  = lambda { |cancel| canceled = cancel }
 
     @resolvers.each do |resolver|
       Puppet.debug("Resolving service '#{name}' using #{resolver.class}")
-      service = resolver.resolve(self, name, ssl_context: ssl_context, error_handler: error_handler)
+      service = resolver.resolve(self, name, ssl_context: ssl_context, canceled_handler: canceled_handler)
       if service
         @resolved_services[name] = service
         Puppet.debug("Resolved service '#{name}' to #{service.url}")
         return service
+      elsif canceled
+        break
       end
     end
 
-    resolution_exceptions.each { |e| Puppet.log_exception(e) }
     raise Puppet::HTTP::RouteError, "No more routes to #{name}"
   end
 

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

@@ -75,7 +75,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   # Is our compiler part of a network, or are we just local?
   def networked?
-    Puppet.run_mode.master?
+    Puppet.run_mode.server?
   end
 
   private

data/lib/puppet/indirector/facts/yaml.rb

@@ -20,7 +20,7 @@ class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
 
   # Return the path to a given node's file.
   def yaml_dir_path
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
     File.join(base, 'facts', '*.yaml')
   end
 

data/lib/puppet/indirector/json.rb

@@ -41,7 +41,7 @@ class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

data/lib/puppet/indirector/msgpack.rb

@@ -48,7 +48,7 @@ class Puppet::Indirector::Msgpack < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

data/lib/puppet/indirector/request.rb

@@ -231,9 +231,9 @@ class Puppet::Indirector::Request
           debug_once _("Selected port from the first entry of the `server_list` setting: %{port}") % {port: primary_server[1]}
           primary_server[1]
         else
-          #TRANSLATORS 'masterport' is the name of a setting and should not be translated
-          debug_once _("Selected port from the `masterport` setting: %{port}") % {port: Puppet.settings[:masterport]}
-          Puppet.settings[:masterport]
+          #TRANSLATORS 'serverport' is the name of a setting and should not be translated
+          debug_once _("Selected port from the `serverport` setting: %{port}") % {port: Puppet.settings[:serverport]}
+          Puppet.settings[:serverport]
         end
       end
     end
@@ -277,7 +277,7 @@ class Puppet::Indirector::Request
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
-      @port = Puppet.settings[:masterport].to_i
+      @port = Puppet.settings[:serverport].to_i
     else
       @port = uri.port.to_i
     end

data/lib/puppet/indirector/yaml.rb

@@ -40,7 +40,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

data/lib/puppet/network/http/api/master/v3/environments.rb

@@ -31,5 +31,4 @@ class Puppet::Network::HTTP::API::Master::V3::Environments
       ttl
     end
   end
-
 end

data/lib/puppet/node/facts.rb

@@ -116,8 +116,25 @@ class Puppet::Node::Facts
     @timestamp = Time.now
   end
 
+  def to_yaml
+    facts_to_display = Psych.parse_stream(YAML.dump(self))
+    quote_special_strings(facts_to_display)
+  end
+
   private
 
+  def quote_special_strings(fact_hash)
+    fact_hash.grep(Psych::Nodes::Scalar).each do |node|
+      next unless node.value =~ /:/
+
+      node.plain  = false
+      node.quoted = true
+      node.style  = Psych::Nodes::Scalar::DOUBLE_QUOTED
+    end
+
+    fact_hash.yaml
+  end
+
   def sanitize_fact(fact)
     if fact.is_a? Hash then
       ret = {}

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -45,9 +45,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     return false if objects.empty?
 
     if @overrides and !objects.empty?
-      overrides[:source].meta_def(:child_of?) do |klass|
-        true
-      end
+      overrides[:source].override = true
 
       objects.each do |res|
         unless @collected.include?(res.ref)

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

@@ -79,9 +79,9 @@ class Runtime3Converter
 
   def convert_String(o, scope, undef_value)
     # Although wasteful, a dup is needed because user code may mutate these strings when applying
-    # Resources. This does not happen when in master mode since it only uses Resources that are
+    # Resources. This does not happen when in server mode since it only uses Resources that are
     # in puppet core and those are all safe.
-    o.frozen? && !Puppet.run_mode.master? ? o.dup : o
+    o.frozen? && !Puppet.run_mode.server? ? o.dup : o
   end
 
   def convert_Object(o, scope, undef_value)

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

@@ -22,7 +22,7 @@ class PMetaType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
+    raise NotImplementedError, "Subclass of PMetaType should implement 'instance?'"
   end
 
   # Called from the TypeParser once it has found a type using the Loader. The TypeParser will

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

@@ -349,6 +349,10 @@ class PTypeSetType < PMetaType
     self.class == o.class && @name_authority == o.name_authority && @name == o.name && @version == o.version
   end
 
+  def instance?(o, guard = nil)
+    o.is_a?(PTypeSetType)
+  end
+
   DEFAULT = self.new({
     KEY_NAME => 'DefaultTypeSet',
     KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,

data/lib/puppet/provider/package/dpkg.rb

@@ -74,7 +74,7 @@ Puppet::Type.type(:package).provide :dpkg, :parent => Puppet::Provider::Package
       elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
         hash[:ensure] = :absent
       end
-      hash[:mark] = :hold if hash[:desired] == 'hold'
+      hash[:mark] = hash[:desired] == 'hold' ? :hold : :none
     else
       Puppet.debug("Failed to match dpkg-query line #{line.inspect}")
     end

data/lib/puppet/provider/package/pip2.rb

@@ -0,0 +1,17 @@
+# Puppet package provider for Python's `pip2` package management frontend.
+# <http://pip.pypa.io/>
+
+Puppet::Type.type(:package).provide :pip2,
+  :parent => :pip do
+
+  desc "Python packages via `pip2`.
+
+  This provider supports the `install_options` attribute, which allows command-line flags to be passed to pip2.
+  These options should be specified as an array where each element is either a string or a hash."
+
+  has_feature :installable, :uninstallable, :upgradeable, :versionable, :install_options, :targetable
+
+  def self.cmd
+    ["pip2"]
+  end
+end

data/lib/puppet/provider/package/puppetserver_gem.rb

@@ -0,0 +1,180 @@
+unless Puppet::Util::Platform.jruby_fips?
+  require 'rubygems/commands/list_command'
+end
+require 'stringio'
+require 'uri'
+
+# Ruby gems support.
+Puppet::Type.type(:package).provide :puppetserver_gem, :parent => :gem do
+  desc "Puppet Server Ruby Gem support. If a URL is passed via `source`, then
+    that URL is appended to the list of remote gem repositories which by default
+    contains rubygems.org; To ensure that only the specified source is used also
+    pass `--clear-sources` in via `install_options`; if a source is present but
+    is not a valid URL, it will be interpreted as the path to a local gem file.
+    If source is not present at all, the gem will be installed from the default
+    gem repositories."
+
+  has_feature :versionable, :install_options, :uninstall_options
+
+  confine :feature => :hocon
+  # see SERVER-2578
+  confine :fips_enabled => false
+
+  # Define the default provider package command name, as the parent 'gem' provider is targetable.
+  # Required by Puppet::Provider::Package::Targetable::resource_or_provider_command
+
+  def self.provider_command
+    command(:puppetservercmd)
+  end
+
+  # The gem command uses HOME to locate a gemrc file.
+  # CommandDefiner in provider.rb will set failonfail, combine, and environment.
+
+  has_command(:puppetservercmd, '/opt/puppetlabs/bin/puppetserver') do
+    environment(HOME: ENV['HOME'])
+  end
+
+  def self.gemlist(options)
+    command_options = ['gem', 'list']
+
+    if options[:local]
+      command_options << '--local'
+    else
+      command_options << '--remote'
+    end
+
+    if options[:source]
+      command_options << '--source' << options[:source]
+    end
+
+    if options[:justme]
+      gem_regex = '\A' + options[:justme] + '\z'
+      command_options << gem_regex
+    end
+
+    if options[:local]
+      list = execute_rubygems_list_command(gem_regex)
+    else
+      begin
+        list = puppetservercmd(command_options)
+      rescue Puppet::ExecutionFailure => detail
+        raise Puppet::Error, _("Could not list gems: %{detail}") % { detail: detail }, detail.backtrace
+      end
+    end
+
+    # When `/tmp` is mounted `noexec`, `puppetserver gem list` will output:
+    # *** LOCAL GEMS ***
+    # causing gemsplit to output:
+    # Warning: Could not match *** LOCAL GEMS ***
+    gem_list = list
+                 .lines
+                 .select { |x| x =~ /^(\S+)\s+\((.+)\)/ }
+                 .map { |set| gemsplit(set) }
+
+    if options[:justme]
+      return gem_list.shift
+    else
+      return gem_list
+    end
+  end
+
+  def install(useversion = true)
+    command_options = ['gem', 'install']
+    command_options += install_options if resource[:install_options]
+
+    command_options << '-v' << resource[:ensure] if (!resource[:ensure].is_a? Symbol) && useversion
+
+    command_options << '--no-document'
+
+    if resource[:source]
+      begin
+        uri = URI.parse(resource[:source])
+      rescue => detail
+        self.fail Puppet::Error, _("Invalid source '%{uri}': %{detail}") % { uri: uri, detail: detail }, detail
+      end
+
+      case uri.scheme
+      when nil
+        # no URI scheme => interpret the source as a local file
+        command_options << resource[:source]
+      when /file/i
+        command_options << uri.path
+      when 'puppet'
+        # we don't support puppet:// URLs (yet)
+        raise Puppet::Error.new(_('puppet:// URLs are not supported as gem sources'))
+      else
+        # interpret it as a gem repository
+        command_options << '--source' << "#{resource[:source]}" << resource[:name]
+      end
+    else
+      command_options << resource[:name]
+    end
+
+    output = puppetservercmd(command_options)
+    # Apparently, some gem versions don't exit non-0 on failure.
+    self.fail _("Could not install: %{output}") % { output: output.chomp } if output.include?('ERROR')
+  end
+
+  def uninstall
+    command_options = ['gem', 'uninstall']
+    command_options << '--executables' << '--all' << resource[:name]
+    command_options += uninstall_options if resource[:uninstall_options]
+
+    output = puppetservercmd(command_options)
+    # Apparently, some gem versions don't exit non-0 on failure.
+    self.fail _("Could not uninstall: %{output}") % { output: output.chomp } if output.include?('ERROR')
+  end
+
+  private
+
+  # The puppetserver gem cli command is very slow, since it starts a JVM.
+  #
+  # Instead, for the list subcommand (which is executed with every puppet run),
+  # use the rubygems library from puppet ruby: setting GEM_HOME and GEM_PATH
+  # to the default values, or the values in the puppetserver configuration file.
+  #
+  # The rubygems library cannot access java platform gems,
+  # for example: json (1.8.3 java)
+  # but java platform gems should not be managed by this (or any) provider.
+
+  def self.execute_rubygems_list_command(gem_regex)
+    puppetserver_default_gem_home            = '/opt/puppetlabs/server/data/puppetserver/jruby-gems'
+    puppetserver_default_vendored_jruby_gems = '/opt/puppetlabs/server/data/puppetserver/vendored-jruby-gems'
+    puppet_default_vendor_gems               = '/opt/puppetlabs/puppet/lib/ruby/vendor_gems'
+    puppetserver_default_gem_path = [puppetserver_default_gem_home, puppetserver_default_vendored_jruby_gems, puppet_default_vendor_gems].join(':')
+
+    pe_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/conf.d/pe-puppet-server.conf'
+    os_puppetserver_conf_file = '/etc/puppetlabs/puppetserver/puppetserver.conf'
+    puppetserver_conf_file = Facter.value(:pe_server_version) ? pe_puppetserver_conf_file : os_puppetserver_conf_file
+    puppetserver_conf = Hocon.load(puppetserver_conf_file)
+
+    gem_env = {}
+    if puppetserver_conf.empty? || puppetserver_conf.key?('jruby-puppet') == false
+      gem_env['GEM_HOME'] = puppetserver_default_gem_home
+      gem_env['GEM_PATH'] = puppetserver_default_gem_path
+    else
+      gem_env['GEM_HOME'] = puppetserver_conf['jruby-puppet'].key?('gem-home') ? puppetserver_conf['jruby-puppet']['gem-home'] : puppetserver_default_gem_home
+      gem_env['GEM_PATH'] = puppetserver_conf['jruby-puppet'].key?('gem-path') ? puppetserver_conf['jruby-puppet']['gem-path'].join(':') : puppetserver_default_gem_path
+    end
+    gem_env['GEM_SPEC_CACHE'] = "/tmp/#{$$}"
+    Gem.paths = gem_env
+
+    sio_inn = StringIO.new
+    sio_out = StringIO.new
+    sio_err = StringIO.new
+    stream_ui = Gem::StreamUI.new(sio_inn, sio_out, sio_err, false)
+    gem_list_cmd = Gem::Commands::ListCommand.new
+    gem_list_cmd.options[:domain] = :local
+    gem_list_cmd.options[:args] = [gem_regex] if gem_regex
+    gem_list_cmd.ui = stream_ui
+    gem_list_cmd.execute
+
+    # There is no method exclude default gems from the local gem list,
+    # for example: psych (default: 2.2.2)
+    # but default gems should not be managed by this (or any) provider.
+    gem_list = sio_out.string.lines.reject { |gem| gem =~ / \(default\: / }
+    gem_list.join("\n")
+  ensure
+    Gem.clear_paths
+  end
+end

data/lib/puppet/provider/package/yum.rb

@@ -328,6 +328,7 @@ defaultfor :osfamily => :redhat, :operatingsystemmajrelease => (4..7).to_a
       return "#{upd[:epoch]}:#{upd[:version]}-#{upd[:release]}"
     else
       # Yum didn't find updates, pretend the current version is the latest
+      self.debug "Yum didn't find updates, current version (#{properties[:ensure]}) is the latest"
       version = properties[:ensure]
       raise Puppet::DevError, _("Tried to get latest on a missing package") if version == :absent || version == :purged
       return version

data/lib/puppet/resource/type.rb

@@ -34,7 +34,7 @@ class Puppet::Resource::Type
   DOUBLE_COLON = '::'.freeze
   EMPTY_ARRAY = [].freeze
 
-  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
+  attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection, :override
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
   # The attributes 'produces' and 'consumes' are arrays of the blueprints
@@ -63,6 +63,7 @@ class Puppet::Resource::Type
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
+    return true if override
     return false unless parent
 
     return(klass == parent_type ? true : parent_type.child_of?(klass))

data/lib/puppet/rest/route.rb

@@ -14,11 +14,11 @@ module Puppet::Rest
     #                 construction
     # @param [Symbol] server_setting the setting to check for special
     #                 server configuration
-    # @param [Symbol] port_setting the setting to check for speical
+    # @param [Symbol] port_setting the setting to check for special
     #                  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)
+    def initialize(api:, server_setting: :server, port_setting: :serverport, 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)

data/lib/puppet/settings.rb

@@ -44,7 +44,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
 
@@ -330,7 +330,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
@@ -564,7 +564,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 +659,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
@@ -829,7 +829,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
 
@@ -1053,6 +1062,11 @@ 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)
+
+    # add :server if sections include :master or :master if sections include :server
+    sections |= [:master, :server] if (sections & [:master, :server]).any?
+
     sections = sections.collect { |s| s.to_sym }
     sections = sections.reject { |s| @used.include?(s) }