puppet 6.25.1-x86-mingw32 → 7.0.0-x86-mingw32

data/lib/puppet/type.rb

@@ -114,29 +114,6 @@ class Type
     attr_reader :properties
   end
 
-  # Allow declaring that a type is actually a capability
-  class << self
-    # @deprecated application orchestration will be removed in puppet 7
-    attr_accessor :is_capability
-
-    # @deprecated application orchestration will be removed in puppet 7
-    def is_capability?
-      c = is_capability
-      c.nil? ? false : c
-    end
-  end
-
-  # Returns whether this type represents an application instance; since
-  # only defined types, i.e., instances of Puppet::Resource::Type can
-  # represent application instances, this implementation always returns
-  # +false+. Having this method though makes code checking whether a
-  # resource is an application instance simpler
-  #
-  # @deprecated application orchestration will be removed in puppet 7
-  def self.application?
-      false
-  end
-
   # Returns all the attribute names of the type in the appropriate order.
   # The {key_attributes} come first, then the {provider}, then the {properties}, and finally
   # the {parameters} and {metaparams},
@@ -1295,7 +1272,7 @@ class Type
       like it does when running normally. However, if a resource attribute is not in
       the desired state (as declared in the catalog), Puppet will take no
       action, and will instead report the changes it _would_ have made. These
-      simulated changes will appear in the report sent to the primary Puppet server, or
+      simulated changes will appear in the report sent to the puppet master, or
       be shown on the console if running puppet agent or puppet apply in the
       foreground. The simulated changes will not send refresh events to any
       subscribing or notified resources, although Puppet will log that a refresh
@@ -1720,59 +1697,6 @@ class Type
     }
   end
 
-  # @deprecated application orchestration will be removed in puppet 7
-  newmetaparam(:export, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :NONE}) do
-          desc <<EOS
-Export a capability resource.
-
-The value of this parameter must be a reference to a capability resource,
-or an array of such references. Each capability resource referenced here
-will be instantiated in the node catalog and exported to consumers of this
-resource. The title of the capability resource will be the title given in
-the reference, and all other attributes of the resource will be filled
-according to the corresponding produces statement.
-
-It is an error if this metaparameter references resources whose type is not
-a capability type, or of there is no produces clause for the type of the
-current resource and the capability resource mentioned in this parameter.
-
-For example:
-
-define web(..) { .. }
-Web produces Http { .. }
-web { server:
-  export => Http[main_server]
-}
-EOS
-  end
-
-  # @deprecated application orchestration will be removed in puppet 7
-  newmetaparam(:consume, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :NONE}) do
-          desc <<EOS
-Consume a capability resource.
-
-The value of this parameter must be a reference to a capability resource,
-or an array of such references. Each capability resource referenced here
-must have been exported by another resource in the same environment.
-
-The referenced capability resources will be looked up, added to the
-current node catalog, and processed following the underlying consumes
-clause.
-
-It is an error if this metaparameter references resources whose type is not
-a capability type, or of there is no consumes clause for the type of the
-current resource and the capability resource mentioned in this parameter.
-
-For example:
-
-define web(..) { .. }
-Web consumes Sql { .. }
-web { server:
-  consume => Sql[my_db]
-}
-EOS
-end
-
   ###############################
   # All of the provider plumbing for the resource types.
   require 'puppet/provider'

data/lib/puppet/util/autoload.rb

@@ -166,7 +166,14 @@ class Puppet::Util::Autoload
     # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
     # and eliminates unnecessary parts of a path.
     def cleanpath(path)
-      Pathname.new(path).cleanpath.to_s
+      # There are two cases here because cleanpath does not handle absolute
+      # paths correctly on windows (c:\ and c:/ are treated as distinct) but
+      # we don't want to convert relative paths to absolute
+      if Puppet::Util.absolute_path?(path)
+        File.expand_path(path)
+      else
+        Pathname.new(path).cleanpath.to_s
+      end
     end
   end
 

