puppet 6.29.0-x64-mingw32 → 7.0.0-x64-mingw32

data/lib/puppet/configurer.rb

@@ -91,7 +91,7 @@ class Puppet::Configurer
 
         if result
           # don't use use cached catalog if it doesn't match server specified environment
-          if result.environment != @environment
+          if @node_environment && result.environment != @environment
             Puppet.err _("Not using cached catalog because its environment '%{catalog_env}' does not match '%{local_env}'") % { catalog_env: result.environment, local_env: @environment }
             return nil
           end
@@ -112,17 +112,14 @@ class Puppet::Configurer
     catalog_conversion_time = thinmark do
       # Will mutate the result and replace all Deferred values with resolved values
       if facts
-        Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, result, Puppet.lookup(:current_environment))
+        Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, result)
       end
 
       catalog = result.to_ral
       catalog.finalize
       catalog.retrieval_duration = duration
-
-      if Puppet[:write_catalog_summary]
-        catalog.write_class_file
-        catalog.write_resource_file
-      end
+      catalog.write_class_file
+      catalog.write_resource_file
     end
     options[:report].add_times(:convert_catalog, catalog_conversion_time) if options[:report]
 
@@ -205,7 +202,6 @@ class Puppet::Configurer
   # This just passes any options on to the catalog,
   # which accepts :tags and :ignoreschedules.
   def run(options = {})
-    pool = Puppet.runtime[:http].pool
     # We create the report pre-populated with default settings for
     # environment and transaction_uuid very early, this is to ensure
     # they are sent regardless of any catalog compilation failures or
@@ -218,41 +214,40 @@ class Puppet::Configurer
 
     completed = nil
     begin
-      Puppet.override(:http_pool => pool) do
-        # Skip failover logic if the server_list setting is empty
-        do_failover = Puppet.settings[:server_list] && !Puppet.settings[:server_list].empty?
-
-        # When we are passed a catalog, that means we're in apply
-        # mode. We shouldn't try to do any failover in that case.
-        if options[:catalog].nil? && do_failover
-          server, port = find_functional_server
-          if server.nil?
-            detail = _("Could not select a functional puppet server from server_list: '%{server_list}'") % { server_list: Puppet.settings.value(:server_list, Puppet[:environment].to_sym, true) }
-            if Puppet[:usecacheonfailure]
-              options[:pluginsync] = false
-              @running_failure = true
-
-              server = Puppet[:server_list].first[0]
-              port = Puppet[:server_list].first[1] || Puppet[:serverport]
-
-              Puppet.err(detail)
-            else
-              raise Puppet::Error, detail
-            end
+      # Skip failover logic if the server_list setting is empty
+      do_failover = Puppet.settings[:server_list] && !Puppet.settings[:server_list].empty?
+
+      # When we are passed a catalog, that means we're in apply
+      # mode. We shouldn't try to do any failover in that case.
+      if options[:catalog].nil? && do_failover
+        server, port = find_functional_server
+        if server.nil?
+          detail = _("Could not select a functional puppet server from server_list: '%{server_list}'") % { server_list: Puppet.settings.value(:server_list, Puppet[:environment].to_sym, true) }
+          if Puppet[:usecacheonfailure]
+            options[:pluginsync] = false
+            @running_failure = true
+
+            server = Puppet[:server_list].first[0]
+            port = Puppet[:server_list].first[1] || Puppet[:serverport]
+
+            Puppet.err(detail)
           else
-            #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-            Puppet.debug _("Selected puppet server from the `server_list` setting: %{server}:%{port}") % { server: server, port: port }
-            report.server_used = "#{server}:#{port}"
-          end
-          Puppet.override(server: server, serverport: port) do
-            completed = run_internal(options)
+            raise Puppet::Error, detail
           end
         else
+          #TRANSLATORS 'server_list' is the name of a setting and should not be translated
+          Puppet.debug _("Selected puppet server from the `server_list` setting: %{server}:%{port}") % { server: server, port: port }
+          report.server_used = "#{server}:#{port}"
+        end
+        Puppet.override(server: server, serverport: port) do
           completed = run_internal(options)
         end
+      else
+        completed = run_internal(options)
       end
     ensure
