puppet 6.25.0-x64-mingw32 → 7.0.0-x64-mingw32

data/lib/puppet/environments.rb

@@ -48,13 +48,6 @@ module Puppet::Environments
         root.instance_variable_set(:@rich_data, nil)
       end
     end
-
-    # The base implementation is a noop, because `get` returns a new environment
-    # each time.
-    #
-    # @see Puppet::Environments::Cached#guard
-    def guard(name); end
-    def unguard(name); end
   end
 
   # @!macro [new] loader_search_paths
@@ -195,7 +188,7 @@ module Puppet::Environments
 
     def self.real_path(dir)
       if Puppet::FileSystem.symlink?(dir) && Puppet[:versioned_environment_dirs]
-        dir = Pathname.new Puppet::FileSystem.expand_path(Puppet::FileSystem.readlink(dir))
+        dir = Puppet::FileSystem.expand_path(Puppet::FileSystem.readlink(dir))
       end
       return dir
     end
@@ -232,9 +225,6 @@ module Puppet::Environments
     private
 
     def create_environment(name)
-      # interpolated modulepaths may be cached from prior environment instances
-      Puppet.settings.clear_environment_settings(name)
-
       env_symbol = name.intern
       setting_values = Puppet.settings.values(env_symbol, Puppet.settings.preferred_run_mode)
       env = Puppet::Node::Environment.create(
@@ -248,7 +238,7 @@ module Puppet::Environments
 
     def validated_directory(envdir)
       env_name = Puppet::FileSystem.basename_string(envdir)
-      envdir = Puppet::Environments::Directories.real_path(envdir).to_s
+      envdir = Puppet::Environments::Directories.real_path(envdir)
       if Puppet::FileSystem.directory?(envdir) && Puppet::Node::Environment.valid_name?(env_name)
         envdir
       else
@@ -337,44 +327,36 @@ module Puppet::Environments
     end
 
     def self.cache_expiration_service=(service)
-      @cache_expiration_service_singleton = service
+      @cache_expiration_service = service
     end
 
     def self.cache_expiration_service
-      @cache_expiration_service_singleton || DefaultCacheExpirationService.new
+      @cache_expiration_service || DefaultCacheExpirationService.new
+    end
+
+    # Returns the end of time (the next Mesoamerican Long Count cycle-end after 2012 (5125+2012) = 7137
+    def self.end_of_time
+      Time.gm(7137)
     end
 
+    END_OF_TIME = end_of_time
+    START_OF_TIME = Time.gm(1)
+
     def initialize(loader)
       @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
     def list
-      # Evict all that have expired, in the same way as `get`
-      clear_all_expired
-
-      # Evict all that was removed from disk
-      cached_envs = @cache.keys.map!(&:to_sym)
-      loader_envs = @loader.list.map!(&:name)
-      removed_envs = cached_envs - loader_envs
-
-      removed_envs.each do |env_name|
-        Puppet.debug { "Environment no longer exists '#{env_name}'"}
-        clear(env_name)
-      end
-
-      @loader.list.map do |env|
-        name = env.name
-        old_entry = @cache[name]
-        if old_entry
-          old_entry.value
-        else
-          add_entry(name, entry(env))
-          env
-        end
-      end
+      @loader.list
     end
 
     # @!macro loader_search_paths
@@ -384,94 +366,70 @@ module Puppet::Environments
 
     # @!macro loader_get
     def get(name)
-      entry = get_entry(name)
-      entry ? entry.value : nil
-    end
-
-    # Get a cache entry for an envionment. It returns nil if the
-    # environment doesn't exist.
-    def get_entry(name, check_expired = true)
       # Aggressively evict all that has expired
       # This strategy favors smaller memory footprint over environment
       # retrieval time.
-      clear_all_expired if check_expired
-      name = name.to_sym
-      entry = @cache[name]
-      if entry
-        Puppet.debug {"Found in cache #{name.inspect} #{entry.label}"}
+      clear_all_expired
+      result = @cache[name]
+      if result
+        Puppet.debug {"Found in cache '#{name}' #{result.label}"}
         # found in cache
-        entry.touch
-      elsif (env = @loader.get(name))
+        result.touch
+        return result.value
+      elsif (result = @loader.get(name))
         # environment loaded, cache it
-        entry = entry(env)
-        add_entry(name, entry)
+        cache_entry = entry(result)
+        @cache_expiration_service.created(result)
+        add_entry(name, cache_entry)
+        result
       end
-      entry
     end
-    private :get_entry
 
     # Adds a cache entry to the cache
     def add_entry(name, cache_entry)
-      Puppet.debug {"Caching environment #{name.inspect} #{cache_entry.label}"}
+      Puppet.debug {"Caching environment '#{name}' #{cache_entry.label}"}
       @cache[name] = cache_entry
-      @cache_expiration_service.created(cache_entry.value)
+      expires = cache_entry.expires
+      @expirations.add(expires)
+      if @next_expiration > expires
+        @next_expiration = expires
+      end
     end
     private :add_entry
 
-    def clear_entry(name, entry)
-      @cache.delete(name)
-      Puppet.debug {"Evicting cache entry for environment #{name.inspect}"}
-      @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)
-      name = name.to_sym
-      entry = @cache[name]
-      clear_entry(name, entry) if entry
+      @cache.delete(name)
+      Puppet::GettextConfig.delete_text_domain(name)
     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
 
     # Clears all environments that have expired, either by exceeding their time to live, or
     # through an explicit eviction determined by the cache expiration service.
     #
