puppet 4.0.0 → 5.0.0

data/lib/hiera/puppet_function.rb

@@ -12,10 +12,15 @@ class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
       param 'Tuple[String, Any, Any, 1, 3]', :args
     end
 
-    dispatch :hiera do
+    dispatch :hiera_no_default do
       scope_param
       param 'String',:key
-      optional_param 'Any',   :default
+    end
+
+    dispatch :hiera_with_default do
+      scope_param
+      param 'String',:key
+      param 'Any',   :default
       optional_param 'Any',   :override
     end
 
@@ -37,35 +42,40 @@ class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
     hiera(scope, *args)
   end
 
-  def hiera(scope, key, default = nil, override = nil)
-    post_lookup(key, lookup(scope, key, default, override))
+  def hiera_no_default(scope, key)
+    post_lookup(scope, key, lookup(scope, key, nil, false, nil))
   end
 
-  def hiera_block1(scope, key, &default_block)
-    common(scope, key, nil, default_block)
+  def hiera_with_default(scope, key, default, override = nil)
+    post_lookup(scope, key, lookup(scope, key, default, true, override))
   end
 
-  def hiera_block2(scope, key, override, &default_block)
-    common(scope, key, override, default_block)
+  def hiera_block1(scope, key, &default_block)
+    post_lookup(scope, key, lookup(scope, key, nil, false, nil, &default_block))
   end
 
-  def common(scope, key, override, default_block)
-    undefined = (@@undefined_value ||= Object.new)
-    result = lookup(scope, key, undefined, override)
-    post_lookup(key, result.equal?(undefined) ? default_block.call(key) : result)
+  def hiera_block2(scope, key, override, &default_block)
+    post_lookup(scope, key, lookup(scope, key, nil, false, override, &default_block))
   end
 
-  private :common
-
-  def lookup(scope, key, default, override)
-    HieraPuppet.lookup(key, default,scope, override, merge_type)
+  def lookup(scope, key, default, has_default, override, &default_block)
+    unless Puppet[:strict] == :off
+      Puppet.warn_once('deprecations', self.class.name,
+        "The function '#{self.class.name}' is deprecated in favor of using 'lookup'. See https://docs.puppet.com/puppet/#{Puppet.minor_version}/reference/deprecated_language.html")
+    end
+    lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {})
+    adapter = lookup_invocation.lookup_adapter
+    lookup_invocation.set_hiera_xxx_call
+    lookup_invocation.set_global_only unless adapter.global_only? || adapter.has_environment_data_provider?(lookup_invocation)
+    lookup_invocation.set_hiera_v3_location_overrides(override) unless override.nil? || override.is_a?(Array) && override.empty?
+    Puppet::Pops::Lookup.lookup(key, nil, default, has_default, merge_type, lookup_invocation, &default_block)
   end
 
   def merge_type
-    :priority
+    :first
   end
 
-  def post_lookup(key, result)
+  def post_lookup(scope, key, result)
     result
   end
 end

data/lib/hiera/scope.rb

@@ -1,9 +1,12 @@
 class Hiera
   class Scope
-    CALLING_CLASS = "calling_class"
-    CALLING_CLASS_PATH = "calling_class_path"
-    CALLING_MODULE = "calling_module"
-    MODULE_NAME = "module_name"
+    CALLING_CLASS = 'calling_class'.freeze
+    CALLING_CLASS_PATH = 'calling_class_path'.freeze
+    CALLING_MODULE = 'calling_module'.freeze
+    MODULE_NAME = 'module_name'.freeze
+
+    CALLING_KEYS = [CALLING_CLASS, CALLING_CLASS_PATH, CALLING_MODULE].freeze
+    EMPTY_STRING = ''.freeze
 
     attr_reader :real
 
@@ -21,20 +24,15 @@ class Hiera
       else
         ans = @real.lookupvar(key)
       end
+      ans == EMPTY_STRING ? nil : ans
+    end
 
-      if ans.nil? or ans == ""
-        nil
-      else
-        ans
-      end
+    def exist?(key)
+      CALLING_KEYS.include?(key) || @real.exist?(key)
     end
 
     def include?(key)
