puppet 6.15.0-universal-darwin → 6.19.1-universal-darwin

data/lib/puppet/pops/loaders.rb

@@ -18,18 +18,18 @@ class Loaders
   attr_reader :private_environment_loader
   attr_reader :environment
 
-  def self.new(environment, for_agent = false)
+  def self.new(environment, for_agent = false, load_from_pcore = true)
     environment.lock.synchronize do
       obj = environment.loaders
       if obj.nil?
         obj = self.allocate
-        obj.send(:initialize, environment, for_agent)
+        obj.send(:initialize, environment, for_agent, load_from_pcore)
       end
       obj
     end
   end
 
-  def initialize(environment, for_agent)
+  def initialize(environment, for_agent, load_from_pcore = true)
     # Protect against environment havoc
     raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
     environment.loaders = self
@@ -51,12 +51,13 @@ class Loaders
     #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
     #    concept of environment the same way as when running as a master (except when doing apply).
     #    The creation mechanisms should probably differ between the two.
-    @private_environment_loader = if for_agent
-      @puppet_cache_loader = create_puppet_cache_loader()
-      create_environment_loader(environment, @puppet_cache_loader)
-    else
-      create_environment_loader(environment, @puppet_system_loader)
-    end
+    @private_environment_loader =
+      if for_agent
+        @puppet_cache_loader = create_puppet_cache_loader
+        create_environment_loader(environment, @puppet_cache_loader, load_from_pcore)
+      else
+        create_environment_loader(environment, @puppet_system_loader, load_from_pcore)
+      end
 
     Pcore.init_env(@private_environment_loader)
 
@@ -362,7 +363,7 @@ class Loaders
     Loader::ModuleLoaders.cached_loader_from(puppet_system_loader, self)
   end
 
-  def create_environment_loader(environment, parent_loader)
+  def create_environment_loader(environment, parent_loader, load_from_pcore = true)
     # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
     # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
     # a module and can hold functions, types etc. then these are available across all other modules without
@@ -387,7 +388,13 @@ class Loaders
     else
       # Create the 3.x resource type loader
       static_loader.runtime_3_init
-      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, env_conf.nil? ? nil : env_path))
+      # Create pcore resource type loader, if applicable
+      pcore_resource_type_loader = if load_from_pcore && env_path
+                                     Loader::ModuleLoaders.pcore_resource_type_loader_from(parent_loader, self, env_path)
+                                   else
+                                     nil
+                                   end
+      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, pcore_resource_type_loader))
 
       if env_path.nil?
         # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?

data/lib/puppet/pops/lookup/context.rb

@@ -47,7 +47,7 @@ class EnvironmentContext < Adaptable::Adapter
     file_data = @file_data_cache[path]
     stat = Puppet::FileSystem.stat(path)
     unless file_data && file_data.valid?(stat)
-      Puppet.debug("File at '#{path}' was changed, reloading") if file_data
+      Puppet.debug { "File at '#{path}' was changed, reloading" } if file_data
       content = Puppet::FileSystem.read(path, :encoding => 'utf-8')
       file_data = FileData.new(path, stat.ino, stat.mtime, stat.size, block_given? ? yield(content) : content)
       @file_data_cache[path] = file_data

data/lib/puppet/pops/lookup/hiera_config.rb

@@ -46,6 +46,7 @@ class HieraConfig
   KEY_DATADIR = 'datadir'.freeze
   KEY_DEFAULT_HIERARCHY = 'default_hierarchy'.freeze
   KEY_HIERARCHY = 'hierarchy'.freeze
+  KEY_PLAN_HIERARCHY = 'plan_hierarchy'.freeze
   KEY_LOGGER = 'logger'.freeze
   KEY_OPTIONS = 'options'.freeze
   KEY_PATH = 'path'.freeze
@@ -580,6 +581,7 @@ class HieraConfigV5 < HieraConfig
           tf.optional(KEY_OPTIONS) => tf.hash_kv(option_name_t, tf.data),
         }),
       tf.optional(KEY_HIERARCHY) => hierarchy_t,
+      tf.optional(KEY_PLAN_HIERARCHY) => hierarchy_t,
       tf.optional(KEY_DEFAULT_HIERARCHY) => hierarchy_t
     })
   end
@@ -600,7 +602,15 @@ class HieraConfigV5 < HieraConfig
       return data_providers
     end
 
