puppet 3.8.7 → 4.0.0.rc1

data/lib/puppet/parser/compiler.rb

@@ -5,6 +5,7 @@ require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
+require 'puppet/loaders'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
@@ -20,22 +21,17 @@ class Puppet::Parser::Compiler
     $env_module_directories = nil
     node.environment.check_for_reparse
 
-    if node.environment.conflicting_manifest_settings?
+    errors = node.environment.validation_errors
+    if !errors.empty?
+      errors.each { |e| Puppet.err(e) } if errors.size > 1
       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",
+        "Compilation has been halted because: #{errors.first}",
+        "For more information, see http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
       ]
       raise(Puppet::Error, errmsg.join(' '))
     end
 
     new(node).compile {|resulting_catalog| resulting_catalog.to_resource }
-  rescue Puppet::ParseErrorWithIssue => detail
-    detail.node = node.name
-    Puppet.log_exception(detail)
-    raise
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
@@ -126,11 +122,7 @@ class Puppet::Parser::Compiler
 
       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", [:compiler, :create_injector]) { injector }
-      end
+      activate_binder
 
       Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
 
@@ -154,18 +146,12 @@ class Puppet::Parser::Compiler
 
   # Constructs the overrides for the context
   def context_overrides()
-    if Puppet.future_parser?(environment)
-      {
-        :current_environment => environment,
-        :global_scope => @topscope,             # 4x placeholder for new global scope
-        :loaders  => lambda {|| loaders() },    # 4x loaders
-        :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
-      }
-    else
-      {
-        :current_environment => environment,
-      }
-    end
+    {
+      :current_environment => environment,
+      :global_scope => @topscope,             # 4x placeholder for new global scope
+      :loaders  => lambda {|| loaders() },    # 4x loaders
+      :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
+    }
   end
 
   def_delegator :@collections, :delete, :delete_collection
@@ -198,18 +184,12 @@ class Puppet::Parser::Compiler
     evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
-  # Evaluate each specified class in turn.  If there are any classes we can't
-  # find, raise an error.  This method really just creates resource objects
+  # Evaluates each specified class in turn. If there are any classes that 
+  # can't be found, an error is raised. This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   #
-  # Sometimes we evaluate classes with a fully qualified name already, in which
-  # case, we tell scope.find_hostclass we've pre-qualified the name so it
-  # doesn't need to search its namespaces again.  This gets around a weird
-  # edge case of duplicate class names, one at top scope and one nested in our
-  # namespace and the wrong one (or both!) getting selected. See ticket #13349
-  # for more detail.  --jeffweiss 26 apr 2012
-  def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
+  def evaluate_classes(classes, scope, lazy_evaluate = true)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
@@ -220,7 +200,7 @@ class Puppet::Parser::Compiler
     end
 
     hostclasses = classes.collect do |name|
-      scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+      scope.find_hostclass(name) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
     end
 
     if class_parameters
@@ -296,19 +276,16 @@ class Puppet::Parser::Compiler
 
   # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
   # @return [Boolean] true if the Puppet Binder should be activated
-  def is_binder_active?
-    should_be_active = Puppet[:binder] || Puppet.future_parser?
-    if should_be_active
-      # TODO: this should be in a central place, not just for ParserFactory anymore...
-      Puppet::Parser::ParserFactory.assert_rgen_installed()
-      @@binder_loaded ||= false
-      unless @@binder_loaded
-        require 'puppet/pops'
-        require 'puppetx'
-        @@binder_loaded = true
-      end
+  def activate_binder
+    # TODO: this should be in a central place
+    Puppet::Parser::ParserFactory.assert_rgen_installed()
+    @@binder_loaded ||= false
+    unless @@binder_loaded
+      require 'puppet/pops'
+      require 'puppet/plugins/configuration'
+      @@binder_loaded = true
     end
-    should_be_active
+    true
   end
 
   private
