puppet 4.2.0-x64-mingw32 → 4.2.1-x64-mingw32

data/lib/puppet/module_tool/applications/unpacker.rb

@@ -93,7 +93,7 @@ module Puppet::ModuleTool
       # @api private
       # @return [String] path to temporary unpacking location
       def tmpdir
-        @dir ||= Dir.mktmpdir('tmp-unpacker', Puppet::Forge::Cache.base_path)
+        @dir ||= Dir.mktmpdir('tmp', Puppet::Forge::Cache.base_path)
       end
     end
   end

data/lib/puppet/module_tool/skeleton/templates/generator/manifests/init.pp.erb

@@ -1,37 +1,44 @@
-# == Class: <%= metadata.name %>
+# Class: <%= metadata.name %>
+# ===========================
 #
 # Full description of class <%= metadata.name %> here.
 #
-# === Parameters
+# Parameters
+# ----------
 #
 # Document parameters here.
 #
-# [*sample_parameter*]
-#   Explanation of what this parameter affects and what it defaults to.
-#   e.g. "Specify one or more upstream ntp servers as an array."
+# * `sample parameter`
+# Explanation of what this parameter affects and what it defaults to.
+# e.g. "Specify one or more upstream ntp servers as an array."
 #
-# === Variables
+# Variables
+# ----------
 #
 # Here you should define a list of variables that this module would require.
 #
-# [*sample_variable*]
-#   Explanation of how this variable affects the function of this class and if
-#   it has a default. e.g. "The parameter enc_ntp_servers must be set by the
-#   External Node Classifier as a comma separated list of hostnames." (Note,
-#   global variables should be avoided in favor of class parameters as
-#   of Puppet 2.6.)
+# * `sample variable`
+#  Explanation of how this variable affects the function of this class and if
+#  it has a default. e.g. "The parameter enc_ntp_servers must be set by the
+#  External Node Classifier as a comma separated list of hostnames." (Note,
+#  global variables should be avoided in favor of class parameters as
+#  of Puppet 2.6.)
 #
-# === Examples
+# Examples
+# --------
 #
-#  class { '<%= metadata.name %>':
-#    servers => [ 'pool.ntp.org', 'ntp.local.company.com' ],
-#  }
+# @example
+#    class { '<%= metadata.name %>':
+#      servers => [ 'pool.ntp.org', 'ntp.local.company.com' ],
+#    }
 #
-# === Authors
+# Authors
+# -------
 #
 # Author Name <author@domain.com>
 #
-# === Copyright
+# Copyright
+# ---------
 #
 # Copyright <%= Time.now.year %> Your name here, unless otherwise noted.
 #

data/lib/puppet/node.rb

@@ -9,6 +9,9 @@ class Puppet::Node
   # the node sources.
   extend Puppet::Indirector
 
+  # Asymmetric serialization/deserialization required in this class via to/from datahash
+  include Puppet::Util::PsychSupport
+
   # Use the node source as the indirection terminus.
   indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
     A node is composed of its name, its facts, and its environment."
@@ -18,13 +21,16 @@ class Puppet::Node
 
   attr_reader :server_facts
 
-  def self.from_data_hash(data)
-    raise ArgumentError, "No name provided in serialized data" unless name = data['name']
+  def initialize_from_hash(data)
+    @name       = data['name']       || (raise ArgumentError, "No name provided in serialized data")
+    @classes    = data['classes']    || []
+    @parameters = data['parameters'] || {}
+    @environment_name = data['environment']
+  end
 
+  def self.from_data_hash(data)
     node = new(name)
-    node.classes = data['classes']
-    node.parameters = data['parameters']
-    node.environment_name = data['environment']
+    node.initialize_from_hash(data)
     node
   end
 

data/lib/puppet/parser/functions/epp.rb

@@ -1,43 +1,35 @@
 Puppet::Parser::Functions::newfunction(:epp, :type => :rvalue, :arity => -2, :doc =>
-"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") do |args|
 
   function_fail(["epp() is only available when parser/evaluator future is in effect"])

data/lib/puppet/parser/functions/inline_epp.rb