-      pool.close
+      # we may sleep for awhile, close connections now
+      Puppet.runtime[:http].close
     end
 
     completed ? report.exit_status : nil
@@ -260,7 +255,6 @@ class Puppet::Configurer
 
   def run_internal(options)
     report = options[:report]
-    report.initial_environment = Puppet[:environment]
 
     if options[:start_time]
       startup_time = Time.now - options[:start_time]
@@ -300,42 +294,69 @@ class Puppet::Configurer
       configured_environment = Puppet[:environment] if Puppet.settings.set_by_config?(:environment)
 
       # We only need to find out the environment to run in if we don't already have a catalog
-      unless (cached_catalog || options[:catalog] || Puppet.settings.set_by_cli?(:environment) || Puppet[:strict_environment_mode])
-        Puppet.debug(_("Environment not passed via CLI and no catalog was given, attempting to find out the last server-specified environment"))
-        initial_environment, loaded_last_environment = last_server_specified_environment
-
-        unless Puppet[:use_last_environment] && loaded_last_environment
-          Puppet.debug(_("Requesting environment from the server"))
-          initial_environment = current_server_specified_environment(@environment, configured_environment, options)
-        end
+      unless (cached_catalog || options[:catalog] || Puppet[:strict_environment_mode])
+        begin
+          node = nil
+          node_retr_time = thinmark do
+            node = Puppet::Node.indirection.find(Puppet[:node_name_value],
+              :environment => Puppet::Node::Environment.remote(@environment),
+              :configured_environment => configured_environment,
+              :ignore_cache => true,
+              :transaction_uuid => @transaction_uuid,
+              :fail_on_404 => true)
+          end
+          options[:report].add_times(:node_retrieval, node_retr_time)
 
-        if initial_environment
-          @environment = initial_environment
-          report.environment = initial_environment
+          if node
+            # If we have deserialized a node from a rest call, we want to set
+            # an environment instance as a simple 'remote' environment reference.
+            if !node.has_environment_instance? && node.environment_name
+              node.environment = Puppet::Node::Environment.remote(node.environment_name)
+            end
 
-          push_current_environment_and_loaders
-        else
-          Puppet.debug(_("Could not find a usable environment in the lastrunfile. Either the file does not exist, does not have the required keys, or the values of 'initial_environment' and 'converged_environment' are identical."))
+            @node_environment = node.environment.to_s
+
+            if node.environment.to_s != @environment
+              Puppet.notice _("Local environment: '%{local_env}' doesn't match server specified node environment '%{node_env}', switching agent to '%{node_env}'.") % { local_env: @environment, node_env: node.environment }
+              @environment = node.environment.to_s
+              report.environment = @environment
+              query_options = nil
+              facts = nil
+
+              new_env = Puppet::Node::Environment.remote(@environment)
+              Puppet.push_context(
+                {
+                  current_environment: new_env,
+                  loaders: Puppet::Pops::Loaders.new(new_env, true)
+                },
+                "Local node environment #{@environment} for configurer transaction"
+              )
+            else
+              Puppet.info _("Using configured environment '%{env}'") % { env: @environment }
+            end
+          end
+        rescue StandardError => detail
+          Puppet.warning(_("Unable to fetch my node definition, but the agent run will continue:"))
+          Puppet.warning(detail)
         end
       end
 
-      Puppet.info _("Using environment '%{env}'") % { env: @environment }
-
       # This is to maintain compatibility with anyone using this class
       # aside from agent, apply, device.
       unless Puppet.lookup(:loaders) { nil }
-        push_current_environment_and_loaders
+        new_env = Puppet::Node::Environment.remote(@environment)
+        Puppet.push_context(
+          {
+            current_environment: new_env,
+            loaders: Puppet::Pops::Loaders.new(new_env, true)
+          },
+          "Local node environment #{@environment} for configurer transaction"
+        )
       end
 
-      temp_value = options[:pluginsync]
-
-      # only validate server environment if pluginsync is requested
-      options[:pluginsync] = valid_server_environment? if options[:pluginsync]
-
       query_options, facts = get_facts(options) unless query_options
-      options[:pluginsync] = temp_value
-
       query_options[:configured_environment] = configured_environment
