puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/parser/compiler.rb

@@ -20,6 +20,17 @@ class Puppet::Parser::Compiler
     $env_module_directories = nil
     node.environment.check_for_reparse
 
+    if node.environment.conflicting_manifest_settings?
+      errmsg = [
+        "The 'disable_per_environment_manifest' setting is true, and this '#{node.environment}'",
+        "has an environment.conf manifest that conflicts with the 'default_manifest' setting.",
+        "Compilation has been halted in order to avoid running a catalog which may be using",
+        "unexpected manifests. For more information, see",
+        "http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
+      ]
+      raise(Puppet::Error, errmsg.join(' '))
+    end
+
     new(node).compile.to_resource
   rescue => detail
     message = "#{detail} on node #{node.name}"
@@ -107,25 +118,25 @@ class Puppet::Parser::Compiler
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
-      Puppet::Util::Profiler.profile("Compile: Set node parameters") { set_node_parameters }
+      Puppet::Util::Profiler.profile("Compile: Set node parameters", [:compiler, :set_node_params]) { set_node_parameters }
 
-      Puppet::Util::Profiler.profile("Compile: Created settings scope") { create_settings_scope }
+      Puppet::Util::Profiler.profile("Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
 
       if is_binder_active?
         # create injector, if not already created - this is for 3x that does not trigger
         # lazy loading of injector via context
-        Puppet::Util::Profiler.profile("Compile: Created injector") { injector }
+        Puppet::Util::Profiler.profile("Compile: Created injector", [:compiler, :create_injector]) { injector }
       end
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated main") { evaluate_main }
+      Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated AST node") { evaluate_ast_node }
+      Puppet::Util::Profiler.profile("Compile: Evaluated AST node", [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated node classes") { evaluate_node_classes }
+      Puppet::Util::Profiler.profile("Compile: Evaluated node classes", [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated generators") { evaluate_generators }
+      Puppet::Util::Profiler.profile("Compile: Evaluated generators", [:compiler, :evaluate_generators]) { evaluate_generators }
 
-      Puppet::Util::Profiler.profile("Compile: Finished catalog") { finish }
+      Puppet::Util::Profiler.profile("Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
 
       fail_on_unevaluated
 
@@ -154,9 +165,6 @@ class Puppet::Parser::Compiler
 
   # Return the node's environment.
   def environment
-    unless node.environment.is_a? Puppet::Node::Environment
-      raise Puppet::DevError, "node #{node} has an invalid environment!"
-    end
     node.environment
   end
 
@@ -204,25 +212,25 @@ class Puppet::Parser::Compiler
       class_parameters = classes
       classes = classes.keys
     end
-    classes.each do |name|
-      # If we can find the class, then make a resource that will evaluate it.
-      if klass = scope.find_hostclass(name, :assume_fqname => fqname)
-
-        # If parameters are passed, then attempt to create a duplicate resource
-        # so the appropriate error is thrown.
-        if class_parameters
-          resource = klass.ensure_in_catalog(scope, class_parameters[name] || {})
-        else
-          next if scope.class_scope(klass)
-          resource = klass.ensure_in_catalog(scope)
-        end
 
-        # If they've disabled lazy evaluation (which the :include function does),
-        # then evaluate our resource immediately.
-        resource.evaluate unless lazy_evaluate
-      else
-        raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+    hostclasses = classes.collect do |name|
+      scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+    end
+
+    if class_parameters
+      resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
+      if !lazy_evaluate
+        resources.each(&:evaluate)
       end
+
+      resources
+    else
+      already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
+      if !lazy_evaluate
+        newly_included.each(&:evaluate)
+      end
+
+      already_included + newly_included
     end
   end
 
@@ -299,6 +307,27 @@ class Puppet::Parser::Compiler
 
   private
 
+  def ensure_classes_with_parameters(scope, hostclasses, parameters)
+    hostclasses.collect do |klass|
+      klass.ensure_in_catalog(scope, parameters[klass.name] || {})
+    end
+  end
+
+  def ensure_classes_without_parameters(scope, hostclasses)
+    already_included = []
+    newly_included = []
+    hostclasses.each do |klass|
+      class_scope = scope.class_scope(klass)
+      if class_scope
+        already_included << class_scope.resource
+      else
+        newly_included << klass.ensure_in_catalog(scope)
+      end
+    end
+
+    [already_included, newly_included]
+  end
+
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
@@ -331,7 +360,7 @@ class Puppet::Parser::Compiler
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
-      Puppet::Util::Profiler.profile("Evaluated collections") do
+      Puppet::Util::Profiler.profile("Evaluated collections", [:compiler, :evaluate_collections]) do
         found_something = false
         @collections.dup.each do |collection|
           found_something = true if collection.evaluate
@@ -346,9 +375,9 @@ class Puppet::Parser::Compiler
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
-      Puppet::Util::Profiler.profile("Evaluated definitions") do
+      Puppet::Util::Profiler.profile("Evaluated definitions", [:compiler, :evaluate_definitions]) do
         !unevaluated_resources.each do |resource|
-          Puppet::Util::Profiler.profile("Evaluated resource #{resource}") do
+          Puppet::Util::Profiler.profile("Evaluated resource #{resource}", [:compiler, :evaluate_resource, resource]) do
             resource.evaluate
           end
         end.empty?
@@ -365,7 +394,7 @@ class Puppet::Parser::Compiler
     loop do
       done = true
 
-      Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators") do
+      Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators", [:compiler, :iterate_on_generators]) do
         # Call collections first, then definitions.
         done = false if evaluate_collections
         done = false if evaluate_definitions
@@ -553,10 +582,8 @@ class Puppet::Parser::Compiler
   end
 
   def create_settings_scope
-    unless settings_type = environment.known_resource_types.hostclass("settings")
-      settings_type = Puppet::Resource::Type.new :hostclass, "settings"
-      environment.known_resource_types.add(settings_type)
-    end
+    settings_type = Puppet::Resource::Type.new :hostclass, "settings"
+    environment.known_resource_types.add(settings_type)
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
 
@@ -566,9 +593,10 @@ class Puppet::Parser::Compiler
 
     scope = @topscope.class_scope(settings_type)
 
+    env = environment
     Puppet.settings.each do |name, setting|
-      next if name.to_s == "name"
-      scope[name.to_s] = environment[name]
+      next if name == :name
+      scope[name.to_s] = env[name]
     end
   end
 

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -19,8 +19,8 @@ class Puppet::Parser::E4ParserAdapter
     @file_watcher = file_watcher || NullFileWatcher.new
     @file = ''
     @string = ''
-    @use = :undefined
-    @@evaluating_parser ||= Puppet::Pops::Parser::EvaluatingParser::Transitional.new()
+    @use = :unspecified
+    @@evaluating_parser ||= Puppet::Pops::Parser::EvaluatingParser.new()
   end
 
   def file=(file)

data/lib/puppet/parser/files.rb

@@ -1,10 +1,10 @@
 require 'puppet/module'
 
-module Puppet; module Parser; module Files
+module Puppet::Parser::Files
 
   module_function
 
-  # Return a list of manifests as absolute filenames matching the given 
+  # Return a list of manifests as absolute filenames matching the given
   # pattern.
   #
   # @param pattern [String] A reference for a file in a module. It is the format "<modulename>/<file glob>"
@@ -25,49 +25,93 @@ module Puppet; module Parser; module Files
     [nil, []]
   end
 
-  # Find the concrete file denoted by +file+. If +file+ is absolute,
-  # return it directly. Otherwise try to find relative to the +templatedir+
-  # config param.  If that fails try to find it as a template in a
-  # module.
-  # In all cases, an absolute path is returned, which does not
-  # necessarily refer to an existing file
+  # Find the path to the given file selector. Files can be selected in
+  # one of two ways:
+  #   * absolute path: the path is simply returned
+  #   * modulename/filename selector: a file is found in the file directory
+  #     of the named module.
+  #
+  # In the second case a nil is returned if there isn't a file found. In the
+  # first case (absolute path), there is no existence check done and so the
+  # path will be returned even if there isn't a file available.
+  #
+  # @param template [String] the file selector
+  # @param environment [Puppet::Node::Environment] the environment in which to search
+  # @return [String, nil] the absolute path to the file or nil if there is no file found
   #
   # @api private
-  def find_template(template, environment)
-    if template == File.expand_path(template)
-      return template
-    end
+  def find_file(file, environment)
+    if Puppet::Util.absolute_path?(file)
+      file
+    else
+      path, module_file = split_file_path(file)
+      mod = environment.module(path)
 
-    if template_paths = templatepath(environment)
-      # If we can find the template in :templatedir, we return that.
-      template_paths.collect { |path|
-        File::join(path, template)
-      }.each do |f|
-        return f if Puppet::FileSystem.exist?(f)
+      if module_file && mod
+        mod.file(module_file)
+      else
+        nil
       end
     end
+  end
 
-    # check in the default template dir, if there is one
-    if td_file = find_template_in_module(template, environment)
-      return td_file
+  # Find the path to the given template selector. Templates can be selected in
+  # a number of ways:
+  #   * absolute path: the path is simply returned
+  #   * path relative to the templatepath setting: a file is found and the path
+  #     is returned
+  #   * modulename/filename selector: a file is found in the template directory
+  #     of the named module.
+  #
+  # In the last two cases a nil is returned if there isn't a file found. In the
+  # first case (absolute path), there is no existence check done and so the
+  # path will be returned even if there isn't a file available.
+  #
+  # @param template [String] the template selector
+  # @param environment [Puppet::Node::Environment] the environment in which to search
+  # @return [String, nil] the absolute path to the template file or nil if there is no file found
+  #
+  # @api private
+  def find_template(template, environment)
+    if Puppet::Util.absolute_path?(template)
+      template
+    else
+      in_templatepath = find_template_in_templatepath(template, environment)
+      if in_templatepath
+        in_templatepath
+      else
+        find_template_in_module(template, environment)
+      end
     end
+  end
 
-    nil
+  # Templatepaths are deprecated functionality, this will be going away in
+  # Puppet 4.
+  #
+  # @api private
+  def find_template_in_templatepath(template, environment)
+    template_paths = templatepath(environment)
+    if template_paths
+      template_paths.collect do |path|
+        File::join(path, template)
+      end.find do |f|
+        Puppet::FileSystem.exist?(f)
+      end
+    else
+      nil
+    end
   end
 
   # @api private
   def find_template_in_module(template, environment)
     path, file = split_file_path(template)
+    mod = environment.module(path)
 
-    # Because templates don't have an assumed template name, like manifests do,
-    # we treat templates with no name as being templates in the main template
-    # directory.
-    return nil unless file
-
-    if mod = environment.module(path) and t = mod.template(file)
-      return t
+    if file && mod
+      mod.template(file)
+    else
+      nil
     end
-    nil
   end
 
   # Return an array of paths by splitting the +templatedir+ config
@@ -84,11 +128,10 @@ module Puppet; module Parser; module Files
   # nil if the path is empty or absolute (starts with a /).
   # @api private
   def split_file_path(path)
-    if path == "" or Puppet::Util.absolute_path?(path)
+    if path == "" || Puppet::Util.absolute_path?(path)
       nil
     else
       path.split(File::SEPARATOR, 2)
     end
   end
-
-end; end; end
+end

data/lib/puppet/parser/functions.rb

@@ -133,12 +133,6 @@ module Puppet::Parser::Functions
   #
   # @api public
   def self.newfunction(name, options = {}, &block)
-    # Short circuit this call when 4x "biff" is in effect to allow the new loader system to load
-    # and define the function a different way.
-    #
-    if Puppet[:biff]
-      return Puppet::Pops::Loader::RubyLegacyFunctionInstantiator.legacy_newfunction(name, options, &block)
-    end
     name = name.intern
     environment = options[:environment] || Puppet.lookup(:current_environment)
 
@@ -160,7 +154,7 @@ module Puppet::Parser::Functions
     env_module = environment_module(environment)
 
     env_module.send(:define_method, fname) do |*args|
-      Puppet::Util::Profiler.profile("Called #{name}") do
+      Puppet::Util::Profiler.profile("Called #{name}", [:functions, name]) do
         if args[0].is_a? Array
           if arity >= 0 and args[0].size != arity
             raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for #{arity})"

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

@@ -0,0 +1,31 @@
+Puppet::Parser::Functions::newfunction(
+  :assert_type,
+  :type => :rvalue,
+  :arity => -3,
+  :doc => "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.
+
+Example: assert that `$b` is a non empty `String` and assign to `$a`:
+
+  $a = assert_type(String[1], $b)
+
+Example using custom error message:
+
+  $a = assert_type(String[1], $b) |$expected, $actual| {
+    fail('The name cannot be empty')
+  }
+
+Example, using a warning and a default:
+
+  $a = assert_type(String[1], $b) |$expected, $actual| {
+    warning('Name is empty, using default')
+    'anonymous'
+  }
+
+See the documentation for 'The Puppet Type System' for more information about types.
+- since Puppet 3.7
+- requires future parser/evaluator
+") do |args|
+  function_fail(["assert_type() is only available when parser/evaluator future is in effect"])
+end

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

@@ -11,16 +11,26 @@ comma-separated list of class names.
 
 A contained class will not be applied before the containing class is
 begun, and will be finished before the containing class is finished.
+
+When the future parser is used, you must use the class's full name;
+relative names are no longer allowed. In addition to names in string form,
+you may also directly use Class and Resource Type values that are produced by
+the future parser's resource and relationship expressions.
 "
 ) do |classes|
   scope = self
 
-  scope.function_include(classes)
+  # Make call patterns uniform and protected against nested arrays, also make
+  # names absolute if so desired.
+  classes = transform_and_assert_classnames(classes.is_a?(Array) ? classes.flatten : [classes])
+
+  containing_resource = scope.resource
 
-  classes.each do |class_name|
-    class_resource = scope.catalog.resource("Class", class_name)
-    if ! scope.catalog.edge?(scope.resource, class_resource)
-      scope.catalog.add_edge(scope.resource, class_resource)
+  # This is the same as calling the include function but faster and does not rely on the include
+  # function (which is a statement) to return something (it should not).
+  (compiler.evaluate_classes(classes, self, false) || []).each do |resource|
+    if ! scope.catalog.edge?(containing_resource, resource)
+      scope.catalog.add_edge(containing_resource, resource)
     end
   end
 end

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

@@ -73,6 +73,10 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
   begin
     resource.safeevaluate(self)
   rescue Puppet::ParseError => internal_error
-    raise internal_error.original
+    if internal_error.original.nil?
+      raise internal_error
+    else
+      raise internal_error.original
+    end
   end
 end

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

@@ -0,0 +1,5 @@
+require 'puppet/util/checksums'
+Puppet::Parser::Functions::newfunction(:digest, :type => :rvalue, :arity => 1, :doc => "Returns a hash value from a provided string using the digest_algorithm setting from the Puppet config file.") do |args|
+  algo = Puppet[:digest_algorithm]
+  Puppet::Util::Checksums.method(algo.intern).call args[0]
+end