@@ -383,7 +360,9 @@ class Puppet::Parser::Compiler
     exceptwrap do
       Puppet::Util::Profiler.profile("Evaluated definitions", [:compiler, :evaluate_definitions]) do
         !unevaluated_resources.each do |resource|
-          resource.evaluate
+          Puppet::Util::Profiler.profile("Evaluated resource #{resource}", [:compiler, :evaluate_resource, resource]) do
+            resource.evaluate
+          end
         end.empty?
       end
     end
@@ -416,7 +395,7 @@ class Puppet::Parser::Compiler
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
-    @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
+    @main = known_resource_types.find_hostclass("") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
@@ -444,16 +423,12 @@ class Puppet::Parser::Compiler
     end
   end
 
-  # Make sure we don't have any remaining collections that specifically
-  # look for resources, because we want to consider those to be
-  # parse errors.
+  # Make sure there are no remaining collections that are waiting for
+  # resources that have not yet been instantiated. If this occurs it
+  # is an error (missing resource - it could not be realized).
+  #
   def fail_on_unevaluated_resource_collections
-    if Puppet.future_parser?
-      remaining = @collections.collect(&:unresolved_resources).flatten.compact
-    else
-      remaining = @collections.collect(&:resources).flatten.compact
-    end
-
+    remaining = @collections.collect(&:unresolved_resources).flatten.compact
     if !remaining.empty?
       raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}"
     end
@@ -545,7 +520,7 @@ class Puppet::Parser::Compiler
     @topscope = Puppet::Parser::Scope.new(self)
 
     # Need to compute overrides here, and remember them, because we are about to
-    # enter the magic zone of known_resource_types and intial import.
+    # enter the magic zone of known_resource_types and initial import.
     # Expensive entries in the context are bound lazily.
     @context_overrides = context_overrides()
 
@@ -580,13 +555,9 @@ class Puppet::Parser::Compiler
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
-    if Puppet[:trusted_node_data]
-      @topscope.set_trusted(node.trusted_data)
-    end
-    if(Puppet[:immutable_node_data])
-      facts_hash = node.facts.nil? ? {} : node.facts.values
-      @topscope.set_facts(facts_hash)
-    end
+    @topscope.set_trusted(node.trusted_data)
+    facts_hash = node.facts.nil? ? {} : node.facts.values
+    @topscope.set_facts(facts_hash)
   end
 
   def create_settings_scope
@@ -627,8 +598,8 @@ class Puppet::Parser::Compiler
   end
 
   def assert_binder_active
-    unless is_binder_active?
-      raise ArgumentError, "The Puppet Binder is only available when either '--binder true' or '--parser future' is used"
+    unless activate_binder()
+      raise Puppet::DevError, "The Puppet Binder was not activated"
     end
   end
 end

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -6,17 +6,7 @@ module Puppet; module Parser; end; end;
 #
 class Puppet::Parser::E4ParserAdapter
 
-  # Empty adapter fulfills watch_file contract without doing anything.
-  # @api private
-  class NullFileWatcher
-    def watch_file(file)
-      #nop
-    end
-  end
-
-  # @param file_watcher [#watch_file] something that can watch a file
-  def initialize(file_watcher = nil)
-    @file_watcher = file_watcher || NullFileWatcher.new
+  def initialize
     @file = ''
     @string = ''
     @use = :unspecified
@@ -26,18 +16,11 @@ class Puppet::Parser::E4ParserAdapter
   def file=(file)
     @file = file
     @use = :file
-    # watch if possible, but only if the file is something worth watching
-    @file_watcher.watch_file(file) if !file.nil? && file != ''
   end
 
   def parse(string = nil)
     self.string= string if string
 
-    if @file =~ /\.rb$/ && @use != :string
-      # Will throw an error
-      parse_ruby_file
-    end
-
     parse_result =
     if @use == :string
       # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