-    @config[use_default_hierarchy ? KEY_DEFAULT_HIERARCHY : KEY_HIERARCHY].each do |he|
+    compiler = Puppet.lookup(:pal_compiler) { nil }
+    config_key = if compiler.is_a?(Puppet::Pal::ScriptCompiler) && !@config[KEY_PLAN_HIERARCHY].nil?
+          KEY_PLAN_HIERARCHY
+        elsif use_default_hierarchy
+          KEY_DEFAULT_HIERARCHY
+        else
+          KEY_HIERARCHY
+        end
+    @config[config_key].each do |he|
       name = he[KEY_NAME]
       if data_providers.include?(name)
         first_line = find_line_matching(/\s+name:\s+['"]?#{name}(?:[^\w]|$)/)
@@ -691,6 +701,9 @@ class HieraConfigV5 < HieraConfig
     defaults = config[KEY_DEFAULTS]
     validate_defaults(defaults) unless defaults.nil?
     config[KEY_HIERARCHY].each { |he| validate_hierarchy(he, defaults, owner) }
+    if config.include?(KEY_PLAN_HIERARCHY)
+      config[KEY_PLAN_HIERARCHY].each { |he| validate_hierarchy(he, defaults, owner) }
+    end
 
     if config.include?(KEY_DEFAULT_HIERARCHY)
       unless owner.is_a?(ModuleDataProvider)

data/lib/puppet/pops/resource/resource_type_impl.rb

@@ -248,6 +248,8 @@ class ResourceTypeImpl
   #######################
 
   # Applications are not supported
+  #
+  # @deprecated application orchestration will be removed in puppet 7
   def application?
     false
   end

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

@@ -23,13 +23,16 @@ module Puppet::Pops::Types
     #
     # An `ArgumentError` is raised for all other objects.
     #
-    # @param o [Object] The object to produce an `Iterable` for
+    # @param my_caller [Object] The calling object to reference in errors
+    # @param obj [Object] The object to produce an `Iterable` for
+    # @param infer_elements [Boolean] Whether or not to recursively infer all elements of obj. Optional
+    #
     # @return [Iterable,nil] The produced `Iterable`
     # @raise [ArgumentError] In case an `Iterable` cannot be produced
     # @api public
-    def self.asserted_iterable(caller, obj)
-      iter = self.on(obj)
-      raise ArgumentError, "#{caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
+    def self.asserted_iterable(my_caller, obj, infer_elements = false)
+      iter = self.on(obj, nil, infer_elements)
+      raise ArgumentError, "#{my_caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
       iter
     end
 
@@ -48,11 +51,14 @@ module Puppet::Pops::Types
     # The value `nil` is returned for all other objects.
     #
     # @param o [Object] The object to produce an `Iterable` for
-    # @param element_type [PAnyType] the element type for the iterator. Optional (inferred if not provided)
+    # @param element_type [PAnyType] the element type for the iterator. Optional
+    # @param infer_elements [Boolean] if element_type is nil, whether or not to recursively
+    #   infer types for the entire collection. Optional
+    #
     # @return [Iterable,nil] The produced `Iterable` or `nil` if it couldn't be produced
     #
     # @api public
-    def self.on(o, element_type = nil)
+    def self.on(o, element_type = nil, infer_elements = true)
       case o
       when IteratorProducer
         o.iterator
@@ -64,7 +70,7 @@ module Puppet::Pops::Types
         if o.empty?
           Iterator.new(PUnitType::DEFAULT, o.each)
         else
-          if element_type.nil?
+          if element_type.nil? && infer_elements
             tc = TypeCalculator.singleton
             element_type = PVariantType.maybe_create(o.map {|e| tc.infer_set(e) })
           end
@@ -75,7 +81,7 @@ module Puppet::Pops::Types
         if o.empty?
           HashIterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
         else
-          if element_type.nil?
+          if element_type.nil? && infer_elements
             tc = TypeCalculator.singleton
             element_type = PTupleType.new([
               PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
@@ -202,6 +208,26 @@ module Puppet::Pops::Types
       @enumeration.send(name, *arguments, &block)
     end
 
+    def next
+      @enumeration.next
+    end
+
+    def map(*args, &block)
+      @enumeration.map(*args, &block)
+    end
+
+    def reduce(*args, &block)
+      @enumeration.reduce(*args, &block)
+    end
+
+    def all?(&block)
+      @enumeration.all?(&block)
+    end
+
+    def any?(&block)
+      @enumeration.any?(&block)
+    end
+
     def step(step, &block)
       raise ArgumentError if step <= 0
       r = self

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/pops/validation/checker4_0.rb

@@ -199,6 +199,11 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
+  def check_Application(o)
+    check_NamedDefinition(o)
+    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => o})
+  end
+
   def check_AssignmentExpression(o)
     case o.operator
     when '='
@@ -296,6 +301,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   end
 
   def check_CapabilityMapping(o)
+    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => o})
     ok =
     case o.component
     when Model::QualifiedReference