-    def clear_all_expired
+    def clear_all_expired()
       t = Time.now
-
-      @cache.each_pair do |name, entry|
-        clear_if_expired(name, entry, t)
+      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.to_sym)
+        clear(name)
+        @expirations.delete(entry.expires)
+        Puppet.settings.clear_environment_settings(name)
       end
+      @next_expiration = @expirations.first || END_OF_TIME
     end
-    private :clear_all_expired
-
-    # 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
-      return if entry.guarded?
-
-      if entry.expired?(t) || @cache_expiration_service.expired?(name.to_sym)
-        clear_entry(name, entry)
-      end
-    end
-    private :clear_if_expired
 
     # This implementation evicts the cache, and always gets the current
     # configuration of the environment
@@ -482,25 +440,10 @@ module Puppet::Environments
     #
     # @!macro loader_get_conf
     def get_conf(name)
-      name = name.to_sym
-      clear_if_expired(name, @cache[name])
+      evict_if_expired(name)
       @loader.get_conf(name)
     end
 
-    # Guard an environment so it can't be evicted while it's in use. The method
-    # may be called multiple times, provided it is unguarded the same number of
-    # times. If you call this method, you must call `unguard` in an ensure block.
-    def guard(name)
-      entry = get_entry(name, false)
-      entry.guard if entry
-    end
-
-    # Unguard an environment.
-    def unguard(name)
-      entry = get_entry(name, false)
-      entry.unguard if entry
-    end
-
     # Creates a suitable cache entry given the time to live for one environment
     #
     def entry(env)
@@ -516,11 +459,18 @@ module Puppet::Environments
       when Float::INFINITY
         Entry.new(env)              # Entry that never expires (avoids syscall to get time)
       else
-        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
+        MRUEntry.new(env, ttl)      # Entry that expires in ttl from when it was last touched
+      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.to_sym))
+        Puppet.debug {"Evicting cache entry for environment '#{name}'"}
+        @cache_expiration_service.evicted(name.to_sym)
+        clear(name)
+        Puppet.settings.clear_environment_settings(name)
       end
     end
 
@@ -530,13 +480,12 @@ module Puppet::Environments
 
       def initialize(value)
         @value = value
-        @guards = 0
       end
 
       def touch
       end
 
-      def expired?(now)
+      def expired?
         false
       end
 
@@ -544,63 +493,50 @@ module Puppet::Environments
         ""
       end
 
-      # These are not protected with a lock, because all of the Cached
-      # methods are protected.
-      def guarded?
-        @guards > 0
-      end
-
-      def guard
-        @guards += 1
-      end
-
-      def unguard
-        @guards -= 1
+      def expires
+        END_OF_TIME
       end
     end
 
     # Always evicting entry
     class NotCachedEntry < Entry
-      def expired?(now)
+      def expired?
         true
       end
 
       def label
         "(ttl = 0 sec)"
       end
+
+      def expires
+        START_OF_TIME
+      end
     end
 
-    # Policy that expires in ttl_seconds from when it was created
-    class TTLEntry < Entry
+    # Policy that expires if it hasn't been touched within ttl_seconds
+    class MRUEntry < Entry
       def initialize(value, ttl_seconds)
         super(value)
         @ttl = Time.now + ttl_seconds
         @ttl_seconds = ttl_seconds
-      end
 
