puppet 4.7.1-x64-mingw32 → 4.8.0-x64-mingw32

data/lib/puppet/functions/regsubst.rb

@@ -1,40 +1,36 @@
 # Perform regexp replacement on a string or array of strings.
 #
-# @example
-#
-# Get the third octet from the node's IP address:
-#
-#   $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
-#
-# Put angle brackets around each octet in the node's IP address:
-#
-#   $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
-#
-# @param target [Array[String]|String]
+# @param target [String, Array[String]]
 #      The string or array of strings to operate on.  If an array, the replacement will be
 #      performed on each of the elements in the array, and the return value will be an array.
-# @param regexp [String|Regexp|Type[Regexp]]
+# @param pattern [String, Regexp, Type[Regexp]]
 #      The regular expression matching the target string.  If you want it anchored at the start
 #      and or end of the string, you must do that with ^ and $ yourself.
-# @param replacement [String|Hash[String, String]]
+# @param replacement [String, Hash[String, String]]
 #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
 #      \\1 (first set of parentheses), and so on.
 #      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
-# @param flags [String]
+# @param flags [Optional[Pattern[/^[GEIM]*$/]], Pattern[/^G?$/]]
 #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
 #      if pattern is a precompiled regexp):
 #        - *E*         Extended regexps
 #        - *I*         Ignore case in regexps
 #        - *M*         Multiline regexps
 #        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
-# @param encoding [String]
+# @param encoding [Enum['N','E','S','U']]
 #      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
 #      precompiled regexp). A single-character string with the following values:
 #        - *N*         None
 #        - *E*         EUC
 #        - *S*         SJIS
 #        - *U*         UTF-8
-# @return [Array[String]|String] The result of the substitution. Result type is the same as for the target parameter.
+# @return [Array[String], String] The result of the substitution. Result type is the same as for the target parameter.
+#
+# @example Get the third octet from the node's IP address:
+#     $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
+#
+# @example Put angle brackets around each octet in the node's IP address:
+#     $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
 #
 Puppet::Functions.create_function(:regsubst) do
   dispatch :regsubst_string do

data/lib/puppet/functions/require.rb

@@ -0,0 +1,37 @@
+# Requires the specified classes
+# For documentation see the 3.x function stub
+Puppet::Functions.create_function(:require, Puppet::Functions::InternalFunction) do
+  dispatch :require_impl do
+    scope_param
+    # The function supports what the type system sees as Ruby runtime objects, and
+    # they cannot be parameterized to find what is actually valid instances.
+    # The validation is instead done in the function body itself via a call to
+    # `transform_and_assert_classnames` on the calling scope.
+    required_repeated_param 'Any', :names
+  end
+
+  def require_impl(scope, *classes)
+    # Make call patterns uniform and protected against nested arrays, also make
+    # names absolute if so desired.
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+
+    # This is the same as calling the include function (but faster) since it again
+    # would otherwise need to perform the optional absolute name transformation
+    # (for no reason since they are already made absolute here).
+    #
+    scope.compiler.evaluate_classes(classes, scope, false)
+    krt = scope.environment.known_resource_types
+
+    classes.each do |klass|
+      # lookup the class in the scopes
+      klass = (classobj = krt.find_hostclass(klass)) ? classobj.name : nil
+      raise Puppet::ParseError.new("Could not find class #{klass}") unless klass
+      ref = Puppet::Resource.new(:class, klass)
+      resource = scope.resource
+      resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
+    end
+    result
+  end
+end

data/lib/puppet/functions/return.rb

@@ -0,0 +1,22 @@
+# Make iteration continue with the next value optionally given a value for this iteration.
+# If a value is not given it defaults to `undef`
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:return, Puppet::Functions::InternalFunction) do
+  dispatch :return_impl do
+    optional_param 'Any', :value
+  end
+
+  def return_impl(value = nil)
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+
+    raise Puppet::Pops::Evaluator::Return.new(value, file, line)
+  end
+end

data/lib/puppet/functions/strftime.rb

@@ -0,0 +1,35 @@
+# (Documentation in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:strftime) do
+  dispatch :format_timespan do
+    param 'Timespan', :time_object
+    param 'String', :format
+  end
+
+  dispatch :format_timestamp do
+    param 'Timestamp', :time_object
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  dispatch :legacy_strftime do
+    param 'String', :format
+    optional_param 'String', :timezone
+  end
+
+  def format_timespan(time_object, format)
+    time_object.format(format)
+  end
+
+  def format_timestamp(time_object, format, timezone = nil)
+    time_object.format(format, timezone)
+  end
+
+  def legacy_strftime(format, timezone = nil)
+    Puppet.warn_once('deprecation', 'legacy#strftime',
+      'The argument signature (String format, [String timezone]) is deprecated for #strfime. See #strftime documentation and Timespan type for more info')
+    Puppet::Pops::Time::Timestamp.format_time(format, Time.now.utc, timezone)
+  end
+end

