puppet 5.5.22 → 6.0.0

data/lib/puppet/face/node/clean.rb

@@ -14,6 +14,7 @@ Puppet::Face.define(:node, '0.0.1') do
 
       <Reports> - ($vardir/reports/node.domain)
 
+      NOTE: this action now cleans up certs via Puppet Server's CA API. A running server is required for certs to be cleaned.
     EOT
 
     when_invoked do |*args|
@@ -29,12 +30,6 @@ Puppet::Face.define(:node, '0.0.1') do
       # certificates correctly.
       Puppet.settings.preferred_run_mode = "master"
 
-      if Puppet::SSL::CertificateAuthority.ca?
-        Puppet::SSL::Host.ca_location = :local
-      else
-        Puppet::SSL::Host.ca_location = :none
-      end
-
       Puppet::Node::Facts.indirection.terminus_class = :yaml
       Puppet::Node::Facts.indirection.cache_class = :yaml
       Puppet::Node.indirection.terminus_class = :yaml
@@ -51,12 +46,21 @@ Puppet::Face.define(:node, '0.0.1') do
     clean_reports(node)
   end
 
+  class LoggerIO
+    def err(message)
+      Puppet.err(message) unless message =~ /^\s*Error:\s*/
+    end
+
+    def inform(message)
+      Puppet.notice(message)
+    end
+  end
+
   # clean signed cert for +host+
   def clean_cert(node)
-    if Puppet::SSL::CertificateAuthority.ca?
-      Puppet::Face[:ca, :current].revoke(node)
-      Puppet::Face[:ca, :current].destroy(node)
-      Puppet.info _("%{node} certificates removed from ca") % { node: node }
+    if Puppet.features.puppetserver_ca?
+      require 'puppetserver/ca/action/clean'
+      Puppetserver::Ca::Action::Clean.new(LoggerIO.new).run({ 'certnames' => [node] })
     else
       Puppet.info _("Not managing %{node} certs as this host is not a CA") % { node: node }
     end

data/lib/puppet/face/plugin.rb

@@ -41,15 +41,8 @@ Puppet::Face.define(:plugin, '0.0.1') do
     when_invoked do |options|
       remote_environment_for_plugins = Puppet::Node::Environment.remote(Puppet[:environment])
 
-      pool = Puppet::Network::HTTP::Pool.new(Puppet[:http_keepalive_timeout])
-      Puppet.override(:http_pool => pool) do
-        begin
-          handler = Puppet::Configurer::PluginHandler.new()
-          handler.download_plugins(remote_environment_for_plugins)
-        ensure
-          pool.close
-        end
-      end
+      handler = Puppet::Configurer::PluginHandler.new()
+      handler.download_plugins(remote_environment_for_plugins)
     end
 
     when_rendering :console do |value|

data/lib/puppet/feature/base.rb

@@ -14,28 +14,7 @@ Puppet.features.add(:posix) do
 end
 
 # We can use Microsoft Windows functions
-Puppet.features.add(:microsoft_windows) do
-  begin
-    # ruby
-    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
-    #
-    # Also, this does not modify the value of WIN32OLE.locale - which defaults
-    # 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'
-    true
-  rescue LoadError => err
-    #TRANSLATORS "win32-process", "win32-dir", and "win32-service" are program names and should not be translated
-    warn _("Cannot run on Microsoft Windows without the win32-process, win32-dir and win32-service gems: %{err}") % { err: err } unless Puppet.features.posix?
-  end
-end
+Puppet.features.add(:microsoft_windows) { Puppet::Util::Platform.windows? }
 
 raise Puppet::Error,_("Cannot determine basic system flavour") unless Puppet.features.posix? or Puppet.features.microsoft_windows?
 
@@ -49,14 +28,14 @@ Puppet.features.add(:usage, :libs => %w{rdoc/ri/ri_paths rdoc/usage})
 Puppet.features.add(:libshadow, :libs => ["shadow"])
 
 # We're running as root.
-Puppet.features.add(:root) { require 'puppet/util/suidmanager'; Puppet::Util::SUIDManager.root? }
+Puppet.features.add(:root) do
+  require 'puppet/util/suidmanager'
+  Puppet::Util::SUIDManager.root?
+end
 
 # We have lcs diff
 Puppet.features.add :diff, :libs => %w{diff/lcs diff/lcs/hunk}
 
