puppet 6.17.0-x86-mingw32 → 6.21.0-x86-mingw32

data/lib/puppet/environments.rb

@@ -159,8 +159,8 @@ module Puppet::Environments
   # Reads environments from a directory on disk. Each environment is
   # represented as a sub-directory. The environment's manifest setting is the
   # `manifest` directory of the environment directory. The environment's
-  # modulepath setting is the global modulepath (from the `[master]` section
-  # for the master) prepended with the `modules` directory of the environment
+  # modulepath setting is the global modulepath (from the `[server]` section
+  # for the server) prepended with the `modules` directory of the environment
   # directory.
   #
   # @api private
@@ -277,7 +277,7 @@ module Puppet::Environments
     def get(name)
       @loaders.each do |loader|
         env = loader.get(name)
-        if env 
+        if env
           return env
         end
       end
@@ -305,13 +305,23 @@ module Puppet::Environments
     include Puppet::Concurrent::Synchronized
 
     class DefaultCacheExpirationService
+      # Called when the environment is created.
+      #
+      # @param [Puppet::Node::Environment] env
       def created(env)
       end
 
+      # Is the environment with this name expired?
+      #
+      # @param [Symbol] env_name The symbolic environment name
+      # @return [Boolean]
       def expired?(env_name)
         false
       end
 
+      # The environment with this name was evicted.
+      #
+      # @param [Symbol] env_name The symbolic environment name
       def evicted(env_name)
       end
     end
@@ -336,12 +346,6 @@ module Puppet::Environments
       @loader = loader
       @cache_expiration_service = Puppet::Environments::Cached.cache_expiration_service
       @cache = {}
-
-      # Holds expiration times in sorted order - next to expire is first
-      @expirations = SortedSet.new
-
-      # Infinity since it there are no entries, this is a cache of the first to expire time
-      @next_expiration = END_OF_TIME
     end
 
     # @!macro loader_list
@@ -362,12 +366,13 @@ module Puppet::Environments
       clear_all_expired
       result = @cache[name]
       if result
+        Puppet.debug {"Found in cache '#{name}' #{result.label}"}
         # found in cache
+        result.touch
         return result.value
       elsif (result = @loader.get(name))
         # environment loaded, cache it
         cache_entry = entry(result)
-        @cache_expiration_service.created(result)
         add_entry(name, cache_entry)
         result
       end
@@ -377,28 +382,36 @@ module Puppet::Environments
     def add_entry(name, cache_entry)
       Puppet.debug {"Caching environment '#{name}' #{cache_entry.label}"}
       @cache[name] = cache_entry
-      expires = cache_entry.expires
-      @expirations.add(expires)
-      if @next_expiration > expires
-        @next_expiration = expires
-      end
+      @cache_expiration_service.created(cache_entry.value)
     end
     private :add_entry
 
+    def clear_entry(name, entry)
+      @cache.delete(name)
+      Puppet.debug {"Evicting cache entry for environment '#{name}'"}
+      @cache_expiration_service.evicted(name.to_sym)
+      Puppet::GettextConfig.delete_text_domain(name)
+      Puppet.settings.clear_environment_settings(name)
+    end
+    private :clear_entry
+
     # Clears the cache of the environment with the given name.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear(name)
-      @cache.delete(name)
-      Puppet::GettextConfig.delete_text_domain(name)
+      entry = @cache[name]
+      clear_entry(name, entry) if entry
     end
 
     # Clears all cached environments.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
-    def clear_all()
+    def clear_all
       super
+
+      @cache.each_pair do |name, entry|
+        clear_entry(name, entry)
+      end
+
       @cache = {}
-      @expirations.clear
-      @next_expiration = END_OF_TIME
       Puppet::GettextConfig.delete_environment_text_domains
     end
 
@@ -407,17 +420,23 @@ module Puppet::Environments
     #
     def clear_all_expired()
       t = Time.now
-      return if t < @next_expiration && ! @cache.any? {|name, _| @cache_expiration_service.expired?(name.to_sym) }
-      to_expire = @cache.select { |name, entry| entry.expires < t || @cache_expiration_service.expired?(name.to_sym) }
-      to_expire.each do |name, entry|
-        Puppet.debug {"Evicting cache entry for environment '#{name}'"}
-        @cache_expiration_service.evicted(name)
-        clear(name)
-        @expirations.delete(entry.expires)
-        Puppet.settings.clear_environment_settings(name)
+
+      @cache.each_pair do |name, entry|
+        clear_if_expired(name, entry, t)
+      end
+    end
+
+    # Clear an environment if it is expired, either by exceeding its time to live, or
+    # through an explicit eviction determined by the cache expiration service.
+    #
+    def clear_if_expired(name, entry, t = Time.now)
+      return unless entry
+
+      if entry.expired?(t) || @cache_expiration_service.expired?(name.to_sym)
+        clear_entry(name, entry)
       end
