puppet 5.0.0 → 6.0.0

data/lib/puppet/application.rb

@@ -209,7 +209,14 @@ class Application
     # @return [Array<String>] the names of available applications
     # @api public
     def available_application_names
-      @loader.files_to_load.map do |fn|
+      # Use our configured environment to load the application, as it may
+      # be in a module we installed locally, otherwise fallback to our
+      # current environment (*root*). Once we load the application the
+      # current environment will change from *root* to the application
+      # specific environment.
+      environment = Puppet.lookup(:environments).get(Puppet[:environment]) ||
+                    Puppet.lookup(:current_environment)
+      @loader.files_to_load(environment).map do |fn|
         ::File.basename(fn, '.rb')
       end.uniq
     end
@@ -281,6 +288,23 @@ class Application
       @run_mode = Puppet::Util::RunMode[ mode_name || Puppet.settings.preferred_run_mode ]
     end
 
+    # Sets environment_mode name
+    # @param mode_name [Symbol] The name of the environment mode to run in. May
+    #   be one of :local, :remote, or :not_required. This impacts where the
+    #   application looks for its specified environment. If :not_required or
+    #   :remote are set, the application will not fail if the environment does
+    #   not exist on the local filesystem.
+    def environment_mode(mode_name)
+      raise Puppet::Error, _("Invalid environment mode '%{mode_name}'") % { mode_name: mode_name } unless [:local, :remote, :not_required].include?(mode_name)
+      @environment_mode = mode_name
+    end
+
+    # Gets environment_mode name. If none is set with `environment_mode=`,
+    # default to :local.
+    def get_environment_mode
+      @environment_mode || :local
+    end
+
     # This is for testing only
     def clear_everything_for_tests
       @run_mode = @banner = @run_status = @option_parser_commands = nil
@@ -294,13 +318,13 @@ class Application
   # handling of this.
   option("--version", "-V") do |arg|
     puts "#{Puppet.version}"
-    exit
+    exit(0)
   end
 
   # Every app responds to --help
   option("--help", "-h") do |v|
     puts help
-    exit
+    exit(0)
   end
 
   def app_defaults()
@@ -339,23 +363,23 @@ class Application
     # I don't really like the names of these lifecycle phases.  It would be nice to change them to some more meaningful
     # names, and make deprecated aliases.  --cprice 2012-03-16
 
-    exit_on_fail(_("get application-specific default settings")) do
+    exit_on_fail(_("Could not get application-specific default settings")) do
       initialize_app_defaults
     end
 
-    Puppet::ApplicationSupport.push_application_context(self.class.run_mode)
+    Puppet::ApplicationSupport.push_application_context(self.class.run_mode, self.class.get_environment_mode)
 
-    exit_on_fail(_("initialize"))                                   { preinit }
-    exit_on_fail(_("parse application options"))                    { parse_options }
-    exit_on_fail(_("prepare for execution"))                        { setup }
+    exit_on_fail(_("Could not initialize"))                { preinit }
+    exit_on_fail(_("Could not parse application options")) { parse_options }
+    exit_on_fail(_("Could not prepare for execution"))     { setup }
 
     if deprecated?
       Puppet.deprecation_warning(_("`puppet %{name}` is deprecated and will be removed in a future release.") % { name: name })
     end
 
-    exit_on_fail(_("configure routes from %{route_file}") % { route_file: Puppet[:route_file] }) { configure_indirector_routes }
-    exit_on_fail(_("log runtime debug info"))                       { log_runtime_environment }
-    exit_on_fail(_("run"))                                          { run_command }
+    exit_on_fail(_("Could not configure routes from %{route_file}") % { route_file: Puppet[:route_file] }) { configure_indirector_routes }
+    exit_on_fail(_("Could not log runtime debug info"))                       { log_runtime_environment }
+    exit_on_fail(_("Could not run"))                                          { run_command }
   end
 
   def main
@@ -474,5 +498,12 @@ class Application
   def help
     _("No help available for puppet %{app_name}") % { app_name: name }
   end
