puppet 2.7.26 → 3.0.0.rc4

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

@@ -11,14 +11,11 @@ class Puppet::Parser::AST
 
     # Return the parameter and the value.
     def evaluate(scope)
-
-            return Puppet::Parser::Resource::Param.new(
-                
-        :name => @param,
-        :value => @value.safeevaluate(scope),
-        
+      return Puppet::Parser::Resource::Param.new(
+        :name   => @param,
+        :value  => @value.safeevaluate(scope),
         :source => scope.source, :line => self.line, :file => self.file,
-        :add => self.add
+        :add    => self.add
       )
     end
 

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

@@ -38,7 +38,13 @@ class Puppet::Parser::AST
     end
 
     def to_s
-      param.to_s + " ? { " + values.collect { |v| v.to_s }.join(', ') + " }"
+      if @values.instance_of? AST::ASTArray or @values.instance_of? Array
+        v = @values
+      else
+        v = [@values]
+      end
+
+      param.to_s + " ? { " + v.collect { |v| v.to_s }.join(', ') + " }"
     end
   end
 end

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

@@ -8,8 +8,6 @@ class Puppet::Parser::AST
 
     attr_accessor :name, :value, :append
 
-    @settor = true
-
     # Look up our name and value, and store them appropriately.  The
     # lexer strips off the syntax stuff like '$'.
     def evaluate(scope)

data/lib/puppet/parser/collector.rb

@@ -1,7 +1,8 @@
 # An object that collects stored objects from the central cache and returns
 # them to the current host, yo.
 class Puppet::Parser::Collector
-  attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
+  attr_accessor :type, :scope, :vquery, :equery, :form
+  attr_accessor :resources, :overrides, :collected
 
   # Call the collection method, mark all of the returned objects as
   # non-virtual, optionally applying parameter overrides. The collector can

data/lib/puppet/parser/compiler.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
@@ -7,8 +9,11 @@ require 'puppet/resource/type_collection_helper'
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
+  extend Forwardable
+
   include Puppet::Util
   include Puppet::Util::Errors
+  include Puppet::Util::MethodHelper
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
@@ -23,20 +28,16 @@ class Puppet::Parser::Compiler
     # ...and we actually do the compile now we have caching ready.
     new(node).compile.to_resource
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    raise Puppet::Error, "#{detail} on node #{node.name}"
+    message = "#{detail} on node #{node.name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
  end
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
 
   # Add a collection to the global list.
-  def add_collection(coll)
-    @collections << coll
-  end
-
-  def add_relationship(dep)
-    @relationships << dep
-  end
+  def_delegator :@collections,   :<<, :add_collection
+  def_delegator :@relationships, :<<, :add_relationship
 
   # Store a resource override.
   def add_override(override)
@@ -57,26 +58,24 @@ class Puppet::Parser::Compiler
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
-    if resource.type.to_s.downcase != "class" && resource[:stage]
+    if not resource.class? and resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
-    return if resource.type.to_s.downcase == "stage"
+    return if resource.stage?
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
-    if resource.type.to_s.downcase != "class"
+    unless resource.class?
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
-  def ast_nodes?
-    known_resource_types.nodes?
-  end
+  def_delegator :known_resource_types, :nodes?, :ast_nodes?
 
   # Store the fact that we've evaluated a class
   def add_class(name)
@@ -85,9 +84,7 @@ class Puppet::Parser::Compiler
 
 
   # Return a list of all of the defined classes.
-  def classlist
-    @catalog.classes
-  end
+  def_delegator :@catalog, :classes, :classlist
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
@@ -111,15 +108,15 @@ class Puppet::Parser::Compiler
     @catalog
   end
 
-  # LAK:FIXME There are no tests for this.
-  def delete_collection(coll)
-    @collections.delete(coll) if @collections.include?(coll)
-  end
+  def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
   def environment
     unless defined?(@environment)
-      @environment = (node.environment and node.environment != "") ? node.environment : nil
+      unless node.environment.is_a? Puppet::Node::Environment
+        raise Puppet::DevError, "node #{node} has an invalid environment!"
+      end
+      @environment = node.environment
     end
     Puppet::Node::Environment.current = @environment
     @environment
@@ -134,21 +131,30 @@ class Puppet::Parser::Compiler
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
-  def evaluate_classes(classes, scope, lazy_evaluate = true)
+  #
+  # 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 it's 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)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
-    param_classes = nil
+    class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
-      param_classes = classes
+      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)
+      if klass = scope.find_hostclass(name, :assume_fqname => fqname)
 
-        if param_classes
-          resource = klass.ensure_in_catalog(scope, param_classes[name] || {})
+        # 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)
@@ -168,21 +174,11 @@ class Puppet::Parser::Compiler
   end
 
   # Return a resource by either its ref or its type and title.
-  def findresource(*args)
-    @catalog.resource(*args)
-  end
+  def_delegator :@catalog, :resource, :findresource
 
   def initialize(node, options = {})
     @node = node
