puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/util/at_fork/noop.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A noop implementation of the Puppet::Util::AtFork handler
 class Puppet::Util::AtFork::Noop
   class << self

data/lib/puppet/util/at_fork/solaris.rb

@@ -1,4 +1,6 @@
-require 'puppet'
+# frozen_string_literal: true
+
+require_relative '../../../puppet'
 require 'fiddle'
 
 # Early versions of Fiddle relied on the deprecated DL module and used
@@ -21,7 +23,7 @@ class Puppet::Util::AtFork::Solaris
 
   {
     'libcontract.so.1' => [
-      #function name,            return value type, parameter types, ...
+      # function name,            return value type, parameter types, ...
       [:ct_ctl_abandon,          Fiddle::TYPE_INT,  Fiddle::TYPE_INT],
       [:ct_tmpl_activate,        Fiddle::TYPE_INT,  Fiddle::TYPE_INT],
       [:ct_tmpl_clear,           Fiddle::TYPE_INT,  Fiddle::TYPE_INT],
@@ -34,19 +36,19 @@ class Puppet::Util::AtFork::Solaris
       [:ct_status_read,          Fiddle::TYPE_INT,  Fiddle::TYPE_INT, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
 
       [:ct_status_get_id,        Fiddle::TYPE_INT,  Fiddle::TYPE_VOIDP],
-      [:ct_status_free,          Fiddle::TYPE_VOID, Fiddle::TYPE_VOIDP],
+      [:ct_status_free,          Fiddle::TYPE_VOID, Fiddle::TYPE_VOIDP]
     ],
   }.each do |library, functions|
     libhandle = Fiddle::Handle.new(library)
 
     functions.each do |f|
-      define_method f[0], Fiddle::Function.new(libhandle[f[0].to_s], f[2..-1], f[1]).method(:call).to_proc
+      define_method f[0], Fiddle::Function.new(libhandle[f[0].to_s], f[2..], f[1]).method(:call).to_proc
     end
   end
 
-  CTFS_PR_ROOT = File.join('', %w(system contract process))
-  CTFS_PR_TEMPLATE = File.join(CTFS_PR_ROOT, %q(template))
-  CTFS_PR_LATEST = File.join(CTFS_PR_ROOT, %q(latest))
+  CTFS_PR_ROOT = File.join('', %w[system contract process])
+  CTFS_PR_TEMPLATE = File.join(CTFS_PR_ROOT, 'template')
+  CTFS_PR_LATEST = File.join(CTFS_PR_ROOT, 'latest')
 
   CT_PR_PGRPONLY = 0x4
   CT_PR_EV_HWERR = 0x20
@@ -61,27 +63,25 @@ class Puppet::Util::AtFork::Solaris
   end
 
   def activate_new_contract_template
-    begin
-      tmpl = File.open(CTFS_PR_TEMPLATE, File::RDWR)
+    tmpl = File.new(CTFS_PR_TEMPLATE, File::RDWR)
 
-      begin
-        tmpl_fd = tmpl.fileno
+    begin
+      tmpl_fd = tmpl.fileno
 
-        raise_if_error { ct_pr_tmpl_set_param(tmpl_fd, CT_PR_PGRPONLY) }
-        raise_if_error { ct_pr_tmpl_set_fatal(tmpl_fd, CT_PR_EV_HWERR) }
-        raise_if_error { ct_tmpl_set_critical(tmpl_fd, 0) }
-        raise_if_error { ct_tmpl_set_informative(tmpl_fd, CT_PR_EV_HWERR) }
+      raise_if_error { ct_pr_tmpl_set_param(tmpl_fd, CT_PR_PGRPONLY) }
+      raise_if_error { ct_pr_tmpl_set_fatal(tmpl_fd, CT_PR_EV_HWERR) }
+      raise_if_error { ct_tmpl_set_critical(tmpl_fd, 0) }
+      raise_if_error { ct_tmpl_set_informative(tmpl_fd, CT_PR_EV_HWERR) }
 
-        raise_if_error { ct_tmpl_activate(tmpl_fd) }
-      rescue
-        tmpl.close
-        raise
-      end
-
-      @tmpl = tmpl
-    rescue => detail
-      Puppet.log_exception(detail, _('Failed to activate a new process contract template'))
+      raise_if_error { ct_tmpl_activate(tmpl_fd) }
+    rescue
+      tmpl.close
+      raise
     end
+
+    @tmpl = tmpl
+  rescue => detail
+    Puppet.log_exception(detail, _('Failed to activate a new process contract template'))
   end
 
   def deactivate_contract_template(parent)
@@ -106,24 +106,22 @@ class Puppet::Util::AtFork::Solaris
   end
 
   def get_latest_child_contract_id
-    begin
-      stat = File.open(CTFS_PR_LATEST, File::RDONLY)
-
-      begin
-        stathdl = Fiddle::Pointer.new(0)
+    stat = File.new(CTFS_PR_LATEST, File::RDONLY)
 
-        raise_if_error { ct_status_read(stat.fileno, CTD_COMMON, stathdl.ref) }
-        ctid = ct_status_get_id(stathdl)
-        ct_status_free(stathdl)
-      ensure
-        stat.close
-      end
+    begin
+      stathdl = Fiddle::Pointer.new(0)
 
-      ctid
-    rescue => detail
-      Puppet.log_exception(detail, _('Failed to get latest child process contract id'))
-      nil
+      raise_if_error { ct_status_read(stat.fileno, CTD_COMMON, stathdl.ref) }
+      ctid = ct_status_get_id(stathdl)
+      ct_status_free(stathdl)
+    ensure
+      stat.close
     end
+
+    ctid
+  rescue => detail
+    Puppet.log_exception(detail, _('Failed to get latest child process contract id'))
+    nil
   end
 
   def abandon_latest_child_contract
@@ -131,7 +129,7 @@ class Puppet::Util::AtFork::Solaris
     return if ctid.nil?
 
     begin
-      ctl = File.open(File.join(CTFS_PR_ROOT, ctid.to_s, %q(ctl)), File::WRONLY)
+      ctl = File.new(File.join(CTFS_PR_ROOT, ctid.to_s, 'ctl'), File::WRONLY)
 
       begin
         raise_if_error { ct_ctl_abandon(ctl.fileno) }

data/lib/puppet/util/at_fork.rb

@@ -1,4 +1,6 @@
-require 'puppet'
+# frozen_string_literal: true
+
+require_relative '../../puppet'
 
 # A module for building AtFork handlers. These handlers are objects providing
 # pre/post fork callbacks modeled after those registered by the `pthread_atfork`
@@ -12,10 +14,10 @@ require 'puppet'
 #   killed in the process as a consequence of running in the same contract as the
 #   service.
 module Puppet::Util::AtFork
-  @handler_class = loop do
-    if Facter.value(:operatingsystem) == 'Solaris'
+  @handler_class = loop do # rubocop:disable Lint/UnreachableLoop
+    if Puppet::Util::Platform.solaris?
       begin
-        require 'puppet/util/at_fork/solaris'
+        require_relative 'at_fork/solaris'
         # using break to return a value from the loop block
         break Puppet::Util::AtFork::Solaris
       rescue LoadError => detail
@@ -24,7 +26,7 @@ module Puppet::Util::AtFork
       end
     end
 
-    require 'puppet/util/at_fork/noop'
+    require_relative 'at_fork/noop'
     # using break to return a value from the loop block
     break Puppet::Util::AtFork::Noop
   end

data/lib/puppet/util/autoload.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'pathname'
-require 'puppet/util/rubygems'
-require 'puppet/util/warnings'
-require 'puppet/pops/adaptable'
+require_relative '../../puppet/util/rubygems'
+require_relative '../../puppet/util/warnings'
+require_relative '../../puppet/pops/adaptable'
+require_relative '../../puppet/concurrent/synchronized'
 
 # An adapter that ties the module_directories cache to the environment where the modules are parsed. This
 # adapter ensures that the life-cycle of this cache doesn't exceed  the life-cycle of the environment.
@@ -9,10 +12,21 @@ require 'puppet/pops/adaptable'
 # @api private
 class Puppet::Util::ModuleDirectoriesAdapter < Puppet::Pops::Adaptable::Adapter
   attr_accessor :directories
+
+  def self.create_adapter(env)
+    adapter = super(env)
+    adapter.directories = env.modulepath.flat_map do |dir|
+      Dir.glob(File.join(dir, '*', 'lib'))
+    end
+    adapter
+  end
 end
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
+  include Puppet::Concurrent::Synchronized
+  extend Puppet::Concurrent::Synchronized
+
   @loaded = {}
 
   class << self
@@ -47,8 +61,10 @@ class Puppet::Util::Autoload
     def changed?(name, env)
       name = cleanpath(name).chomp('.rb')
       return true unless loaded.include?(name)
+
       file, old_mtime = loaded[name]
       return true unless file == get_file(name, env)
+
       begin
         old_mtime.to_i != File.mtime(file).to_i
       rescue Errno::ENOENT
@@ -61,11 +77,12 @@ class Puppet::Util::Autoload
     def load_file(name, env)
       file = get_file(name.to_s, env)
       return false unless file
+
       begin
         mark_loaded(name, file)
         Kernel.load file
-        return true
-      rescue SystemExit,NoMemoryError
+        true
+      rescue SystemExit, NoMemoryError
         raise
       rescue Exception => detail
         message = _("Could not autoload %{name}: %{detail}") % { name: name, detail: detail }
@@ -94,18 +111,18 @@ class Puppet::Util::Autoload
     # returns nil if no file is found
     # @api private
     def get_file(name, env)
-      name = name + '.rb' unless name =~ /\.rb$/
+      name += '.rb' unless name =~ /\.rb$/
       path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
       path and File.join(path, name)
     end
 
     def files_to_load(path, env)
-      search_directories(env).map {|dir| files_in_dir(dir, path) }.flatten.uniq
+      search_directories(env).map { |dir| files_in_dir(dir, path) }.flatten.uniq
     end
 
     # @api private
     def files_in_dir(dir, path)
-      dir = Pathname.new(File.expand_path(dir))
+      dir = Pathname.new(Puppet::FileSystem.expand_path(dir))
       Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
         Pathname.new(file).relative_path_from(dir).to_s
       end
@@ -115,26 +132,7 @@ class Puppet::Util::Autoload
     def module_directories(env)
       raise ArgumentError, "Autoloader requires an environment" unless env
 
-      Puppet::Util::ModuleDirectoriesAdapter.adapt(env) do |a|
-        a.directories ||= env.modulepath.collect do |dir|
-          Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
-        end.flatten.find_all do |d|
-          FileTest.directory?(d)
-        end
-      end.directories
-    end
-
-    # @api private
-    def vendored_modules
-      dir = Puppet[:vendormoduledir]
-      if dir && File.directory?(dir)
-        Dir.entries(dir)
-          .reject { |f| f =~ /^\./ }
-          .collect { |f| File.join(dir, f, "lib") }
-          .find_all { |d| FileTest.directory?(d) }
-      else
-        []
-      end
+      Puppet::Util::ModuleDirectoriesAdapter.adapt(env).directories
     end
 
     # @api private
@@ -164,11 +162,6 @@ class Puppet::Util::Autoload
       # "app_defaults_initialized?" method on the main puppet Settings object.
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
-        unless @initialized
-          $LOAD_PATH.unshift(Puppet[:libdir])
-          $LOAD_PATH.concat(vendored_modules)
-          @initialized = true
-        end
         gem_directories + module_directories(env) + $LOAD_PATH
       else
         gem_directories + $LOAD_PATH
@@ -178,14 +171,7 @@ 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)
-      # 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
+      Pathname.new(path).cleanpath.to_s
     end
   end
 