-      def expired?(now)
-        now > @ttl
+        touch
       end
 
-      def label
-        "(ttl = #{@ttl_seconds} sec)"
+      def touch
+        @ttl = Time.now + @ttl_seconds
       end
-    end
-
-    # 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
+      def expired?
+        Time.now > @ttl
       end
 
-      def touch
-        @ttl = Time.now + @ttl_seconds
+      def expires
+        @ttl
       end
 
       def label
-        "(mru = #{@ttl_seconds} sec)"
+        "(ttl = #{@ttl_seconds} sec)"
       end
     end
   end

data/lib/puppet/face/facts.rb

@@ -1,21 +1,5 @@
 require 'puppet/indirector/face'
 require 'puppet/node/facts'
-require 'puppet/util/fact_dif'
-
-EXCLUDE_LIST = %w[ ^facterversion$
-  ^load_averages\..*$
-  ^processors\.speed$
-  ^swapfree$ ^swapfree_mb$
-  ^memoryfree$ ^memoryfree_mb$
-  ^memory\.swap\.available_bytes$ ^memory\.swap\.used_bytes$
-  ^memory\.swap\.available$ ^memory\.swap\.capacity$ ^memory\.swap\.used$
-  ^memory\.system\.available_bytes$ ^memory\.system\.used_bytes$
-  ^memory\.system\.available$ ^memory\.system\.capacity$ ^memory\.system\.used$
-  ^mountpoints\..*\.available.*$ ^mountpoints\..*\.capacity$ ^mountpoints\..*\.used.*$
-  ^sp_uptime$ ^system_profiler\.uptime$
-  ^uptime$ ^uptime_days$ ^uptime_hours$ ^uptime_seconds$
-  ^system_uptime\.uptime$ ^system_uptime\.days$ ^system_uptime\.hours$ ^system_uptime\.seconds$
-]
 
 Puppet::Indirector::Face.define(:facts, '0.0.1') do
   copyright "Puppet Inc.", 2011
@@ -47,7 +31,6 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
 
     $ puppet facts find
   EOT
-  find.default = true
 
   deactivate_action(:destroy)
   deactivate_action(:search)
@@ -60,16 +43,12 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
     EOT
     returns "Nothing."
     notes <<-'EOT'
-      This action requires that the puppet master's `auth.conf` file
+      This action requires that the Puppet Server's `auth.conf` file
       allow `PUT` or `save` access to the `/puppet/v3/facts` API endpoint.
 
       For details on configuring Puppet Server's `auth.conf`, see:
 
       <https://puppet.com/docs/puppetserver/latest/config_file_auth.html>
-
-      For legacy Rack-based Puppet Masters, see:
-
-      <https://puppet.com/docs/puppet/latest/config_file_auth.html>
     EOT
     examples <<-'EOT'
       Upload facts:
@@ -104,65 +83,6 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
     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
-
-    option("--structured") do
-      default_to { false }
-      summary _("Render the different facts as structured.")
-    end
-
-    option("--exclude " + _("<regex>")) do
-      summary _("Regex used to exclude specific facts from diff.")
-    end
-
-    when_invoked do |*args|
-      options = args.pop
-
-      Puppet.settings.preferred_run_mode = :agent
-      Puppet::Node::Facts.indirection.terminus_class = :facter
-
-      if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('facterversion'), '4.0.0') < 0
-        cmd_flags = '--render-as json --show-legacy'
-
-        # puppet/ruby are in PATH since it was updated in the wrapper script
-        puppet_show_cmd  = "puppet facts show"
-        if Puppet::Util::Platform.windows?
-          puppet_show_cmd = "ruby -S -- #{puppet_show_cmd}"
-        end
-
-        facter_3_result = Puppet::Util::Execution.execute("#{puppet_show_cmd} --no-facterng #{cmd_flags}", combine: false)
-        facter_ng_result = Puppet::Util::Execution.execute("#{puppet_show_cmd} --facterng #{cmd_flags}", combine: false)
-
-        exclude_list = options[:exclude].nil? ? EXCLUDE_LIST : EXCLUDE_LIST + [ options[:exclude] ]
-        fact_diff = FactDif.new(facter_3_result, facter_ng_result, exclude_list, options[:structured])
-        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
-
-    when_rendering :console do |result|
-      case result
-      when Array, Hash
-        Puppet::Util::Json.dump(result, :pretty => true)
-      else
-        result
-      end
-    end
-  end
-
   action(:show) do
     summary _("Retrieve current node's facts.")
     arguments _("[<facts>]")
