puppet 4.2.0 → 4.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8992a4a919d62e657181b071a42be09406a6d707
+  data.tar.gz: 6f1b3395bdf1187d079a204aa344229c28ea06a3
+SHA512:
+  metadata.gz: 078c55ab6450b165ecf373ff0502b6ca30715fab6cc5d38637559f341d5c3edf88cf6d6563f217dbb32dbfdf37dabca04de45f61013de73071262ad1d9db466c
+  data.tar.gz: 5b6f1b6e17a0326eff3e928acb0326c557be5938d46c2bc974eb28a819afbb089aede8ccb5ef1ce4696dd7f0dc9403094e7fab12d0299c92dee0820d59a9fbe5

data/Gemfile

@@ -25,7 +25,7 @@ end
 
 gem "puppet", :path => File.dirname(__FILE__), :require => false
 gem "facter", *location_for(ENV['FACTER_LOCATION'] || ['> 2.0', '< 4'])
-gem "hiera", *location_for(ENV['HIERA_LOCATION'] || ['>= 2.0', '< 3'])
+gem "hiera", *location_for(ENV['HIERA_LOCATION'] || ['>= 2.0', '< 4'])
 gem "rake", "10.1.1", :require => false
 
 group(:development, :test) do

data/ext/project_data.yaml

@@ -16,7 +16,7 @@ gem_default_executables: 'puppet'
 gem_forge_project: 'puppet'
 gem_runtime_dependencies:
   facter: ['> 2.0', '< 4']
-  hiera: ['>= 2.0', '< 3']
+  hiera: ['>= 2.0', '< 4']
   json_pure:
 gem_rdoc_options:
   - --title

data/ext/suse/client.init

@@ -36,7 +36,6 @@
 lockfile=/var/lock/subsys/puppet
 pidfile=/var/run/puppetlabs/agent.pid
 puppetd=/opt/puppetlabs/puppet/bin/puppet
-RETVAL=0
 
 PUPPET_OPTS="agent"
 
@@ -63,9 +62,18 @@ case "$1" in
         ## Start daemon with startproc(8). If this fails
         ## the echo return value is set appropriate.
 
-        # startproc should return 0, even if service is
-        # already running to match LSB spec.
-        startproc -p ${pidfile} $puppetd ${PUPPET_OPTS} ${PUPPET_EXTRA_OPTS} && touch ${lockfile}
+        ## This accounts for the behavior of startproc on sles 10.
+        ## Check to see if a running process matches the contents
+        ## of the pidfile, and do nothing if true. Otherwise
+        ## force a process start
+        if [ -f "${pidfile}" ]; then
+            PID=$(cat "$pidfile")
+            if [ "$PID" -eq $(pgrep -f "$puppetd") ] ; then
+                rc_status -v
+                rc_exit
+            fi
+        fi
+        startproc -f -w -p "${pidfile}" "${puppetd}" "${PUPPET_OPTS}" "${PUPPET_EXTRA_OPTS}" && touch "${lockfile}"
         # Remember status and be verbose
         rc_status -v
         ;;
@@ -74,7 +82,7 @@ case "$1" in
         ## Stop daemon with killproc(8) and if this fails
         ## set echo the echo return value.
 
-        killproc -QUIT -p ${pidfile} $puppetd && rm -f ${lockfile} ${pidfile}
+        killproc -QUIT -p "${pidfile}" "${puppetd}" && rm -f "${lockfile}" "${pidfile}"
 
         # Remember status and be verbose
         rc_status -v
@@ -103,7 +111,7 @@ case "$1" in
 
         echo -n "Reload service puppet"
         ## if it supports it:
-        killproc -HUP -p ${pidfile} $puppetd
+        killproc -HUP -p "${pidfile}" "${puppetd}"
         rc_status -v
         ;;
     reload)
@@ -112,7 +120,7 @@ case "$1" in
 
         # If it supports signalling:
         echo -n "Reload puppet services."
-        killproc -HUP -p ${pidfile} $puppetd
+        killproc -HUP -p "${pidfile}" "${puppetd}"
         rc_status -v
         ;;
     status)
@@ -127,12 +135,17 @@ case "$1" in
         # 3 - service not running
 
         # NOTE: checkproc returns LSB compliant status values.
