puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/lib/puppet/defaults.rb

@@ -21,7 +21,8 @@ module Puppet
         :default => false,
         :type    => :boolean,
         :desc    => 'Whether to enable a pre-Facter 3.0 release of native Facter (distributed as
-          the "cfacter" package). This is not necessary if Facter 3.0 or later is installed.',
+          the "cfacter" package). This is not necessary if Facter 3.0 or later is installed.
+          This setting is deprecated, as Facter 3 is now the default in puppet-agent.',
         :hook    => proc do |value|
           return unless value
           raise ArgumentError, 'facter has already evaluated facts.' if Facter.instance_variable_get(:@collection)
@@ -526,6 +527,15 @@ module Puppet
       :desc    => "The directory where catalog previews per node are generated."
     }
   )
+
+  define_settings(:main,
+      :app_management => {
+          :default  => false,
+          :type     => :boolean,
+          :desc     => "Whether the application management feature is on or off. You must restart Puppet Server after changing this setting.",
+      }
+  )
+
   Puppet.define_settings(:module_tool,
     :module_repository  => {
       :default  => 'https://forgeapi.puppetlabs.com',
@@ -545,7 +555,7 @@ module Puppet
     },
     :module_groups => {
         :default  => nil,
-        :desc     => "Extra module groups to request from the Puppet Forge",
+        :desc     => "Extra module groups to request from the Puppet Forge. This is an internal setting, and users should never change it.",
     }
   )
 

data/lib/puppet/error.rb

@@ -93,4 +93,8 @@ module Puppet
   class MissingCommand < Puppet::Error
   end
 
+  # Raised when we failed to aquire a lock
+  class LockError < Puppet::Error
+  end
+
 end

data/lib/puppet/face/module/changes.rb

@@ -4,7 +4,8 @@ Puppet::Face.define(:module, '1.0.0') do
     description <<-EOT
       Shows any files in a module that have been modified since it was
       installed. This action compares the files on disk to the md5 checksums
-      included in the module's metadata.
+      included in the module's checksums.json or, if that is missing, in
+      metadata.json.
     EOT
 
     returns "Array of strings representing paths of modified files."

data/lib/puppet/feature/cfacter.rb

@@ -2,6 +2,7 @@ require 'facter'
 require 'puppet/util/feature'
 
 Puppet.features.add :cfacter do
+  Puppet.deprecation_warning("The cfacter setting is deprecated. You can use Facter 3 and higher without this setting.")
   begin
     require 'cfacter'
 

data/lib/puppet/file_bucket/dipper.rb

@@ -2,6 +2,8 @@ require 'pathname'
 require 'puppet/file_bucket'
 require 'puppet/file_bucket/file'
 require 'puppet/indirector/request'
+require 'puppet/util/diff'
+require 'tempfile'
 
 class Puppet::FileBucket::Dipper
   include Puppet::Util::Checksums
@@ -22,7 +24,7 @@ class Puppet::FileBucket::Dipper
       @rest_path  = nil
     else
       @local_path = nil
-      @rest_path = "https://#{server}:#{port}/#{environment}/file_bucket_file/"
+      @rest_path = "filebucket://#{server}:#{port}/"
     end
     @checksum_type = Puppet[:digest_algorithm].to_sym
     @digest = method(@checksum_type)
@@ -56,6 +58,46 @@ class Puppet::FileBucket::Dipper
     end
   end
 