+
+  # The description used in top level `puppet help` output
+  # If left empty in implementations, we will attempt to extract
+  # the summary from the help text itself.
+  def summary
+    ""
+  end
 end
 end

data/lib/puppet/application_support.rb

@@ -14,9 +14,11 @@ module Puppet
     # before being set in a pushed Puppet Context.
     #
     # @param run_mode [Puppet::Util::RunMode] Puppet's current Run Mode.
+    # @param environment_mode [Symbol] optional, Puppet's
+    #   current Environment Mode. Defaults to :local
     # @return [void]
     # @api private
-    def self.push_application_context(run_mode)
+    def self.push_application_context(run_mode, environment_mode = :local)
       Puppet.push_context(Puppet.base_context(Puppet.settings), "Update for application settings (#{run_mode})")
       # This use of configured environment is correct, this is used to establish
       # the defaults for an application that does not override, or where an override
@@ -25,6 +27,9 @@ module Puppet
       configured_environment_name = Puppet[:environment]
       if run_mode.name == :agent
         configured_environment = Puppet::Node::Environment.remote(configured_environment_name)
+      elsif environment_mode == :not_required
+        configured_environment =
+          Puppet.lookup(:environments).get(configured_environment_name) || Puppet::Node::Environment.remote(configured_environment_name)
       else
         configured_environment = Puppet.lookup(:environments).get!(configured_environment_name)
       end
@@ -47,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/downloader.rb

@@ -54,7 +54,7 @@ class Puppet::Configurer::Downloader
       :backup => false,
       :noop => false
     }