data/lib/puppet/util/command_line.rb

@@ -135,7 +135,7 @@ module Puppet
 
               # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
               # pickup the new $LOAD_PATH.
-              Puppet.runtime[:facter].reset
+              Facter.reset
             end
           end
 

data/lib/puppet/util/execution.rb

@@ -94,17 +94,6 @@ module Puppet::Util::Execution
   end
   private_class_method :exitstatus
 
-  # Wraps execution of {execute} with mapping of exception to given exception (and output as argument).
-  # @raise [exception] under same conditions as {execute}, but raises the given `exception` with the output as argument
-  # @return (see execute)
-  # @api public
-  # @deprecated
-  def self.execfail(command, exception)
-    execute(command)
-  rescue Puppet::ExecutionFailure => detail
-    raise exception, detail.message, detail.backtrace
-  end
-
   # Default empty options for {execute}
   NoOptionsSpecified = {}
 

data/lib/puppet/util/filetype.rb

@@ -215,7 +215,7 @@ class Puppet::Util::FileType
     # Remove a specific @path's cron tab.
     def remove
       cmd = "#{cmdbase} -r"
-      if %w{Darwin FreeBSD DragonFly}.include?(Puppet.runtime[:facter].value("operatingsystem"))
+      if %w{Darwin FreeBSD DragonFly}.include?(Facter.value("operatingsystem"))
         cmd = "/bin/echo yes | #{cmd}"
       end
 
@@ -244,7 +244,7 @@ class Puppet::Util::FileType
     # Only add the -u flag when the @path is different.  Fedora apparently
     # does not think I should be allowed to set the @path to my own user name
     def cmdbase
-      if @uid == Puppet::Util::SUIDManager.uid || Puppet.runtime[:facter].value(:operatingsystem) == "HP-UX"
+      if @uid == Puppet::Util::SUIDManager.uid || Facter.value(:operatingsystem) == "HP-UX"
         return "crontab"
       else
         return "crontab -u #{@path}"

data/lib/puppet/util/http_proxy.rb

@@ -1,217 +1,4 @@
-require 'uri'
-require 'puppet/ssl/openssl_loader'
 require 'puppet/http'
 