-      if [CALLING_CLASS, CALLING_CLASS_PATH, CALLING_MODULE].include? key
-        true
-      else
-        @real.lookupvar(key) != ""
-      end
+      CALLING_KEYS.include?(key) || @real.include?(key)
     end
 
     def catalog

data/lib/hiera_puppet.rb

@@ -67,21 +67,13 @@ module HieraPuppet
   end
 
   def hiera_config_file
-    config_file = nil
-
-    if Puppet.settings[:hiera_config].is_a?(String)
-      expanded_config_file = File.expand_path(Puppet.settings[:hiera_config])
-      if Puppet::FileSystem.exist?(expanded_config_file)
-        config_file = expanded_config_file
-      end
-    elsif Puppet.settings[:confdir].is_a?(String)
-      expanded_config_file = File.expand_path(File.join(Puppet.settings[:confdir], '/hiera.yaml'))
-      if Puppet::FileSystem.exist?(expanded_config_file)
-        config_file = expanded_config_file
-      end
+    hiera_config = Puppet.settings[:hiera_config]
+    if Puppet::FileSystem.exist?(hiera_config)
+      hiera_config
+    else
+      Puppet.warning "Config file #{hiera_config} not found, using Hiera defaults"
+      nil
     end
-
-    config_file
   end
 end
 

data/lib/puppet/agent/disabler.rb

@@ -10,20 +10,20 @@ require 'puppet/util/json_lockfile'
 #  because it used by external tools such as mcollective.
 #
 # For more information, please see docs on the website.
-#  http://links.puppetlabs.com/agent_lockfiles
+#  http://links.puppet.com/agent_lockfiles
 module Puppet::Agent::Disabler
   DISABLED_MESSAGE_JSON_KEY = "disabled_message"
 
   # Let the daemon run again, freely in the filesystem.
   def enable
-    Puppet.notice "Enabling Puppet."
+    Puppet.notice _("Enabling Puppet.")
     disable_lockfile.unlock
   end
 
   # Stop the daemon from making any catalog runs.
   def disable(msg=nil)
     data = {}
-    Puppet.notice "Disabling Puppet."
+    Puppet.notice _("Disabling Puppet.")
     if (! msg.nil?)
       data[DISABLED_MESSAGE_JSON_KEY] = msg
     end

data/lib/puppet/agent/locker.rb

@@ -1,4 +1,5 @@
 require 'puppet/util/pidlock'
+require 'puppet/error'
 
 # This module is responsible for encapsulating the logic for "locking" the
 # puppet agent during a catalog run; in other words, keeping track of enough
@@ -10,10 +11,10 @@ require 'puppet/util/pidlock'
 # Puppet API because it used by external tools such as mcollective.
 #
 # For more information, please see docs on the website.
-#  http://links.puppetlabs.com/agent_lockfiles
+#  http://links.puppet.com/agent_lockfiles
 module Puppet::Agent::Locker
-  # Yield if we get a lock, else do nothing.  Return
-  # true/false depending on whether we get the lock.
+  # Yield if we get a lock, else raise Puppet::LockError. Return
+  # value of block yielded.
   def lock
     if lockfile.lock
       begin
@@ -21,10 +22,18 @@ module Puppet::Agent::Locker
       ensure
         lockfile.unlock
       end
+    else
+      fail Puppet::LockError, _('Failed to acquire lock')
     end
   end
 
+  # @deprecated
   def running?
+    Puppet.deprecation_warning _(<<-ENDHEREDOC)
+Puppet::Agent::Locker.running? is deprecated as it is inherently unsafe.
+The only safe way to know if the lock is locked is to try lock and perform some
+action and then handle the LockError that may result.
+ENDHEREDOC
     lockfile.locked?
   end
 

data/lib/puppet/agent.rb

@@ -1,4 +1,6 @@
 require 'puppet/application'
+require 'puppet/error'
+require 'puppet/util/at_fork'
 
 # A general class for triggering a run of another
 # class.
@@ -9,11 +11,12 @@ class Puppet::Agent
   require 'puppet/agent/disabler'
   include Puppet::Agent::Disabler
 