data/lib/puppet/functions/warning.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level notice.
+Puppet::Functions.create_function(:warning, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :warning do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def warning(scope, *values)
+    Puppet::Util::Log.log_func(scope, :warning, values)
+  end
+end

data/lib/puppet/generate/models/type/type.rb

@@ -24,6 +24,9 @@ module Puppet
           # Gets the isomorphic member attribute of the type
           attr_reader :isomorphic
 
+          # Gets the capability member attribute of the type
+          attr_reader :capability
+
           # Initializes a type model.
           # @param type [Puppet::Type] The Puppet type to model.
           # @return [void]
@@ -45,6 +48,7 @@ module Puppet
               ]
             end]
             @isomorphic = type.isomorphic?
+            @capability = type.is_capability?
           end
 
           def render(template)

data/lib/puppet/generate/templates/type/pcore.erb

@@ -37,5 +37,6 @@ Puppet::Resource::ResourceType3.new(
     <%= mapping[0] %> => [<%= mapping[1].join(', ')%>]<%= "," if index + 1 < title_patterns.size %>
 <%- end -%>
   },
-  <%= isomorphic -%>
+  <%= isomorphic -%>,
+  <%= capability -%>
 )

data/lib/puppet/indirector/face.rb

@@ -39,7 +39,12 @@ class Puppet::Indirector::Face < Puppet::Face
 
   def call_indirection_method(method, key, options)
     begin
-      result = indirection.__send__(method, key, options)
+      if method == :save
+        # key is really the instance to save
+        result = indirection.__send__(method, key, nil, options)
+      else
+        result = indirection.__send__(method, key, options)
+      end
     rescue => detail
       message = "Could not call '#{method}' on '#{indirection_name}': #{detail}"
       Puppet.log_exception(detail, message)

data/lib/puppet/network/http/error.rb

@@ -59,11 +59,11 @@ module Puppet::Network::HTTP::Error
 
     def initialize(original_error, issue_kind = Issues::RUNTIME_ERROR)
       super("Server Error: " + original_error.message, CODE, issue_kind)
-      @backtrace = ["Warning: The 'stacktrace' property is deprecated and will be removed in a future version of Puppet. For security reasons, stacktraces are not returned with Puppet HTTP Error responses."]
+      @backtrace = original_error.backtrace
     end
 
     def to_json
-      JSON({:message => message, :issue_kind => @issue_kind, :stacktrace => self.backtrace})
+      JSON({:message => message, :issue_kind => @issue_kind})
     end
   end
 end

data/lib/puppet/network/http/handler.rb

@@ -68,7 +68,7 @@ module Puppet::Network::HTTP::Handler
     new_response.respond_with(e.status, "application/json", e.to_json)
   rescue StandardError => e
     http_e = Puppet::Network::HTTP::Error::HTTPServerError.new(e)
-    log_msg = [http_e.message, *e.backtrace].join("\n")
+    log_msg = [http_e.message, *http_e.backtrace].join("\n")
     Puppet.err(log_msg)
     new_response.respond_with(http_e.status, "application/json", http_e.to_json)
   ensure
@@ -168,7 +168,7 @@ module Puppet::Network::HTTP::Handler
 
   def configure_profiler(request_headers, request_params)
     if (request_headers.has_key?(Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase) or Puppet[:profile])
-      Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:debug), request_params.object_id))
+      Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::Aggregate.new(Puppet.method(:info), request_params.object_id))
     end
   end
 

data/lib/puppet/node/environment.rb

@@ -218,6 +218,17 @@ class Puppet::Node::Environment
     errors
   end
 
+  # Checks if this environment permits use of rich data types in the catalog
+  # @return [Boolean] `true` if rich data is permitted.
+  # @api private
+  def rich_data?
+    if @rich_data.nil?
+      environment_conf = Puppet.lookup(:environments).get_conf(name)
+      @rich_data = (environment_conf.nil? ? Puppet[:rich_data] : environment_conf.rich_data)
+    end
+    @rich_data
+  end
+
   # Return an environment-specific Puppet setting.
   #
   # @api public

data/lib/puppet/parser/ast.rb

@@ -29,6 +29,11 @@ class Puppet::Parser::AST
     # is called so many times during parsing.
     begin
       return self.evaluate(scope)
+    rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+      raise detail
+#      # Only deals with StopIteration from the break() function as a general
+#      # StopIteration is a general runtime problem
+#      raise Puppet::ParseError.new(detail.message, detail.file, detail.line, detail)
     rescue Puppet::Error => detail
       raise adderrorcontext(detail)
     rescue => detail

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -61,6 +61,19 @@ class Puppet::Parser::AST::PopsBridge
     end
   end
 
+  class ExpressionSupportingReturn < Expression
+    def initialize args
+      super
+    end
+
+    def evaluate(scope)
+      return catch(:return) do
+        return catch(:next) do
+          return super(scope)
+        end
+      end
+    end
+  end
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
@@ -174,26 +187,26 @@ class Puppet::Parser::AST::PopsBridge
     end
 
     # Produces a hash with data for Definition and HostClass
