puppet 6.28.0-universal-darwin → 7.0.0-universal-darwin

data/lib/puppet/network/http_pool.rb

@@ -1,19 +1,15 @@
 require 'puppet/network/http/connection'
-require 'puppet/network/http/connection_adapter'
-require 'puppet/util/platform'
 
 module Puppet::Network; end
 
-# This module contains the factory methods that should be used for getting a
-# {Puppet::Network::HTTP::Connection} instance. The pool may return a new
-# connection or a persistent cached connection, depending on the underlying
-# pool implementation in use.
+# This module is deprecated.
 #
 # @api public
+# @deprecated Use {Puppet::HTTP::Client} instead.
 #
 module Puppet::Network::HttpPool
 
-  @http_client_class = Puppet::Network::HTTP::ConnectionAdapter
+  @http_client_class = Puppet::Network::HTTP::Connection
 
   def self.http_client_class
     @http_client_class
@@ -30,37 +26,20 @@ module Puppet::Network::HttpPool
   # @param verify_peer [Boolean] Whether to verify the peer credentials, if possible. Verification will not take place if the CA certificate is missing.
   # @return [Puppet::Network::HTTP::Connection]
   #
-  # @deprecated Use {#http_connection} instead.
+  # @deprecated Use {Puppet.runtime[:http]} instead.
   # @api public
   #
   def self.http_instance(host, port, use_ssl = true, verify_peer = true)
-    verifier = if verify_peer
-                 Puppet::SSL::Validator.default_validator()
-               else
-                 Puppet::SSL::Validator.no_validator()
-               end
+    Puppet.warn_once('deprecations', self, "The method 'Puppet::Network::HttpPool.http_instance' is deprecated. Use Puppet.runtime[:http] instead")
 
-    http_client_class.new(host, port,
-                            :use_ssl => use_ssl,
-                            :verify => verifier)
-  end
-
-  # Get an http connection that will be secured with SSL and have the
-  # connection verified with the given verifier
-  #
-  # @param host [String] the DNS name to connect to
-  # @param port [Integer] the port to connect to
-  # @param verifier [#setup_connection, #peer_certs, #verify_errors] An object that will setup the appropriate
-  #   verification on a Net::HTTP instance and report any errors and the certificates used.
-  # @return [Puppet::Network::HTTP::Connection]
-  #
-  # @deprecated Use {#http_connection} instead.
-  # @api public
-  #
-  def self.http_ssl_instance(host, port, verifier = Puppet::SSL::Validator.default_validator())
-    http_client_class.new(host, port,
-                            :use_ssl => true,
-                            :verify => verifier)
+    if verify_peer
+      verifier = Puppet::SSL::Verifier.new(host, nil)
+      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
+    else
+      ssl = Puppet::SSL::SSLProvider.new
+      verifier = Puppet::SSL::Verifier.new(host, ssl.create_insecure_context)
+      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
+    end
   end
 
   # Retrieve a connection for the given host and port.
@@ -72,9 +51,12 @@ module Puppet::Network::HttpPool
   #   when making HTTPS connections. Required when `use_ssl` is `true`.
   # @return [Puppet::Network::HTTP::Connection]
   #
+  # @deprecated Use {Puppet.runtime[:http]} instead.
   # @api public
   #
   def self.connection(host, port, use_ssl: true, ssl_context: nil)
+    Puppet.warn_once('deprecations', self, "The method 'Puppet::Network::HttpPool.connection' is deprecated. Use Puppet.runtime[:http] instead")
+
     if use_ssl
       unless ssl_context
         # TRANSLATORS 'ssl_context' is an argument and should not be translated

data/lib/puppet/node/environment.rb

@@ -305,9 +305,7 @@ class Puppet::Node::Environment
                        {}
                      end
       modulepath.each do |path|
-        Puppet::FileSystem.children(path).map do |p|
-          Puppet::FileSystem.basename_string(p)
-        end.each do |name|
+        Dir.entries(path).each do |name|
           next unless Puppet::Module.is_module_directory?(name, path)
           warn_about_mistaken_path(path, name)
           if not seen_modules[name]