@@ -194,6 +180,7 @@ class Puppet::Util::Autoload
   def initialize(obj, path)
     @path = path.to_s
     raise ArgumentError, _("Autoload paths cannot be fully qualified") if Puppet::Util.absolute_path?(@path)
+
     @object = obj
   end
 

data/lib/puppet/util/backups.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'find'
 require 'fileutils'
 module Puppet::Util::Backups
-
   # Deal with backups.
   def perform_backup(file = nil)
     # if they specifically don't want a backup, then just say
@@ -12,27 +13,28 @@ module Puppet::Util::Backups
     file ||= self[:path]
     return true unless Puppet::FileSystem.exist?(file)
 
-    return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
+    (bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
   end
 
   private
 
   def perform_backup_with_bucket(fileobj)
-    file = (fileobj.class == String) ? fileobj : fileobj.name
+    file = fileobj.instance_of?(String) ? fileobj : fileobj.name
     case Puppet::FileSystem.lstat(file).ftype
     when "directory"
       # we don't need to backup directories when recurse is on
       return true if self[:recurse]
+
       info _("Recursively backing up to filebucket")
       Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
     when "file"; backup_file_with_filebucket(file)
-    when "link";
+    when "link"; # do nothing
     end
     true
   end
 
   def perform_backup_with_backuplocal(fileobj, backup)
-    file = (fileobj.class == String) ? fileobj : fileobj.name
+    file = fileobj.instance_of?(String) ? fileobj : fileobj.name
     newfile = file + backup
 
     remove_backup(newfile)
@@ -42,7 +44,7 @@ module Puppet::Util::Backups
 
       # N.B. cp_r works on both files and directories
       FileUtils.cp_r(file, bfile, :preserve => true)
-      return true
+      true
     rescue => detail
       # since they said they want a backup, let's error out
       # if we couldn't make one
@@ -51,7 +53,7 @@ module Puppet::Util::Backups
   end
 
   def remove_backup(newfile)
-    if self.class.name == :file and self[:links] != :follow
+    if instance_of?(Puppet::Type::File) and self[:links] != :follow
       method = :lstat
     else
       method = :stat
@@ -73,14 +75,14 @@ module Puppet::Util::Backups
       Puppet::FileSystem.unlink(newfile)
     rescue => detail
       message = _("Could not remove old backup: %{detail}") % { detail: detail }
-      self.log_exception(detail, message)
+      log_exception(detail, message)
       self.fail Puppet::Error, message, detail
     end
   end
 
   def backup_file_with_filebucket(f)
-    sum = self.bucket.backup(f)
-    self.info _("Filebucketed %{f} to %{filebucket} with sum %{sum}") % { f: f, filebucket: self.bucket.name, sum: sum }
-    return sum
+    sum = bucket.backup(f)
+    info _("Filebucketed %{f} to %{filebucket} with sum %{sum}") % { f: f, filebucket: bucket.name, sum: sum }
+    sum
   end
 end

data/lib/puppet/util/character_encoding.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # A module to centralize heuristics/practices for managing character encoding in Puppet
 
 module Puppet::Util::CharacterEncoding
@@ -18,12 +20,13 @@ module Puppet::Util::CharacterEncoding
       string_copy = string.dup
       begin
         if original_encoding == Encoding::UTF_8
-          if !string_copy.valid_encoding?
-            Puppet.debug(_("%{value} is already labeled as UTF-8 but this encoding is invalid. It cannot be transcoded by Puppet.") %
-              { value: string.dump })
+          unless string_copy.valid_encoding?
+            Puppet.debug {
+              _("%{value} is already labeled as UTF-8 but this encoding is invalid. It cannot be transcoded by Puppet.") % { value: string.dump }
+            }
           end
           # String is already valid UTF-8 - noop
-          return string_copy
+          string_copy
         else
           # If the string comes to us as BINARY encoded, we don't know what it
           # started as. However, to encode! we need a starting place, and our
@@ -31,7 +34,7 @@ module Puppet::Util::CharacterEncoding
           # So set external_encoding to default_external before we try to
           # transcode to UTF-8.
           string_copy.force_encoding(Encoding.default_external) if original_encoding == Encoding::BINARY
-          return string_copy.encode(Encoding::UTF_8)
+          string_copy.encode(Encoding::UTF_8)
         end
       rescue EncodingError => detail
         # Set the encoding on our copy back to its original if we modified it
@@ -40,9 +43,10 @@ module Puppet::Util::CharacterEncoding
         # Catch both our own self-determined failure to transcode as well as any
         # error on ruby's part, ie Encoding::UndefinedConversionError on a
         # failure to encode!.
-        Puppet.debug(_("%{error}: %{value} cannot be transcoded by Puppet.") %
-          { error: detail.inspect, value: string.dump })
-        return string_copy
+        Puppet.debug {
+          _("%{error}: %{value} cannot be transcoded by Puppet.") % { error: detail.inspect, value: string.dump }
+        }
+        string_copy
       end
     end
 
@@ -64,12 +68,15 @@ module Puppet::Util::CharacterEncoding
       string_copy = string.dup
       original_encoding = string_copy.encoding
       return string_copy if original_encoding == Encoding::UTF_8
+
       if string_copy.force_encoding(Encoding::UTF_8).valid_encoding?
-        return string_copy
+        string_copy
       else
-        Puppet.debug(_("%{value} is not valid UTF-8 and result of overriding encoding would be invalid.") % { value: string.dump })
+        Puppet.debug {
+          _("%{value} is not valid UTF-8 and result of overriding encoding would be invalid.") % { value: string.dump }
+        }
         # Set copy back to its original encoding before returning
-        return string_copy.force_encoding(original_encoding)
+        string_copy.force_encoding(original_encoding)
       end
     end
   end

data/lib/puppet/util/checksums.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 require 'digest/sha1'
 require 'time'
@@ -7,11 +9,26 @@ require 'time'
 module Puppet::Util::Checksums
   module_function
 
+  KNOWN_CHECKSUMS = [
+    :sha256, :sha256lite,
+    :md5, :md5lite,
+    :sha1, :sha1lite,
+    :sha512,
+    :sha384,
+    :sha224,
+    :mtime, :ctime, :none
+  ].freeze
+
   # It's not a good idea to use some of these in some contexts: for example, I
   # wouldn't try bucketing a file using the :none checksum type.
   def known_checksum_types
-    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, 
-      :mtime, :ctime, :none]
+    KNOWN_CHECKSUMS
+  end
+
+  def valid_checksum?(type, value)
+    !!send("#{type}?", value)
+  rescue NoMethodError
+    false
   end
 
   class FakeChecksum