@@ -53,7 +36,7 @@ class Puppet::Parser::E4ParserAdapter
     # * a Model::Program
     # * a Model::Expression
     #
-    model = parse_result.nil? ? nil : parse_result.current 
+    model = parse_result.nil? ? nil : parse_result.current
     args = {}
     Puppet::Pops::Model::AstTransformer.new(@file).merge_location(args, model)
 
@@ -74,8 +57,4 @@ class Puppet::Parser::E4ParserAdapter
     @string = string
     @use = :string
   end
-
-  def parse_ruby_file
-    raise Puppet::ParseError, "Ruby DSL is no longer supported. Attempt to parse #{@file}"
-  end
 end

data/lib/puppet/parser/files.rb

@@ -1,5 +1,3 @@
-require 'puppet/module'
-
 module Puppet::Parser::Files
 
   module_function
@@ -7,22 +5,20 @@ module Puppet::Parser::Files
   # 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>"
+  # @param pattern [String] A reference for a file in a module. It is the
+  #   format "<modulename>/<file glob>"
   # @param environment [Puppet::Node::Environment] the environment of modules
   #
   # @return [Array(String, Array<String>)] the module name and the list of files found
   # @api private
   def find_manifests_in_modules(pattern, environment)
     module_name, file_pattern = split_file_path(pattern)
-    begin
-      if mod = environment.module(module_name)
-        return [mod.name, mod.match_manifests(file_pattern)]
-      end
-    rescue Puppet::Module::InvalidName
-      # one of the modules being loaded might have an invalid name and so
-      # looking for one might blow up since we load them lazily.
+
+    if mod = environment.module(module_name)
+      [mod.name, mod.match_manifests(file_pattern)]
+    else
+      [nil, []]
     end
-    [nil, []]
   end
 
   # Find the path to the given file selector. Files can be selected in
@@ -41,25 +37,14 @@ module Puppet::Parser::Files
   #
   # @api private
   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 module_file && mod
-        mod.file(module_file)
-      else
-        nil
-      end
+    find_in_module(file, environment) do |mod,module_file|
+      mod.file(module_file)
     end
   end
 
   # Find the path to the given template selector. Templates can be selected in
-  # a number of ways:
+  # a couple 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.
   #
@@ -73,54 +58,24 @@ module Puppet::Parser::Files
   #
   # @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
-
-  # 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
+    find_in_module(template, environment) do |mod,template_file|
+      mod.template(template_file)
     end
   end
 
   # @api private
-  def find_template_in_module(template, environment)
-    path, file = split_file_path(template)
-    mod = environment.module(path)
-
-    if file && mod
-      mod.template(file)
+  def find_in_module(reference, environment)
+    if Puppet::Util.absolute_path?(reference)
+      reference
     else
-      nil
-    end
-  end
+      path, file = split_file_path(reference)
+      mod = environment.module(path)
 
-  # Return an array of paths by splitting the +templatedir+ config
-  # parameter.
-  # @api private
-  def templatepath(environment)
-    dirs = Puppet.settings.value(:templatedir, environment.to_s).split(File::PATH_SEPARATOR)
-    dirs.select do |p|
-      File::directory?(p)
+      if file && mod
+        yield(mod, file)
+      else
+        nil
+      end
     end
   end
 

data/lib/puppet/parser/functions.rb

@@ -33,9 +33,7 @@ module Puppet::Parser::Functions
   #
   # @api private
   def self.autoloader
-    @autoloader ||= Puppet::Util::Autoload.new(
-      self, "puppet/parser/functions", :wrap => false
-    )
+    @autoloader ||= Puppet::Util::Autoload.new(self, "puppet/parser/functions")
   end
 
   # Get the module that functions are mixed into corresponding to an

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

@@ -24,8 +24,7 @@ Example, using a warning and a default:
   }
 
 See the documentation for 'The Puppet Type System' for more information about types.