-      @next_expiration = @expirations.first || END_OF_TIME
     end
+    private :clear_if_expired
 
     # This implementation evicts the cache, and always gets the current
     # configuration of the environment
@@ -428,32 +447,30 @@ module Puppet::Environments
     #
     # @!macro loader_get_conf
     def get_conf(name)
-      evict_if_expired(name)
+      clear_if_expired(name, @cache[name])
       @loader.get_conf(name)
     end
 
     # Creates a suitable cache entry given the time to live for one environment
     #
     def entry(env)
-      ttl = (conf = get_conf(env.name)) ? conf.environment_timeout : Puppet.settings.value(:environment_timeout)
+      ttl = if (conf = get_conf(env.name))
+              conf.environment_timeout
+            else
+              Puppet[:environment_timeout]
+            end
+
       case ttl
       when 0
         NotCachedEntry.new(env)     # Entry that is always expired (avoids syscall to get time)
       when Float::INFINITY
         Entry.new(env)              # Entry that never expires (avoids syscall to get time)
       else
-        TTLEntry.new(env, ttl)
-      end
-    end
-
-    # Evicts the entry if it has expired
-    # Also clears caches in Settings that may prevent the entry from being updated
-    def evict_if_expired(name)
-      if (result = @cache[name]) && (result.expired? || @cache_expiration_service.expired?(name))
-        Puppet.debug {"Evicting cache entry for environment '#{name}'"}
-        @cache_expiration_service.evicted(name)
-        clear(name)
-        Puppet.settings.clear_environment_settings(name)
+        if Puppet[:environment_timeout_mode] == :from_last_used
+          MRUEntry.new(env, ttl)    # Entry that expires in ttl from when it was last touched
+        else
+          TTLEntry.new(env, ttl)    # Entry that expires in ttl from when it was created
+        end
       end
     end
 
@@ -465,52 +482,60 @@ module Puppet::Environments
         @value = value
       end
 
-      def expired?
+      def touch
+      end
+
+      def expired?(now)
         false
       end
 
       def label
         ""
       end
-
-      def expires
-        END_OF_TIME
-      end
     end
 
     # Always evicting entry
     class NotCachedEntry < Entry
-      def expired?
+      def expired?(now)
         true
       end
 
       def label
         "(ttl = 0 sec)"
       end
-
-      def expires
-        START_OF_TIME
-      end
     end
 
-    # Time to Live eviction policy entry
+    # Policy that expires in ttl_seconds from when it was created
     class TTLEntry < Entry
       def initialize(value, ttl_seconds)
-        super value
+        super(value)
         @ttl = Time.now + ttl_seconds
         @ttl_seconds = ttl_seconds
       end
 
-      def expired?
-        Time.now > @ttl
+      def expired?(now)
+        now > @ttl
       end
 
       def label
         "(ttl = #{@ttl_seconds} sec)"
       end
+    end
 
-      def expires
-        @ttl
+    # Policy that expires if it hasn't been touched within ttl_seconds
+    class MRUEntry < TTLEntry
+      def initialize(value, ttl_seconds)
+        super(value, ttl_seconds)
+
+        touch
+      end
+
+      def touch
+        @ttl = Time.now + @ttl_seconds
+      end
+
+      def label
+        "(mru = #{@ttl_seconds} sec)"
       end
     end
   end

data/lib/puppet/face/catalog.rb

@@ -97,7 +97,7 @@ Puppet::Indirector::Face.define(:catalog, '0.0.1') do
       A serialized catalog.
     EOT
     when_invoked do |*args|
-      Puppet.settings.preferred_run_mode = :master
+      Puppet.settings.preferred_run_mode = :server
       Puppet::Face[:catalog, :current].find(*args)
     end
   end

data/lib/puppet/face/config.rb

@@ -20,10 +20,10 @@ Puppet::Face.define(:config, '0.0.1') do
     description <<-EOT
       The section of the puppet.conf configuration file to interact with.
 
-      The three most commonly used sections are 'main', 'master', and 'agent'.
+      The three most commonly used sections are 'main', 'server', and 'agent'.
       'Main' is the default, and is used by all Puppet applications. Other
       sections can override 'main' values for specific applications --- the
-      'master' section affects Puppet Server, and the 'agent'
+      'server' section affects Puppet Server, and the 'agent'
       section affects puppet agent.
 
       Less commonly used is the 'user' section, which affects puppet apply. Any