@@ -1,76 +1,51 @@
 Puppet::Parser::Functions::newfunction(:inline_epp, :type => :rvalue, :arity => -2, :doc =>
-"Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
+"Evaluates an Embedded Puppet (EPP) template string and returns the rendered
+text result as a String.
 
-EPP support the following tags:
+`inline_epp('<EPP TEMPLATE STRING>', <PARAMETER HASH>)`
 
-* `<%= 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.
+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.
 
-Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
-are used - see further below:
+- 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.
 
-* 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
+For example, to evaluate an inline EPP template and pass it the `docroot` and
+`virtual_docroot` parameters, call the `inline_epp` function like this:
 
-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
+`inline_epp('docroot: <%= $docroot %> Virtual docroot: <%= $virtual_docroot %>',
+{ 'docroot' => '/var/www/html', 'virtual_docroot' => '/var/www/example' })`
 
-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.
+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.
 
-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):
+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.
 
-    # produces 'Hello local variable world!'
-    $x ='local variable'
-    inline_epptemplate(@(END:epp))
-    <%- |$x| -%>
-    Hello <%= $x %> world!
-    END
+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.
 
-    # produces 'Hello given argument world!'
-    $x ='local variable world'
-    inline_epptemplate(@(END:epp), { x =>'given argument'})
-    <%- |$x| -%>
-    Hello <%= $x %> world!
-    END
+For example, to evaluate an inline EPP template using a heredoc, call the
+`inline_epp` function like this:
 
-    # 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
+~~~ puppet
+# Outputs 'Hello given argument planet!'
+inline_epp(@(END), { x => 'given argument' })
+<%- | $x, $y = planet | -%>
+Hello <%= $x %> <%= $y %>!
+END
+~~~
 
 - Since 3.5
-- Requires Future Parser") do |arguments|
+- Requires [future parser](/puppet/3.8/reference/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
 
   function_fail(["inline_epp() is only available when parser/evaluator future is in effect"])
 end

data/lib/puppet/pops/issues.rb

@@ -261,11 +261,15 @@ module Puppet::Pops::Issues
   end
 
   ILLEGAL_NAME = hard_issue :ILLEGAL_NAME, :name do
-    "Illegal name. The given name #{name} does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\w*)*$/"
+    "Illegal name. The given name '#{name}' does not conform to the naming rule /^((::)?[a-z_]\w*)(::[a-z]\\w*)*$/"
+  end
+
+  ILLEGAL_PARAM_NAME = hard_issue :ILLEGAL_PARAM_NAME, :name do
+    "Illegal parameter name. The given name '#{name}' does not conform to the naming rule /^[a-z_]\\w*$/"
   end
 
   ILLEGAL_VAR_NAME = hard_issue :ILLEGAL_VAR_NAME, :name do
-    "Illegal variable name, The given name '#{name}' does not conform to the naming rule /^((::)?[a-z]\w*)*((::)?[a-z_]\w*)$/"
+    "Illegal variable name, The given name '#{name}' does not conform to the naming rule /^((::)?[a-z]\\w*)*((::)?[a-z_]\\w*)$/"
   end
 
   ILLEGAL_NUMERIC_VAR_NAME = hard_issue :ILLEGAL_NUMERIC_VAR_NAME, :name do

data/lib/puppet/pops/patterns.rb

@@ -38,6 +38,9 @@ module Puppet::Pops::Patterns
   # Note, that only the final segment may start with an underscore.
   VAR_NAME = %r{\A(:?(::)?[a-z]\w*)*(:?(::)?[a-z_]\w*)\z}
 
+  # PARAM_NAME matches the name part of a parameter (The $ character is not included)
+  PARAM_NAME = %r{\A[a-z_]\w*\z}
+
   # A Numeric var name must be the decimal number 0, or a decimal number not starting with 0
   NUMERIC_VAR_NAME = %r{\A(?:0|(?:[1-9][0-9]*))\z}
 

data/lib/puppet/pops/types/type_parser.rb

@@ -356,7 +356,7 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size == 1
         case parameters[0]
         when Integer
-          TYPES.range(parameters[0], parameters[0])
+          TYPES.range(parameters[0], :default)
         when :default
           TYPES.integer # unbound
         end
@@ -370,7 +370,7 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
-          TYPES.float_range(parameters[0], parameters[0])
+          TYPES.float_range(parameters[0], :default)
         when :default
           TYPES.float # unbound
         end

data/lib/puppet/pops/validation/checker4_0.rb

@@ -433,6 +433,10 @@ class Puppet::Pops::Validation::Checker4_0
     if o.name =~ /^(?:0x)?[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
+
+    unless o.name =~ Puppet::Pops::Patterns::PARAM_NAME
+      acceptor.accept(Issues::ILLEGAL_PARAM_NAME, o, :name => o.name)
+    end
     return unless o.value
 
     if o.value.is_a?(Puppet::Pops::Model::AssignmentExpression)

data/lib/puppet/provider/zone/solaris.rb

@@ -234,10 +234,10 @@ Puppet::Type.type(:zone).provide(:solaris) do
           end
           current[$1.intern] = $2
         else
-          Puppet.err "Ignoring '#{line}'"
+          err "Ignoring '#{line}'"
         end
       else
-        Puppet.debug "Ignoring zone output '#{line}'"
+        debug "Ignoring zone output '#{line}'"
       end
     end
 

data/lib/puppet/type.rb

@@ -1539,7 +1539,7 @@ class Type
 
   newmetaparam(:require, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :NONE}) do
     desc "One or more resources that this resource depends on, expressed as
-      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
+      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_data_resource_reference.html).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
@@ -1553,7 +1553,7 @@ class Type
 
   newmetaparam(:subscribe, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :ALL_EVENTS, :callback => :refresh}) do
     desc "One or more resources that this resource depends on, expressed as
-      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
+      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_data_resource_reference.html).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
@@ -1571,7 +1571,7 @@ class Type
 
   newmetaparam(:before, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :NONE}) do
     desc "One or more resources that depend on this resource, expressed as
-      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
+      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_data_resource_reference.html).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 
@@ -1585,7 +1585,7 @@ class Type
 
   newmetaparam(:notify, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :ALL_EVENTS, :callback => :refresh}) do
     desc "One or more resources that depend on this resource, expressed as
-      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_datatypes.html#resource-references).
+      [resource references](http://docs.puppetlabs.com/puppet/latest/reference/lang_data_resource_reference.html).
       Multiple resources can be specified as an array of references. When this
       attribute is present:
 

data/lib/puppet/util.rb

@@ -260,7 +260,15 @@ module Util
       $stdout.reopen(stdout)
       $stderr.reopen(stderr)
 
-      3.upto(256){|fd| IO::new(fd).close rescue nil}
+      begin
+        Dir.foreach('/proc/self/fd') do |f|
+          if f != '.' && f != '..' && f.to_i >= 3
+            IO::new(f.to_i).close rescue nil
+          end
+        end
+      rescue Errno::ENOENT # /proc/self/fd not found
+        3.upto(256){|fd| IO::new(fd).close rescue nil}
+      end
 
       block.call if block
     end

data/lib/puppet/util/command_line.rb

@@ -117,6 +117,10 @@ module Puppet
               configured_environment.each_plugin_directory do |dir|
                 $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
               end
+
+              # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
+              # pickup the new $LOAD_PATH.
+              Facter.reset
             end
           end
 

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '4.2.0'
+  PUPPETVERSION = '4.2.1'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/parser/compiler_spec.rb

@@ -1202,13 +1202,15 @@ describe Puppet::Parser::Compiler do
 
     it 'should recompute the version after input files are re-parsed' do
       Puppet[:code] = 'class foo { }'
-      Time.stubs(:now).returns(1)
+      first_time = Time.at(1)
+      second_time = Time.at(200)
+      Time.stubs(:now).returns(first_time)
       node = Puppet::Node.new('mynode')
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(1)
-      Time.stubs(:now).returns(2)
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(1) # no change because files didn't change
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
+      Time.stubs(:now).returns(second_time)
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
       Puppet[:code] = nil
-      expect(Puppet::Parser::Compiler.compile(node).version).to eq(2)
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)
     end
 
     ['define', 'class', 'node'].each do |thing|