-        checkproc -p ${pidfile} $puppetd
-        rc_status -v
+        if [ -f "${pidfile}" ]; then
+            checkproc -p "${pidfile}" "${puppetd}"
+            rc_status -v
+        else
+            rc_failed 3
+            rc_status -v
+        fi
         ;;
     once)
         shift
-        $puppetd ${PUPPET_OPTS} --onetime ${PUPPET_EXTRA_OPTS} $@
+        $puppetd "${PUPPET_OPTS}" --onetime "${PUPPET_EXTRA_OPTS}" $@
         ;;
     *)
         echo "Usage: $0 {start|stop|status|try-restart|restart|force-reload|reload|once}"

data/lib/hiera/puppet_function.rb

@@ -43,13 +43,13 @@ class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
   end
 
   def hiera_no_default(scope, key)
-    post_lookup(key, lookup(scope, key, nil, nil))
+    post_lookup(scope, key, lookup(scope, key, nil, nil))
   end
 
   def hiera_with_default(scope, key, default, override = nil)
     undefined = (@@undefined_value ||= Object.new)
     result = lookup(scope, key, undefined, override)
-    post_lookup(key, result.equal?(undefined) ? default : result)
+    post_lookup(scope, key, result.equal?(undefined) ? default : result)
   end
 
   def hiera_block1(scope, key, &default_block)
@@ -63,20 +63,20 @@ class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
   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)
+    post_lookup(scope, key, result.equal?(undefined) ? default_block.call(key) : result)
   end
 
   private :common
 
   def lookup(scope, key, default, override)
-    HieraPuppet.lookup(key, default,scope, override, merge_type)
+    HieraPuppet.lookup(key, default, scope, override, merge_type)
   end
 
   def merge_type
     :priority
   end
 
-  def post_lookup(key, result)
+  def post_lookup(scope, key, result)
     result
   end
 end

data/lib/puppet/application/agent.rb

@@ -181,10 +181,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
+  '--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.
+
+  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

data/lib/puppet/application/apply.rb

@@ -83,10 +83,19 @@ configuration options can also be generated by running puppet with
   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. If enabled, 'puppet
+  apply' 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.
+
+  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.
 
 * --help:
   Print this help message

data/lib/puppet/defaults.rb

@@ -531,7 +531,7 @@ module Puppet
       :desc     => "The module repository",
     },
     :module_working_dir => {
-        :default  => '$vardir/puppet-module',
+        :default  => (Puppet.features.microsoft_windows? ? Dir.tmpdir() : '$vardir/puppet-module'),
         :desc     => "The directory into which module tool data is stored",
     },
     :module_skeleton_dir => {

data/lib/puppet/environments.rb

@@ -282,10 +282,29 @@ module Puppet::Environments
       @cache_expiration_service || DefaultCacheExpirationService.new
     end
 
+    # Returns the end of time (the next Mesoamerican Long Count cycle-end after 2012 (5125+2012) = 7137,
+    # of for a 32 bit machine using Ruby < 1.9.3, the year 2038.
+    def self.end_of_time
+      begin
+        Time.gm(7137)
+      rescue ArgumentError
+        Time.gm(2038)
+      end
+    end
+
+    END_OF_TIME = end_of_time
+    START_OF_TIME = Time.gm(1)
+
     def initialize(loader)
       @loader = loader
-      @cache = {}
       @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
@@ -300,15 +319,34 @@ module Puppet::Environments
 
     # @!macro loader_get
     def get(name)
-      evict_if_expired(name)
+      # Aggressively evict all that has expired
+      # This strategy favors smaller memory footprint over environment
+      # retrieval time.
+      clear_all_expired
       if result = @cache[name]
+        # found in cache
         return result.value
       elsif (result = @loader.get(name))
-        @cache[name] = entry(result)
+        # environment loaded, cache it
+        cache_entry = entry(result)
+        @cache_expiration_service.created(result)
+        add_entry(name, cache_entry)
         result
       end
     end
 
+    # Adds a cache entry to the cache
+    def add_entry(name, cache_entry)
+      Puppet.debug {"Caching environment '#{name}' #{cache_entry.label}"}
+      @cache[name] = cache_entry
+      expires = cache_entry.expires
+      @expirations.add(expires)
+      if @next_expiration > expires
+        @next_expiration = expires
+      end
+    end
+    private :add_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)
@@ -319,6 +357,25 @@ module Puppet::Environments
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear_all()
       @cache = {}