-    def args_from_definition(o, modname)
+    def args_from_definition(o, modname, expr_class = Expression)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
        :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
-        args[:code] = Expression.new(:value => o.body)
+        args[:code] = expr_class.new(:value => o.body)
       end
       @ast_transformer.merge_location(args, o)
     end
 
     def instantiate_HostClassDefinition(o, modname)
-      args = args_from_definition(o, modname)
+      args = args_from_definition(o, modname, ExpressionSupportingReturn)
       args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
-      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname, ExpressionSupportingReturn)))
       Puppet::Pops::Loaders.register_runtime3_type(instance.name, Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).to_uri)
       instance
     end

data/lib/puppet/parser/compiler.rb

@@ -585,6 +585,11 @@ class Puppet::Parser::Compiler
         urs = unevaluated_resources.each do |resource|
          begin
             resource.evaluate
+         rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+           # needs to be handled specifically as the error has the file/line/position where this
+           # occurred rather than the resource
+           fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, {:detail => detail.message}, detail)
+
           rescue Puppet::Error => e
             # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
             # call stack instead
@@ -860,11 +865,34 @@ class Puppet::Parser::Compiler
     scope = @topscope.class_scope(settings_type)
 
     env = environment
+    settings_hash = {}
     Puppet.settings.each do |name, setting|
       next if name == :name
-      scope[name.to_s] = env[name]
+      s_name = name.to_s
+      # Construct a hash (in anticipation it will be set in top scope under a name like $settings)
+      settings_hash[s_name] = transform_setting(env[name])
+      scope[s_name] = settings_hash[s_name]
+    end
+  end
+
+  def transform_setting(val)
+    case val
+    when Integer, Float, String, TrueClass, FalseClass, NilClass
+      val
+    when Symbol
+      val == :undef ? nil : val.to_s
+    when Array
+      val.map {|entry| transform_setting(entry) }
+    when Hash
+      result = {}
+      val.each {|k,v| result[transform_setting(k)] = transform_setting(v) }
+      result
+    else
+      # not ideal, but required as there are settings values that are special
+      val.to_s
     end
   end
+  private :transform_setting
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.

data/lib/puppet/parser/functions.rb

@@ -269,4 +269,10 @@ module Puppet::Parser::Functions
       environment_module(environment).get_function_info(name.intern) || environment_module(Puppet.lookup(:root_environment)).get_function_info(name.intern)
     end
   end
+
+  class Error
+    def self.is4x(name)
+      raise Puppet::ParseError, "#{name}() can only be called using the 4.x function API. See Scope#call_function"
+    end
+  end
 end

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

@@ -56,5 +56,5 @@ For more information about data types, see the
 - Since 4.0.0
 DOC
 ) do |args|
-  function_fail(["assert_type() is only available when parser/evaluator future is in effect"])
+  Error.is4x('assert_type')
 end

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

@@ -0,0 +1,24 @@
+Puppet::Parser::Functions::newfunction(
+  :binary_file,
+  :type => :rvalue,
+  :arity => 1,
+:doc => <<-DOC
+Loads a binary file from a module or file system and returns its contents as a Binary.
+
+The argument to this function should be a `<MODULE NAME>/<FILE>`
+reference, which will load `<FILE>` from a module's `files`
+directory. (For example, the reference `mysql/mysqltuner.pl` will load the
+file `<MODULES DIRECTORY>/mysql/files/mysqltuner.pl`.)
+
+This function also accepts an absolute file path that allows reading
+binary file content from anywhere on disk.
+
+An error is raised if the given file does not exists.
+
+To search for the existence of files, use the `find_file()` function.
+
+- since 4.8.0
+DOC
+) do |args|
+  Error.is4x('binary_file')
+end

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

@@ -0,0 +1,39 @@
+Puppet::Parser::Functions::newfunction(
+  :break,
+  :arity => 0,
+  :doc => <<-DOC
+Breaks the innermost iteration as if it encountered an end of input.
+This function does not return to the caller.
+
+The signal produced to stop the iteration bubbles up through
+the call stack until either terminating the innermost iteration or
+raising an error if the end of the call stack is reached.
+
+The break() function does not accept an argument.
+
+**Example:** Using `break`
+
+```puppet
+$data = [1,2,3]
+notice $data.map |$x| { if $x == 3 { break() } $x*10 }
+```
+
+Would notice the value `[10, 20]`
+
+**Example:** Using a nested `break`
+
+```puppet
+function break_if_even($x) {
+  if $x % 2 == 0 { break() }
+}
+$data = [1,2,3]
+notice $data.map |$x| { break_if_even($x); $x*10 }
+```
+Would notice the value `[10]`
+
+* Also see functions `next` and `return`
+* Since 4.8.0
+DOC
+) do |args|
+  Error.is4x('break')
+end