@@ -28,12 +45,12 @@ module Puppet::Util::Checksums
 
   # Strip the checksum type from an existing checksum
   def sumdata(checksum)
-    checksum =~ /^\{(\w+)\}(.+)/ ? $2 : nil
+    checksum =~ /^\{(\w+)\}(.+)/ ? ::Regexp.last_match(2) : nil
   end
 
   # Strip the checksum type from an existing checksum
   def sumtype(checksum)
-    checksum =~ /^\{(\w+)\}/ ? $1 : nil
+    checksum =~ /^\{(\w+)\}/ ? ::Regexp.last_match(1) : nil
   end
 
   # Calculate a checksum using Digest::SHA256.
@@ -50,7 +67,7 @@ module Puppet::Util::Checksums
     require 'digest/sha2'
 
     digest = Digest::SHA256.new
-    checksum_file(digest, filename,  lite)
+    checksum_file(digest, filename, lite)
   end
 
   def sha256_stream(lite = false, &block)
@@ -97,7 +114,7 @@ module Puppet::Util::Checksums
     require 'digest/sha2'
 
     digest = Digest::SHA384.new
-    checksum_file(digest, filename,  lite)
+    checksum_file(digest, filename, lite)
   end
 
   def sha384_stream(lite = false, &block)
@@ -124,7 +141,7 @@ module Puppet::Util::Checksums
     require 'digest/sha2'
 
     digest = Digest::SHA512.new