-  attr_reader :client_class, :client, :splayed, :should_fork
+  require 'puppet/util/splayer'
+  include Puppet::Util::Splayer
 
-  def initialize(client_class, should_fork=true)
-    @splayed = false
+  attr_reader :client_class, :client, :should_fork
 
+  def initialize(client_class, should_fork=true)
     @should_fork = can_fork? && should_fork
     @client_class = client_class
   end
@@ -28,12 +31,8 @@ class Puppet::Agent
 
   # Perform a run with our client.
   def run(client_options = {})
-    if running?
-      Puppet.notice "Run of #{client_class} already in progress; skipping  (#{lockfile_path} exists)"
-      return
-    end
     if disabled?
-      Puppet.notice "Skipping run of #{client_class}; administratively disabled (Reason: '#{disable_message}');\nUse 'puppet agent --enable' to re-enable."
+      Puppet.notice _("Skipping run of %{client_class}; administratively disabled (Reason: '%{disable_message}');\nUse 'puppet agent --enable' to re-enable.") % { client_class: client_class, disable_message: disable_message }
       return
     end
 
@@ -41,18 +40,21 @@ class Puppet::Agent
     block_run = Puppet::Application.controlled_run do
       splay client_options.fetch :splay, Puppet[:splay]
       result = run_in_fork(should_fork) do
-        with_client do |client|
+        with_client(client_options[:transaction_uuid], client_options[:job_id]) do |client|
           begin
-            client_args = client_options.merge(:pluginsync => Puppet[:pluginsync])
+            client_args = client_options.merge(:pluginsync => Puppet::Configurer.should_pluginsync?)
             lock { client.run(client_args) }
+          rescue Puppet::LockError
+            Puppet.notice _("Run of %{client_class} already in progress; skipping  (%{lockfile_path} exists)") % { client_class: client_class, lockfile_path: lockfile_path }
+            return
           rescue StandardError => detail
-            Puppet.log_exception(detail, "Could not run #{client_class}: #{detail}")
+            Puppet.log_exception(detail, _("Could not run %{client_class}: %{detail}") % { client_class: client_class, detail: detail })
           end
         end
       end
       true
     end
-    Puppet.notice "Shutdown/restart in progress (#{Puppet::Application.run_status.inspect}); skipping run" unless block_run
+    Puppet.notice _("Shutdown/restart in progress (%{status}); skipping run") % { status: Puppet::Application.run_status.inspect } unless block_run
     result
   end
 
@@ -60,35 +62,29 @@ class Puppet::Agent
     Puppet::Application.stop_requested?
   end
 
-  # Have we splayed already?
-  def splayed?
-    splayed
-  end
-
-  # Sleep when splay is enabled; else just return.
-  def splay(do_splay = Puppet[:splay])
-    return unless do_splay
-    return if splayed?
-
-    time = rand(Puppet[:splaylimit] + 1)
-    Puppet.info "Sleeping for #{time} seconds (splay is enabled)"
-    sleep(time)
-    @splayed = true
-  end
-
   def run_in_fork(forking = true)
     return yield unless forking or Puppet.features.windows?
 
-    child_pid = Kernel.fork do
-      $0 = "puppet agent: applying configuration"
-      begin
-        exit(yield)
-      rescue SystemExit
-        exit(-1)
-      rescue NoMemoryError
-        exit(-2)
+    atForkHandler = Puppet::Util::AtFork.get_handler
+
+    atForkHandler.prepare
+
+    begin
+      child_pid = Kernel.fork do
+        atForkHandler.child
+        $0 = _("puppet agent: applying configuration")
+        begin
+          exit(yield)
+        rescue SystemExit
+          exit(-1)
+        rescue NoMemoryError
+          exit(-2)
+        end
       end
+    ensure
+      atForkHandler.parent
     end
+
     exit_code = Process.waitpid2(child_pid)
     case exit_code[1].exitstatus
     when -1
@@ -103,11 +99,11 @@ class Puppet::Agent
 
   # Create and yield a client instance, keeping a reference
   # to it during the yield.
-  def with_client
+  def with_client(transaction_uuid, job_id = nil)
     begin