-    if !Puppet.features.microsoft_windows?
+    if !Puppet::Util::Platform.windows?
       defargs.merge!(
         {
           :owner => Process.uid,

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

@@ -4,21 +4,44 @@
 require 'puppet/configurer'
 
 class Puppet::Configurer::PluginHandler
-  def initialize(factory)
-    @factory = factory
-  end
+  SUPPORTED_LOCALES_MOUNT_AGENT_VERSION = Gem::Version.new("5.3.4")
 
-  # Retrieve facts from the central server.
   def download_plugins(environment)
-    plugin_downloader = @factory.create_plugin_downloader(environment)
+    source_permissions = Puppet::Util::Platform.windows? ? :ignore : :use
 
-    result = []
+    plugin_downloader = Puppet::Configurer::Downloader.new(
+      "plugin",
+      Puppet[:plugindest],
+      Puppet[:pluginsource],
+      Puppet[:pluginsignore],
+      environment
+    )
+    plugin_fact_downloader = Puppet::Configurer::Downloader.new(
+      "pluginfacts",
+      Puppet[:pluginfactdest],
+      Puppet[:pluginfactsource],
+      Puppet[:pluginsignore],
+      environment,
+      source_permissions
+    )
 
-    plugin_fact_downloader = @factory.create_plugin_facts_downloader(environment)
+    result = []
     result += plugin_fact_downloader.evaluate
-
     result += plugin_downloader.evaluate
-    Puppet::Util::Autoload.reload_changed
+
+    server_agent_version = Puppet.lookup(:server_agent_version) { "0.0" }
+    if Gem::Version.new(server_agent_version) >= SUPPORTED_LOCALES_MOUNT_AGENT_VERSION
+      locales_downloader = Puppet::Configurer::Downloader.new(
+        "locales",
+        Puppet[:localedest],
+        Puppet[:localesource],
+        Puppet[:pluginsignore] + " *.pot config.yaml",
+        environment
+      )
+      result += locales_downloader.evaluate
+    end
+
+    Puppet::Util::Autoload.reload_changed(Puppet.lookup(:current_environment))
 
     result
   end

data/lib/puppet/configurer.rb

@@ -4,11 +4,12 @@ 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'
   require 'puppet/configurer/plugin_handler'
-  require 'puppet/configurer/downloader_factory'
 
   include Puppet::Configurer::FactHandler
 
@@ -23,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
 
@@ -56,7 +53,7 @@ class Puppet::Configurer
     end
   end
 
-  def initialize(factory = Puppet::Configurer::DownloaderFactory.new, transaction_uuid = nil, job_id = nil)
+  def initialize(transaction_uuid = nil, job_id = nil)
     @running = false
     @splayed = false
     @cached_catalog_status = 'not_used'
@@ -65,7 +62,7 @@ class Puppet::Configurer
     @job_id = job_id
     @static_catalog = true
     @checksum_type = Puppet[:supported_checksum_types]
-    @handler = Puppet::Configurer::PluginHandler.new(factory)
+    @handler = Puppet::Configurer::PluginHandler.new()
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
@@ -103,19 +100,36 @@ class Puppet::Configurer
   end
 
   # Convert a plain resource catalog into our full host catalog.
-  def convert_catalog(result, duration)
-    catalog = result.to_ral
-    catalog.finalize
-    catalog.retrieval_duration = duration
-    catalog.write_class_file
-    catalog.write_resource_file
+  def convert_catalog(result, duration, options = {})
+    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
+      catalog.write_class_file
+      catalog.write_resource_file
+    end
+    options[:report].add_times(:convert_catalog, catalog_conversion_time) if options[:report]
+
     catalog
   end
 
   def get_facts(options)
     if options[:pluginsync]
-      remote_environment_for_plugins = Puppet::Node::Environment.remote(@environment)
-      download_plugins(remote_environment_for_plugins)
+      plugin_sync_time = thinmark do
+        remote_environment_for_plugins = Puppet::Node::Environment.remote(@environment)
+        download_plugins(remote_environment_for_plugins)
+
+        Puppet::GettextConfig.reset_text_domain('agent')
+        Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+      end
+      options[:report].add_times(:plugin_sync, plugin_sync_time) if options[:report]
     end
 
     facts_hash = {}
@@ -125,7 +139,12 @@ class Puppet::Configurer
       # get a hash with both of these pieces of information.
       #
       # facts_for_uploading may set Puppet[:node_name_value] as a side effect
-      facts_hash = facts_for_uploading
+      facter_time = thinmark do
+        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
@@ -147,17 +166,19 @@ class Puppet::Configurer
 
     # retrieve_catalog returns json catalog
     catalog = retrieve_catalog(query_options)
-    return convert_catalog(catalog, @duration) if catalog
+    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
+  def prepare_and_retrieve_catalog_from_cache(options = {})
     result = retrieve_catalog_from_cache({:transaction_uuid => @transaction_uuid, :static_catalog => @static_catalog})
     if result
       Puppet.info _("Using cached catalog from environment '%{catalog_env}'") % { catalog_env: result.environment }
-      return convert_catalog(result, @duration)
+      # 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
@@ -165,15 +186,15 @@ class Puppet::Configurer
   # Apply supplied catalog and return associated application report
   def apply_catalog(catalog, options)
     report = options[:report]
-    begin
-      report.configuration_version = catalog.version
+    report.configuration_version = catalog.version
 
-      benchmark(:notice, _("Applied catalog")) do
+    benchmark(:notice, _("Applied catalog in %{seconds} seconds")) do
+      apply_catalog_time = thinmark do
         catalog.apply(options)
       end
-    ensure
-      report.finalize_report
+      options[:report].add_times(:catalog_application, apply_catalog_time)
     end
+
     report
   end
 
@@ -192,48 +213,51 @@ class Puppet::Configurer
 
     Puppet::Util::Log.newdestination(report)
 
+    completed = nil
     begin
       Puppet.override(:http_pool => pool) do
 
         # Skip failover logic if the server_list setting is empty
         if Puppet.settings[:server_list].nil? || Puppet.settings[:server_list].empty?
-          do_failover = false;
+          do_failover = false
         else
           do_failover = true
         end
         # 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
-          found = find_functional_server()
-          server = found[:server]
-          if server.nil?
-            Puppet.warning _("Could not select a functional puppet master")
-            server = [nil, nil]
-          end
-          Puppet.override(:server => server[0], :serverport => server[1]) do
-            if !server.first.nil?
-              Puppet.debug "Selected master: #{server[0]}:#{server[1]}"
-              report.master_used = "#{server[0]}:#{server[1]}"
+          server, port = find_functional_server
+          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
-
-            run_internal(options.merge(:node => found[:node]))
+            completed = run_internal(options)
           end
         else
-          run_internal(options)
+          completed = run_internal(options)
         end
       end
     ensure
       pool.close
     end
+
+    completed ? report.exit_status : nil
   end
 
   def run_internal(options)
+    start = Time.now
     report = options[:report]
 
     # If a cached catalog is explicitly requested, attempt to retrieve it. Skip the node request,
     # don't pluginsync and switch to the catalog's environment if we successfully retrieve it.
     if Puppet[:use_cached_catalog]
-      if catalog = prepare_and_retrieve_catalog_from_cache
+      Puppet::GettextConfig.reset_text_domain('agent')
+      Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+
+      if catalog = prepare_and_retrieve_catalog_from_cache(options)
         options[:catalog] = catalog
         @cached_catalog_status = 'explicitly_requested'
 
@@ -262,13 +286,18 @@ class Puppet::Configurer
       # We only need to find out the environment to run in if we don't already have a catalog
       unless (options[:catalog] || Puppet[:strict_environment_mode])
         begin
-          if node = options[:node] || Puppet::Node.indirection.find(Puppet[:node_name_value],
+          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 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
@@ -293,19 +322,22 @@ class Puppet::Configurer
       end
 
       current_environment = Puppet.lookup(:current_environment)
-      local_node_environment =
       if current_environment.name == @environment.intern
-        current_environment
+        local_node_environment = current_environment
       else
-        Puppet::Node::Environment.create(@environment,
+        local_node_environment = Puppet::Node::Environment.create(@environment,
                                          current_environment.modulepath,
                                          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(options, query_options)
         return nil
@@ -342,7 +374,7 @@ class Puppet::Configurer
       options[:report].catalog_uuid = catalog.catalog_uuid
       options[:report].cached_catalog_status = @cached_catalog_status
       apply_catalog(catalog, options)
-      report.exit_status
+      true
     rescue => detail
       Puppet.log_exception(detail, _("Failed to apply catalog: %{detail}") % { detail: detail })
       return nil
@@ -351,38 +383,31 @@ class Puppet::Configurer
     end
   ensure
     report.cached_catalog_status ||= @cached_catalog_status
+    report.add_times(:total, Time.now - start)
+    report.finalize_report
     Puppet::Util::Log.close(report)
     send_report(report)
     Puppet.pop_context
   end
   private :run_internal
 
-  def find_functional_server()
-    configured_environment = Puppet[:environment] if Puppet.settings.set_by_config?(:environment)
-
-    node = nil
-    selected_server = Puppet.settings[:server_list].find do |server|
-      # Puppet.override doesn't return the result of its block, so we
-      # need to handle this manually
-      found = false
-      server[1] ||= Puppet[:masterport]
-      Puppet.override(:server => server[0], :serverport => server[1]) do
-        begin
-          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 => false)
-          found = true
-        rescue Exception => e
-          # Nothing to see here
-        end
+  def find_functional_server
+    Puppet.settings[:server_list].each do |server|
+      host = server[0]
+      port = server[1] || Puppet[:masterport]
+      begin
+        http = Puppet::Network::HttpPool.http_ssl_instance(host, port)
+        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
+        # Nothing to see here
+        Puppet.debug(_("Puppet server %{host}:%{port} is unreachable") % { host: host, port: port })
       end
-      found
     end
-    { :node => node,
-      :server => selected_server }
+    [nil, nil]
   end
   private :find_functional_server
 
@@ -420,8 +445,13 @@ class Puppet::Configurer
   def retrieve_catalog_from_cache(query_options)
     result = nil
     @duration = thinmark do
-      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value],
-        query_options.merge(:ignore_terminus => true, :environment => Puppet::Node::Environment.remote(@environment)))
+      result = Puppet::Resource::Catalog.indirection.find(
+        Puppet[:node_name_value],
+        query_options.merge(
+          :ignore_terminus => true,
+          :environment     => Puppet::Node::Environment.remote(@environment)
+        )
+      )
     end
     result
   rescue => detail
@@ -432,8 +462,16 @@ class Puppet::Configurer
   def retrieve_new_catalog(query_options)
     result = nil
     @duration = thinmark do
-      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value],
-        query_options.merge(:ignore_cache => true, :environment => Puppet::Node::Environment.remote(@environment), :fail_on_404 => true))
+      result = Puppet::Resource::Catalog.indirection.find(
+        Puppet[:node_name_value],
+        query_options.merge(
+          :ignore_cache      => 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
+        )
+      )
     end
     result
   rescue StandardError => detail