-# We have augeas
-Puppet.features.add(:augeas, :libs => ["augeas"])
-
 # We have OpenSSL
 Puppet.features.add(:openssl, :libs => ["openssl"])
 
@@ -93,3 +72,5 @@ Puppet.features.add(:manages_symlinks) do
     WindowsSymlink.is_implemented
   end
 end
+
+Puppet.features.add(:puppetserver_ca, libs: ['puppetserver/ca'])

data/lib/puppet/feature/eventlog.rb

@@ -1,5 +1,5 @@
 require 'puppet/util/feature'
 
-if Puppet.features.microsoft_windows?
+if Puppet::Util::Platform.windows?
   Puppet.features.add(:eventlog)
 end

data/lib/puppet/file_bucket/dipper.rb

@@ -77,7 +77,7 @@ class Puppet::FileBucket::Dipper
           tmp_file.unlink
         end
       else
-        raise Puppet::Error, _("Please provide a file or checksum to diff with")
+        raise Puppet::Error, _("Please provide a file or checksum do diff with")
       end
     elsif file_a
       if checksum_b

data/lib/puppet/file_serving/base.rb

@@ -1,12 +1,9 @@
 require 'puppet/file_serving'
 require 'puppet/util'
-require 'puppet/util/methodhelper'
 
 # The base class for Content and Metadata; provides common
 # functionality like the behaviour around links.
 class Puppet::FileServing::Base
-  include Puppet::Util::MethodHelper
-
   # This is for external consumers to store the source that was used
   # to retrieve the metadata.
   attr_accessor :source
@@ -27,7 +24,7 @@ class Puppet::FileServing::Base
       full_path = File.join(path, relative_path)
     end
 
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       # Replace multiple slashes as long as they aren't at the beginning of a filename
       full_path.gsub(%r{(./)/+}, '\1')
     else
@@ -35,10 +32,13 @@ class Puppet::FileServing::Base
     end
   end
 
-  def initialize(path, options = {})
+  def initialize(path, links: nil, relative_path: nil, source: nil)
     self.path = path
     @links = :manage
-    set_options(options)
+
+    self.links = links if links
+    self.relative_path = relative_path if relative_path
+    self.source = source if source
   end
 
   # Determine how we deal with links.
@@ -81,6 +81,6 @@ class Puppet::FileServing::Base
   end
 
   def self.absolute?(path)
-    Puppet::Util.absolute_path?(path, :posix) or (Puppet.features.microsoft_windows? and Puppet::Util.absolute_path?(path, :windows))
+    Puppet::Util.absolute_path?(path, :posix) || (Puppet::Util::Platform.windows? && Puppet::Util.absolute_path?(path, :windows))
   end
 end

data/lib/puppet/file_serving/fileset.rb

@@ -25,7 +25,7 @@ class Puppet::FileServing::Fileset
   end
 
   def initialize(path, options = {})
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       # REMIND: UNC path
       path = path.chomp(File::SEPARATOR) unless path =~ /^[A-Za-z]:\/$/
     else
@@ -122,7 +122,7 @@ class Puppet::FileServing::Fileset
     def children
       return [] unless directory?
 
-      Dir.entries(path, encoding: Encoding::UTF_8).
+      Dir.entries(path).
         reject { |child| ignore?(child) }.
         collect { |child| down_level(child) }
     end

data/lib/puppet/file_serving/http_metadata.rb

@@ -40,7 +40,7 @@ class Puppet::FileServing::HttpMetadata < Puppet::FileServing::Metadata
     [ @checksum_type, :md5, :sha256, :sha384, :sha512, :sha224, :mtime ].each do |type|
       @checksum_type = type
       @checksum = @checksums[type]
-      break if @checksum
+      return if @checksum
     end
   end
 end

data/lib/puppet/file_serving/metadata.rb

@@ -65,7 +65,7 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::Base
   end
 
   class WindowsStat < MetaStat
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       require 'puppet/util/windows/security'
     end
 