-module Puppet::Util::HttpProxy
-  def self.proxy(uri)
-    if http_proxy_host && !no_proxy?(uri)
-      Net::HTTP.new(uri.host, uri.port, self.http_proxy_host, self.http_proxy_port, self.http_proxy_user, self.http_proxy_password)
-    else
-      http = Net::HTTP.new(uri.host, uri.port, nil, nil, nil, nil)
-      # Net::HTTP defaults the proxy port even though we said not to
-      # use one. Set it to nil so caller is not surprised
-      http.proxy_port = nil
-      http
-    end
-  end
-
-  def self.http_proxy_env
-    # Returns a URI object if proxy is set, or nil
-    proxy_env = ENV["http_proxy"] || ENV["HTTP_PROXY"]
-    begin
-      return URI.parse(proxy_env) if proxy_env
-    rescue URI::InvalidURIError
-      return nil
-    end
-    return nil
-  end
-
-  # The documentation around the format of the no_proxy variable seems
-  # inconsistent.  Some suggests the use of the * as a way of matching any
-  # hosts under a domain, e.g.:
-  #   *.example.com
-  # Other documentation suggests that just a leading '.' indicates a domain
-  # level exclusion, e.g.:
-  #   .example.com
-  # We'll accommodate both here.
-  def self.no_proxy?(dest)
-    no_proxy = self.no_proxy
-    unless no_proxy
-      return false
-    end
-
-    unless dest.is_a? URI
-      begin
-        dest = URI.parse(dest)
-      rescue URI::InvalidURIError
-        return false
-      end
-    end
-
-    no_proxy.split(/\s*,\s*/).each do |d|
-      host, port = d.split(':')
-      host = Regexp.escape(host).gsub('\*', '.*')
-
-      #If this no_proxy entry specifies a port, we want to match it against
-      #the destination port.  Otherwise just match hosts.
-      if port
-        no_proxy_regex  = %r(#{host}:#{port}$)
-        dest_string     = "#{dest.host}:#{dest.port}"
-      else
-        no_proxy_regex  = %r(#{host}$)
-        dest_string     = "#{dest.host}"
-      end
-
-      if no_proxy_regex.match(dest_string)
-        return true
-      end
-    end
-
-    return false
-  end
-
-  def self.http_proxy_host
-    env = self.http_proxy_env
-
-    if env and env.host
-      return env.host
-    end
-
-    if Puppet.settings[:http_proxy_host] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:http_proxy_host]
-  end
-
-  def self.http_proxy_port
-    env = self.http_proxy_env
-
-    if env and env.port
-      return env.port
-    end
-
-    return Puppet.settings[:http_proxy_port]
-  end
-
-  def self.http_proxy_user
-    env = self.http_proxy_env
-
-    if env and env.user
-      return env.user
-    end
-
-    if Puppet.settings[:http_proxy_user] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:http_proxy_user]
-  end
-
-  def self.http_proxy_password
-    env = self.http_proxy_env
-
-    if env and env.password
-      return env.password
-    end
-
-    if Puppet.settings[:http_proxy_user] == 'none' or Puppet.settings[:http_proxy_password] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:http_proxy_password]
-  end
-
-  def self.no_proxy
-    no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"]
-
-    if no_proxy_env
-      return no_proxy_env
-    end
-
-    if Puppet.settings[:no_proxy] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:no_proxy]
-  end
-
-  # Return a Net::HTTP::Proxy object.
-  #
-  # This method optionally configures SSL correctly if the URI scheme is
-  # 'https', including setting up the root certificate store so remote server
-  # SSL certificates can be validated.
-  #
-  # @param [URI] uri The URI that is to be accessed.
-  # @return [Net::HTTP::Proxy] object constructed tailored for the passed URI
-  def self.get_http_object(uri)
-    proxy = proxy(uri)
-
-    if uri.scheme == 'https'
-      cert_store = OpenSSL::X509::Store.new
-      cert_store.set_default_paths
-
-      proxy.use_ssl = true
-      proxy.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      proxy.cert_store = cert_store
-    end
-
-    if Puppet[:http_debug]
-      proxy.set_debug_output($stderr)
-    end
-
-    proxy.open_timeout = Puppet[:http_connect_timeout]
-    proxy.read_timeout = Puppet[:http_read_timeout]
-
-    proxy
-  end
-
-  # Retrieve a document through HTTP(s), following redirects if necessary. The
-  # returned response body may be compressed, and it is the caller's
-  # responsibility to decompress it based on the 'content-encoding' header.
-  #
-  # Based on the the client implementation in the HTTP pool.
-  #
-  # @see Puppet::Network::HTTP::Connection#request_with_redirects
-  #
-  # @param [URI] uri The address of the resource to retrieve.
-  # @param [symbol] method The name of the Net::HTTP method to use, typically :get, :head, :post etc.
-  # @param [FixNum] redirect_limit The number of redirections that can be followed.
-  # @return [Net::HTTPResponse] a response object
-  def self.request_with_redirects(uri, method, redirect_limit = 10, &block)
-    current_uri = uri
-    response = nil
-
-    0.upto(redirect_limit) do |redirection|
-      proxy = get_http_object(current_uri)
-
-      headers = { 'Accept' => '*/*', 'User-Agent' => Puppet[:http_user_agent] }
-      if Puppet.features.zlib?
-        headers["Accept-Encoding"] = Puppet::HTTP::ACCEPT_ENCODING
-      end
-
-      response = proxy.send(:head, current_uri, headers)
-      Puppet.debug("HTTP HEAD request to #{current_uri} returned #{response.code} #{response.message}")
-
-      if [301, 302, 307].include?(response.code.to_i)
-        # handle the redirection
-        current_uri = URI.parse(response['location'])
-        next
-      end
-
-      if method != :head
-        if block_given?
-          response = proxy.send("request_#{method}".to_sym, current_uri, headers, &block)
-        else
-          response = proxy.send(method, current_uri, headers)
-        end
-
-        Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
-      end
-
-      return response
-    end
-
-    raise RedirectionLimitExceededException, _("Too many HTTP redirections for %{uri}") % { uri: uri }
-  end
-end
+# for backwards compatibility
+Puppet::Util::HttpProxy = Puppet::HTTP::Proxy