-    checksum_file(digest, filename,  lite)
+    checksum_file(digest, filename, lite)
   end
 
   def sha512_stream(lite = false, &block)
@@ -139,8 +156,8 @@ module Puppet::Util::Checksums
 
   # Calculate a checksum using Digest::SHA224.
   def sha224(content)
-    require 'openssl'
-    OpenSSL::Digest::SHA224.new.hexdigest(content)
+    require_relative '../../puppet/ssl/openssl_loader'
+    OpenSSL::Digest.new('SHA224').hexdigest(content)
   end
 
   def sha224?(string)
@@ -148,15 +165,15 @@ module Puppet::Util::Checksums
   end
 
   def sha224_file(filename, lite = false)
-    require 'openssl'
+    require_relative '../../puppet/ssl/openssl_loader'
 
-    digest = OpenSSL::Digest::SHA224.new
-    checksum_file(digest, filename,  lite)
+    digest = OpenSSL::Digest.new('SHA224')
+    checksum_file(digest, filename, lite)
   end
 
   def sha224_stream(lite = false, &block)
-    require 'openssl'
-    digest = OpenSSL::Digest::SHA224.new
+    require_relative '../../puppet/ssl/openssl_loader'
+    digest = OpenSSL::Digest.new('SHA224')
     checksum_stream(digest, block, lite)
   end
 