+  # Diffs two filebucket files identified by their sums
+  def diff(checksum_a, checksum_b, file_a, file_b)
+    raise RuntimeError, "Diff is not supported on this platform" if Puppet[:diff] == ""
+    if checksum_a
+      source_path = "#{@rest_path}#{@checksum_type}/#{checksum_a}"
+      if checksum_b
+        file_diff = Puppet::FileBucket::File.indirection.find(
+          source_path,
+          :bucket_path => @local_path,
+          :diff_with => checksum_b)
+      elsif file_b
+        tmp_file = ::Tempfile.new('diff')
+        begin
+          restore(tmp_file.path, checksum_a)
+          file_diff = Puppet::Util::Diff.diff(tmp_file.path, file_b)
+        ensure
+          tmp_file.close
+          tmp_file.unlink
+        end
+      else
+        raise Puppet::Error, "Please provide a file or checksum do diff with"
+      end
+    elsif file_a
+      if checksum_b
+        tmp_file = ::Tempfile.new('diff')
+        begin
+          restore(tmp_file.path, checksum_b)
+          file_diff = Puppet::Util::Diff.diff(file_a, tmp_file.path)
+        ensure
+          tmp_file.close
+          tmp_file.unlink
+        end
+      elsif file_b
+        file_diff = Puppet::Util::Diff.diff(file_a, file_b)
+      end
+    end
+    raise Puppet::Error, "Failed to diff files" unless file_diff
+    file_diff.to_s
+  end
+
   # Retrieves a file by sum.
   def getfile(sum)
     get_bucket_file(sum).to_s
@@ -109,10 +151,24 @@ class Puppet::FileBucket::Dipper
     end
   end
 
+  # List Filebucket content.
+  def list(fromdate, todate)
+    raise Puppet::Error, "Listing remote file buckets is not allowed" unless local?
+
+    source_path = "#{@rest_path}#{@checksum_type}/"
+    file_bucket_list = Puppet::FileBucket::File.indirection.find(
+      source_path,
+      :bucket_path => @local_path,
+      :list_all => true,
+      :fromdate => fromdate,
+      :todate => todate)
+    raise Puppet::Error, "File not found" unless file_bucket_list
+    file_bucket_list.to_s
+  end
+
   private
   def absolutize_path( path )
     Pathname.new(path).realpath
   end
 
 end
-

data/lib/puppet/functions.rb

@@ -349,12 +349,10 @@ module Puppet::Functions
     def block_param(*type_and_name)
       case type_and_name.size
       when 0
-        # the type must be an independent instance since it will be contained in another type
-        type = @all_callables.copy
+        type = @all_callables
         name = :block
       when 1
-        # the type must be an independent instance since it will be contained in another type
-        type = @all_callables.copy
+        type = @all_callables
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name

data/lib/puppet/functions/assert_type.rb

@@ -1,18 +1,54 @@
-# Returns the given value if it is an instance of the given type, and raises an error otherwise.
-# Optionally, if a block is given (accepting two parameters), it will be called instead of raising
-# an error. This to enable giving the user richer feedback, or to supply a default value.
+# Returns the given value if it is of the given
+# [data type](https://docs.puppetlabs.com/puppet/latest/reference/lang_data.html), or
+# otherwise either raises an error or executes an optional two-parameter
+# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html).
 #
-# @example how to assert type
-#   # assert that `$b` is a non empty `String` and assign to `$a`
-#   $a = assert_type(String[1], $b)
+# The function takes two mandatory arguments, in this order:
 #
-# @example using custom error message
-#   $a = assert_type(String[1], $b) |$expected, $actual| { fail("The name cannot be empty") }
+# 1. The expected data type.
+# 2. A value to compare against the expected data type.
 #
-# @example using a warning and a default
-#   $a = assert_type(String[1], $b) |$expected, $actual| { warning("Name is empty, using default") 'anonymous' }
+# @example Using `assert_type`
 #