+      options[:convert_for_node] = node
 
       catalog = prepare_and_retrieve_catalog(cached_catalog, facts, options, query_options)
       unless catalog
@@ -360,8 +381,6 @@ class Puppet::Configurer
         @environment = catalog.environment
         report.environment = @environment
 
-        push_current_environment_and_loaders
-
         query_options, facts = get_facts(options)
         query_options[:configured_environment] = configured_environment
 
@@ -376,29 +395,16 @@ class Puppet::Configurer
       if !cached_catalog && options[:catalog]
         ral_catalog = options[:catalog]
       else
-        # Ordering here matters. We have to resolve deferred resources in the
-        # resource catalog, convert the resource catalog to a RAL catalog (which
-        # triggers type/provider validation), and only if that is successful,
-        # should we cache the *original* resource catalog. However, deferred
-        # evaluation mutates the resource catalog, so we need to make a copy of
-        # it here. If PUP-9323 is ever implemented so that we resolve deferred
-        # resources in the RAL catalog as they are needed, then we could eliminate
-        # this step.
-        catalog_to_cache = Puppet.override(:rich_data => Puppet[:rich_data]) do
-          Puppet::Resource::Catalog.from_data_hash(catalog.to_data_hash)
-        end
-
         # REMIND @duration is the time spent loading the last catalog, and doesn't
         # account for things like we failed to download and fell back to the cache
         ral_catalog = convert_catalog(catalog, @duration, facts, options)
 
-        # Validation succeeded, so commit the `catalog_to_cache` for non-noop runs. Don't
-        # commit `catalog` since it contains the result of deferred evaluation. Ideally
+        # If not noop, commit the cached resource catalog (not ral catalog). Ideally
         # we'd just copy the downloaded response body, instead of serializing the
         # in-memory catalog, but that's hard due to the indirector.
         indirection = Puppet::Resource::Catalog.indirection
         if !Puppet[:noop] && indirection.cache?
-          request = indirection.request(:save, nil, catalog_to_cache, environment: Puppet::Node::Environment.remote(catalog_to_cache.environment))
+          request = indirection.request(:save, nil, catalog, environment: Puppet::Node::Environment.remote(catalog.environment))
           Puppet.info("Caching catalog for #{request.key}")
           indirection.cache.save(request)
         end
@@ -435,29 +441,6 @@ class Puppet::Configurer
   end
   private :run_internal
 
-  def valid_server_environment?
-    session = Puppet.lookup(:http_session)
-    begin
-      fs = session.route_to(:fileserver)
-      fs.get_file_metadatas(path: URI(Puppet[:pluginsource]).path, recurse: :false, environment: @environment)
-      true
-    rescue Puppet::HTTP::ResponseError => detail
-      if detail.response.code == 404
-        if Puppet[:strict_environment_mode]
-          raise Puppet::Error.new(_("Environment '%{environment}' not found on server, aborting run.") % { environment: @environment })
-        else
-          Puppet.notice(_("Environment '%{environment}' not found on server, skipping initial pluginsync.") % { environment: @environment })
-        end
-      else
-        Puppet.log_exception(detail, detail.message)
-      end
-      false
-    rescue => detail
-      Puppet.log_exception(detail, detail.message)
-      false
-    end
-  end
-
   def find_functional_server
     begin
       session = Puppet.lookup(:http_session)
@@ -474,78 +457,10 @@ class Puppet::Configurer
   end
   private :find_functional_server
 