-
-    options.each do |param, value|
-      begin
-        send(param.to_s + "=", value)
-      rescue NoMethodError
-        raise ArgumentError, "Compiler objects do not accept #{param}"
-      end
-    end
-
+    set_options(options)
     initvars
   end
 
@@ -190,8 +186,7 @@ class Puppet::Parser::Compiler
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
-    options[:compiler] = self
-    scope = Puppet::Parser::Scope.new(options)
+    scope = Puppet::Parser::Scope.new(self, options)
     scope.parent = parent
     scope
   end
@@ -419,8 +414,10 @@ class Puppet::Parser::Compiler
     @catalog = Puppet::Resource::Catalog.new(@node.name)
     @catalog.version = known_resource_types.version
 
+    @catalog.environment = @node.environment.to_s
+
     # Create our initial scope and a resource that will evaluate main.
-    @topscope = Puppet::Parser::Scope.new(:compiler => self)
+    @topscope = Puppet::Parser::Scope.new(self)
 
     @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
     @catalog.add_resource(@main_stage_resource)
@@ -439,7 +436,7 @@ class Puppet::Parser::Compiler
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
-      @topscope.setvar(param, value)
+      @topscope[param] = value
     end
 
     # These might be nil.
@@ -463,7 +460,7 @@ class Puppet::Parser::Compiler
 
     Puppet.settings.each do |name, setting|
       next if name.to_s == "name"
-      scope.setvar name.to_s, environment[name]
+      scope[name.to_s] = environment[name]
     end
   end
 

data/lib/puppet/parser/files.rb

@@ -8,25 +8,23 @@ require 'puppet/parser/parser'
 module Puppet::Parser::Files
   module_function
 
-  # 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 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)
+  # Return a list of manifests (as absolute filenames) that match +pat+
+  # with the current directory set to +cwd+. If the first component of
+  # +pat+ does not contain any wildcards and is an existing module, return
+  # a list of manifests in that module matching the rest of +pat+
+  # Otherwise, try to find manifests matching +pat+ relative to +cwd+
+  def find_manifests(start, options = {})
+    cwd = options[:cwd] || Dir.getwd
+    module_name, pattern = split_file_path(start)
     begin