+      @expirations.clear
+      @next_expiration = END_OF_TIME
+    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()
+      t = Time.now
+      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)
+        clear(name)
+        @expirations.delete(entry.expires)
+        Puppet.settings.clear_environment_settings(name)
+      end
+      @next_expiration = @expirations.first || END_OF_TIME
     end
 
     # This implementation evicts the cache, and always gets the current
@@ -337,9 +394,7 @@ module Puppet::Environments
     # Creates a suitable cache entry given the time to live for one environment
     #
     def entry(env)
-      @cache_expiration_service.created(env)
       ttl = (conf = get_conf(env.name)) ? conf.environment_timeout : Puppet.settings.value(:environment_timeout)
-      Puppet.debug {"Caching environment '#{env.name}' (cache ttl: #{ttl})"}
       case ttl
       when 0
         NotCachedEntry.new(env)     # Entry that is always expired (avoids syscall to get time)
@@ -373,6 +428,14 @@ module Puppet::Environments
       def expired?
         false
       end
+
+      def label
+        ""
+      end
+
+      def expires
+        END_OF_TIME
+      end
     end
 
     # Always evicting entry
@@ -380,6 +443,14 @@ module Puppet::Environments
       def expired?
         true
       end
+
+      def label
+        "(ttl = 0 sec)"
+      end
+
+      def expires
+        START_OF_TIME
+      end
     end
 
     # Time to Live eviction policy entry
@@ -387,11 +458,20 @@ module Puppet::Environments
       def initialize(value, ttl_seconds)
         super value
         @ttl = Time.now + ttl_seconds
+        @ttl_seconds = ttl_seconds
       end
 
       def expired?
         Time.now > @ttl
       end
+
+      def label
+        "(ttl = #{@ttl_seconds} sec)"
+      end
+
+      def expires
+        @ttl
+      end
     end
   end
 end

data/lib/puppet/functions/epp.rb

@@ -1,42 +1,34 @@
-# Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
+# Evaluates an Embedded Puppet (EPP) template file and returns the rendered text
+# result as a String.
+#
+# `epp('<MODULE NAME>/<TEMPLATE FILE>', <PARAMETER HASH>)`
 #
 # The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
-# reference, which will load `<TEMPLATE FILE>` from a module's `templates`
-# directory. (For example, the reference `apache/vhost.conf.epp` will load the
-# file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
-#
-# The second argument is optional; if present, it should be a hash containing parameters for the
-# template. (See below.)
-#
-# EPP supports the following tags:
-#
-# * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
-# * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
-# * `<%# comment %>` - The tag and its content renders nothing.
-# * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
-# * `<%-` - Same as `<%` but suppresses any leading whitespace.
-# * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
-# * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
-#
-# File based EPP supports the following visibilities of variables in scope:
-#
-# * Global scope (i.e. top + node scopes) - global scope is always visible
-# * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
-# * Global + declared parameters - if the EPP declares parameters, given argument names must match
-#
-# EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
-# `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
-# given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
-# defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
-# Note that `<%-` must be used or any leading whitespace will be interpreted as text
-#
-# Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
-# are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
-# (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
-# Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
-# scope where the `epp` function is called from.
-#
-# @see function inline_epp for examples of EPP
+# reference, which loads `<TEMPLATE FILE>` from `<MODULE NAME>`'s `templates`
+# directory. In most cases, the last argument is optional; if used, it should be a
+# [hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+# pass to the template.
+#
+# - See the [template](/puppet/latest/reference/lang_template.html) documentation
+# for general template usage information.
+# - See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+# documentation for examples of EPP.
+#
+# For example, to call the apache module's `templates/vhost/_docroot.epp`
+# template and pass the `docroot` and `virtual_docroot` parameters, call the `epp`
+# function like this:
+#
+# `epp('apache/templates/vhost/_docroot.epp', { 'docroot' => '/var/www/html',
+# 'virtual_docroot' => '/var/www/example' })`
+#
+# Puppet produces a syntax error if you pass more parameters than are declared in
+# the template's parameter tag. When passing parameters to a template that
+# contains a parameter tag, use the same names as the tag's declared parameters.
+#
+# Parameters are required only if they are declared in the called template's
+# parameter tag without default values. Puppet produces an error if the `epp`
+# function fails to pass any required parameter.
+#
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do

data/lib/puppet/functions/hiera_include.rb

@@ -10,8 +10,8 @@ Puppet::Functions.create_function(:hiera_include, Hiera::PuppetFunction) do
     :array
   end
 