-      @client = client_class.new
+      @client = client_class.new(Puppet::Configurer::DownloaderFactory.new, transaction_uuid, job_id)
     rescue StandardError => detail
-      Puppet.log_exception(detail, "Could not create instance of #{client_class}: #{detail}")
+      Puppet.log_exception(detail, _("Could not create instance of %{client_class}: %{detail}") % { client_class: client_class, detail: detail })
       return
     end
     yield @client

data/lib/puppet/application/agent.rb

@@ -21,7 +21,7 @@ class Puppet::Application::Agent < Puppet::Application
   def preinit
     # Do an initial trap, so that cancels don't get a stack trace.
     Signal.trap(:INT) do
-      $stderr.puts "Cancelling startup"
+      $stderr.puts _("Cancelling startup")
       exit(0)
     end
 
@@ -71,6 +71,10 @@ class Puppet::Application::Agent < Puppet::Application
     options[:waitforcert] = arg.to_i
   end
 
+  option("--job-id ID") do |arg|
+    options[:job_id] = arg
+  end
+
   def help
     <<-'HELP'
 
@@ -118,14 +122,14 @@ go into the background, attempt to get a signed certificate, and retrieve
 and apply its configuration every 30 minutes.
 
 Some flags are meant specifically for interactive use -- in particular,
-'test', 'tags' or 'fingerprint' are useful. 'test' enables verbose
-logging, causes the daemon to stay in the foreground, exits if the
-server's configuration is invalid (this happens if, for instance, you've
-left a syntax error on the server), and exits after running the
-configuration once (rather than hanging around as a long-running
-process).
-
-'tags' allows you to specify what portions of a configuration you want
+'test', 'tags' and 'fingerprint' are useful.
+
+'--test' does a single run in the foreground with verbose logging, then exits.
+It will also exit if it can't get a valid catalog. The exit code after running
+with '--test' is 0 if the catalog was successfully applied, and 1 if the run
+either failed or wasn't attempted (due to another run already in progress).
+
+'--tags' allows you to specify what portions of a configuration you want
 to apply. Puppet elements are tagged with all of the class or definition
 names that contain them, and you can use the 'tags' flag to specify one
 of these names, causing only configuration elements contained within
@@ -136,7 +140,7 @@ class, and call puppet with '--tags ntpd', which would only apply that
 small portion of the configuration during your testing, rather than
 applying the whole thing.
 
-'fingerprint' is a one-time flag. In this mode 'puppet agent' will run
+'--fingerprint' is a one-time flag. In this mode 'puppet agent' will run
 once and display on the console (and in the log) the current certificate
 (or certificate request) fingerprint. Providing the '--digest' option
 allows to use a different digest algorithm to generate the fingerprint.
@@ -155,7 +159,7 @@ specify '--server <servername>' as an argument. Boolean settings translate into
 '--setting' and '--no-setting' pairs.
 
 See the configuration file documentation at
-http://docs.puppetlabs.com/references/stable/configuration.html for the
+https://docs.puppetlabs.com/puppet/latest/reference/configuration.html for the
 full list of acceptable settings. A commented list of all settings can also be
 generated by running puppet agent with '--genconfig'.
 
@@ -181,10 +185,20 @@ generated by running puppet agent with '--genconfig'.
   Enable full debugging.
 
 * --detailed-exitcodes:
-  Provide transaction information via exit codes. If this is enabled, an exit
-  code of '2' means there were changes, an exit code of '4' means there were
-  failures during the transaction, and an exit code of '6' means there were both
-  changes and failures.
+  Provide extra information about the run via exit codes; only works if '--test'
+  or '--onetime' is also specified. If enabled, 'puppet agent' will use the
+  following exit codes:
+
+  0: The run succeeded with no changes or failures; the system was already in
+  the desired state.
+
+  1: The run failed, or wasn't attempted due to another run already in progress.
+
+  2: The run succeeded, and some resources were changed.
+
+  4: The run succeeded, and some resources failed.
+
+  6: The run succeeded, and included both changes and failures.
 
 * --digest:
   Change the certificate fingerprinting digest algorithm. The default is
@@ -222,12 +236,21 @@ generated by running puppet agent with '--genconfig'.
 * --help:
   Print this help message
 