@@ -52,9 +52,9 @@ Puppet::Face.define(:config, '0.0.1') do
 
       $ puppet config print rundir
 
-      Get a list of important directories from the master's config:
+      Get a list of important directories from the server's config:
 
-      $ puppet config print all --section master | grep -E "(path|dir)"
+      $ puppet config print all --section server | grep -E "(path|dir)"
     EOT
 
     when_invoked do |*args|
@@ -144,7 +144,7 @@ Puppet::Face.define(:config, '0.0.1') do
 
       if name == 'environment' && options[:section] == 'main'
         Puppet.warning _(<<-EOM).chomp
-The environment should be set in either the `[user]`, `[agent]`, or `[master]`
+The environment should be set in either the `[user]`, `[agent]`, or `[server]`
 section. Variables set in the `[agent]` section are used when running
 `puppet agent`. Variables set in the `[user]` section are used when running
 various other puppet subcommands, like `puppet apply` and `puppet module`; these
@@ -159,11 +159,38 @@ https://puppet.com/docs/puppet/latest/configuration.html#environment
         report_section_and_environment(options[:section], Puppet.settings[:environment])
       end
 
+      # only validate settings we recognize
+      setting = Puppet.settings.setting(name.to_sym)
+      if setting
+        # set the value, which will call `on_*_and_write` hooks, if any
+        Puppet.settings[setting.name] = value
+
+        # read the value to trigger interpolation and munge validation logic
+        Puppet.settings[setting.name]
+      end
+
       path = Puppet::FileSystem.pathname(Puppet.settings.which_configuration_file)
       Puppet::FileSystem.touch(path)
       Puppet::FileSystem.open(path, nil, 'r+:UTF-8') do |file|
         Puppet::Settings::IniFile.update(file) do |config|
-          config.set(options[:section], name, value)
+          if options[:section] == "master"
+            # delete requested master section if it exists,
+            # as server section should be used
+            setting_string = config.delete("master", name)
+            if setting_string
+
+              if Puppet::Util::Log.sendlevel?(:info)
+                report_section_and_environment(options[:section], Puppet.settings[:environment])
+              end
+
+              puts(_("Deleted setting from '%{section_name}': '%{setting_string}', and adding it to 'server' section") %
+                       { section_name: options[:section], name: name, setting_string: setting_string.strip })
+            end
+            # add the setting to the to server section instead of master section
+            config.set("server", name, value)
+          else
+            config.set(options[:section], name, value)
+          end
         end
       end
       nil
@@ -185,9 +212,9 @@ https://puppet.com/docs/puppet/latest/configuration.html#environment
 
       $ puppet config delete setting_name
 
-      Delete the setting 'setting_name' from the 'master' configuration domain:
+      Delete the setting 'setting_name' from the 'server' configuration domain:
 
-      $ puppet config delete setting_name --section master
+      $ puppet config delete setting_name --section server
     EOT
 
     when_invoked do |name, options|
@@ -202,18 +229,31 @@ https://puppet.com/docs/puppet/latest/configuration.html#environment
       if Puppet::FileSystem.exist?(path)
         Puppet::FileSystem.open(path, nil, 'r+:UTF-8') do |file|
           Puppet::Settings::IniFile.update(file) do |config|
-            setting_string = config.delete(options[:section], name)
-            if setting_string
 
-              if Puppet::Util::Log.sendlevel?(:info)
-                report_section_and_environment(options[:section], Puppet.settings[:environment])
-              end
+            # delete from both master section and server section
+            if options[:section] == "master" || options[:section] == "server"
+              master_setting_string = config.delete("master", name)
+              puts(_("Deleted setting from '%{section_name}': '%{setting_string}'") %
+              { section_name: 'master', name: name, setting_string: master_setting_string.strip[/[^=]+/] }) if master_setting_string
 
+              server_setting_string = config.delete("server", name)
               puts(_("Deleted setting from '%{section_name}': '%{setting_string}'") %
-                       { section_name: options[:section], name: name, setting_string: setting_string.strip })
+              { section_name: 'server', name: name, setting_string: server_setting_string.strip[/[^=]+/] }) if server_setting_string
+
             else
-              Puppet.warning(_("No setting found in configuration file for section '%{section_name}' setting name '%{name}'") %
-                                 { section_name: options[:section], name: name })
+              setting_string = config.delete(options[:section], name)
+              if setting_string
+
+                if Puppet::Util::Log.sendlevel?(:info)
+                  report_section_and_environment(options[:section], Puppet.settings[:environment])
+                end
+
+                puts(_("Deleted setting from '%{section_name}': '%{setting_string}'") %
+                         { section_name: options[:section], name: name, setting_string: setting_string.strip })
+              else
+                Puppet.warning(_("No setting found in configuration file for section '%{section_name}' setting name '%{name}'") %
+                                   { section_name: options[:section], name: name })
+              end
             end
           end
         end

