puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/lib/puppet/application_support.rb

@@ -52,11 +52,10 @@ module Puppet
     def self.configure_indirector_routes(application_name)
       route_file = Puppet[:route_file]
       if Puppet::FileSystem.exist?(route_file)
-        routes = YAML.load_file(route_file)
+        routes = Puppet::Util::Yaml.safe_load_file(route_file, [Symbol])
         application_routes = routes[application_name]
         Puppet::Indirector.configure_routes(application_routes) if application_routes
       end
     end
-
   end
 end

data/lib/puppet/configurer.rb

@@ -4,6 +4,8 @@ require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
 require 'securerandom'
+#require 'puppet/parser/script_compiler'
+require 'puppet/pops/evaluator/deferred_resolver'
 
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
@@ -22,14 +24,10 @@ class Puppet::Configurer
   end
 
   def self.should_pluginsync?
-    if Puppet.settings.set_by_cli?(:pluginsync) || Puppet.settings.set_by_config?(:pluginsync)
-      Puppet[:pluginsync]
+    if Puppet[:use_cached_catalog]
+      false
     else
-      if Puppet[:use_cached_catalog]
-        false
-      else
-        true
-      end
+      true
     end
   end
 
@@ -58,7 +56,6 @@ class Puppet::Configurer
   def initialize(transaction_uuid = nil, job_id = nil)
     @running = false
     @splayed = false
-    @pluginsync_failed = false
     @cached_catalog_status = 'not_used'
     @environment = Puppet[:environment]
     @transaction_uuid = transaction_uuid || SecureRandom.uuid
@@ -71,16 +68,8 @@ class Puppet::Configurer
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog(query_options)
     query_options ||= {}
-    if Puppet[:use_cached_catalog] || @pluginsync_failed
-      result = retrieve_catalog_from_cache(query_options)
-    end
-
-    if result
-      if Puppet[:use_cached_catalog]
-        @cached_catalog_status = 'explicitly_requested'
-      elsif @pluginsync_failed
-        @cached_catalog_status = 'on_failure'
-      end
+    if (Puppet[:use_cached_catalog] && result = retrieve_catalog_from_cache(query_options))
+      @cached_catalog_status = 'explicitly_requested'
 
       Puppet.info _("Using cached catalog from environment '%{environment}'") % { environment: result.environment }
     else
@@ -115,6 +104,11 @@ class Puppet::Configurer
     catalog = nil
 
     catalog_conversion_time = thinmark do
+      # Will mutate the result and replace all Deferred values with resolved values
+      if facts = options[:convert_with_facts]
+        Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, result)
+      end
+
       catalog = result.to_ral
       catalog.finalize
       catalog.retrieval_duration = duration
@@ -146,17 +140,18 @@ class Puppet::Configurer
       #
       # facts_for_uploading may set Puppet[:node_name_value] as a side effect
       facter_time = thinmark do
-        facts_hash = facts_for_uploading
+        facts = find_facts
+        options[:convert_with_facts] =  facts
+        facts_hash = encode_facts(facts) # encode for uploading # was: facts_for_uploading
       end
       options[:report].add_times(:fact_generation, facter_time) if options[:report]
     end
     facts_hash
   end
 
-  def prepare_and_retrieve_catalog(cached_catalog, options, query_options)
+  def prepare_and_retrieve_catalog(options, query_options)
     # set report host name now that we have the fact
     options[:report].host = Puppet[:node_name_value]
-
     query_options[:transaction_uuid] = @transaction_uuid
     query_options[:job_id] = @job_id
     query_options[:static_catalog] = @static_catalog
@@ -166,19 +161,26 @@ class Puppet::Configurer
     query_options[:checksum_type] = @checksum_type.join('.')
 
     # apply passes in ral catalog
-    catalog = cached_catalog || options[:catalog]
-    unless catalog
-      # retrieve_catalog returns resource catalog
-      catalog = retrieve_catalog(query_options)
-      Puppet.err _("Could not retrieve catalog; skipping run") unless catalog
-    end
-    catalog
+    catalog = options.delete(:catalog)
+    return catalog if catalog
+
+    # retrieve_catalog returns json catalog
+    catalog = retrieve_catalog(query_options)
+    return convert_catalog(catalog, @duration, options) if catalog
+
+    Puppet.err _("Could not retrieve catalog; skipping run")
+    nil
   end
 
   def prepare_and_retrieve_catalog_from_cache(options = {})
     result = retrieve_catalog_from_cache({:transaction_uuid => @transaction_uuid, :static_catalog => @static_catalog})