+* --job-id:
+  Attach the specified job id to the catalog request and the report used for
+  this agent run. This option only works when '--onetime' is used.
+
 * --logdest:
   Where to send log messages. Choose between 'syslog' (the POSIX syslog
   service), 'eventlog' (the Windows Event Log), 'console', or the path to a log
   file. If debugging or verbosity is enabled, this defaults to 'console'.
   Otherwise, it defaults to 'syslog' on POSIX systems and 'eventlog' on Windows.
 
+  A path ending with '.json' will receive structured output in JSON format. The
+  log file will not have an ending ']' automatically written to it due to the
+  appending nature of logging. It must be appended manually to make the content
+  valid JSON.
+
 * --masterport:
   The port on which to contact the puppet master.
   (This is a Puppet setting, and can go in puppet.conf.)
@@ -248,8 +271,8 @@ generated by running puppet agent with '--genconfig'.
 
 * --test:
   Enable the most common options used for testing. These are 'onetime',
-  'verbose', 'ignorecache', 'no-daemonize', 'no-usecacheonfailure',
-  'detailed-exitcodes', 'no-splay', and 'show_diff'.
+  'verbose', 'no-daemonize', 'no-usecacheonfailure', 'detailed-exitcodes',
+  'no-splay', and 'show_diff'.
 
 * --verbose:
   Turn on verbose reporting.
@@ -294,7 +317,7 @@ Luke Kanies
 
 COPYRIGHT
 ---------
-Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
+Copyright (c) 2011 Puppet Inc., LLC Licensed under the Apache 2.0 License
 
     HELP
   end
@@ -307,6 +330,9 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
       # waiting for certificates so that we don't block
       daemon = daemonize_process_when(Puppet[:daemonize])
 
+      # Setup signal traps immediately after daemonization so we clean up the daemon
+      daemon.set_signal_traps
+
       wait_for_certificates
 
       if Puppet[:onetime]
@@ -320,20 +346,19 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
   def fingerprint
     host = Puppet::SSL::Host.new
     unless cert = host.certificate || host.certificate_request
-      $stderr.puts "Fingerprint asked but no certificate nor certificate request have yet been issued"
+      $stderr.puts _("Fingerprint asked but no certificate nor certificate request have yet been issued")
       exit(1)
       return
     end
     unless digest = cert.digest(options[:digest].to_s)
-      raise ArgumentError, "Could not get fingerprint for digest '#{options[:digest]}'"
+      raise ArgumentError, _("Could not get fingerprint for digest '%{digest}'") % { digest: options[:digest] }
     end
     puts digest.to_s
   end
 
   def onetime(daemon)
-    daemon.set_signal_traps
     begin
-      exitstatus = daemon.agent.run
+      exitstatus = daemon.agent.run(:job_id => options[:job_id])
     rescue => detail
       Puppet.log_exception(detail)
     end
@@ -350,13 +375,12 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
   end
 
   def main(daemon)
-    Puppet.notice "Starting Puppet client version #{Puppet.version}"
+    Puppet.notice _("Starting Puppet client version %{version}") % { version: Puppet.version }
     daemon.start
   end
 
   # Enable all of the most common test options.
   def setup_test
-    Puppet.settings.handlearg("--ignorecache")
     Puppet.settings.handlearg("--no-usecacheonfailure")
     Puppet.settings.handlearg("--no-splay")
     Puppet.settings.handlearg("--show_diff")
@@ -367,6 +391,8 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
   end
 
   def setup
+    raise ArgumentError, _("The puppet agent command does not take parameters") unless command_line.args.empty?
+
     setup_test if options[:test]
 
     setup_logs
@@ -385,7 +411,9 @@ Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
     # we want the last report to be persisted locally
     Puppet::Transaction::Report.indirection.cache_class = :yaml
 
-    if Puppet[:catalog_cache_terminus]
+    if Puppet[:noop]
+      Puppet::Resource::Catalog.indirection.cache_class = nil
+    elsif Puppet[:catalog_cache_terminus]
       Puppet::Resource::Catalog.indirection.cache_class = Puppet[:catalog_cache_terminus]
     end