puppet 6.17.0-x86-mingw32 → 7.1.0-x86-mingw32

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/monkey_patches.rb

@@ -102,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/posix.rb

@@ -12,9 +12,16 @@ module Puppet::Util::POSIX
   class << self
     # Returns an array of all the groups that the user's a member of.
     def groups_of(user)
-      groups = []
-      Puppet::Etc.group do |group|
-        groups << group.name if group.mem.include?(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
       end
   
       uniq_groups = groups.uniq
@@ -24,6 +31,39 @@ 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
@@ -144,8 +184,17 @@ module Puppet::Util::POSIX
       name = get_posix_field(location, :name, id)
       check_value = name
     end
+
     if check_value != field
-      return search_posix_field(location, id_field, 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
     else
       return id
     end

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/rubygems.rb

@@ -41,7 +41,11 @@ module Puppet::Util::RubyGems
     def directories
       # `require 'mygem'` will consider and potentially load
       # prerelease gems, so we need to match that behavior.
-      Gem::Specification.latest_specs(true).collect do |spec|
+      #
+      # Just load the stub which points to the gem path, and
+      # delay loading the full specification until if/when the
+      # gem is required.
+      Gem::Specification.stubs.collect do |spec|
         File.join(spec.full_gem_path, 'lib')
       end
     end

data/lib/puppet/util/run_mode.rb

@@ -18,8 +18,12 @@ module Puppet
         end
       end
 
+      def server?
+        name == :master || name == :server
+      end
+
       def master?
-        name == :master
+        name == :master || name == :server
       end
 
       def agent?
@@ -70,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
@@ -92,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
@@ -103,7 +115,7 @@ module Puppet
     private
 
       def windows_common_base(*extra)
-        [Dir::COMMON_APPDATA, "PuppetLabs"] + extra
+        [ENV['ALLUSERSPROFILE'], "PuppetLabs"] + extra
       end
     end
   end

data/lib/puppet/util/windows.rb

@@ -1,4 +1,5 @@
 require 'puppet/util/platform'
+
 module Puppet::Util::Windows
   module ADSI
     class ADSIObject; end
@@ -15,8 +16,6 @@ module Puppet::Util::Windows
   class EventLog; end
 
   if Puppet::Util::Platform.windows?
-    require 'Win32API' # case matters in this require!
-
     # Note: Setting codepage here globally ensures all strings returned via
     # WIN32OLE (Ruby's late-bound COM support) are encoded in Encoding::UTF_8
     #
@@ -24,13 +23,9 @@ module Puppet::Util::Windows
     # to 2048 (at least on US English Windows) and is not listed in the MS
     # locales table, here: https://msdn.microsoft.com/en-us/library/ms912047(v=winembedded.10).aspx
     require 'win32ole' ; WIN32OLE.codepage = WIN32OLE::CP_UTF8
-    # gems
-    require 'win32/process'
-    require 'win32/dir'
-    require 'win32/service'
 
     # these reference platform specific gems
-    require 'puppet/util/windows/api_types'
+    require 'puppet/ffi/windows'
     require 'puppet/util/windows/string'
     require 'puppet/util/windows/error'
     require 'puppet/util/windows/com'
@@ -48,5 +43,6 @@ module Puppet::Util::Windows
     require 'puppet/util/windows/registry'
     require 'puppet/util/windows/eventlog'
     require 'puppet/util/windows/service'
+    require 'puppet/util/windows/monkey_patches/process'
   end
 end