puppet 3.7.4 → 3.7.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f35aa37f286ceab033a202d14fbf844afec75f18
+  data.tar.gz: 5430d6624f88720053d913dbb1d5cc0b4c2622f5
+SHA512:
+  metadata.gz: 6ed0a9019235a4f7766cf5be591386846daaf8829cb3082f50689c9a99cdc47add53d72cfe5730dffe882c670d636c8289c95f589bc7a51fd9fef70b1d210c5b
+  data.tar.gz: 6944a721ef0d81d257b08fb42ed7d1f9fc50949afc99e5308d1f32bdd0240415fc13846fa1bb6024dba254bd22734b0b5d8c8320a5030166ccd2709ef5f632f5

data/CONTRIBUTING.md

@@ -53,7 +53,7 @@ top of things.
 For changes of a trivial nature to comments and documentation, it is not
 always necessary to create a new ticket in Jira. In this case, it is
 appropriate to start the first line of a commit with '(doc)' instead of
-a ticket number. 
+a ticket number.
 
 ````
     (doc) Add documentation commit example to CONTRIBUTING
@@ -63,7 +63,7 @@ a ticket number.
     is left to assume how a commit of this nature may appear.
 
     The first line is a real life imperative statement with '(doc)' in
-    place of what would have been the ticket number in a 
+    place of what would have been the ticket number in a
     non-documentation related commit. The body describes the nature of
     the new documentation or comments added.
 ````
@@ -77,15 +77,20 @@ a ticket number.
   * Include a link to the pull request in the ticket.
 * The core team looks at Pull Requests on a regular basis in a weekly triage
   meeting that we hold in a public Google Hangout. The hangout is announced in