-# See the documentation for "The Puppet Type System" for more information about types.
+# ~~~ puppet
+# $raw_username = 'Amy Berry'
+#
+# # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+# $valid_username = assert_type(String[1], $raw_username)
+#
+# # $valid_username contains "Amy Berry".
+# # If $raw_username was an empty string or a different data type, the Puppet run would
+# # fail with an "Expected type does not match actual" error.
+# ~~~
+#
+# You can use an optional lambda to provide enhanced feedback. The lambda takes two
+# mandatory parameters, in this order:
+#
+# 1. The expected data type as described in the function's first argument.
+# 2. The actual data type of the value.
+#
+# @example Using `assert_type` with a warning and default value
+#
+# ~~~ puppet
+# $raw_username = 'Amy Berry'
+#
+# # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+# # If it isn't, output a warning describing the problem and use a default value.
+# $valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
+#   warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
+#   'anonymous'
+# }
+#
+# # $valid_username contains "Amy Berry".
+# # If $raw_username was an empty string, the Puppet run would set $valid_username to
+# # "anonymous" and output a warning: "The username should be 'String[1, default]', not
+# # 'String[0, 0]'. Using 'anonymous'."
+# ~~~
+#
+# For more information about data types, see the
+# [documentation](https://docs.puppetlabs.com/puppet/latest/reference/lang_data.html).
+#
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:assert_type) do
   dispatch :assert_type do
@@ -42,7 +78,7 @@ Puppet::Functions.create_function(:assert_type) do
         # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
         # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
         #
-        actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
+        actual = Puppet::Pops::Types::TypeCalculator.generalize(inferred_type)
         raise Puppet::Pops::Types::TypeAssertionError.new("assert_type(): Expected type #{type} does not match actual: #{actual}", type,actual)
       end
     end

data/lib/puppet/functions/defined.rb

@@ -1,70 +1,101 @@
-# Determines whether
-# a given class or resource type is defined. This function can also determine whether a
-# specific resource has been declared, or whether a variable has been assigned a value
-# (including undef...as opposed to never having been assigned anything). Returns true
-# or false. Accepts class names, type names, resource references, and variable
-# reference strings of the form '$name'.  When more than one argument is
-# supplied, defined() returns true if any are defined.
+# Determines whether a given class or resource type is defined and returns a Boolean
+# value. You can also use `defined` to determine whether a specific resource is defined,
+# or whether a variable has a value (including `undef`, as opposed to the variable never
+# being declared or assigned).
+#
+# This function takes at least one string argument, which can be a class name, type name,
+# resource reference, or variable reference of the form `'$name'`.
 #
 # The `defined` function checks both native and defined types, including types
-# provided as plugins via modules. Types and classes are both checked using their names:
+# provided by modules. Types and classes are matched by their names. The function matches
+# resource declarations by using resource references.
+#
+# **Examples**: Different types of `defined` function matches
+#
+# ~~~ puppet
+# # Matching resource types
+# defined("file")
+# defined("customtype")
+#
+# # Matching defines and classes
+# defined("foo")
+# defined("foo::bar")
+#
+# # Matching variables
+# defined('$name')
+#
+# # Matching declared resources
+# defined(File['/tmp/file'])
+# ~~~
+#
+# Puppet depends on the configuration's evaluation order when checking whether a resource
+# is declared.
 #
-#     defined("file")
-#     defined("customtype")
-#     defined("foo")
-#     defined("foo::bar")
-#     defined('$name')
+# @example Importance of evaluation order when using `defined`
 #
-# Resource declarations are checked using resource references, e.g.
-# `defined( File['/tmp/myfile'] )`, or `defined( Class[myclass] )`.
-# Checking whether a given resource
-# has been declared is, unfortunately, dependent on the evaluation order of
-# the configuration, and the following code will not work:
+# ~~~ puppet
+# # Assign values to $is_defined_before and $is_defined_after using identical `defined`
+# # functions.
 #
-#     if defined(File['/tmp/foo']) {
-#         notify { "This configuration includes the /tmp/foo file.":}
-#     }
-#     file { "/tmp/foo":
-#         ensure => present,
-#     }
+# $is_defined_before = defined(File['/tmp/file'])
 #
-# However, this order requirement refers to evaluation order only, and ordering of
-# resources in the configuration graph (e.g. with `before` or `require`) does not
-# affect the behavior of `defined`.
+# file { "/tmp/file":
+#   ensure => present,
+# }
 #