@@ -352,6 +350,9 @@ class Puppet::Node::Environment
 
   # Modules broken out by directory in the modulepath
   #
+  # @note This method _changes_ the current working directory while enumerating
+  #   the modules. This seems rather dangerous.
+  #
   # @api public
   #
   # @return [Hash<String, Array<Puppet::Module>>] A hash whose keys are file
@@ -360,13 +361,13 @@ class Puppet::Node::Environment
     modules_by_path = {}
     modulepath.each do |path|
       if Puppet::FileSystem.exist?(path)
-        module_names = Puppet::FileSystem.children(path).map do |p|
-          Puppet::FileSystem.basename_string(p)
-        end.select do |name|
-          Puppet::Module.is_module_directory?(name, path)
-        end
-        modules_by_path[path] = module_names.sort.map do |name|
-          Puppet::Module.new(name, File.join(path, name), self)
+        Dir.chdir(path) do
+          module_names = Dir.entries(path).select do |name|
+            Puppet::Module.is_module_directory?(name, path)
+          end
+          modules_by_path[path] = module_names.sort.map do |name|
+            Puppet::Module.new(name, File.join(path, name), self)
+          end
         end
       else
         modules_by_path[path] = []

data/lib/puppet/node.rb

@@ -89,7 +89,7 @@ class Puppet::Node
     unless @environment.nil?
       # always set the environment parameter. It becomes top scope $environment for a manifest during catalog compilation.
       @parameters[ENVIRONMENT] = @environment.name.to_s
-      self.environment_name = @environment.name
+      self.environment_name = @environment.name if instance_variable_defined?(:@environment_name)
     end
     @environment
   end
@@ -183,36 +183,7 @@ class Puppet::Node
   # Calculate the list of names we might use for looking
   # up our node.  This is only used for AST nodes.
   def names
-    return [name] if Puppet.settings[:strict_hostname_checking]
-
-    names = []
-
-    names += split_name(name) if name.include?(".")
-
-    # First, get the fqdn
-    fqdn = parameters["fqdn"]
-    unless fqdn
-      if parameters["hostname"] and parameters["domain"]
-        fqdn = parameters["hostname"] + "." + parameters["domain"]
-      else
-        Puppet.warning _("Host is missing hostname and/or domain: %{name}") % { name: name }
-      end
-    end
-
-    # Now that we (might) have the fqdn, add each piece to the name
-    # list to search, in order of longest to shortest.
-    names += split_name(fqdn) if fqdn
-
-    # And make sure the node name is first, since that's the most
-    # likely usage.
-    #   The name is usually the Certificate CN, but it can be
-    # set to the 'facter' hostname instead.
-    if Puppet[:node_name] == 'cert'
-      names.unshift name
-    else
-      names.unshift parameters["hostname"]
-    end
-    names.uniq
+    @names ||= [name]
   end
 
   def split_name(name)

data/lib/puppet/pal/json_catalog_encoder.rb

@@ -4,6 +4,8 @@
 #
 # @api public
 #
+module Puppet
+module Pal
 class JsonCatalogEncoder
   # Is the resulting Json pretty printed or not.
   attr_reader :pretty
@@ -65,3 +67,5 @@ class JsonCatalogEncoder
   end
   private :possibly_filtered_catalog
 end
+end
+end

data/lib/puppet/pal/pal_impl.rb

@@ -5,6 +5,7 @@ require 'puppet'
 require 'puppet/parser/script_compiler'
 require 'puppet/parser/catalog_compiler'
 
+module Puppet
 # This is the main entry point for "Puppet As a Library" PAL.
 # This file should be required instead of "puppet"
 # Initially, this will require ALL of puppet - over time this will change as the monolithical "puppet" is broken up
@@ -24,7 +25,7 @@ require 'puppet/parser/catalog_compiler'
 #   end
 #   # The result is what 'mymodule::myfunction' returns
 #
-module Puppet
+# @api public
 module Pal
 
   # Defines a context in which multiple operations in an env with a script compiler can be performed in a given block.
@@ -274,6 +275,7 @@ module Pal
   # @return [Object] returns what the given block returns
   # @yieldparam [Puppet::Pal] context, a context that responds to Puppet::Pal methods
   #