data/lib/puppet/confine.rb

@@ -21,7 +21,7 @@ class Puppet::Confine
   end
 
   def self.test(name)
-    unless @tests[name]
+    unless @tests.include?(name)
       begin
         require "puppet/confine/#{name}"
       rescue LoadError => detail
@@ -29,6 +29,9 @@ class Puppet::Confine
           warn "Could not load confine test '#{name}': #{detail}"
         end
         # Could not find file
+        if !Puppet[:always_retry_plugins]
+          @tests[name] = nil
+        end
       end
     end
     @tests[name]

data/lib/puppet/context.rb

@@ -52,7 +52,7 @@ class Puppet::Context
     elsif block
       block.call
     else
-      raise UndefinedBindingError, _("no '%{name}' in %{table} at top of %{stack}") % { name: name, table: @table.inspect, stack: @stack.inspect }
+      raise UndefinedBindingError, _("Unable to lookup '%{name}'") % { name: name }
     end
   end
 

data/lib/puppet/daemon.rb

@@ -79,7 +79,7 @@ class Puppet::Daemon
   end
 
   def reexec
-    raise Puppet::DevError, "Cannot reexec unless ARGV arguments are set" unless argv
+    raise Puppet::DevError, _("Cannot reexec unless ARGV arguments are set") unless argv
     command = $0 + " " + argv.join(" ")
     Puppet.notice "Restarting with '#{command}'"
     stop(:exit => false)