-      if mod = Puppet::Module.find(module_name, environment)
-        return [mod.name, mod.match_manifests(file_pattern)]
+      if mod = Puppet::Module.find(module_name, options[:environment])
+        return [mod.name, mod.match_manifests(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.
+      # Than that would be a "no."
     end
-    [nil, []]
+    abspat = File::expand_path(start, cwd)
+    [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
   end
 
   # Find the concrete file denoted by +file+. If +file+ is absolute,
@@ -82,12 +80,9 @@ module Puppet::Parser::Files
 
   # Split the path into the module and the rest of the path, or return
   # nil if the path is empty or absolute (starts with a /).
+  # This method can return nil & anyone calling it needs to handle that.
   def split_file_path(path)
-    if path == "" or Puppet::Util.absolute_path?(path)
-      nil
-    else
-      path.split(File::SEPARATOR, 2)
-    end
+    path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
   end
 
 end

data/lib/puppet/parser/functions.rb

@@ -26,20 +26,17 @@ module Puppet::Parser::Functions
   end
 
   def self.autoloader
-    unless defined?(@autoloader)
-      @autoloader = Puppet::Util::Autoload.new(
-        self,
-        "puppet/parser/functions",
-        :wrap => false
-      )
-    end
-
-    @autoloader
+    @autoloader ||= Puppet::Util::Autoload.new(
+      self, "puppet/parser/functions", :wrap => false
+    )
   end
 
   def self.environment_module(env = nil)
+    if env and ! env.is_a?(Puppet::Node::Environment)
+      env = Puppet::Node::Environment.new(env)
+    end
     @modules.synchronize {
-      @modules[ env || Environment.current || Environment.root ] ||= Module.new
+      @modules[ (env || Environment.current || Environment.root).name ] ||= Module.new
     }
   end
 
@@ -47,7 +44,7 @@ module Puppet::Parser::Functions
   def self.newfunction(name, options = {}, &block)
     name = name.intern
 
-    raise Puppet::DevError, "Function #{name} already defined" if get_function(name)
+    Puppet.warning "Overwriting previous definition for function #{name}" if get_function(name)
 
     ftype = options[:type] || :statement
 
@@ -67,26 +64,6 @@ module Puppet::Parser::Functions
     func
   end
 
-  # Remove a function added by newfunction
-  def self.rmfunction(name)
-    Puppet.deprecation_warning "Puppet::Parser::Functions.rmfunction is deprecated and will be removed in 3.0"
-    name = name.intern
-
-    raise Puppet::DevError, "Function #{name} is not defined" unless get_function(name)
-
-    @functions.synchronize {
-      @functions[Environment.current].delete(name)
-      # This seems wrong because it won't delete a function defined on root if
-      # the current environment is different
-      #@functions[Environment.root].delete(name)
-    }
-
-    fname = "function_#{name}"
-    # This also only deletes from the module associated with
-    # Environment.current
-    environment_module.send(:remove_method, fname)
-  end
-
   # Determine if a given name is a function
   def self.function(name)
     name = name.intern
@@ -125,20 +102,12 @@ module Puppet::Parser::Functions
     ret
   end
 
-  def self.functions(env = nil)
-    Puppet.deprecation_warning "Puppet::Parser::Functions.functions is deprecated and will be removed in 3.0"
-    @functions.synchronize {
-      @functions[ env || Environment.current || Environment.root ]
-    }
-  end
-
   # Determine if a given function returns a value or not.
   def self.rvalue?(name)
     func = get_function(name)
     func ? func[:type] == :rvalue : false
   end
 
-
   class << self
     private
 

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

@@ -50,7 +50,7 @@ Now create the following data files in /etc/puppet/manifests/extdata:
 Now you can replace the case statement with the simple single line to achieve
 the exact same outcome:
 
-   $snmp_contact = extlookup(\"snmp_contact\")
+    $snmp_contact = extlookup(\"snmp_contact\")
 
 The above code shows some other features, you can use any fact or variable that
 is in scope by simply using %{varname} in your data files, you can return arrays
@@ -60,7 +60,7 @@ In the event that a variable is nowhere to be found a critical error will be rai
 that will prevent your manifest from compiling, this is to avoid accidentally putting
 in empty values etc.  You can however specify a default value:
 
-   $ntp_servers = extlookup(\"ntp_servers\", \"1.${country}.pool.ntp.org\")
+    $ntp_servers = extlookup(\"ntp_servers\", \"1.${country}.pool.ntp.org\")
 
 In this case it will default to \"1.${country}.pool.ntp.org\" if nothing is defined in
 any data file.
@@ -91,9 +91,9 @@ This is for back compatibility to interpolate variables with %. % interpolation
 
   raise Puppet::ParseError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
 
-  extlookup_datadir = undef_as('',lookupvar('::extlookup_datadir'))
+  extlookup_datadir = undef_as('',self['::extlookup_datadir'])
 
-  extlookup_precedence = undef_as([],lookupvar('::extlookup_precedence')).collect { |var| var.gsub(/%\{(.+?)\}/) { lookupvar("::#{$1}") } }
+  extlookup_precedence = undef_as([],self['::extlookup_precedence']).collect { |var| var.gsub(/%\{(.+?)\}/) { self["::#{$1}"] } }
 
   datafiles = Array.new
 
@@ -121,9 +121,9 @@ This is for back compatibility to interpolate variables with %. % interpolation
           if result[0].length == 2
             val = result[0][1].to_s
 
-            # parse %{}'s in the CSV into local variables using lookupvar()
+            # parse %{}'s in the CSV into local variables using the current scope
             while val =~ /%\{(.+?)\}/
-              val.gsub!(/%\{#{$1}\}/, lookupvar($1))
+              val.gsub!(/%\{#{$1}\}/, self[$1])
             end
 
             desired = val
@@ -134,9 +134,9 @@ This is for back compatibility to interpolate variables with %. % interpolation
             # Individual cells in a CSV result are a weird data type and throws
             # puppets yaml parsing, so just map it all to plain old strings
             desired = cells.map do |c|
-              # parse %{}'s in the CSV into local variables using lookupvar()
+              # parse %{}'s in the CSV into local variables using the current scope
               while c =~ /%\{(.+?)\}/
-                c.gsub!(/%\{#{$1}\}/, lookupvar($1))
+                c.gsub!(/%\{#{$1}\}/, self[$1])
               end
 
               c.to_s

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

@@ -1,23 +1,23 @@
 # Returns the contents of a file
 
-      Puppet::Parser::Functions::newfunction(
-        :file, :type => :rvalue,
-
-    :doc => "Return the contents of a file.  Multiple files
-    can be passed, and the first file that exists will be read in.") do |vals|
-      ret = nil
-      vals.each do |file|
-        unless Puppet::Util.absolute_path?(file)
-          raise Puppet::ParseError, "Files must be fully qualified"
-        end
-        if FileTest.exists?(file)
-          ret = File.read(file)
-          break
-        end
+Puppet::Parser::Functions::newfunction(
+  :file, :type => :rvalue,
+  :doc => "Return the contents of a file.  Multiple files
+  can be passed, and the first file that exists will be read in."
+) do |vals|
+    ret = nil
+    vals.each do |file|
+      unless Puppet::Util.absolute_path?(file)
+        raise Puppet::ParseError, "Files must be fully qualified"
       end
-      if ret
-        ret
-      else
-        raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
+      if FileTest.exists?(file)
+        ret = File.read(file)
+        break
       end
+    end
+    if ret
+      ret
+    else
+      raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
+    end
 end