-  def post_lookup(key, value)
+  def post_lookup(scope, key, value)
     raise Puppet::ParseError, "Could not find data item #{key}" if value.nil?
-    call_function('include', value) unless value.empty?
+    call_function_with_scope(scope, 'include', value) unless value.empty?
   end
 end

data/lib/puppet/functions/inline_epp.rb

@@ -1,74 +1,47 @@
-# Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
-#
-# EPP support the following tags:
-#
-# * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
-# * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
-# * `<%# comment %>` - The tag and its content renders nothing.
-# * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
-# * `<%-` - Same as `<%` but suppresses any leading whitespace.
-# * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
-# * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
-#
-# Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
-# are used - see further below:
-#
-# * Global scope (i.e. top + node scopes) - global scope is always visible
-# * Global + Enclosing scope - if the EPP template does not declare parameters, and no arguments are given
-# * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
-# * Global + declared parameters - if the EPP declares parameters, given argument names must match
-#
-# EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
-# `<%- |$x, $y, $z='unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
-# given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
-# defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
-# Note that `<%-` must be used or any leading whitespace will be interpreted as text
-#
-# Arguments are passed to the template by calling `inline_epp` with a Hash as the last argument, where parameters
-# are bound to values, e.g. `inline_epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
-# (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
-# Template parameters shadow variables in outer scopes.
-#
-# Note: An inline template is best stated using a single-quoted string, or a heredoc since a double-quoted string
-# is subject to expression interpolation before the string is parsed as an EPP template. Here are examples
-# (using heredoc to define the EPP text):
-#
-# @example Various Examples using `inline_epp`
-#
-#     # produces 'Hello local variable world!'
-#     $x ='local variable'
-#     inline_epptemplate(@(END:epp))
-#     <%- |$x| -%>
-#     Hello <%= $x %> world!
-#     END
-# 
-#     # produces 'Hello given argument world!'
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x| -%>
-#     Hello <%= $x %> world!
-#     END
-#
-#     # produces 'Hello given argument world!'
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x| -%>
-#     Hello <%= $x %>!
-#     END
-#
-#     # results in error, missing value for y
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x, $y| -%>
-#     Hello <%= $x %>!
-#     END
-#
-#     # Produces 'Hello given argument planet'
-#     $x ='local variable world'
-#     inline_epptemplate(@(END:epp), { x =>'given argument'})
-#     <%- |$x, $y=planet| -%>
-#     Hello <%= $x %> <%= $y %>!
-#     END
+# Evaluates an Embedded Puppet (EPP) template string and returns the rendered
+# text result as a String.
+#
+# `inline_epp('<EPP TEMPLATE STRING>', <PARAMETER HASH>)`
+#
+# The first argument to this function should be a string containing an EPP
+# template. In most cases, the last argument is optional; if used, it should be a
+# [hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
+# pass to the template.
+#
+# - See the [template](/puppet/latest/reference/lang_template.html) documentation
+# for general template usage information.
+# - See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
+# documentation for examples of EPP.
+#
+# For example, to evaluate an inline EPP template and pass it the `docroot` and
+# `virtual_docroot` parameters, call the `inline_epp` function like this:
+#
+# `inline_epp('docroot: <%= $docroot %> Virtual docroot: <%= $virtual_docroot %>',
+# { 'docroot' => '/var/www/html', 'virtual_docroot' => '/var/www/example' })`
+#
+# Puppet produces a syntax error if you pass more parameters than are declared in
+# the template's parameter tag. When passing parameters to a template that
+# contains a parameter tag, use the same names as the tag's declared parameters.
+#
+# Parameters are required only if they are declared in the called template's
+# parameter tag without default values. Puppet produces an error if the
+# `inline_epp` function fails to pass any required parameter.
+#
+# An inline EPP template should be written as a single-quoted string or
+# [heredoc](puppet/latest/reference/lang_data_string.html#heredocs).
+# A double-quoted string is subject to expression interpolation before the string
+# is parsed as an EPP template.
+#
+# For example, to evaluate an inline EPP template using a heredoc, call the
+# `inline_epp` function like this:
+#
+# ~~~ puppet
+# # Outputs 'Hello given argument planet!'
+# inline_epp(@(END), { x => 'given argument' })
+# <%- | $x, $y = planet | -%>
+# Hello <%= $x %> <%= $y %>!
+# END
+# ~~~
 #
 # @since 4.0.0
 #