@@ -176,7 +193,7 @@ module Puppet::Util::Checksums
   # Calculate a checksum of a file's content using Digest::MD5.
   def md5_file(filename, lite = false)
     digest = Digest::MD5.new
-    checksum_file(digest, filename,  lite)
+    checksum_file(digest, filename, lite)
   end
 
   def md5_stream(lite = false, &block)
@@ -216,6 +233,7 @@ module Puppet::Util::Checksums
 
   def mtime?(string)
     return true if string.is_a? Time
+
     !!DateTime.parse(string)
   rescue
     false
@@ -223,7 +241,7 @@ module Puppet::Util::Checksums
 
   # Return the :mtime timestamp of a file.
   def mtime_file(filename)
-    Puppet::FileSystem.stat(filename).send(:mtime)
+    Puppet::FileSystem.stat(filename).mtime
   end
 
   # by definition this doesn't exist
@@ -286,6 +304,7 @@ module Puppet::Util::Checksums
 
   def ctime?(string)
     return true if string.is_a? Time
+
     !!DateTime.parse(string)
   rescue
     false
@@ -293,7 +312,7 @@ module Puppet::Util::Checksums
 
   # Return the :ctime of a file.
   def ctime_file(filename)
-    Puppet::FileSystem.stat(filename).send(:ctime)
+    Puppet::FileSystem.stat(filename).ctime
   end
 
   def ctime_stream(&block)
@@ -344,7 +363,7 @@ module Puppet::Util::Checksums
   def checksum_file(digest, filename, lite = false)
     buffer = lite ? 512 : 4096
     File.open(filename, 'rb') do |file|
-      while content = file.read(buffer)
+      while content = file.read(buffer) # rubocop:disable Lint/AssignmentInCondition
         digest << content
         break if lite
       end
@@ -357,5 +376,4 @@ module Puppet::Util::Checksums
     block.call(DigestLite.new(digest, lite))
     digest.hexdigest
   end
-
 end