+  # @api public
   def self.in_environment(env_name,
       modulepath:    nil,
       pre_modulepath: [],
@@ -413,7 +415,7 @@ module Pal
 
     # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
     # pickup the new $LOAD_PATH.
-    Puppet.runtime[:facter].reset
+    Facter.reset
 
     node = Puppet.lookup(:pal_current_node)
     pal_facts = Puppet.lookup(:pal_facts)

data/lib/puppet/parser/ast/leaf.rb

@@ -50,9 +50,8 @@ class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
 end
 
 class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
-  def initialize(value: nil, file: nil, line: nil, pos: nil)
-    super(value: value, file: file, line: line, pos: pos)
-
+  def initialize(hash)
+    super(**hash)
     # transform value from hash options unless it is already a regular expression
     @value = Regexp.new(@value) unless @value.is_a?(Regexp)
   end

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -92,14 +92,8 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
-        when Puppet::Pops::Model::CapabilityMapping
-          instantiate_CapabilityMapping(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
-        when Puppet::Pops::Model::SiteDefinition
-            instantiate_SiteDefinition(d, modname)
-        when Puppet::Pops::Model::Application
-          instantiate_ApplicationDefinition(d, modname)
         else
           loaders = Puppet::Pops::Loaders.loaders
           loaders.instantiate_definition(d, loaders.find_loader(modname))
@@ -214,27 +208,6 @@ class Puppet::Parser::AST::PopsBridge
       instance
     end
 
-    def instantiate_CapabilityMapping(o, modname)
-      # Use an intermediate 'capability_mapping' type to pass this info to the compiler where the
-      # actual mapping takes place
-      Puppet::Resource::Type.new(:capability_mapping, "#{o.component} #{o.kind} #{o.capability}", { :arguments => {
-        'component'     => o.component,
-        'kind'          => o.kind,
-        'blueprint'     => {
-          :capability => o.capability,
-          :mappings   => o.mappings.reduce({}) do |memo, mapping|
-            memo[mapping.attribute_name] =
-              Expression.new(:value => mapping.value_expr)
-            memo
-          end
-      }}})
-    end
-
-    def instantiate_ApplicationDefinition(o, modname)
-      args = args_from_definition(o, modname)
-      Puppet::Resource::Type.new(:application, o.name, @context.merge(args))
-    end
-
     def instantiate_NodeDefinition(o, modname)
       args = { :module_name => modname }
 
@@ -253,17 +226,6 @@ class Puppet::Parser::AST::PopsBridge
       end
     end
 
-    def instantiate_SiteDefinition(o, modname)
-      args = { :module_name => modname }
-
-      unless is_nop?(o.body)
-        args[:code] = Expression.new(:value => o.body)
-      end
-
-      args = @ast_transformer.merge_location(args, o)
-      Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
-    end
-
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -1,6 +1,5 @@
 class Puppet::Parser::Compiler
-  # Validator that asserts that only 'require', 'consume', and 'export' is used when declaring relationships
-  # to capability resources.
+  # Validator that asserts relationship metaparameters refer to valid resources
   class CatalogValidator::RelationshipValidator < CatalogValidator
     def validate
       catalog.resources.each do |resource|
@@ -16,48 +15,24 @@ class Puppet::Parser::Compiler
 
     private
 
-    # A hash lookup is 6x avg times faster than find among 3 values.
-    CAPABILITY_ACCEPTED_METAPARAMS = {:require => true, :consume => true, :export => true}.freeze
-
     def validate_relationship(param)
-      # when relationship is to a capability
-      if has_capability?(param.value)
-        unless CAPABILITY_ACCEPTED_METAPARAMS[param.name]
-          raise CatalogValidationError.new(
-            _("'%{param}' is not a valid relationship to a capability") % { param: param.name },
-              param.file, param.line)
+      # the referenced resource must exist
+      refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
+      refs.each do |r|
+        next if r.nil? || r == :undef
+        res = r.to_s
+        begin
+          found = catalog.resource(res)
+        rescue ArgumentError => e
+          # Raise again but with file and line information
+          raise CatalogValidationError.new(e.message, param.file, param.line)
         end
-      else
-        # all other relationships requires the referenced resource to exist
-        refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
-        refs.each do |r|
-          next if r.nil? || r == :undef
-          res = r.to_s
-          begin
-            found = catalog.resource(res)
-          rescue ArgumentError => e
-            # Raise again but with file and line information
-            raise CatalogValidationError.new(e.message, param.file, param.line)
-          end
-          unless found
-            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: res, param: param.name.to_s }
-            raise CatalogValidationError.new(msg, param.file, param.line)
-          end
+        unless found
+          msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: res, param: param.name.to_s }
+          raise CatalogValidationError.new(msg, param.file, param.line)
         end
       end
     end