@@ -179,6 +99,7 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
 
     $ puppet facts show os
     EOT
+    default true
 
     option("--config-file " + _("<path>")) do
       default_to { nil }
@@ -207,42 +128,23 @@ Puppet::Indirector::Face.define(:facts, '0.0.1') do
       summary _("Show legacy facts when querying all facts.")
     end
 
-    option("--value-only") do
-      summary _("Show only the value when the action is called with a single query")
-    end
-
     when_invoked do |*args|
       options = args.pop
 
       Puppet.settings.preferred_run_mode = :agent
       Puppet::Node::Facts.indirection.terminus_class = :facter
 
-      if options[:value_only] && !args.count.eql?(1)
-        options[:value_only] = nil
-        Puppet.warning("Incorrect use of --value-only argument; it can only be used when querying for a single fact!")
-      end
 
       options[:user_query] = args
       options[:resolve_options] = true
       result = Puppet::Node::Facts.indirection.find(Puppet.settings[:certname], options)
 
-      if options[:value_only]
-        result.values.values.first
-      else
-        result.values
-      end
+      result.values
     end
 
     when_rendering :console do |result|
-      # VALID_TYPES = [Integer, Float, TrueClass, FalseClass, NilClass, Symbol, String, Array, Hash].freeze
-      # from https://github.com/puppetlabs/facter/blob/4.0.49/lib/facter/custom_facts/util/normalization.rb#L8
-
-      case result
-      when Array, Hash
-        Puppet::Util::Json.dump(result, :pretty => true)
-      else # one of VALID_TYPES above
-        result
-      end
+      Puppet::Util::Json.dump(result, :pretty => true)
     end
   end
 end
+

data/lib/puppet/face/help/action.erb

@@ -54,7 +54,6 @@ undocumented option
 	end
 	unless action.options.empty?
       action.options.sort.each do |name|
-        next if name == :extra
         option = action.get_option name -%>
 <%= "  " + option.optparse.join(" | ")[0,(optionroom - 1)].ljust(optionroom) + ' - ' -%>
 <%     if !(option.summary) -%>

data/lib/puppet/face/help/face.erb

@@ -49,7 +49,6 @@ undocumented option
 	end
  	unless face.options.empty?
       face.options.sort.each do |name|
-        next if name == :extra
         option = face.get_option name -%>
 <%= "  " + option.optparse.join(" | ")[0,(optionroom - 1)].ljust(optionroom) + ' - ' -%>
 <%     if !(option.summary) -%>

data/lib/puppet/face/help.rb

@@ -222,7 +222,7 @@ Puppet::Face.define(:help, '0.0.1') do
   #private :horribly_extract_summary_from
 
   def exclude_from_docs?(appname)
-    %w{face_base indirection_base cert key man report status}.include? appname
+    %w{face_base indirection_base report status}.include? appname
   end
   # This should absolutely be a private method, but for some reason it appears
   #  that you can't use the 'private' keyword inside of a Face definition.

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

@@ -47,17 +47,6 @@ Puppet::Face.define(:node, '0.0.1') do
   end
 
   class LoggerIO
-    def debug(message)
-      Puppet.debug(message)
-    end
-
-    # Notice: For Puppet 6.x, the function below does not matter as it
-    # does not have any functionality.  But we decided to keep it here
-    # for the ease of merge up to 7.x and having the same code base.
-    def warn(message)
-      Puppet.warning(message) unless message =~ /cadir is currently configured to be inside/
-    end
-
     def err(message)
       Puppet.err(message) unless message =~ /^\s*Error:\s*/
     end

data/lib/puppet/face/plugin.rb

@@ -41,14 +41,11 @@ Puppet::Face.define(:plugin, '0.0.1') do
     when_invoked do |options|
       remote_environment_for_plugins = Puppet::Node::Environment.remote(Puppet[:environment])
 
-      pool = Puppet.runtime[:http].pool
-      Puppet.override(:http_pool => pool) do
-        begin
-          handler = Puppet::Configurer::PluginHandler.new
-          handler.download_plugins(remote_environment_for_plugins)
-        ensure
-          pool.close
-        end
+      begin
+        handler = Puppet::Configurer::PluginHandler.new
+        handler.download_plugins(remote_environment_for_plugins)
+      ensure
+        Puppet.runtime[:http].close
       end
     end