@@ -589,36 +595,40 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   # @api private
   class Puppet::Util::FileNamespaceAdapter < Puppet::Pops::Adaptable::Adapter
     attr_accessor :file_to_namespace
+
+    def self.create_adapter(env)
+      adapter = super(env)
+      adapter.file_to_namespace = {}
+      adapter
+    end
   end
 
   def namespace_for_file(file)
     env = Puppet.lookup(:current_environment)
     return NO_NAMESPACE if env.nil?
 
-    Puppet::Util::FileNamespaceAdapter.adapt(env) do |adapter|
-      adapter.file_to_namespace ||= {}
+    adapter = Puppet::Util::FileNamespaceAdapter.adapt(env)
 
-      file_namespace = adapter.file_to_namespace[file]
-      return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
+    file_namespace = adapter.file_to_namespace[file]
+    return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
 
-      path = Pathname.new(file)
+    path = Pathname.new(file)
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
 
-      path = path.expand_path
+    path = path.expand_path
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
 
-      #All auto-loaded files from modules come from a module search path dir
-      relative_path = get_module_relative_path(path, env.full_modulepath)
+    #All auto-loaded files from modules come from a module search path dir
+    relative_path = get_module_relative_path(path, env.full_modulepath)
 
-      return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
+    return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
 
-      #If a file comes from a module, but isn't in the right place, always error
-      names = dir_to_names(relative_path)
+    #If a file comes from a module, but isn't in the right place, always error
+    names = dir_to_names(relative_path)
 
-      return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
-    end
+    return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
   end
 
   def initial_manifest?(path, manifest_setting)
@@ -865,6 +875,10 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     rvalue(o.matching_expr)
   end
 
+  def check_SiteDefinition(o)
+    acceptor.accept(Issues::DEPRECATED_APP_ORCHESTRATION, o, {:klass => o})
+  end
+
   def check_UnaryExpression(o)
     rvalue(o.expr)
   end

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -31,6 +31,7 @@ class ValidatorFactory_4_0 < Factory
     p[Issues::RT_NO_STORECONFIGS]             = Puppet[:storeconfigs] ? :ignore : :warning
 
     p[Issues::FUTURE_RESERVED_WORD]           = :deprecation
+    p[Issues::DEPRECATED_APP_ORCHESTRATION]   = :deprecation
 
     p[Issues::DUPLICATE_KEY]                  = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     p[Issues::NAME_WITH_HYPHEN]               = :error

data/lib/puppet/provider/file/windows.rb

@@ -126,7 +126,7 @@ Puppet::Type.type(:file).provide :windows do
           # If the SYSTEM account does _not_ have FullControl in this scenario, we should
           # force the resource out of sync no matter what.
           #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("%{resource_name}: %{mode_part_type} set to SYSTEM. SYSTEM permissions cannot be set below FullControl ('7')") % { resource_name: resource[:name], mode_part_type: mode_part['type']}
+          Puppet.debug { _("%{resource_name}: %{mode_part_type} set to SYSTEM. SYSTEM permissions cannot be set below FullControl ('7')") % { resource_name: resource[:name], mode_part_type: mode_part['type']} }
           return nil
         end
       end

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

@@ -29,6 +29,15 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
 
   attr_accessor   :latest_info
 
+  STATE_CODE = {
+    'A' => :applied,
+    'B' => :broken,
+    'C' => :committed,
+    'E' => :efix_locked,
+    'O' => :obsolete,
+    '?' => :inconsistent,
+  }.freeze
+
   def self.srclistcmd(source)
     [ command(:installp), "-L", "-d", source ]
   end
@@ -97,6 +106,11 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
     if output =~ /^#{Regexp.escape(@resource[:name])}\s+.*\s+Already superseded by.*$/
       self.fail _("aix package provider is unable to downgrade packages")
     end
+
+    pkg_info = query
+    if pkg_info && [:broken, :inconsistent].include?(pkg_info[:status])
+      self.fail _("Package '%{name}' is in a %{status} state and requires manual intervention") % { name: @resource[:name], status: pkg_info[:status] }
+    end
   end
 
   def self.pkglist(hash = {})
@@ -108,8 +122,9 @@ Puppet::Type.type(:package).provide :aix, :parent => Puppet::Provider::Package d
     end
 
     begin
-      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*)/).collect { |n,e|
-        { :name => n, :ensure => e, :provider => self.name }
+      list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*):[^:]*:[^:]*:([^:])/).collect { |n,e,s|
+        e = :absent if [:broken, :inconsistent].include?(STATE_CODE[s])
+        { :name => n, :ensure => e, :status => STATE_CODE[s], :provider => self.name }
       }
     rescue Puppet::ExecutionFailure => detail
       if hash[:pkgname]

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