@@ -88,7 +88,7 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::Base
   def collect_stat(path)
     stat = stat()
 
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       WindowsStat.new(stat, path, @source_permissions)
     else
       MetaStat.new(stat, @source_permissions)
@@ -136,7 +136,8 @@ class Puppet::FileServing::Metadata < Puppet::FileServing::Base
     @destination = data.delete('destination')
     @source      = data.delete('source')
     @content_uri = data.delete('content_uri')
-    super(path,data)
+
+    super(path, data.map { |k, v| [k.to_sym, v] }.to_h)
   end
 
   def to_data_hash

data/lib/puppet/file_serving/mount/locales.rb

@@ -16,13 +16,14 @@ class Puppet::FileServing::Mount::Locales < Puppet::FileServing::Mount
   def search(relative_path, request)
     # We currently only support one kind of search on locales - return
     # them all.
+    Puppet.debug("Warning: calling Locales.search with empty module path.") if request.environment.modules.empty?
     paths = request.environment.modules.find_all { |mod| mod.locales? }.collect { |mod| mod.locale_directory }
     if paths.empty?
       # If the modulepath is valid then we still need to return a valid root
       # directory for the search, but make sure nothing inside it is
       # returned.
       request.options[:recurse] = false
-      request.environment.modulepath.empty? ? [Puppet[:codedir]] : request.environment.modulepath
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
     else
       paths
     end

data/lib/puppet/file_serving/mount/pluginfacts.rb

@@ -16,13 +16,14 @@ class Puppet::FileServing::Mount::PluginFacts < Puppet::FileServing::Mount
   def search(relative_path, request)
     # We currently only support one kind of search on plugins - return
     # them all.
+    Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
     paths = request.environment.modules.find_all { |mod| mod.pluginfacts? }.collect { |mod| mod.plugin_fact_directory }
     if paths.empty?
       # If the modulepath is valid then we still need to return a valid root
       # directory for the search, but make sure nothing inside it is
       # returned.
       request.options[:recurse] = false
-      request.environment.modulepath.empty? ? [Puppet[:codedir]] : request.environment.modulepath
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
     else
       paths
     end

data/lib/puppet/file_serving/mount/plugins.rb

@@ -16,13 +16,14 @@ class Puppet::FileServing::Mount::Plugins < Puppet::FileServing::Mount
   def search(relative_path, request)
     # We currently only support one kind of search on plugins - return
     # them all.
+    Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
     paths = request.environment.modules.find_all { |mod| mod.plugins? }.collect { |mod| mod.plugin_directory }
     if paths.empty?
       # If the modulepath is valid then we still need to return a valid root
       # directory for the search, but make sure nothing inside it is
       # returned.
       request.options[:recurse] = false
-      request.environment.modulepath.empty? ? [Puppet[:codedir]] : request.environment.modulepath
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
     else
       paths
     end

data/lib/puppet/file_system.rb

@@ -89,6 +89,14 @@ module Puppet::FileSystem
     @impl.path_string(@impl.basename(assert_path(path)))
   end
 
+  # @return [Integer] the size of the file
+  #
+  # @api public
+  #
+  def self.size(path)
+    @impl.size(assert_path(path))
+  end
+
   # Allows exclusive updates to a file to be made by excluding concurrent
   # access using flock. This means that if the file is on a filesystem that
   # does not support flock, this method will provide no protection.

data/lib/puppet/file_system/memory_file.rb

@@ -61,6 +61,6 @@ class Puppet::FileSystem::MemoryFile
   end
 
   def inspect
-    "<Puppet::FileSystem::MemoryFile:#{self}>"
+    "<Puppet::FileSystem::MemoryFile:#{to_s}>"
   end
 end

data/lib/puppet/file_system/posix.rb

@@ -14,12 +14,11 @@ class Puppet::FileSystem::Posix < Puppet::FileSystem::FileImpl
       bsize = stream_blksize(this, stream)
       sa = "".force_encoding('ASCII-8BIT')
       sb = "".force_encoding('ASCII-8BIT')
-      loop do
+      begin
         this.read(bsize, sa)
         stream.read(bsize, sb)
         return true if sa.empty? && sb.empty?
-        break if sa != sb
-      end
+      end while sa == sb
       false
     end
   end

data/lib/puppet/file_system/uniquefile.rb