-  the weekly status updates that are sent to the puppet-dev list.
+  the weekly status updates that are sent to the puppet-dev list. Notes are
+  posted to the [Puppet Community community-triage
+  repo](https://github.com/puppet-community/community-triage/tree/master/core/notes)
+  and include a link to a YouTube recording of the hangout.
 * After feedback has been given we expect responses within two weeks. After two
-  weeks will may close the pull request if it isn't showing any activity.
+  weeks we may close the pull request if it isn't showing any activity.
 
 # Additional Resources
 
-* [More information on contributing](http://links.puppetlabs.com/contribute-to-puppet)
+* [Puppet Labs community guildelines](http://docs.puppetlabs.com/community/community_guidelines.html)
 * [Bug tracker (Jira)](http://tickets.puppetlabs.com)
 * [Contributor License Agreement](http://links.puppetlabs.com/cla)
 * [General GitHub documentation](http://help.github.com/)
 * [GitHub pull request documentation](http://help.github.com/send-pull-requests/)
-* #puppet-dev IRC channel on freenode.org
+* #puppet-dev IRC channel on freenode.org ([Archive](https://botbot.me/freenode/puppet-dev/))
+* [puppet-dev mailing list](https://groups.google.com/forum/#!forum/puppet-dev)
+* [Community PR Triage notes](https://github.com/puppet-community/community-triage/tree/master/core/notes)

data/ext/build_defaults.yaml

@@ -26,8 +26,8 @@ build_msi:
     repo: 'git://github.com/puppetlabs/hiera.git'
   sys:
     ref:
-      x86: '57068e7b7c87288c51ff39d96c80cfb509a42091'
-      x64: '531319f5c121e98990772e018eb9781bf7dc6316'
+      x86: '8db9d84da9950760144b5dfcd807213eecee4842'
+      x64: '12030f11e9bb2f085c68108bff34be6956b25df9'
     repo: 'git://github.com/puppetlabs/puppet-win32-ruby.git'
 apt_host: 'apt.puppetlabs.com'
 apt_repo_url: 'http://apt.puppetlabs.com'

data/ext/systemd/puppet.service

@@ -7,6 +7,7 @@ After=basic.target network.target puppetmaster.service
 EnvironmentFile=-/etc/sysconfig/puppetagent
 EnvironmentFile=-/etc/sysconfig/puppet
 ExecStart=/usr/bin/puppet agent ${PUPPET_EXTRA_OPTS} --no-daemonize
+KillMode=process
 
 [Install]
 WantedBy=multi-user.target

data/lib/hiera/puppet_function.rb

@@ -0,0 +1,71 @@
+require 'hiera_puppet'
+
+# Provides the base class for the puppet functions hiera, hiera_array, hiera_hash, and hiera_include.
+# The actual function definitions will call init_dispatch and override the merge_type and post_lookup methods.
+#
+# @see hiera_array.rb, hiera_include.rb under lib/puppet/functions for sample usage
+#
+class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
+  def self.init_dispatch
+    dispatch :hiera_splat do
+      scope_param
+      param 'Tuple[String, Any, Any, 1, 3]', :args
+    end
+
+    dispatch :hiera do
+      scope_param
+      param 'String',:key
+      optional_param 'Any',   :default
+      optional_param 'Any',   :override
+    end
+
+    dispatch :hiera_block1 do
+      scope_param
+      param 'String',              :key
+      block_param 'Callable[1,1]', :default_block
+    end
+
+    dispatch :hiera_block2 do
+      scope_param
+      param 'String',              :key
+      param 'Any',                 :override
+      block_param 'Callable[1,1]', :default_block
+    end
+  end
+
+  def hiera_splat(scope, args)
+    hiera(scope, *args)
+  end
+
+  def hiera(scope, key, default = nil, override = nil)
+    post_lookup(key, lookup(scope, key, default, override))
+  end
+
+  def hiera_block1(scope, key, &default_block)
+    common(scope, key, nil, default_block)
+  end
+
+  def hiera_block2(scope, key, override, &default_block)
+    common(scope, key, override, 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)
+  end
+
+  private :common
+
+  def lookup(scope, key, default, override)
+    HieraPuppet.lookup(key, default,scope, override, merge_type)
+  end
+
+  def merge_type
+    :priority
+  end
+
+  def post_lookup(key, result)
+    result
+  end
+end

data/lib/puppet.rb

@@ -258,6 +258,18 @@ module Puppet
 
   # The single instance used for normal operation
   @context = Puppet::Context.new(bootstrap_context)
+
+  def self.future_parser?
+    env = Puppet.lookup(:current_environment) { return Puppet[:parser] == 'future' }
+    env_conf = Puppet.lookup(:environments).get_conf(env.name)
+
+    if env_conf.nil?
+      # Case for non-directory environments
+      Puppet[:parser] == 'future'
+    else
+      env_conf.parser == 'future'
+    end
+  end
 end
 
 # This feels weird to me; I would really like for us to get to a state where there is never a "require" statement

data/lib/puppet/application/device.rb

@@ -115,9 +115,10 @@ parameter, so you can specify '--server <servername>' as an argument.
 
 * --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.
+  code of '1' means at least one device had a compile failure, an exit code of
+  '2' means at least one device had resource changes, and an exit code of '4'
+  means at least one device had resource failures. Exit codes of '3', '5', '6',
+  or '7' means that a bitwise combination of the preceeding exit codes happened.
 
 * --help:
   Print this help message
@@ -167,9 +168,13 @@ Licensed under the Apache 2.0 License
       Puppet.err "No device found in #{Puppet[:deviceconfig]}"
       exit(1)
     end
-    devices.each_value do |device|
+    returns = devices.collect do |devicename,device|
       begin
-        Puppet.info "starting applying configuration to #{device.name} at #{device.url}"
+        device_url = URI.parse(device.url)
+        # Handle nil scheme & port
+        scheme = "#{device_url.scheme}://" if device_url.scheme
+        port = ":#{device_url.port}" if device_url.port
+        Puppet.info "starting applying configuration to #{device.name} at #{scheme}#{device_url.host}#{port}#{device_url.path}"
 
         # override local $vardir and $certname
         Puppet[:confdir] = ::File.join(Puppet[:devicedir], device.name)
@@ -192,6 +197,8 @@ Licensed under the Apache 2.0 License
         configurer.run(:network_device => true, :pluginsync => Puppet[:pluginsync])
       rescue => detail
         Puppet.log_exception(detail)
+        # If we rescued an error, then we return 1 as the exit code
+        1
       ensure
         Puppet[:vardir] = vardir
         Puppet[:confdir] = confdir
@@ -199,6 +206,16 @@ Licensed under the Apache 2.0 License
         Puppet::SSL::Host.reset
       end
     end
+    if ! returns or returns.compact.empty?
+      exit(1)
+    elsif options[:detailed_exitcodes]
+      # Bitwise OR the return codes together, puppet style
+      exit(returns.compact.reduce(:|))
+    elsif returns.include? 1
+      exit(1)
+    else
+      exit(0)
+    end
   end
 
   def setup_host

data/lib/puppet/daemon.rb

@@ -21,11 +21,14 @@ require 'puppet/scheduler'
 #
 # @api private
 class Puppet::Daemon
+  SIGNAL_CHECK_INTERVAL = 5
+
   attr_accessor :agent, :server, :argv
 
   def initialize(pidfile, scheduler = Puppet::Scheduler::Scheduler.new())
     @scheduler = scheduler
     @pidfile = pidfile
+    @signals = []
   end
 
   def daemonname
@@ -109,8 +112,8 @@ class Puppet::Daemon
     signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }) unless Puppet.features.microsoft_windows?
     signals.each do |signal, method|
       Signal.trap(signal) do
-        Puppet.notice "Caught #{signal}; calling #{method}"
-        send(method)
+        Puppet.notice "Caught #{signal}; storing #{method}"
+        @signals << method
       end
     end
   end
@@ -173,10 +176,16 @@ class Puppet::Daemon
       end
     end
 
+    signal_loop = Puppet::Scheduler.create_job(SIGNAL_CHECK_INTERVAL) do
+      while method = @signals.shift
+        Puppet.notice "Processing #{method}"
+        send(method)
+      end
+    end
+
     reparse_run.disable if Puppet[:filetimeout] == 0
     agent_run.disable unless agent
 
-    @scheduler.run_loop([reparse_run, agent_run])
+    @scheduler.run_loop([reparse_run, agent_run, signal_loop])
   end
 end
-

data/lib/puppet/defaults.rb

@@ -452,12 +452,35 @@ module Puppet
       a file (such as manifests or templates) has changed on disk. #{AS_DURATION}",
     },
     :environment_timeout => {
-      :default    => "3m",
+      :default    => "0",
       :type       => :ttl,
-      :desc       => "The time to live for a cached environment.
+      :desc       => "How long the Puppet master should cache data it loads from an
+      environment.
       #{AS_DURATION}
-      This setting can also be set to `unlimited`, which causes the environment to
-      be cached until the master is restarted."
+      A value of `0` will disable caching. This setting can also be set to
+      `unlimited`, which will cache environments until the master is restarted
+      or told to refresh the cache.
+
+      You should change this setting once your Puppet deployment is doing
+      non-trivial work. We chose the default value of `0` because it lets new
+      users update their code without any extra steps, but it lowers the
+      performance of your Puppet master.
+
+      We recommend setting this to `unlimited` and explicitly refreshing your
+      Puppet master as part of your code deployment process.
+
+      * With Puppet Server, you should refresh environments by calling the
+        `environment-cache` API endpoint. See the docs for the Puppet Server
+        administrative API.
+      * With a Rack Puppet master, you should restart the web server or the
+        application server. Passenger lets you touch a `restart.txt` file to
+        refresh an application without restarting Apache; see the Passenger docs
+        for details.
+
+      We don't recommend using any value other than `0` or `unlimited`, since
+      most Puppet masters use a pool of Ruby interpreters which all have their
+      own cache timers. When these timers drift out of sync, agents can be served
+      inconsistent catalogs."
     },
     :queue_type => {
       :default    => "stomp",

data/lib/puppet/environments.rb

@@ -107,7 +107,7 @@ module Puppet::Environments
     def get_conf(name)
       env = get(name)
       if env
-        Puppet::Settings::EnvironmentConf.static_for(env)
+        Puppet::Settings::EnvironmentConf.static_for(env, Puppet[:parser])
       else
         nil
       end

data/lib/puppet/error.rb

@@ -54,6 +54,10 @@ module Puppet
     include ExternalFileError
   end
 
+  # An error that already contains location information in the message text
+  class PreformattedError < Puppet::ParseError
+  end
+
   # An error class for when I don't know what happened.  Automatically
   # prints a stack trace when in debug mode.
   class DevError < Puppet::Error

data/lib/puppet/functions.rb

@@ -57,13 +57,13 @@
 # @example Dispatching to different methods by type
 #   Puppet::Functions.create_function('math::min') do
 #     dispatch :numeric_min do
-#       param 'Numeric', 'a'
-#       param 'Numeric', 'b'
+#       param 'Numeric', :a
+#       param 'Numeric', :b
 #     end
 #
 #     dispatch :string_min do
-#       param 'String', 'a'
-#       param 'String', 'b'
+#       param 'String', :a
+#       param 'String', :b
 #     end
 #
 #     def numeric_min(a, b)
@@ -82,25 +82,33 @@
 # be the same as the number of parameters, and all of the parameters are of
 # type 'Any'.
 #
-# To express that the last parameter captures the rest, the method
-# `last_captures_rest` can be called. This indicates that the last parameter is
-# a varargs parameter and will be passed to the implementing method as an array
-# of the given type.
+# The following methods can be used to define a parameter
 #
-# When defining a dispatch for a function, the resulting dispatch matches
-# against the specified argument types and min/max occurrence of optional
-# entries. When the dispatch makes the call to the implementation method the
-# arguments are simply passed and it is the responsibility of the method's
-# implementor to ensure it can handle those arguments (i.e. there is no check
-# that what was declared as optional actually has a default value, and that
-# a "captures rest" is declared using a `*`).
+#  - _param_ - the argument must be given in the call.
+#  - _optional_param_ - the argument may be missing in the call. May not be followed by a required parameter
+#  - _repeated_param_ - the type specifies a repeating type that occurs 0 to "infinite" number of times. It may only appear last or just before a block parameter.
+#  - _block_param_ - a block must be given in the call. May only appear last.
+#  - _optional_block_param_ - a block may be given in the call. May only appear last.
 #
-# @example Varargs
+# The method name _required_param_ is an alias for _param_ and _required_block_param_ is an alias for _block_param_
+#
+# A parameter definition takes 2 arguments:
+#  - _type_ A string that must conform to a type in the puppet language
+#  - _name_ A symbol denoting the parameter name
+#
+# Both arguments are optional when defining a block parameter. The _type_ defaults to "Callable"
+# and the _name_ to :block.
+#
+# Note that the dispatch definition is used to match arguments given in a call to the function with the defined
+# parameters. It then dispatches the call to the implementation method simply passing the given arguments on to
+# that method without any further processing and it is the responsibility of that method's implementor to ensure
+# that it can handle those arguments.
+#
+# @example Variable number of arguments
 #   Puppet::Functions.create_function('foo') do
 #     dispatch :foo do
-#       param 'Numeric', 'first'
-#       param 'Numeric', 'values'
-#       last_captures_rest
+#       param 'Numeric', :first
+#       repeated_param 'Numeric', :values
 #     end
 #
 #     def foo(first, *values)
@@ -108,6 +116,23 @@
 #     end
 #   end
 #
+# There is no requirement for direct mapping between parameter definitions and the parameters in the
+# receiving implementation method so the following example is also legal. Here the dispatch will ensure
+# that `*values` in the receiver will be an array with at least one entry of type String and that any
+# remaining entries are of type Numeric:
+#
+# @example Inexact mapping or parameters
+#   Puppet::Functions.create_function('foo') do
+#     dispatch :foo do
+#       param 'String', :first
+#       repeated_param 'Numeric', :values
+#     end
+#
+#     def foo(*values)
+#       # do something
+#     end
+#   end
+#
 # Access to Scope
 # ---
 # In general, functions should not need access to scope; they should be
@@ -260,24 +285,51 @@ module Puppet::Functions
       @dispatcher = dispatcher
     end
 
-    # Defines a positional parameter with type and name
+    # Defines a required positional parameter with _type_ and _name_.
     #
     # @param type [String] The type specification for the parameter.
-    # @param name [String] The name of the parameter. This is primarily used
-    #   for error message output and does not have to match the name of the
-    #   parameter on the implementation method.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
     # @return [Void]
     #
     # @api public
     def param(type, name)
-      if type.is_a?(String)
-        @types << type
-        @names << name
-        # mark what should be picked for this position when dispatching
-        @weaving << @names.size()-1
-      else
-        raise ArgumentError, "Type signature argument must be a String reference to a Puppet Data Type. Got #{type.class}"
-      end
+      internal_param(type, name)
+      raise ArgumentError, 'A required parameter cannot be added after an optional parameter' if @min != @max
+      @min += 1
+      @max += 1
+    end
+    alias required_param param
+
+    # Defines an optional positional parameter with _type_ and _name_.
+    # May not be followed by a required parameter.
+    #
+    # @param type [String] The type specification for the parameter.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
+    # @return [Void]
+    #
+    # @api public
+    def optional_param(type, name)
+      internal_param(type, name)
+      @max += 1
+    end
+
+    # Defines a repeated positional parameter with _type_ and _name_ that may occur 0 to "infinite" number of times.
+    # It may only appear last or just before a block parameter.
+    #
+    # @param type [String] The type specification for the parameter.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
+    # @return [Void]
+    #
+    # @api public
+    def repeated_param(type, name)
+      internal_param(type, name)
+      @max = :default
     end
 
     # Defines one required block parameter that may appear last. If type and name is missing the
@@ -285,7 +337,7 @@ module Puppet::Functions
     # parameter is given, then that is the name and the type is "Callable".
     #
     # @api public
-    def required_block_param(*type_and_name)
+    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
@@ -314,9 +366,10 @@ module Puppet::Functions
         @block_type = type
         @block_name = name
       else
-        raise ArgumentError, "Attempt to redefine block"
+        raise ArgumentError, 'Attempt to redefine block'
       end
     end
+    alias required_block_param block_param
 
     # Defines one optional block parameter that may appear last. If type or name is missing the
     # defaults are "any callable", and the name is "block". The implementor of the dispatch target
@@ -329,36 +382,22 @@ module Puppet::Functions
       @block_type = Puppet::Pops::Types::TypeFactory.optional(@block_type)
     end
 
-    # Specifies the min and max occurance of arguments (of the specified types)
-    # if something other than the exact count from the number of specified
-    # types). The max value may be specified as :default if an infinite number of
-    # arguments are supported. When max is > than the number of specified
-    # types, the last specified type repeats.
-    #
-    # @api public
-    def arg_count(min_occurs, max_occurs)
-      @min = min_occurs
-      @max = max_occurs
-      unless min_occurs.is_a?(Integer) && min_occurs >= 0
-        raise ArgumentError, "min arg_count of function parameter must be an Integer >=0, got #{min_occurs.class} '#{min_occurs}'"
-      end
-      unless max_occurs == :default || (max_occurs.is_a?(Integer) && max_occurs >= 0)
-        raise ArgumentError, "max arg_count of function parameter must be an Integer >= 0, or :default, got #{max_occurs.class} '#{max_occurs}'"
-      end
-      unless max_occurs == :default || (max_occurs.is_a?(Integer) && max_occurs >= min_occurs)
-        raise ArgumentError, "max arg_count must be :default (infinite) or >= min arg_count, got min: '#{min_occurs}, max: '#{max_occurs}'"
-      end
-    end
+    private
 
-    # Specifies that the last argument captures the rest.
-    #
-    # @api public
-    def last_captures_rest
-      @last_captures = true
+    # @api private
+    def internal_param(type, name)
+      raise ArgumentError, 'Parameters cannot be added after a block parameter' unless @block_type.nil?
+      raise ArgumentError, 'Parameters cannot be added after a repeated parameter' if @max == :default
+      if type.is_a?(String)
+        @types << type
+        @names << name
+        # mark what should be picked for this position when dispatching
+        @weaving << @names.size()-1
+      else
+        raise ArgumentError, "Parameter 'type' must be a String reference to a Puppet Data Type. Got #{type.class}"
+      end
     end
 
-    private
-
     # @api private
     def dispatch(meth_name, &block)
       # an array of either an index into names/types, or an array with
@@ -369,14 +408,13 @@ module Puppet::Functions
       @names = []
       @weaving = []
       @injections = []
-      @min = nil
-      @max = nil
-      @last_captures = false
+      @min = 0
+      @max = 0
       @block_type = nil
       @block_name = nil
       self.instance_eval &block
       callable_t = create_callable(@types, @block_type, @min, @max)
-      @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @last_captures)
+      @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @max == :default)
     end
 
     # Handles creation of a callable type from strings specifications of puppet
@@ -390,7 +428,8 @@ module Puppet::Functions
         @type_parser.parse(t)
       end
 
-      if !(from.nil? && to.nil?)
+      if from != to
+        # :optional and/or :repeated parameters are present.
         mapped_types << from
         mapped_types << to
       end
@@ -471,6 +510,20 @@ module Puppet::Functions
         instance_variable_get(ivar)
       end
     end
+
+    # Allows the implementation of a function to call other functions by name and pass the caller
+    # scope. The callable functions are those visible to the same loader that loaded this function
+    # (the calling function).
+    #
+    # @param scope [Puppet::Parser::Scope] The caller scope
+    # @param function_name [String] The name of the function
+    # @param *args [Object] splat of arguments
+    # @return [Object] The result returned by the called function
+    #
+    # @api public
+    def call_function_with_scope(scope, function_name, *args)
+      internal_call_function(scope, function_name, args)
+    end
   end
 
   # @note WARNING: This style of creating functions is not public. It is a system