@@ -16,6 +16,7 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
 
   commands :aptget => "/usr/bin/apt-get"
   commands :aptcache => "/usr/bin/apt-cache"
+  commands :aptmark => "/usr/bin/apt-mark"
   commands :preseed => "/usr/bin/debconf-set-selections"
 
   defaultfor :osfamily => :debian
@@ -30,6 +31,39 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     false
   end
 
+  def self.instances
+    packages = super
+    manual_marks = aptmark('showmanual').split("\n")
+    packages.each do |package|
+      package.mark = :manual if manual_marks.include?(package.name)
+    end
+    packages
+  end
+
+  def query
+    hash = super
+    hash[:mark] = :manual if aptmark('showmanual').split("\n").include?(@resource[:name])
+    hash
+  end
+
+  def initialize(value={})
+    super(value)
+    @property_flush = {}
+  end
+
+  def mark=(value)
+    @property_flush[:mark] = value
+  end
+
+  def flush
+    # unless we are removing the package mark it if it hasn't already been marked
+    if @property_flush
+      unless @property_flush[:mark] || [:purge, :absent].include?(resource[:ensure])
+        aptmark('manual', resource[:name])
+      end
+    end
+  end
+
   # A derivative of DPKG; this is how most people actually manage
   # Debian boxes, and the only thing that differs is that it can
   # install packages from remote sites.
@@ -77,7 +111,10 @@ Puppet::Type.type(:package).provide :apt, :parent => :dpkg, :source => :dpkg do
     if should.is_a?(String)
       begin
         should_range = VersionRange.parse(should, DebianVersion)
-        should = best_version(should_range)
+
+        unless should_range.is_a?(VersionRange::Eq)
+          should = best_version(should_range)
+        end
       rescue VersionRange::ValidationFailure, DebianVersion::ValidationFailure
         Puppet.debug("Cannot parse #{should} as a debian version range, falling through")
       end

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

@@ -16,7 +16,7 @@ Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg
     output = aptitude(*args)
 
     # Yay, stupid aptitude doesn't throw an error when the package is missing.
-    if args.include?(:install) and output =~ /Couldn't find any package/
+    if args.include?(:install) and output.to_s =~ /Couldn't find any package/
       raise Puppet::Error.new(
         _("Could not find package %{name}") % { name: self.name }
       )

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

@@ -12,7 +12,7 @@ require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
 
-  has_feature :installable, :uninstallable, :versionable, :supports_flavors
+  has_feature :installable, :uninstallable, :versionable, :supports_flavors, :disableable
   #has_feature :upgradeable
   # it's not (yet) feasible to make this upgradeable since module streams don't
   # always have matching version types (i.e. idm has streams DL1 and client,
@@ -34,10 +34,10 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
 
   def self.instances
     packages = []
-    cmd = "#{command(:dnf)} module list --enabled -d 0 -e #{error_level}"
+    cmd = "#{command(:dnf)} module list -d 0 -e #{error_level}"
     execute(cmd).each_line do |line|
       # select only lines with actual packages since DNF clutters the output
-      next unless line =~ /\[[ei]\][, ]/
+      next unless line =~ /\[[eix]\][, ]/
       line.gsub!(/\[d\]/, '')  # we don't care about the default flag
 
       flavor = if line.include?('[i]')
@@ -48,7 +48,11 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
 
       packages << new(
         name: line.split[0],
-        ensure: line.split[1],
+        ensure: if line.include?('[x]')
+                  :disabled
+                else
+                  line.split[1]
+                end,
         flavor: flavor,
         provider: name
       )
@@ -98,6 +102,18 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
     end
   end
 
+  # should only get here when @resource[ensure] is :disabled
+  def insync?(is)
+    if resource[:ensure] == :disabled
+      # in sync only if package is already disabled
+      pkg = self.class.instances.find do |package|
+        @resource[:name] == package.name && package.properties[:ensure] == :disabled
+      end
+      return true if pkg
+    end
+    return false
+  end
+
   def enable(args = @resource[:name])
     execute([command(:dnf), 'module', 'enable', '-d', '0', '-e', self.class.error_level, '-y', args])
   end
@@ -107,6 +123,10 @@ Puppet::Type.type(:package).provide :dnfmodule, :parent => :dnf do
     reset  # reset module to the default stream
   end
 
+  def disable(args = @resource[:name])
+    execute([command(:dnf), 'module', 'disable', '-d', '0', '-e', self.class.error_level, '-y', args])
+  end
+
   def reset
     execute([command(:dnf), 'module', 'reset', '-d', '0', '-e', self.class.error_level, '-y', @resource[:name]])
   end