-
-    def has_capability?(value)
-      case value
-      when Array
-        value.find { |v| has_capability?(v) }
-      when Puppet::Resource
-        rt = value.resource_type
-        !rt.nil? && rt.is_capability?
-      else
-        false
-      end
-    end
   end
 end
 

data/lib/puppet/parser/compiler.rb

@@ -72,22 +72,6 @@ class Puppet::Parser::Compiler
   end
 
   def add_resource(scope, resource)
-    type = resource.resource_type
-    if type.is_a?(Puppet::Resource::Type) && type.application?
-      @applications << resource
-      assert_app_in_site(scope, resource)
-      return
-    end
-
-    if @current_app
-      # We are in the process of pulling application components out that
-      # apply to this node
-      Puppet.notice "Check #{resource}"
-      return unless @current_components.any? do |comp|
-        comp.type == resource.type && comp.title == resource.title
-      end
-    end
-
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
@@ -110,22 +94,6 @@ class Puppet::Parser::Compiler
     end
   end
 
-  def assert_app_in_site(scope, resource)
-    if resource.type == 'App'
-      if scope.resource
-        # directly contained in a Site
-        return if scope.resource.type == 'Site'
-        # contained in something that may be contained in Site
-        upstream = @catalog.upstream_from_vertex(scope.resource)
-        if upstream
-          return if upstream.keys.map(&:type).include?('Site')
-        end
-      end
-      #TRANSLATORS "Site" is a puppet keyword and should not be translated
-      raise ArgumentError, _("Application instances like '%{resource}' can only be contained within a Site") % { resource: resource }
-    end
-  end
-
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
@@ -160,22 +128,13 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
 
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated capability mappings"), [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
-
       #TRANSLATORS "main" is a function name and should not be translated
       Puppet::Util::Profiler.profile(_("Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
 
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
-
       Puppet::Util::Profiler.profile(_("Compile: Evaluated AST node"), [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
       Puppet::Util::Profiler.profile(_("Compile: Evaluated node classes"), [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
-
-      # New capability mappings may have been defined when the site was evaluated
-      Puppet::Util::Profiler.profile(_("Compile: Evaluated site capability mappings"), [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
-
       Puppet::Util::Profiler.profile(_("Compile: Evaluated generators"), [:compiler, :evaluate_generators]) { evaluate_generators }
 
       Puppet::Util::Profiler.profile(_("Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
@@ -184,8 +143,6 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
 
-      Puppet::Util::Profiler.profile(_("Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
-
       fail_on_unevaluated
 
       Puppet::Util::Profiler.profile(_("Compile: Validate Catalog final"), [:compiler, :validate_final]) do
@@ -243,112 +200,6 @@ class Puppet::Parser::Compiler
     evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
-  # Evaluates the site - the top container for an environment catalog
-  # The site contain behaves analogous to a node - for the environment catalog, node expressions are ignored
-  # as the result is cross node. The site expression serves as a container for everything that is across
-  # all nodes.
-  #
-  # @api private
-  #
-  def evaluate_site
-    # Has a site been defined? If not, do nothing but issue a warning.
-    #
-    site = environment.known_resource_types.find_site()
-    unless site
-      on_empty_site()
-      return
-    end
-
-    # Create a resource to model this site and add it to catalog
-    resource = site.ensure_in_catalog(topscope)
-
-    # The site sets node scope to be able to shadow what is in top scope
-    @node_scope = topscope.class_scope(site)
-
-    # Evaluates the logic contain in the site expression
-    resource.evaluate
-  end
-
-  # @api private
-  def on_empty_site
-    # do nothing
-  end
-
-  # Prunes the catalog by dropping all resources are contained under the Site (if a site expression is used).
-  # As a consequence all edges to/from dropped resources are also dropped.
-  # Once the pruning is performed, this compiler returns the pruned list when calling the #resources method.
-  # The pruning does not alter the order of resources in the resources list.
-  #
-  # @api private
-  def prune_catalog
-    prune_node_catalog
-  end
-
-  def prune_node_catalog
-    # Everything under Site[site] should be pruned as that is for the environment catalog, not a node
-    #
-    the_site_resource = @catalog.resource('Site', 'site')
-
-    if the_site_resource
-      # Get downstream vertexes returns a hash where the keys are the resources and values nesting level
-      to_be_removed = @catalog.downstream_from_vertex(the_site_resource).keys
-
-      # Drop the Site[site] resource if it has no content
-      if to_be_removed.empty?
-        to_be_removed << the_site_resource
-      end
-    else
-      to_be_removed = []
-    end
-
-    # keep_from_site is populated with any App resources.
-    application_resources = @resources.select {|r| r.type == 'App' }
-    # keep all applications plus what is directly referenced from applications
-    keep_from_site = application_resources
-    keep_from_site += application_resources.map {|app| @catalog.direct_dependents_of(app) }.flatten
-
-    to_be_removed -= keep_from_site
-    @catalog.remove_resource(*to_be_removed)
-    # set the pruned result
-    @resources = @catalog.resources
-  end
-
-  # @api private
-  def evaluate_applications
-    @applications.each do |app|
-      components = []
-      mapping = app.parameters[:nodes] ? app.parameters[:nodes].value : {}
-      raise Puppet::Error, _("Invalid node mapping in %{app}: Mapping must be a hash") % { app: app.ref } unless mapping.is_a?(Hash)
-      all_mapped = Set.new
-      mapping.each do |k,v|
-        raise Puppet::Error, _("Invalid node mapping in %{app}: Key %{k} is not a Node") % { app: app.ref, k: k } unless k.is_a?(Puppet::Resource) && k.type == 'Node'
-        v = [v] unless v.is_a?(Array)
-        v.each do |res|
-          raise Puppet::Error, _("Invalid node mapping in %{app}: Value %{res} is not a resource") % { app: app.ref, res: res } unless res.is_a?(Puppet::Resource)
-          raise Puppet::Error, _("Application %{app} maps component %{res} to multiple nodes") % { app: app.ref, res: res } if all_mapped.add?(res.ref).nil?
-          components << res if k.title == node.name
-        end
-      end
-      begin
-        @current_app = app
-        @current_components = components
-        unless @current_components.empty?
-          Puppet.notice "EVAL APP #{app} #{components.inspect}"
-          # Add the app itself since components mapped to the current node
-          # will have a containment edge for it
-          # @todo lutter 2015-01-28: the node mapping winds up in the
-          # catalog, but probably shouldn't
-          @catalog.add_resource(@current_app)
-          @current_app.evaluate
-        end
-      ensure
-        @current_app = nil
-        @current_components = nil
-      end
-    end
-  end
-
-
   # If ast nodes are enabled, then see if we can find and evaluate one.
   #
   # @api private
@@ -391,12 +242,6 @@ class Puppet::Parser::Compiler
       classes = classes.keys
     end
 
-    unless @current_components.nil?
-      classes = classes.select do |title|
-        @current_components.any? { |comp| comp.class? && comp.title == title }
-      end
-    end
-
     hostclasses = classes.collect do |name|
       environment.known_resource_types.find_hostclass(name) or raise Puppet::Error, _("Could not find class %{name} for %{node}") % { name: name, node: node.name }
     end
@@ -427,16 +272,6 @@ class Puppet::Parser::Compiler
 
   def initialize(node, code_id: nil)
     @node = sanitize_node(node)
-    # Array of resources representing all application instances we've found
-    @applications = []
-    # We use @current_app and @current_components to signal to the
-    # evaluator that we are in the middle of evaluating an
-    # application. They are set in evaluate_applications to the application
-    # instance, resp. to an array of the components of that application
-    # that is mapped to the current node. They are only non-nil when we are
-    # in the middle of executing evaluate_applications
-    @current_app = nil
-    @current_components = nil
     @code_id = code_id
     initvars
     add_catalog_validators
@@ -481,39 +316,6 @@ class Puppet::Parser::Compiler
     [already_included, newly_included]
   end
 
-  def evaluate_capability_mappings
-    krt = environment.known_resource_types
-    krt.capability_mappings.each_value do |capability_mapping|
-      args = capability_mapping.arguments
-      component_ref = args['component']
-      kind = args['kind']
-
-      # That component_ref is either a QREF or a Class['literal'|QREF] is asserted during validation so no
-      # need to check that here
-      if component_ref.is_a?(Puppet::Pops::Model::QualifiedReference)
-        component_name = component_ref.cased_value
-        component_type = 'type'
-        component = krt.find_definition(component_name)
-      else
-        component_name = component_ref.keys[0].value
-        component_type = 'class'
-        component = krt.find_hostclass(component_name)
-      end
-      if component.nil?
-        raise Puppet::ParseError, _("Capability mapping error: %{kind} clause references nonexistent %{component_type} %{component_name}") %
-            { kind: kind, component_type: component_type, component_name: component_name }
-      end
-
-      blueprint = args['blueprint']
-      if kind == 'produces'
-        component.add_produces(blueprint)
-      else
-        component.add_consumes(blueprint)
-      end
-    end
-    krt.capability_mappings.clear # No longer needed
-  end
-
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections

data/lib/puppet/parser/functions/fqdn_rand.rb

@@ -2,16 +2,13 @@ require 'digest/md5'
 require 'digest/sha2'
 
 Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
-  "Usage: `fqdn_rand(MAX, [SEED], [DOWNCASE])`. MAX is required and must be a positive
-  integer; SEED is optional and may be any number or string; DOWNCASE is optional
-  and should be a boolean true or false.
+  "Usage: `fqdn_rand(MAX, [SEED])`. MAX is required and must be a positive
+  integer; SEED is optional and may be any number or string.
 
   Generates a random Integer number greater than or equal to 0 and less than MAX,
   combining the `$fqdn` fact and the value of SEED for repeatable randomness.
   (That is, each node will get a different random number from this function, but
-  a given node's result will be the same every time unless its hostname changes.) If
-  DOWNCASE is true, then the `fqdn` fact will be downcased when computing the value
-  so that the result is not sensitive to the case of the `fqdn` fact.
+  a given node's result will be the same every time unless its hostname changes.)
 
   This function is usually used for spacing out runs of resource-intensive cron
   tasks that run on many nodes, which could cause a thundering herd or degrade
@@ -20,12 +17,7 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   node. (For example, `fqdn_rand(30)`, `fqdn_rand(30, 'expensive job 1')`, and
   `fqdn_rand(30, 'expensive job 2')` will produce totally different numbers.)") do |args|
     max = args.shift.to_i
-    initial_seed = args.shift
-    downcase = !!args.shift
-
-    fqdn = self['::fqdn']
-    fqdn = fqdn.downcase if downcase
-
+ 
     # Puppet 5.4's fqdn_rand function produces a different value than earlier versions
     # for the same set of inputs.
     # This causes problems because the values are often written into service configuration files.
@@ -35,9 +27,9 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
     # when running on a non-FIPS enabled platform and only using SHA256 on FIPS enabled
     # platforms.
     if Puppet::Util::Platform.fips_enabled?
-      seed = Digest::SHA256.hexdigest([fqdn,max,initial_seed].join(':')).hex
+      seed = Digest::SHA256.hexdigest([self['::fqdn'],max,args].join(':')).hex
     else
-      seed = Digest::MD5.hexdigest([fqdn,max,initial_seed].join(':')).hex
+      seed = Digest::MD5.hexdigest([self['::fqdn'],max,args].join(':')).hex
     end
 
     Puppet::Util.deterministic_rand_int(seed,max)