puppet 6.29.0 → 7.0.0

data/lib/puppet/resource/type.rb

@@ -11,16 +11,13 @@ class Puppet::Resource::Type
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
-  # @deprecated application orchestration will be removed in puppet 7 (capability_mapping, application, site)
-  RESOURCE_KINDS = [:hostclass, :node, :definition, :capability_mapping, :application, :site]
+  RESOURCE_KINDS = [:hostclass, :node, :definition]
 
   # Map the names used in our documentation to the names used internally
   RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
       :hostclass => "class",
       :node => "node",
-      :definition => "defined_type",
-      :application => "application",
-      :site => 'site'
+      :definition => "defined_type"
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
@@ -37,15 +34,6 @@ class Puppet::Resource::Type
   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
-  # of capabilities this type can produce/consume. The entries in the array
-  # are a fairly direct representation of what goes into produces/consumes
-  # clauses. Each entry is a hash with attributes
-  #   :capability  - the type name of the capres produced/consumed
-  #   :mappings    - a hash of attribute_name => Expression
-  # These two attributes are populated in
-  # PopsBridge::instantiate_CapabilityMapping
-
   # Map from argument (aka parameter) names to Puppet Type
   # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
   #
@@ -69,53 +57,6 @@ class Puppet::Resource::Type
     return(klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
-  # Evaluate the resources produced by the given resource. These resources are
-  # evaluated in a separate but identical scope from the rest of the resource.
-  #
-  # @deprecated application orchestration will be removed in puppet 7
-  def evaluate_produces(resource, scope)
-    # Only defined types and classes can produce capabilities
-    return unless definition? || hostclass?
-
-    resource.export.map do |ex|
-      # Assert that the ref really is a resource reference
-      raise Puppet::Error, _("Invalid export in %{reference}: %{ex} is not a resource") % { reference: resource.ref, ex: ex } unless ex.is_a?(Puppet::Resource)
-      raise Puppet::Error, _("Invalid export in %{reference}: %{ex} is not a capability resource") % { reference: resource.ref, ex: ex } if ex.resource_type.nil? || !ex.resource_type.is_capability?
-
-      blueprint = produces.find { |pr| pr[:capability] == ex.type }
-      if blueprint.nil?
-        raise Puppet::ParseError, _("Resource type %{res_type} does not produce %{ex_type}") % { res_type: resource.type, ex_type: ex.type }
-      end
-      t = ex.type
-      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
-      produced_resource = Puppet::Parser::Resource.new(t, ex.title, :scope => scope, :source => self)
-
-      produced_resource.resource_type.parameters.each do |name|
-        next if name == :name
-
-        expr = blueprint[:mappings][name.to_s]
-        if expr
-          produced_resource[name] = expr.safeevaluate(scope)
-        else
-          produced_resource[name] = scope[name.to_s]
-        end
-      end
-      # Tag the produced resource so we can later distinguish it from
-      # copies of the resource that wind up in the catalogs of nodes that
-      # use this resource. We tag the resource with producer:<environment>,
-      # meaning produced resources need to be unique within their
-      # environment
-      # @todo lutter 2014-11-13: we would really like to use a dedicated
-      # metadata field to indicate the producer of a resource, but that
-      # requires changes to PuppetDB and its API; so for now, we just use
-      # tagging
-      produced_resource.tag("producer:#{scope.catalog.environment}")
-      scope.catalog.add_resource(produced_resource)
-      produced_resource[:require] = resource.ref
-      produced_resource
-    end
-  end
-
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
 
@@ -129,8 +70,6 @@ class Puppet::Resource::Type
 
     resource.add_edge_to_stage
 
-    evaluate_produces(resource, scope)
-
     if code
       if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
         scope.with_guarded_scope do
@@ -165,28 +104,6 @@ class Puppet::Resource::Type
     @module_name = options[:module_name]
   end
 
-  # @deprecated application orchestration will be removed in puppet 7
-  def produces
-    @produces || EMPTY_ARRAY
-  end
-
-  # @deprecated application orchestration will be removed in puppet 7
-  def consumes
-    @consumes || EMPTY_ARRAY
-  end
-
-  # @deprecated application orchestration will be removed in puppet 7
-  def add_produces(blueprint)
-    @produces ||= []
-    @produces << blueprint
-  end
-
-  # @deprecated application orchestration will be removed in puppet 7
-  def add_consumes(blueprint)
-    @consumes ||= []
-    @consumes << blueprint
-  end
-
   # This is only used for node names, and really only when the node name
   # is a regexp.
   def match(string)
@@ -242,9 +159,6 @@ class Puppet::Resource::Type
       :class
     when :node
       :node
-    when :site
-      # @deprecated application orchestration will be removed in puppet 7
-      :site
     end
 
     # Do nothing if the resource already exists; this makes sure we don't
@@ -289,21 +203,6 @@ class Puppet::Resource::Type
     @name.is_a?(Regexp)
   end
 
-  # @deprecated Not used by Puppet
-  # @api private
-  def assign_parameter_values(parameters, resource)
-    Puppet.deprecation_warning(_('The method Puppet::Resource::Type.assign_parameter_values is deprecated and will be removed in the next major release of Puppet.'))
-
-    return unless parameters
-
-    # It'd be nice to assign default parameter values here,
-    # but we can't because they often rely on local variables
-    # created during set_resource_parameters.
-    parameters.each do |name, value|
-      resource.set_parameter name, value
-    end
-  end
-
   def parent_type(scope = nil)
     return nil unless parent
 
@@ -326,7 +225,6 @@ class Puppet::Resource::Type
     caller_name = resource[:caller_module_name] || scope.parent_module_name
     scope[CALLER_MODULE_NAME] = caller_name unless caller_name.nil?
 
-    resource.add_parameters_from_consume
     inject_external_parameters(resource, scope)
 
     if @type == :hostclass
@@ -389,7 +287,7 @@ class Puppet::Resource::Type
   private :assign_defaults
 
   def validate_resource_hash(resource, resource_hash)
-    Puppet::Pops::Types::TypeMismatchDescriber.validate_parameters(resource.to_s, parameter_struct, resource_hash, resource.is_unevaluated_consumer?)
+    Puppet::Pops::Types::TypeMismatchDescriber.validate_parameters(resource.to_s, parameter_struct, resource_hash, false)
   end
   private :validate_resource_hash
 
@@ -444,14 +342,6 @@ class Puppet::Resource::Type
     end
   end
 
-  # Returns boolean true if an instance of this type is a capability. This
-  # implementation always returns false. This "duck-typing" interface is
-  # shared among other classes and makes it easier to detect capabilities
-  # when they are intermixed with non capability instances.
-  def is_capability?
-    false
-  end
-
   private
 
   def convert_from_ast(name)
@@ -516,12 +406,6 @@ class Puppet::Resource::Type
     type_factory = Puppet::Pops::Types::TypeFactory
     members = { type_factory.optional(type_factory.string(NAME)) =>  type_factory.any }
 
-    if application?
-      resource_type = type_factory.type_type(type_factory.resource)
-      members[type_factory.string(NODES)] = type_factory.hash_of(type_factory.variant(
-          resource_type, type_factory.array_of(resource_type)), type_factory.type_type(type_factory.resource('node')))
-    end
-
     Puppet::Type.eachmetaparam do |name|
       # TODO: Once meta parameters are typed, this should change to reflect that type
       members[name.to_s] = type_factory.any

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

@@ -11,7 +11,7 @@ class Puppet::Resource
   include Puppet::Util::PsychSupport
 
   include Enumerable
-  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict, :kind
+  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
   attr_reader :type, :title, :parameters
 
   # @!attribute [rw] sensitive_parameters
@@ -29,15 +29,9 @@ class Puppet::Resource
   EMPTY_ARRAY = [].freeze
   EMPTY_HASH = {}.freeze
 
-  ATTRIBUTES = [:file, :line, :exported, :kind].freeze
+  ATTRIBUTES = [:file, :line, :exported].freeze
   TYPE_CLASS = 'Class'.freeze
   TYPE_NODE  = 'Node'.freeze
-  TYPE_SITE  = 'Site'.freeze
-
-  CLASS_STRING = 'class'.freeze
-  DEFINED_TYPE_STRING = 'defined_type'.freeze
-  COMPILABLE_TYPE_STRING = 'compilable_type'.freeze
-  UNKNOWN_TYPE_STRING  = 'unknown'.freeze
 
   PCORE_TYPE_KEY = '__ptype'.freeze
   VALUE_KEY = 'value'.freeze
@@ -199,18 +193,6 @@ class Puppet::Resource
     resource_type.is_a?(Puppet::CompilableResourceType)
   end
 
-  def self.to_kind(resource_type)
-    if resource_type == CLASS_STRING
-      CLASS_STRING
-    elsif resource_type.is_a?(Puppet::Resource::Type) && resource_type.type == :definition
-      DEFINED_TYPE_STRING
-    elsif resource_type.is_a?(Puppet::CompilableResourceType)
-      COMPILABLE_TYPE_STRING
-    else
-      UNKNOWN_TYPE_STRING
-    end
-  end
-
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     parameters.each { |p,v| yield p, v }
@@ -265,7 +247,6 @@ class Puppet::Resource
       src = type
       self.file = src.file
       self.line = src.line
-      self.kind = src.kind
       self.exported = src.exported
       self.virtual = src.virtual
       self.set_tags(src)
@@ -328,7 +309,6 @@ class Puppet::Resource
 
       rt = resource_type
 
-      self.kind = self.class.to_kind(rt) unless kind
       if strict? && rt.nil?
         if self.class?
           raise ArgumentError, _("Could not find declared class %{title}") % { title: title }
@@ -359,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
@@ -396,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
@@ -512,24 +468,10 @@ class Puppet::Resource
     ref
   end
 
-  # Convert our resource to a RAL resource instance. Creates component
-  # instances for resource types that are not of a compilable_type kind. In case
-  # the resource doesn’t exist and it’s compilable_type kind, raise an error.
-  # There are certain cases where a resource won't be in a catalog, such as 
-  # when we create a resource directly by using Puppet::Resource.new(...), so we 
-  # must check its kind before deciding whether the catalog format is of an older
-  # version or not.
+  # Convert our resource to a RAL resource instance.  Creates component
+  # instances for resource types that don't exist.
   def to_ral
-    if self.kind == COMPILABLE_TYPE_STRING
-      typeklass = Puppet::Type.type(self.type)
-    elsif self.catalog && self.catalog.catalog_format >= 2
-      typeklass = Puppet::Type.type(:component)
-    else
-      typeklass =  Puppet::Type.type(self.type) || Puppet::Type.type(:component)
-    end
-
-    raise(Puppet::Error, "Resource type '#{self.type}' was not found") unless typeklass
-
+    typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
     typeklass.new(self)
   end
 
@@ -548,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
@@ -588,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
       {