@@ -174,10 +174,6 @@ class Puppet::FileSystem::Uniquefile < DelegateClass(File)
       lock = tmpname + '.lock'
       mkdir(lock)
       yield
-    rescue Errno::ENOENT => e
-      ex = Errno::ENOENT.new("A directory component in #{lock} does not exist or is a dangling symbolic link")
-      ex.set_backtrace(e.backtrace)
-      raise ex
     ensure
       rmdir(lock) if Puppet::FileSystem.exist?(lock)
     end

data/lib/puppet/forge.rb

@@ -17,15 +17,11 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
 
   USER_AGENT = "PMT/1.1.1 (v3; Net::HTTP)".freeze
 
-  # From https://forgeapi.puppet.com/#!/release/getReleases
-  MODULE_RELEASE_EXCLUSIONS=%w[readme changelog license uri module tags supported file_size downloads created_at updated_at deleted_at].join(',').freeze
-
   attr_reader :host, :repository
 
-  def initialize(host = Puppet[:module_repository], strict_semver = true)
+  def initialize(host = Puppet[:module_repository])
     @host = host
     @repository = Puppet::Forge::Repository.new(host, USER_AGENT)
-    @strict_semver = strict_semver
   end
 
   # Return a list of module metadata hashes that match the search query.
@@ -59,7 +55,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
     matches = []
     uri = "/v3/modules?query=#{term}"
     if Puppet[:module_groups]
-      uri += "&module_groups=#{Puppet[:module_groups].tr('+', ' ')}"
+      uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end
 
     while uri
@@ -93,9 +89,9 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
   # @see SemanticPuppet::Dependency::Source#fetch
   def fetch(input)
     name = input.tr('/', '-')
-    uri = "/v3/releases?module=#{name}&sort_by=version&exclude_fields=#{MODULE_RELEASE_EXCLUSIONS}"
+    uri = "/v3/releases?module=#{name}&sort_by=version"
     if Puppet[:module_groups]
-      uri += "&module_groups=#{Puppet[:module_groups].tr('+', ' ')}"
+      uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end
     releases = []
 
@@ -123,7 +119,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
   class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
     attr_reader :install_dir, :metadata
 
-    def initialize(source, data, strict_semver = true)
+    def initialize(source, data)
       @data = data
       @metadata = meta = data['metadata']
 
@@ -135,7 +131,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
         dependencies = meta['dependencies'].collect do |dep|
           begin
             Puppet::ModuleTool::Metadata.new.add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
-            Puppet::ModuleTool.parse_module_dependency(release, dep, strict_semver)[0..1]
+            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
           rescue ArgumentError => e
             raise ArgumentError, _("Malformed dependency: %{name}.") % { name: dep['name'] } +
                 ' ' + _("Exception was: %{detail}") % { detail: e }
@@ -227,7 +223,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
     l = list.map do |release|
       metadata = release['metadata']
       begin
-        ModuleRelease.new(self, release, @strict_semver)
+        ModuleRelease.new(self, release)
       rescue ArgumentError => e
         Puppet.warning _("Cannot consider release %{name}-%{version}: %{error}") % { name: metadata['name'], version: metadata['version'], error: e }
         false
@@ -240,6 +236,6 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
   def decode_uri(uri)
     return if uri.nil?
 
-    URI.decode(uri.tr('+', ' '))
+    URI.decode(uri.gsub('+', ' '))
   end
 end

data/lib/puppet/functions.rb

@@ -385,6 +385,7 @@ module Puppet::Functions
     end
   end
 
+
   # Public api methods of the DispatcherBuilder are available within dispatch()
   # blocks declared in a Puppet::Function.create_function() call.
   #
@@ -679,6 +680,128 @@ module Puppet::Functions
     end
   end
 