data/lib/puppet/face/epp.rb

@@ -440,7 +440,12 @@ Puppet::Face.define(:epp, '0.0.1') do
 
   def render_inline(epp_source, compiler, options)
     template_args = get_values(compiler, options)
-    Puppet::Pops::Evaluator::EppEvaluator.inline_epp(compiler.topscope, epp_source, template_args)
+    result = Puppet::Pops::Evaluator::EppEvaluator.inline_epp(compiler.topscope, epp_source, template_args)
+    if result.instance_of?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      result.unwrap
+    else
+      result
+    end
   end
 
   def render_file(epp_template_name, compiler, options, show_filename, file_nbr)
@@ -457,7 +462,12 @@ Puppet::Face.define(:epp, '0.0.1') do
       if template_file.nil? && Puppet::FileSystem.exist?(epp_template_name)
         epp_template_name = File.expand_path(epp_template_name)
       end
-      output << Puppet::Pops::Evaluator::EppEvaluator.epp(compiler.topscope, epp_template_name, compiler.environment, template_args)
+      result = Puppet::Pops::Evaluator::EppEvaluator.epp(compiler.topscope, epp_template_name, compiler.environment, template_args)
+      if result.instance_of?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        output << result.unwrap
+      else
+        output << result
+      end
     rescue Puppet::ParseError => detail
       Puppet.err("--- #{epp_template_name}") if show_filename
       raise detail

data/lib/puppet/face/facts.rb

@@ -1,5 +1,29 @@
 require 'puppet/indirector/face'
 require 'puppet/node/facts'
+require 'puppet/util/fact_dif'
+
+EXCLUDE_LIST = %w[facterversion
+  swapfree_mb swapsize_mb
+  load_averages\.*
+  memory\.swap\.available_bytes memory\.swap\.capacity memory\.swap\.total_bytes
+  memory\.swap\.used_bytes memory\.swap\.available
+  memory\.system\.available memory\.system\.available_bytes memory\.system\.capacity memory\.swap\.used
+  memory\.system\.total_bytes memory\.system\.used memory\.system\.used_bytes
+  memoryfree memoryfree_mb memorysize_mb
+  mountpoints\..* mtu_.* mountpoints\..*\.capacity
+  networking\.interfaces\..*\.mtu networking\.mtu partitions\..*\.filesystem
+  partitions\..*\.size_bytes partitions\..*\.mount partitions\..*\.uuid
+  disks\..*\.size_bytes
+  hypervisors\.lpar\.partition_number hypervisors\.xen\.privileged hypervisors\.zone\..* hypervisors\.ldom\..*
+  processors\.speed
+  ldom_.*
+  boardassettag dmi\.board\.asset_tag
+  blockdevice_.*_vendor blockdevice_.*_size
+  system_uptime\.days system_uptime\.hours system_uptime\.seconds system_uptime\.uptime
+  uptime_days uptime_hours uptime_seconds
+  system_profiler\.uptime
+  sp_uptime
+  uptime]
 
 Puppet::Indirector::Face.define(:facts, '0.0.1') do
   copyright "Puppet Inc.", 2011
@@ -87,4 +111,40 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
       nil
     end
   end
+
+  action(:diff) do
+    summary _("Compare Facter 3 output with Facter 4 output")
+    description <<-'EOT'
+    Compares output from facter 3 with Facter 4 and prints the differences
+    EOT
+    returns "Differences between Facter 3 and Facter 4 output as an array."
+    notes <<-'EOT'
+    EOT
+    examples <<-'EOT'
+    get differences between facter versions:
+    $ puppet facts diff
+    EOT
+
+    render_as :json
+
+    when_invoked do |*args|
+      Puppet.settings.preferred_run_mode = :agent
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+
+      if Puppet::Util::Package.versioncmp(Facter.value('facterversion'), '4.0.0') < 0
+        facter3_result = Puppet::Node::Facts.indirection.find(Puppet.settings[:certname])
+        begin
+          require 'facter-ng'
+          facter4_result = Puppet::Node::Facts.indirection.find(Puppet.settings[:certname])
+        rescue LoadError
+          raise ArgumentError, 'facter-ng could not be loaded'
+        end
+        fact_diff = FactDif.new(facter3_result.to_json, facter4_result.to_json, EXCLUDE_LIST)
+        fact_diff.difs
+      else
+        Puppet.warning _("Already using Facter 4. To use `puppet facts diff` remove facterng from the .conf file or run `puppet config set facterng false`.")
+        exit 0
+      end
+    end
+  end
 end