-    Puppet.info _("Using cached catalog from environment '%{catalog_env}'") % { catalog_env: result.environment } if result
-    result
+    if result
+      Puppet.info _("Using cached catalog from environment '%{catalog_env}'") % { catalog_env: result.environment }
+      # get facts now so that the convert_catalog method can resolve deferred values
+      get_facts(options)
+      return convert_catalog(result, @duration, options)
+    end
+    nil
   end
 
   # Apply supplied catalog and return associated application report
@@ -225,14 +227,13 @@ class Puppet::Configurer
         # 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?
-            raise Puppet::Error, _("Could not select a functional puppet master from server_list: '%{server_list}'") % { server_list: Puppet.settings.value(:server_list, Puppet[:environment].to_sym, true) }
-          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.master_used = "#{server}:#{port}"
-          end
           Puppet.override(server: server, serverport: port) do
+            if server
+              Puppet.debug _("Selected puppet server: %{server}:%{port}") % { server: server, port: port }
+              report.master_used = "#{server}:#{port}"
+            else
+              Puppet.warning _("Could not select a functional puppet server")
+            end
             completed = run_internal(options)
           end
         else
@@ -256,12 +257,13 @@ class Puppet::Configurer
       Puppet::GettextConfig.reset_text_domain('agent')
       Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
 
-      if cached_catalog = prepare_and_retrieve_catalog_from_cache(options)
+      if catalog = prepare_and_retrieve_catalog_from_cache(options)
+        options[:catalog] = catalog
         @cached_catalog_status = 'explicitly_requested'
 
-        if @environment != cached_catalog.environment && !Puppet[:strict_environment_mode]
-          Puppet.notice _("Local environment: '%{local_env}' doesn't match the environment of the cached catalog '%{catalog_env}', switching agent to '%{catalog_env}'.") % { local_env: @environment, catalog_env: cached_catalog.environment }
-          @environment = cached_catalog.environment
+        if @environment != catalog.environment && !Puppet[:strict_environment_mode]
+          Puppet.notice _("Local environment: '%{local_env}' doesn't match the environment of the cached catalog '%{catalog_env}', switching agent to '%{catalog_env}'.") % { local_env: @environment, catalog_env: catalog.environment }
+          @environment = catalog.environment
         end
 
         report.environment = @environment
@@ -282,7 +284,7 @@ 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[:strict_environment_mode])
+      unless (options[:catalog] || Puppet[:strict_environment_mode])
         begin
           node = nil
           node_retr_time = thinmark do
@@ -328,12 +330,16 @@ class Puppet::Configurer
                                          current_environment.manifest,
                                          current_environment.config_version)
       end
-      Puppet.push_context({:current_environment => local_node_environment}, "Local node environment for configurer transaction")
+      Puppet.push_context({
+        :current_environment => local_node_environment, 
+        :loaders => Puppet::Pops::Loaders.new(local_node_environment, true)
+      }, "Local node environment for configurer transaction")
 
       query_options = get_facts(options) unless query_options
       query_options[:configured_environment] = configured_environment
+      options[:convert_for_node] = node
 
-      unless catalog = prepare_and_retrieve_catalog(cached_catalog, options, query_options)
+      unless catalog = prepare_and_retrieve_catalog(options, query_options)
         return nil
       end
 
@@ -358,37 +364,16 @@ class Puppet::Configurer
         query_options = get_facts(options)
         query_options[:configured_environment] = configured_environment
 
-        # if we get here, ignore the cached catalog
-        return nil unless catalog = prepare_and_retrieve_catalog(nil, options, query_options)
+        return nil unless catalog = prepare_and_retrieve_catalog(options, query_options)
         tries += 1
       end
 
-      # now that environment has converged, convert resource catalog into ral catalog
-      # unless we were given a RAL catalog
-      if !cached_catalog && options[:catalog]
-        ral_catalog = options[:catalog]
-      else
-        # 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, options)
-
-        # 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, environment: Puppet::Node::Environment.remote(catalog.environment))
-          Puppet.info("Caching catalog for #{request.key}")
-          indirection.cache.save(request)
-        end
-      end
-
       execute_prerun_command or return nil
 