-# You may also search using types:
+# $is_defined_after = defined(File['/tmp/file'])
 #
-#     defined(Resource['file','/some/file'])
-#     defined(File['/some/file'])
-#     defined(Class['foo'])
+# # $is_defined_before returns false, but $is_defined_after returns true.
+# ~~~
 #
-# The `defined` function does not answer if data types (e.g. `Integer`) are defined. If
-# given the string 'integer' the result is false, and if given a non CatalogEntry type,
-# an error is raised.
+# This order requirement only refers to evaluation order. The order of resources in the
+# configuration graph (e.g. with `before` or `require`) does not affect the `defined`
+# function's behavior.
 #
-# The rules for asking for undef, empty strings, and the main class are different from 3.x
-# (non future parser) and 4.x (with future parser or in Puppet 4.0.0 and later):
+# > **Warning:** Avoid relying on the result of the `defined` function in modules, as you
+# > might not be able to guarantee the evaluation order well enough to produce consistent
+# > results. This can cause other code that relies on the function's result to behave
+# > inconsistently or fail.
 #
-#     defined('')     # 3.x => true,  4.x => false
-#     defined(undef)  # 3.x => true,  4.x => error
-#     defined('main') # 3.x => false, 4.x => true
+# If you pass more than one argument to `defined`, the function returns `true` if _any_
+# of the arguments are defined. You can also match resources by type, allowing you to
+# match conditions of different levels of specificity, such as whether a specific resource
+# is of a specific data type.
 #
-# With the future parser, it is also possible to ask specifically if a name is
-# a resource type (built in or defined), or a class, by giving its type:
+# @example Matching multiple resources and resources by different types with `defined`
 #
-#     defined(Type[Class['foo']])
-#     defined(Type[Resource['foo']])
+# ~~~ puppet
+# file { "/tmp/file1":
+#   ensure => file,
+# }
 #
-# Which is different from asking:
+# $tmp_file = file { "/tmp/file2":
+#   ensure => file,
+# }
 #
-#     defined('foo')
+# # Each of these statements return `true` ...
+# defined(File['/tmp/file1'])
+# defined(File['/tmp/file1'],File['/tmp/file2'])
+# defined(File['/tmp/file1'],File['/tmp/file2'],File['/tmp/file3'])
+# # ... but this returns `false`.
+# defined(File['/tmp/file3'])
 #
-# Since the later returns true if 'foo' is either a class, a built-in resource type, or a user defined
-# resource type, and a specific request like `Type[Class['foo']]` only returns true if `'foo'` is a class.
+# # Each of these statements returns `true` ...
+# defined(Type[Resource['file','/tmp/file2']])
+# defined(Resource['file','/tmp/file2'])
+# defined(File['/tmp/file2'])
+# defined('$tmp_file')
+# # ... but each of these returns `false`.
+# defined(Type[Resource['exec','/tmp/file2']])
+# defined(Resource['exec','/tmp/file2'])
+# defined(File['/tmp/file3'])
+# defined('$tmp_file2')
+# ~~~
 #
 # @since 2.7.0
-# @since 3.6.0 variable reference and future parser types")
+# @since 3.6.0 variable reference and future parser types
 # @since 3.8.1 type specific requests with future parser
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunction) do
 

data/lib/puppet/functions/each.rb

@@ -1,38 +1,96 @@
-#  Applies a parameterized block to each element in a sequence of selected entries from the first
-#  argument and returns the first argument.
+# Runs a [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# repeatedly using each value in a data structure, then returns the values unchanged.
 #
-# This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
-# of enumerable type (integer, Integer range, or String), and the second
-# a parameterized block as produced by the puppet syntax:
+# This function takes two mandatory arguments, in this order:
 #