+  class Function3x < InternalFunction
+
+    # Table of optimized parameter names - 0 to 5 parameters
+    PARAM_NAMES = [
+      [],
+      ['p0'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze, 'p3'.freeze].freeze,
+      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze, 'p3'.freeze, 'p4'.freeze].freeze,
+    ]
+
+    # Creates an anonymous Function3x class that wraps a 3x function
+    #
+    # @api private
+    def self.create_function(func_name, func_info, loader)
+      func_name = func_name.to_s
+
+      # Creates an anonymous class to represent the function
+      # The idea being that it is garbage collected when there are no more
+      # references to it.
+      #
+      # (Do not give the class the block here, as instance variables should be set first)
+      the_class = Class.new(Function3x)
+
+      unless loader.nil?
+        the_class.instance_variable_set(:'@loader', loader.private_loader)
+      end
+
+      the_class.instance_variable_set(:'@func_name', func_name)
+      the_class.instance_variable_set(:'@method3x', :"function_#{func_name}")
+
+      # Make the anonymous class appear to have the class-name <func_name>
+      # Even if this class is not bound to such a symbol in a global ruby scope and
+      # must be resolved via the loader.
+      # This also overrides any attempt to define a name method in the given block
+      # (Since it redefines it)
+      #
+      the_class.instance_eval do
+        def name
+          @func_name
+        end
+
+        def loader
+          @loader
+        end
+
+        def method3x
+          @method3x
+        end
+      end
+
+      # Add the method that is called - it simply delegates to
+      # the 3.x function by calling it via the calling scope using the @method3x symbol
+      # :"function_#{name}".
+      #
+      # When function is not an rvalue function, make sure it produces nil
+      #
+      the_class.class_eval do
+
+        # Bypasses making the  call via the dispatcher to make sure errors
+        # are reported exactly the same way as in 3x. The dispatcher is still needed as it is
+        # used to support other features than calling.
+        #
+        def call(scope, *args, &block)
+          begin
+            result = catch(:return) do
+              mapped_args = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, scope, '')
+              # this is the scope.function_xxx(...) call
+              return scope.send(self.class.method3x, mapped_args)
+            end
+            return result.value
+          rescue Puppet::Pops::Evaluator::Next => jumper
+            begin
+              throw :next, jumper.value
+            rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
+              raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
+            end
+          rescue Puppet::Pops::Evaluator::Return => jumper
+            begin
+              throw :return, jumper
+            rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
+              raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
+            end
+          end
+        end
+      end
+
+      # Create a dispatcher based on func_info
+      type, names = Puppet::Functions.any_signature(*from_to_names(func_info))
+      last_captures_rest = (type.size_range[1] == Float::INFINITY)
+
+      # The method '3x_function' here is a dummy as the dispatcher is not used for calling, only for information.
+      the_class.dispatcher.add(Puppet::Pops::Functions::Dispatch.new(type, '3x_function', names, last_captures_rest))
+      # The function class is returned as the result of the create function method
+      the_class
+    end
+
+    # Compute min and max number of arguments and a list of constructed
+    # parameter names p0 - pn (since there are no parameter names in 3x functions).
+    #
+    # @api private
+    def self.from_to_names(func_info)
+      arity = func_info[:arity]
+      if arity.nil?
+        arity = -1
+      end
+      if arity < 0
+        from = -arity - 1 # arity -1 is 0 min param, -2 is min 1 param
+        to = :default     # infinite range
+        count = -arity    # the number of named parameters
+      else
+        count = from = to = arity
+      end
+      # Names of parameters, up to 5 are optimized and use frozen version
+      # Note that (0..count-1) produces expected empty array for count == 0, 0-n for count >= 1
+      names = count <= 5 ? PARAM_NAMES[count] : (0..count-1).map {|n| "p#{n}" }
+      [from, to, names]
+    end
+  end
+
+
   # Injection and Weaving of parameters
   # ---
   # It is possible to inject and weave a set of well known parameters into a call.
@@ -714,6 +837,21 @@ module Puppet::Functions
       inject(:pal_script_compiler)
     end
 
+    # Inject a parameter getting a cached hash for this function
+    def cache_param
+      inject(:cache)
+    end
+
+    # Inject parameter for `Puppet::Pal::CatalogCompiler`
+    def compiler_param
+      inject(:pal_catalog_compiler)
+    end
+
+    # Inject parameter for either `Puppet::Pal::CatalogCompiler` or `Puppet::Pal::ScriptCompiler`
+    def pal_compiler_param
+      inject(:pal_compiler)
+    end
+
     private
 
     def inject(injection_name)