@@ -113,7 +113,7 @@ class Puppet::Daemon
     end
 
     # extended signals not supported under windows
-    if !Puppet.features.microsoft_windows?
+    if !Puppet::Util::Platform.windows?
       signals = {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }
       signals.each do |signal, method|
         Signal.trap(signal) do
@@ -140,7 +140,7 @@ class Puppet::Daemon
   def start
     create_pidfile
 
-    raise Puppet::DevError, "Daemons must have an agent, server, or both" unless agent or server
+    raise Puppet::DevError, _("Daemons must have an agent, server, or both") unless agent or server
 
     # Start the listening server, if required.
     server.start if server

data/lib/puppet/datatypes/error.rb

@@ -0,0 +1,21 @@
+Puppet::DataTypes.create_type('Error') do
+  interface <<-PUPPET
+    type_parameters => {
+      kind => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]],
+      issue_code => Optional[Variant[String,Regexp,Type[Enum],Type[Pattern],Type[NotUndef],Type[Undef]]]
+    },
+    attributes => {
+      msg => String[1],
+      kind => { type => Optional[String[1]], value => undef },
+      details => { type => Optional[Hash[String[1],Data]], value => undef },
+      issue_code => { type => Optional[String[1]], value => undef },
+    },
+    functions => {
+      message => Callable[[], String[1]]
+    }
+    PUPPET
+
+  require 'puppet/datatypes/impl/error'
+
+  implementation_class Puppet::DataTypes::Error
+end