-      options[:report].code_id = ral_catalog.code_id
-      options[:report].catalog_uuid = ral_catalog.catalog_uuid
+      options[:report].code_id = catalog.code_id
+      options[:report].catalog_uuid = catalog.catalog_uuid
       options[:report].cached_catalog_status = @cached_catalog_status
-      apply_catalog(ral_catalog, options)
+      apply_catalog(catalog, options)
       true
     rescue => detail
       Puppet.log_exception(detail, _("Failed to apply catalog: %{detail}") % { detail: detail })
@@ -397,14 +382,6 @@ class Puppet::Configurer
       execute_postrun_command or return nil
     end
   ensure
-    if Puppet[:resubmit_facts]
-      # TODO: Should mark the report as "failed" if an error occurs and
-      #       resubmit_facts returns false. There is currently no API for this.
-      resubmit_facts_time = thinmark { resubmit_facts }
-
-      report.add_times(:resubmit_facts, resubmit_facts_time)
-    end
-
     report.cached_catalog_status ||= @cached_catalog_status
     report.add_times(:total, Time.now - start)
     report.finalize_report
@@ -420,14 +397,14 @@ class Puppet::Configurer
       port = server[1] || Puppet[:masterport]
       begin
         http = Puppet::Network::HttpPool.http_ssl_instance(host, port)
-        response = http.get('/status/v1/simple/master')
-        return [host, port] if response.is_a?(Net::HTTPOK) || response.is_a?(Net::HTTPForbidden)
+        response = http.get('/status/v1/simple')
+        return [host, port] if response.is_a?(Net::HTTPOK)
 
         Puppet.debug(_("Puppet server %{host}:%{port} is unavailable: %{code} %{reason}") %
                      { host: host, port: port, code: response.code, reason: response.message })
-      rescue => detail
-        #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-        Puppet.debug _("Unable to connect to server from server_list setting: %{detail}") % {detail: detail}
+      rescue
+        # Nothing to see here
+        Puppet.debug(_("Puppet server %{host}:%{port} is unreachable") % { host: host, port: port })
       end
     end
     [nil, nil]
@@ -451,40 +428,6 @@ class Puppet::Configurer
     Puppet.log_exception(detail, _("Could not save last run local report: %{detail}") % { detail: detail })
   end
 
-  # Submit updated facts to the Puppet Server
-  #
-  # This method will clear all current fact values, load a fresh set of
-  # fact data, and then submit it to the Puppet Server.
-  #
-  # @return [true] If fact submission succeeds.
-  # @return [false] If an exception is raised during fact generation or
-  #   submission.
-  def resubmit_facts
-    ::Facter.clear
-    facts = find_facts
-
-    saved_fact_terminus = Puppet::Node::Facts.indirection.terminus_class
-    begin
-      Puppet::Node::Facts.indirection.terminus_class = :rest
-
-      server = Puppet::Node::Facts::Rest.server
-      Puppet.info(_("Uploading facts for %{node} to %{server}") % {
-                    node: facts.name,
-                    server: server})
-
-      Puppet::Node::Facts.indirection.save(facts, nil, :environment => Puppet::Node::Environment.remote(@environment))
-
-      return true
-    ensure
-      Puppet::Node::Facts.indirection.terminus_class = saved_fact_terminus
-    end
-  rescue => detail
-    Puppet.log_exception(detail, _("Failed to submit facts: %{detail}") %
-                                 { detail: detail })
-
-    return false
-  end
-
   private
 
   def execute_from_setting(setting)
@@ -523,8 +466,8 @@ class Puppet::Configurer
         Puppet[:node_name_value],
         query_options.merge(
           :ignore_cache      => true,
-          # don't update cache until after environment converges
-          :ignore_cache_save => true,
+          # We never want to update the cached Catalog if we're running in noop mode.
+          :ignore_cache_save => Puppet[:noop],
           :environment       => Puppet::Node::Environment.remote(@environment),
           :fail_on_404       => true
         )
@@ -537,14 +480,6 @@ class Puppet::Configurer
   end
 
   def download_plugins(remote_environment_for_plugins)