-- since Puppet 3.7
-- requires future parser/evaluator
+- Since 4.0.0
 ") do |args|
   function_fail(["assert_type() is only available when parser/evaluator future is in effect"])
 end

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

@@ -12,10 +12,12 @@ 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 must use the class's full name;
+relative names are not 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.
+evaluating resource and relationship expressions.
+
+- Since 4.0.0 support for Class and Resource Type values, absolute names
 "
 ) do |classes|
   scope = self

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

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

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

@@ -1,11 +1,12 @@
 # Test whether a given class or definition is defined
-Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2, :doc => "Determine whether
+Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
+  :doc => "Determine 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.
+  specific resource has been defined, 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.
 
   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:
@@ -18,7 +19,7 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
 
   Resource declarations are checked using resource references, e.g.
   `defined( File['/tmp/myfile'] )`. Checking whether a given resource
-  has been declared is, unfortunately, dependent on the parse order of
+  has been declared is, unfortunately, dependent on the evaluation order of
   the configuration, and the following code will not work:
 
       if defined(File['/tmp/foo']) {
@@ -28,71 +29,42 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2,
           ensure => present,
       }
 
-  However, this order requirement refers to parse order only, and ordering of
+  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`.
 
-  If the future parser is in effect, you may also search using types:
+  You may also search using types:
 
       defined(Resource[\'file\',\'/some/file\'])
       defined(File[\'/some/file\'])
       defined(Class[\'foo\'])
 
-  The `defined` function does not answer if 4.x 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.
-
-  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):
-
-      defined('')     # 3.x => true, 4.x => false
-      defined(undef)  # 3.x => true, 4.x => error
-      defined('main') # 3.x => false, 4.x => true
-
-  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:
-
-      defined(Type[Class['foo']])
-      defined(Type[Resource['foo']])
-
-  Which is different from asking:
-
-      defined('foo')
-
-  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.
-
  - Since 2.7.0
  - Since 3.6.0 variable reference and future parser types
- - Since 3.8.1 type specific requests with future parser") do |vals|
-    vals = [vals] unless vals.is_a?(Array)
-    vals.any? do |val|
-      case val
-      when String
-        if m = /^\$(.+)$/.match(val)
-          exist?(m[1])
-        else
-          find_resource_type(val) or find_definition(val) or find_hostclass(val)
-        end
-      when Puppet::Resource
-        compiler.findresource(val.type, val.title)
+ - Since 4.0.0") do |vals|
+  vals = [vals] unless vals.is_a?(Array)
+  vals.any? do |val|
+    case val
+    when String
+      if m = /^\$(.+)$/.match(val)
+        exist?(m[1])
+      else
+        find_resource_type(val) || find_definition(val) || find_hostclass(val)
+      end
+    when Puppet::Resource
+      compiler.findresource(val.type, val.title)
+    when Puppet::Pops::Types::PResourceType
+      raise ArgumentError, "The given resource type is a reference to all kind of types" if val.type_name.nil?
+      if val.title.nil?
+        find_builtin_resource_type(val.type_name) || find_definition(val.type_name)
       else
-        if Puppet.future_parser?
-          case val
-          when Puppet::Pops::Types::PResourceType
-            raise ArgumentError, "The given resource type is a reference to all kind of types" if val.type_name.nil?
-            if val.title.nil?
-              find_builtin_resource_type(val.type_name) || find_definition(val.type_name)
-            else
-              compiler.findresource(val.type_name, val.title)
-            end
-          when Puppet::Pops::Types::PHostClassType
-            raise  ArgumentError, "The given class type is a reference to all classes" if val.class_name.nil?
-            find_hostclass(val.class_name)
-          end
-        else
-          raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
-        end
+        compiler.findresource(val.type_name, val.title)
       end
+    when Puppet::Pops::Types::PHostClassType
+      raise  ArgumentError, "The given class type is a reference to all classes" if val.class_name.nil?
+      find_hostclass(val.class_name)
+    else
+      raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
     end
+  end
 end