-#       $a.each |$x| { ... }
-#       each($a) |$x| { ... }
+# 1. An array or hash the function will iterate over.
+# 2. A lambda, which the function calls for each element in the first argument. It can
+# request one or two parameters.
 #
-# When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
-# should define one or two block parameters.
-# For each application of the block, the next element from the array is selected, and it is passed to
-# the block if the block has one parameter. If the block has two parameters, the first is the elements
-# index, and the second the value. The index starts from 0.
+# @example Using the `each` function
 #
-#       $a.each |$index, $value| { ... }
-#       each($a) |$index, $value| { ... }
+# `$data.each |$parameter| { <PUPPET CODE BLOCK> }`
 #
-# When the first argument is a Hash, the parameterized block should define one or two parameters.
-# When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
-# and when two parameters are defined the iteration is performed with key and value.
+# or
 #
-#       $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
-#       $a.each |$key, $value| { ..."key ${key}, value ${value}" }
+# `each($data) |$parameter| { <PUPPET CODE BLOCK> }`
 #
-# @example using each
+# When the first argument (`$data` in the above example) is an array, Puppet passes each
+# value in turn to the lambda, then returns the original values.
 #
-#       [1,2,3].each |$val| { ... }                       # 1, 2, 3
-#       [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
-#       {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
-#       {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
-#       Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
-#       "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
-#       3.each |$number| { ... }                          # 0, 1, 2
+# @example Using the `each` function with an array and a one-parameter lambda
+#
+# ~~~ puppet
+# # For the array $data, run a lambda that creates a resource for each item.
+# $data = ["routers", "servers", "workstations"]
+# $data.each |$item| {
+#  notify { $item:
+#    message => $item
+#  }
+# }
+# # Puppet creates one resource for each of the three items in $data. Each resource is
+# # named after the item's value and uses the item's value in a parameter.
+# ~~~
+#
+# When the first argument is a hash, Puppet passes each key and value pair to the lambda
+# as an array in the form `[key, value]` and returns the original hash.
+#
+# @example Using the `each` function with a hash and a one-parameter lambda
+#
+# ~~~ puppet
+# # For the hash $data, run a lambda using each item as a key-value array that creates a
+# # resource for each item.
+# $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+# $data.each |$items| {
+#  notify { $items[0]:
+#    message => $items[1]
+#  }
+# }
+# # Puppet creates one resource for each of the three items in $data, each named after the
+# # item's key and containing a parameter using the item's value.
+# ~~~
+#
+# When the first argument is an array and the lambda has two parameters, Puppet passes the
+# array's indexes (enumerated from 0) in the first parameter and its values in the second
+# parameter.
+#
+# @example Using the `each` function with an array and a two-parameter lambda
+#
+# ~~~ puppet
+# # For the array $data, run a lambda using each item's index and value that creates a
+# # resource for each item.
+# $data = ["routers", "servers", "workstations"]
+# $data.each |$index, $value| {
+#  notify { $value:
+#    message => $index
+#  }
+# }
+# # Puppet creates one resource for each of the three items in $data, each named after the
+# # item's value and containing a parameter using the item's index.
+# ~~~
+#
+# When the first argument is a hash, Puppet passes its keys to the first parameter and its
+# values to the second parameter.
+#
+# @example Using the `each` function with a hash and a two-parameter lambda
+#
+# ~~~ puppet
+# # For the hash $data, run a lambda using each item's key and value to create a resource
+# # for each item.
+# $data = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+# $data.each |$key, $value| {
+#  notify { $key:
+#    message => $value
+#  }
+# }
+# # Puppet creates one resource for each of the three items in $data, each named after the
+# # item's key and containing a parameter using the item's value.
+# ~~~
+#
+# For an example that demonstrates how to create multiple `file` resources using `each`,
+# see the Puppet
+# [iteration](https://docs.puppetlabs.com/puppet/latest/reference/lang_iteration.html)
+# documentation.
 #
 # @since 4.0.0
 #