data/lib/puppet/util/json.rb

@@ -60,9 +60,6 @@ module Puppet::Util
     def self.dump(object, options = {})
       if defined? MultiJson
         MultiJson.dump(object, options)
-      elsif options.is_a?(JSON::State)
-        # we're being called recursively
-        object.to_json(options)
       else
         options.merge!(::JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
         object.to_json(options)

data/lib/puppet/util/log.rb

@@ -2,6 +2,7 @@ require 'puppet/util/tagging'
 require 'puppet/util/classgen'
 require 'puppet/util/psych_support'
 require 'puppet/network/format_support'
+require 'facter'
 
 # Pass feedback to the user.  Log levels are modeled after syslog's, and it is
 # expected that that will be the most common log destination.  Supports
@@ -110,7 +111,7 @@ class Puppet::Util::Log
     @loglevel = @levels.index(level)
 
     # Enable or disable Facter debugging
-    Puppet.runtime[:facter].debugging(level == :debug)
+    Facter.debugging(level == :debug) if Facter.respond_to? :debugging
   end
 
   def Log.levels

data/lib/puppet/util/logging.rb

@@ -2,6 +2,8 @@
 require 'puppet/util/log'
 require 'puppet/error'
 
+require 'facter'
+
 module Puppet::Util
 module Logging
 
@@ -252,7 +254,29 @@ module Logging
   # Sets up Facter logging.
   # This method causes Facter output to be forwarded to Puppet.
   def self.setup_facter_logging!
-    Puppet.runtime[:facter]
+    # Only recent versions of Facter support this feature
+    return false unless Facter.respond_to? :on_message
+
+    # The current Facter log levels are: :trace, :debug, :info, :warn, :error, and :fatal.
+    # Convert to the corresponding levels in Puppet
+    Facter.on_message do |level, message|
+      case level
+      when :trace, :debug
+        level = :debug
+      when :info
+        # Same as Puppet
+      when :warn
+        level = :warning
+      when :error
+        level = :err
+      when :fatal
+        level = :crit
+      else
+        next
+      end
+      Puppet::Util::Log.create({:level => level, :source => 'Facter', :message => message})
+      nil
+    end
     true
   end
 

data/lib/puppet/util/monkey_patches.rb

@@ -32,13 +32,6 @@ end
 # (#19151) Reject all SSLv2 ciphers and handshakes
 require 'puppet/ssl/openssl_loader'
 unless Puppet::Util::Platform.jruby_fips?
-  unless defined?(OpenSSL::SSL::TLS1_VERSION)
-    module OpenSSL::SSL
-      # see https://github.com/ruby/ruby/commit/609103dbb5fb182eec12f052226c43e39b907682#diff-09f822c26289f5347111795ca22ed7ed1cfadd6ebd28f987991d1d414eef565aR2755-R2759
-      OpenSSL::SSL::TLS1_VERSION = 0x301
-    end
-  end
-
   class OpenSSL::SSL::SSLContext
     if DEFAULT_PARAMS[:options]
       DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
@@ -109,49 +102,3 @@ unless Puppet::Util::Platform.jruby_fips?
     end
   end
 end
-
-unless Puppet::Util::Platform.jruby_fips?
-  unless OpenSSL::PKey::EC.instance_methods.include?(:private?)
-    class OpenSSL::PKey::EC
-      # Added in ruby 2.4.0 in https://github.com/ruby/ruby/commit/7c971e61f04
-      alias :private? :private_key?
-    end
-  end
-
-  unless OpenSSL::PKey::EC.singleton_methods.include?(:generate)
-    class OpenSSL::PKey::EC
-      # Added in ruby 2.4.0 in https://github.com/ruby/ruby/commit/85500b66342
-      def self.generate(string)
-        ec = OpenSSL::PKey::EC.new(string)
-        ec.generate_key
-      end
-    end
-  end
-end
-
-# The Enumerable#uniq method was added in Ruby 2.4.0 (https://bugs.ruby-lang.org/issues/11090)
-# This is a backport to earlier Ruby versions.
-#
-unless Enumerable.instance_methods.include?(:uniq)
-  module Enumerable
-    def uniq
-      result = []
-      uniq_map = {}
-      if block_given?
-        each do |value|
-          key = yield value
-          next if uniq_map.has_key?(key)
-          uniq_map[key] = true
-          result << value
-        end
-      else
-        each do |value|
-          next if uniq_map.has_key?(value)
-          uniq_map[value] = true
-          result << value
-        end
-      end
-      result
-    end
-  end
-end

data/lib/puppet/util/pidlock.rb

@@ -46,7 +46,7 @@ class Puppet::Util::Pidlock
   private
 
   def ps_argument_for_current_kernel
-    case Puppet.runtime[:facter].value(:kernel)
+    case Facter.value(:kernel)
       when "Linux"
         "-eq"
       when "AIX"

data/lib/puppet/util/posix.rb

@@ -12,18 +12,11 @@ module Puppet::Util::POSIX
   class << self
     # Returns an array of all the groups that the user's a member of.
     def groups_of(user)
-      begin
-        require 'puppet/ffi/posix'
-        groups = get_groups_list(user)
-      rescue StandardError, LoadError => e
-        Puppet.debug("Falling back to Puppet::Etc.group: #{e.message}")
-
-        groups = []
-        Puppet::Etc.group do |group|
-          groups << group.name if group.mem.include?(user)
-        end
+      groups = []
+      Puppet::Etc.group do |group|
+        groups << group.name if group.mem.include?(user)
       end
-
+  
       uniq_groups = groups.uniq
       if uniq_groups != groups
         Puppet.debug(_('Removing any duplicate group entries'))
@@ -31,39 +24,6 @@ module Puppet::Util::POSIX
 
       uniq_groups
     end
-
-    private
-    def get_groups_list(user)
-      raise LoadError, "The 'getgrouplist' method is not available" unless Puppet::FFI::POSIX::Functions.respond_to?(:getgrouplist)
-
-      user_gid = Puppet::Etc.getpwnam(user).gid
-      ngroups = Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS
-
-      while true do # rubocop:disable Lint/LiteralInCondition
-        FFI::MemoryPointer.new(:int) do |ngroups_ptr|
-          FFI::MemoryPointer.new(:uint, ngroups) do |groups_ptr|
-            old_ngroups = ngroups
-            ngroups_ptr.write_int(ngroups)
-
-            if Puppet::FFI::POSIX::Functions::getgrouplist(user, user_gid, groups_ptr, ngroups_ptr) != -1
-              groups_gids = groups_ptr.get_array_of_uint(0, ngroups_ptr.read_int)
-
-              result = []
-              groups_gids.each do |group_gid|
-                group_info = Puppet::Etc.getgrgid(group_gid)
-                result |= [group_info.name] if group_info.mem.include?(user)
-              end
-              return result
-            end
-
-            ngroups = ngroups_ptr.read_int
-            if ngroups <= old_ngroups
-              ngroups *= 2
-            end
-          end
-        end
-      end
-    end
   end
 
   # Retrieve a field from a POSIX Etc object.  The id can be either an integer
@@ -184,17 +144,8 @@ module Puppet::Util::POSIX
       name = get_posix_field(location, :name, id)
       check_value = name
     end
-
     if check_value != field
-      check_value_id = get_posix_field(location, id_field, check_value) if check_value
-
-      if id == check_value_id
-        Puppet.debug("Multiple entries found for resource: '#{location}' with #{id_field}: #{id}")
-        return id
-      else
-        Puppet.debug("The value retrieved: '#{check_value}' is different than the required state: '#{field}', searching in all entries")
-        return search_posix_field(location, id_field, field)
-      end
+      return search_posix_field(location, id_field, field)
     else
       return id
     end

data/lib/puppet/util/rdoc/parser/puppet_parser_core.rb

@@ -154,7 +154,7 @@ module RDoc::PuppetParserCore
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
-        elsif line =~ /^[ \t]*(Facter.add|Puppet\.runtime\[:facter\].add)\(['"](.*?)['"]\)/
+        elsif line =~ /^[ \t]*Facter.add\(['"](.*?)['"]\)/
           current_fact = RDoc::Fact.new($1,{})
           look_for_directives_in(container, comments) unless comments.empty?
           current_fact.comment = comments

data/lib/puppet/util/rdoc.rb

@@ -26,13 +26,6 @@ module Puppet::Util::RDoc
 
     options << "--force-update"
     options += [ "--charset", charset] if charset
-    # Rdoc root default is Dir.pwd, but the win32-dir gem monkey patches Dir.pwd
-    # replacing Ruby's normal / with \.  When RDoc generates relative paths it
-    # uses relative_path_from that will generate errors when the slashes don't
-    # properly match.  This is a workaround for that issue.
-    if Puppet::Util::Platform.windows? && RDoc::VERSION !~ /^[0-3]\./
-      options += [ "--root", Dir.pwd.tr('\\', '/')]
-    end
     options += files
 
     # launch the documentation process

data/lib/puppet/util/retry_action.rb

@@ -7,7 +7,7 @@ module Puppet::Util::RetryAction
   # Execute the supplied block retrying with exponential backoff.
   #
   # @param [Hash] options the retry options
-  # @option options [FixNum] :retries Maximum number of times to retry.
+  # @option options [Integer] :retries Maximum number of times to retry.
   # @option options [Array<Exception>] :retry_exceptions ([StandardError]) Optional array of exceptions that are allowed to be retried.
   # @yield The block to be executed.
   def self.retry_action(options = {})

data/lib/puppet/util/run_mode.rb

@@ -74,6 +74,10 @@ module Puppet
         which_dir("/opt/puppetlabs/puppet/cache", "~/.puppetlabs/opt/puppet/cache")
       end
 
+      def public_dir
+        which_dir("/opt/puppetlabs/puppet/public", "~/.puppetlabs/opt/puppet/public")
+      end
+
       def run_dir
         which_dir("/var/run/puppetlabs", "~/.puppetlabs/var/run")
       end
@@ -96,6 +100,10 @@ module Puppet
         which_dir(File.join(windows_common_base("puppet/cache")), "~/.puppetlabs/opt/puppet/cache")
       end
 
+      def public_dir
+        which_dir(File.join(windows_common_base("puppet/public")), "~/.puppetlabs/opt/puppet/public")
+      end
+
       def run_dir
         which_dir(File.join(windows_common_base("puppet/var/run")), "~/.puppetlabs/var/run")
       end
@@ -107,7 +115,7 @@ module Puppet
     private
 
       def windows_common_base(*extra)
-        [Dir::COMMON_APPDATA, "PuppetLabs"] + extra
+        [ENV['ALLUSERSPROFILE'], "PuppetLabs"] + extra
       end
     end
   end