-    begin
-      @handler.download_plugins(remote_environment_for_plugins)
-    rescue Puppet::Error => detail
-      if !Puppet[:ignore_plugin_errors] && Puppet[:usecacheonfailure]
-        @pluginsync_failed = true
-      else
-        raise detail
-      end
-    end
+    @handler.download_plugins(remote_environment_for_plugins)
   end
 end

data/lib/puppet/configurer/downloader.rb

@@ -11,53 +11,32 @@ class Puppet::Configurer::Downloader
     files = []
     begin
       catalog.apply do |trans|
-        unless Puppet[:ignore_plugin_errors]
-          # Propagate the first failure associated with the transaction. The any_failed?
-          # method returns the first resource status that failed or nil, not a boolean.
-          first_failure = trans.any_failed?
-          if first_failure
-            event = (first_failure.events || []).first
-            detail = event ? event.message : 'unknown'
-            raise Puppet::Error.new(_("Failed to retrieve %{name}: %{detail}") % { name: name, detail: detail })
-          end
-        end
-
         trans.changed?.each do |resource|
           yield resource if block_given?
           files << resource[:path]
         end
       end
     rescue Puppet::Error => detail
-      if Puppet[:ignore_plugin_errors]
-        Puppet.log_exception(detail, _("Could not retrieve %{name}: %{detail}") % { name: name, detail: detail })
-      else
-        raise detail
-      end
+      Puppet.log_exception(detail, _("Could not retrieve %{name}: %{detail}") % { name: name, detail: detail })
     end
     files
   end
 
   def initialize(name, path, source, ignore = nil, environment = nil, source_permissions = :ignore)
     @name, @path, @source, @ignore, @environment, @source_permissions = name, path, source, ignore, environment, source_permissions
-
   end
 
-  def file
-    unless @file
-      args = default_arguments.merge(:path => path, :source => source)
-      args[:ignore] = ignore.split if ignore
-      @file = Puppet::Type.type(:file).new(args)
-    end
-    @file
+  def catalog
+    catalog = Puppet::Resource::Catalog.new("PluginSync", @environment)
+    catalog.host_config = false
+    catalog.add_resource(file)
+    catalog
   end
 
-  def catalog
-    unless @catalog
-      @catalog = Puppet::Resource::Catalog.new("PluginSync", @environment)
-      @catalog.host_config = false
-      @catalog.add_resource(file)
-    end
-    @catalog
+  def file
+    args = default_arguments.merge(:path => path, :source => source)
+    args[:ignore] = ignore.split if ignore
+    Puppet::Type.type(:file).new(args)
   end
 
   private
@@ -75,9 +54,13 @@ class Puppet::Configurer::Downloader
       :backup => false,
       :noop => false
     }
-    if !Puppet.features.microsoft_windows?
-      defargs[:owner] = Process.uid
-      defargs[:group] = Process.gid
+    if !Puppet::Util::Platform.windows?
+      defargs.merge!(
+        {
+          :owner => Process.uid,
+          :group => Process.gid
+        }
+      )
     end
     return defargs
   end

data/lib/puppet/configurer/fact_handler.rb

@@ -28,7 +28,11 @@ module Puppet::Configurer::FactHandler
   end
 
   def facts_for_uploading
-    facts = find_facts
+    encode_facts(find_facts)
+  end
+
+  def encode_facts(facts)
+    #facts = find_facts
 
     # NOTE: :facts specified as parameters are URI encoded here,
     # then  encoded for a second time depending on their length:

data/lib/puppet/configurer/plugin_handler.rb

@@ -7,7 +7,7 @@ class Puppet::Configurer::PluginHandler
   SUPPORTED_LOCALES_MOUNT_AGENT_VERSION = Gem::Version.new("5.3.4")
 
   def download_plugins(environment)
-    source_permissions = Puppet.features.microsoft_windows? ? :ignore : :use
+    source_permissions = Puppet::Util::Platform.windows? ? :ignore : :use
 
     plugin_downloader = Puppet::Configurer::Downloader.new(
       "plugin",
@@ -41,8 +41,7 @@ class Puppet::Configurer::PluginHandler
       result += locales_downloader.evaluate
     end
 
-
-    Puppet::Util::Autoload.reload_changed
+    Puppet::Util::Autoload.reload_changed(Puppet.lookup(:current_environment))
 
     result
   end