-  #
-  # @api private
-  #
-  # Read the last server-specified environment from the lastrunfile. The
-  # environment is considered to be server-specified if the values of
-  # `initial_environment` and `converged_environment` are different.
-  #
-  # @return [String, Boolean] An array containing a string with the environment
-  #   read from the lastrunfile in case the server is authoritative, and a
-  #   boolean marking whether the last environment was correctly loaded.
-  def last_server_specified_environment
-    return @last_server_specified_environment, @loaded_last_environment if @last_server_specified_environment
-
-    if Puppet::FileSystem.exist?(Puppet[:lastrunfile])
-      summary = Puppet::Util::Yaml.safe_load_file(Puppet[:lastrunfile])
-      return [nil, nil] unless summary['application']['run_mode'] == 'agent'
-      initial_environment = summary['application']['initial_environment']
-      converged_environment = summary['application']['converged_environment']
-      @last_server_specified_environment = converged_environment if initial_environment != converged_environment
-      Puppet.debug(_("Successfully loaded last environment from the lastrunfile"))
-      @loaded_last_environment = true
-    end
-
-    Puppet.debug(_("Found last server-specified environment: %{environment}") % { environment: @last_server_specified_environment }) if @last_server_specified_environment
-    [@last_server_specified_environment, @loaded_last_environment]
-  rescue => detail
-    Puppet.debug(_("Could not find last server-specified environment: %{detail}") % { detail: detail })
-    [nil, nil]
-  end
-  private :last_server_specified_environment
-
-  def current_server_specified_environment(current_environment, configured_environment, options)
-    return @server_specified_environment if @server_specified_environment
-
-    begin
-      node_retr_time = thinmark do
-        node = Puppet::Node.indirection.find(Puppet[:node_name_value],
-                                             :environment => Puppet::Node::Environment.remote(current_environment),
-                                             :configured_environment => configured_environment,
-                                             :ignore_cache => true,
-                                             :transaction_uuid => @transaction_uuid,
-                                             :fail_on_404 => true)
-
-        @server_specified_environment = node.environment_name.to_s
-
-        if @server_specified_environment != @environment
-          Puppet.notice _("Local environment: '%{local_env}' doesn't match server specified node environment '%{node_env}', switching agent to '%{node_env}'.") % { local_env: @environment, node_env: @server_specified_environment }
-        end
-      end
-
-      options[:report].add_times(:node_retrieval, node_retr_time)
-
-      @server_specified_environment
-    rescue => detail
-      Puppet.warning(_("Unable to fetch my node definition, but the agent run will continue:"))
-      Puppet.warning(detail)
-      nil
-    end
-  end
-  private :current_server_specified_environment
-
   def send_report(report)
     puts report.summary if Puppet[:summarize]
     save_last_run_summary(report)
-    if Puppet[:report]
-      remote = Puppet::Node::Environment.remote(@environment)
-      begin
-        Puppet::Transaction::Report.indirection.save(report, nil, ignore_cache: true, environment: remote)
-      ensure
-        Puppet::Transaction::Report.indirection.save(report, nil, ignore_terminus: true, environment: remote)
-      end
-    end
+    Puppet::Transaction::Report.indirection.save(report, nil, :environment => Puppet::Node::Environment.remote(@environment)) if Puppet[:report]
   rescue => detail
     Puppet.log_exception(detail, _("Could not send report: %{detail}") % { detail: detail })
   end
@@ -568,7 +483,7 @@ class Puppet::Configurer
   # @return [false] If an exception is raised during fact generation or
   #   submission.
   def resubmit_facts
-    Puppet.runtime[:facter].clear
+    ::Facter.clear
     facts = find_facts
 
     client = Puppet.runtime[:http]
@@ -603,17 +518,6 @@ class Puppet::Configurer
     end
   end
 
-  def push_current_environment_and_loaders
-    new_env = Puppet::Node::Environment.remote(@environment)
-    Puppet.push_context(
-      {
-        :current_environment => new_env,
-        :loaders => Puppet::Pops::Loaders.new(new_env, true)
-      },
-      "Local node environment #{@environment} for configurer transaction"
-    )
-  end
-
   def retrieve_catalog_from_cache(query_options)
     result = nil
     @duration = thinmark do
@@ -641,7 +545,6 @@ class Puppet::Configurer
           # don't update cache until after environment converges
           :ignore_cache_save => true,
           :environment       => Puppet::Node::Environment.remote(@environment),
-          :check_environment => true,
           :fail_on_404       => true,
           :facts_for_catalog => facts
         )

data/lib/puppet/confine/variable.rb

@@ -18,7 +18,7 @@ class Puppet::Confine::Variable < Puppet::Confine
 
   # Retrieve the value from facter
   def facter_value
-    @facter_value ||= Puppet.runtime[:facter].value(name).to_s.downcase
+    @facter_value ||= ::Facter.value(name).to_s.downcase
   end
 
   def initialize(values)