puppet 0.22.4 → 0.23.0

data/lib/puppet/parser/ast.rb

@@ -12,11 +12,6 @@ class Puppet::Parser::AST
 
     include Puppet::Util::Errors
     include Puppet::Util::MethodHelper
-
-    Puppet.setdefaults("ast",
-        :typecheck => [true, "Whether to validate types during parsing."],
-        :paramcheck => [true, "Whether to validate parameters during parsing."]
-    )
     attr_accessor :line, :file, :parent, :scope
 
     # Just used for 'tree', which is only used in debugging.
@@ -122,4 +117,4 @@ end
 
 require 'puppet/parser/ast/leaf'
 
-# $Id: ast.rb 2231 2007-02-27 21:31:02Z luke $
+# $Id: ast.rb 2463 2007-05-04 23:09:34Z luke $

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

@@ -15,37 +15,43 @@ class Puppet::Parser::AST
         # The class name
         @name = :definition
 
-        attr_accessor :type, :arguments, :code, :scope, :keyword
-        attr_accessor :exported, :namespace, :fqname, :interp
+        attr_accessor :classname, :arguments, :code, :scope, :keyword
+        attr_accessor :exported, :namespace, :interp, :virtual
 
         # These are retrieved when looking up the superclass
         attr_accessor :name
 
+        attr_reader :parentclass
+
         def child_of?(klass)
             false
         end
 
         def evaluate(hash)
             origscope = hash[:scope]
-            objtype = hash[:type]
             title = hash[:title]
             args = symbolize_options(hash[:arguments] || {})
 
             name = args[:name] || title
 
             exported = hash[:exported]
+            virtual = hash[:virtual]
 
             pscope = origscope
             scope = subscope(pscope, title)
 
+            if virtual or origscope.virtual?
+                scope.virtual = true
+            end
+
             if exported or origscope.exported?
                 scope.exported = true
             end
 
             # Additionally, add a tag for whatever kind of class
             # we are
-            if @type != "" and ! @type.nil?
-                scope.tag(@type)
+            if @classname != "" and ! @classname.nil?
+                @classname.split(/::/).each { |tag| scope.tag(tag) }
             end
 
             [name, title].each do |str|
@@ -68,7 +74,7 @@ class Puppet::Parser::AST
                             #    [default.inspect, arg.inspect, @name.inspect]
                         else
                             parsefail "Must pass %s to %s of type %s" %
-                                    [arg,title,@type]
+                                    [arg,title,@classname]
                         end
                     end
                 }
@@ -78,7 +84,7 @@ class Puppet::Parser::AST
             # component's scope.
             args.each { |arg,value|
                 unless validattr?(arg)
-                    parsefail "%s does not accept attribute %s" % [@type, arg]
+                    parsefail "%s does not accept attribute %s" % [@classname, arg]
                 end
 
                 exceptwrap do
@@ -133,16 +139,14 @@ class Puppet::Parser::AST
             end
         end
 
-        def parentclass
-            parentobj do |name|
-                @interp.findclass(namespace, name)
-            end
+        def find_parentclass
+            @interp.findclass(namespace, parentclass)
         end
 
         # Set our parent class, with a little check to avoid some potential
         # weirdness.
         def parentclass=(name)
-            if name == self.type
+            if name == self.classname
                 parsefail "Parent classes must have dissimilar names"
             end
 
@@ -153,8 +157,8 @@ class Puppet::Parser::AST
         def parentobj
             if @parentclass
                 # Cache our result, since it should never change.
-                unless @parentclass.is_a?(AST::HostClass)
-                    unless tmp = yield(@parentclass)
+                unless defined?(@parentobj)
+                    unless tmp = find_parentclass
                         parsefail "Could not find %s %s" % [self.class.name, @parentclass]
                     end
 
@@ -162,9 +166,9 @@ class Puppet::Parser::AST
                         parsefail "Parent classes must have dissimilar names"
                     end
 
-                    @parentclass = tmp
+                    @parentobj = tmp
                 end
-                @parentclass
+                @parentobj
             else
                 nil
             end
@@ -173,13 +177,12 @@ class Puppet::Parser::AST
         # Create a new subscope in which to evaluate our code.
         def subscope(scope, name = nil)
             args = {
-                :type => @type,
+                :type => self.classname,
                 :keyword => self.keyword,
                 :namespace => self.namespace
             }
 
             args[:name] = name if name
-            args[:type] = self.type if self.type
             scope = scope.newscope(args)
             scope.source = self
 
@@ -187,7 +190,7 @@ class Puppet::Parser::AST
         end
 
         def to_s
-            fqname
+            classname
         end
 
         # Check whether a given argument is valid.  Searches up through
@@ -220,4 +223,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: component.rb 2393 2007-04-19 18:34:03Z luke $
+# $Id: component.rb 2562 2007-06-11 21:54:37Z luke $

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

@@ -12,10 +12,10 @@ class Puppet::Parser::AST
         def child_of?(klass)
             return false unless self.parentclass
 
-            if klass == self.parentclass
+            if klass == self.parentobj
                 return true
             else
-                return self.parentclass.child_of?(klass)
+                return self.parentobj.child_of?(klass)
             end
         end
 
@@ -31,15 +31,11 @@ class Puppet::Parser::AST
             end
 
             pnames = nil
-            if @parentclass
-                if pklass = self.parentclass
-                    pklass.safeevaluate :scope => scope
+            if pklass = self.parentobj
+                pklass.safeevaluate :scope => scope
 
-                    scope = parent_scope(scope, pklass)
-                    pnames = scope.namespaces
-                else
-                    parsefail "Could not find class %s" % @parentclass
-                end
+                scope = parent_scope(scope, pklass)
+                pnames = scope.namespaces
             end
 
             unless hash[:nosubscope]
@@ -79,4 +75,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: hostclass.rb 2226 2007-02-27 16:30:09Z luke $
+# $Id: hostclass.rb 2511 2007-05-14 15:19:48Z luke $

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

@@ -66,6 +66,9 @@ class Puppet::Parser::AST
     # double-colon separated class names
     class ClassName < AST::Leaf; end
 
+    # undef values; equiv to nil
+    class Undef < AST::Leaf; end
+
     # Host names, either fully qualified or just the short name
     class HostName < AST::Leaf
         def initialize(hash)
@@ -92,4 +95,4 @@ class Puppet::Parser::AST
 
 end
 
-# $Id: leaf.rb 2239 2007-02-28 01:21:58Z luke $
+# $Id: leaf.rb 2522 2007-05-17 21:43:51Z luke $

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

@@ -19,7 +19,7 @@ class Puppet::Parser::AST
 
             # We don't have to worry about the declarativeness of node parentage,
             # because the entry point is always a single node definition.
-            if parent = self.parentclass
+            if parent = self.parentobj
                 scope = parent.safeevaluate :scope => scope
             end
 
@@ -53,14 +53,12 @@ class Puppet::Parser::AST
             end
         end
 
-        def parentclass
-            parentobj do |name|
-                @interp.nodesearch(name)
-            end
-
-            @parentclass
+        private
+        # Search for the object matching our parent class.
+        def find_parentclass
+            @interp.nodesearch(parentclass)
         end
     end
 end
 
-# $Id: node.rb 1727 2006-10-04 18:44:26Z luke $
+# $Id: node.rb 2511 2007-05-14 15:19:48Z luke $

data/lib/puppet/parser/functions.rb

@@ -142,7 +142,7 @@ module Functions
     # specified tags are unset, we return false.
     newfunction(:tagged, :type => :rvalue, :doc => "A boolean function that
     tells you whether the current container is tagged with the specified tags.
-    The tags are ANDed, so thta all of the specified tags must be included for
+    The tags are ANDed, so that all of the specified tags must be included for
     the function to return true.") do |vals|
         classlist = self.classlist
 
@@ -196,9 +196,12 @@ module Functions
     end
 
     newfunction(:template, :type => :rvalue, :doc => "Evaluate a template and
-    return its value.  See [the templating docs](/trac/puppet/wiki/PuppetTemplating)
+    return its value.  See `the templating docs`_
     for more information.  Note that if multiple templates are specified, their
-    output is all concatenated and returned as the output of the function.") do |vals|
+    output is all concatenated and returned as the output of the function.
+    
+    .. _the templating docs: /trac/puppet/wiki/PuppetTemplating
+    ") do |vals|
         require 'erb'
 
         vals.collect do |file|
@@ -297,4 +300,4 @@ module Functions
 end
 end
 
-# $Id: functions.rb 2406 2007-04-23 06:16:10Z luke $
+# $Id: functions.rb 2502 2007-05-10 21:27:40Z luke $

data/lib/puppet/parser/interpreter.rb

@@ -5,66 +5,55 @@
 require 'puppet'
 require 'timeout'
 require 'puppet/rails'
+require 'puppet/util/methodhelper'
 require 'puppet/parser/parser'
 require 'puppet/parser/scope'
 
 class Puppet::Parser::Interpreter
+    class NodeDef
+        include Puppet::Util::MethodHelper
+        attr_accessor :name, :classes, :parameters, :source
+
+        def evaluate(options)
+            begin
+                parameters.each do |param, value|
+                    # Don't try to override facts with these parameters
+                    options[:scope].setvar(param, value) unless options[:scope].lookupvar(param, false) != :undefined
+                end
+
+                # Also, set the 'nodename', since it might not be obvious how the node was looked up
+                options[:scope].setvar("nodename", @name) unless options[:scope].lookupvar(@nodename, false) != :undefined
+            rescue => detail
+                raise Puppet::ParseError, "Could not set parameters for %s: %s" % [name, detail]
+            end
+
+            # Then evaluate the classes.
+            begin
+                options[:scope].function_include(classes)
+            rescue => detail
+                raise Puppet::ParseError, "Could not evaluate classes for %s: %s" % [name, detail]
+            end
+        end
+
+        def initialize(args)
+            set_options(args)
+
+            raise Puppet::DevError, "NodeDefs require names" unless self.name
+
+            if self.classes.is_a?(String)
+                @classes = [@classes]
+            else
+                @classes ||= []
+            end
+            @parameters ||= {}
+        end
+
+        def safeevaluate(args)
+            evaluate(args)
+        end
+    end
+
     include Puppet::Util
-    
-    Puppet.setdefaults(:puppet,
-        :casesensitive => [false,
-            "Whether matching in case statements and selectors
-            should be case-sensitive.  Case insensitivity is
-            handled by downcasing all values before comparison."],
-        :external_nodes => ["none",
-            "An external command that can produce node information.  The
-            first line of output must be either the parent node or blank,
-            and if there is a second line of output it should be a list of
-            whitespace-separated classes to include on that node.  This command
-            makes it straightforward to store your node mapping information
-            in other data sources like databases.
-            
-            For unknown nodes, the commands should exit with an exit code of 1."])
-
-    Puppet.setdefaults("ldap",
-        :ldapnodes => [false,
-            "Whether to search for node configurations in LDAP."],
-        :ldapssl => [false,
-            "Whether SSL should be used when searching for nodes.
-            Defaults to false because SSL usually requires certificates
-            to be set up on the client side."],
-        :ldaptls => [false,
-            "Whether TLS should be used when searching for nodes.
-            Defaults to false because TLS usually requires certificates
-            to be set up on the client side."],
-        :ldapserver => ["ldap",
-            "The LDAP server.  Only used if ``ldapnodes`` is enabled."],
-        :ldapport => [389,
-            "The LDAP port.  Only used if ``ldapnodes`` is enabled."],
-        :ldapstring => ["(&(objectclass=puppetClient)(cn=%s))",
-            "The search string used to find an LDAP node."],
-        :ldapattrs => ["puppetclass",
-            "The LDAP attributes to use to define Puppet classes.  Values
-            should be comma-separated."],
-        :ldapparentattr => ["parentnode",
-            "The attribute to use to define the parent node."],
-        :ldapuser => ["",
-            "The user to use to connect to LDAP.  Must be specified as a
-            full DN."],
-        :ldappassword => ["",
-            "The password to use to connect to LDAP."],
-        :ldapbase => ["",
-            "The search base for LDAP searches.  It's impossible to provide
-            a meaningful default here, although the LDAP libraries might
-            have one already set.  Generally, it should be the 'ou=Hosts'
-            branch under your main directory."]
-    )
-
-    Puppet.setdefaults(:puppetmaster,
-        :storeconfigs => [false,
-            "Whether to store each client's configuration.  This
-             requires ActiveRecord from Ruby on Rails."]
-    )
 
     attr_accessor :usenodes
 
@@ -211,7 +200,8 @@ class Puppet::Parser::Interpreter
             klass.safeevaluate :scope => scope, :nosubscope => true
         end
 
-        # Next evaluate the node
+        # Next evaluate the node.  We pass the facts so they can be used
+        # when building the list of names for which to search.
         evalnode(client, scope, facts)
 
         # If we were passed any classes, evaluate those.
@@ -313,51 +303,6 @@ class Puppet::Parser::Interpreter
         return nil
     end
 
-    # Create a new node, just from a list of names, classes, and an optional parent.
-    def gennode(name, hash, source = nil)
-        facts = hash[:facts]
-        classes = hash[:classes]
-        parent = hash[:parentnode]
-        arghash = {
-            :name => name,
-            :interp => self,
-            :fqname => name
-        }
-
-        if (classes.is_a?(Array) and classes.empty?) or classes.nil?
-            arghash[:code] = AST::ASTArray.new(:children => [])
-        else
-            classes = [classes] unless classes.is_a?(Array)
-
-            classcode = @parser.ast(AST::ASTArray, :children => classes.collect do |klass|
-                @parser.ast(AST::FlatString, :value => klass)
-            end)
-
-            # Now generate a function call.
-            code = @parser.ast(AST::Function,
-                :name => "include",
-                :arguments => classcode,
-                :ftype => :statement
-            )
-
-            arghash[:code] = code
-        end
-
-        if parent
-            arghash[:parentclass] = parent
-        end
-
-        # Create the node
-        if source
-            arghash[:file] = source
-        else
-            arghash[:file] = nil
-        end
-        arghash[:line] = nil
-        node = @parser.ast(AST::Node, arghash)
-        return node
-    end
-
     # create our interpreter
     def initialize(hash)
         if @code = hash[:Code]
@@ -372,33 +317,15 @@ class Puppet::Parser::Interpreter
             @usenodes = true
         end
 
-        # By default, we only search for parsed nodes.
-        @nodesources = []
 
         if Puppet[:ldapnodes]
             # Nodes in the file override nodes in ldap.
-            @nodesources << :ldap
-        end
-
-        if hash[:NodeSources]
-            unless hash[:NodeSources].is_a?(Array)
-                hash[:NodeSources] = [hash[:NodeSources]]
-            end
-            hash[:NodeSources].each do |src|
-                if respond_to? "nodesearch_#{src.to_s}"
-                    @nodesources << src.to_s.intern
-                else
-                    Puppet.warning "Node source '#{src}' not supported"
-                end
-            end
-        end
-
-        unless @nodesources.include?(:code)
-            @nodesources << :code
-        end
-        
-        unless Puppet[:external_nodes] == "none"
-            @nodesources << :external
+            @nodesource = :ldap
+        elsif Puppet[:external_nodes] != "none"
+            @nodesource = :external
+        else
+            # By default, we only search for parsed nodes.
+            @nodesource = :code
         end
 
         @setup = false
@@ -444,26 +371,31 @@ class Puppet::Parser::Interpreter
         @definetable = {}
     end
 
-    # Find the ldap node and extra the info, returning just
-    # the critical data.
+    # Find the ldap node, return the class list and parent node specially,
+    # and everything else in a parameter hash.
     def ldapsearch(node)
         unless defined? @ldap and @ldap
             setup_ldap()
             unless @ldap
                 Puppet.info "Skipping ldap source; no ldap connection"
-                return nil, []
+                return nil
             end
         end
 
         filter = Puppet[:ldapstring]
-        attrs = Puppet[:ldapattrs].split("\s*,\s*")
-        sattrs = attrs.dup
+        classattrs = Puppet[:ldapclassattrs].split("\s*,\s*")
+        if Puppet[:ldapattrs] == "all"
+            # A nil value here causes all attributes to be returned.
+            search_attrs = nil
+        else
+            search_attrs = classattrs + Puppet[:ldapattrs].split("\s*,\s*")
+        end
         pattr = nil
         if pattr = Puppet[:ldapparentattr]
             if pattr == ""
                 pattr = nil
             else
-                sattrs << pattr
+                search_attrs << pattr unless search_attrs.nil?
             end
         end
 
@@ -473,12 +405,14 @@ class Puppet::Parser::Interpreter
 
         parent = nil
         classes = []
+        parameters = nil
 
         found = false
         count = 0
+
         begin
             # We're always doing a sub here; oh well.
-            @ldap.search(Puppet[:ldapbase], 2, filter, sattrs) do |entry|
+            @ldap.search(Puppet[:ldapbase], 2, filter, search_attrs) do |entry|
                 found = true
                 if pattr
                     if values = entry.vals(pattr)
@@ -493,11 +427,20 @@ class Puppet::Parser::Interpreter
                     end
                 end
 
-                attrs.each { |attr|
+                classattrs.each { |attr|
                     if values = entry.vals(attr)
                         values.each do |v| classes << v end
                     end
                 }
+
+                parameters = entry.to_hash.inject({}) do |hash, ary|
+                    if ary[1].length == 1
+                        hash[ary[0]] = ary[1].shift
+                    else
+                        hash[ary[0]] = ary[1]
+                    end
+                    hash
+                end
             end
         rescue => detail
             if count == 0
@@ -516,7 +459,11 @@ class Puppet::Parser::Interpreter
             classes = nil
         end
 
-        return parent, classes
+        if parent or classes or parameters
+            return parent, classes, parameters
+        else
+            return nil
+        end
     end
 
     # Split an fq name into a namespace and name
@@ -528,20 +475,20 @@ class Puppet::Parser::Interpreter
     end
 
     # Create a new class, or merge with an existing class.
-    def newclass(fqname, options = {})
-        fqname = fqname.downcase
-        if @definetable.include?(fqname)
+    def newclass(name, options = {})
+        name = name.downcase
+        if @definetable.include?(name)
             raise Puppet::ParseError, "Cannot redefine class %s as a definition" %
-                fqname
+                name
         end
         code = options[:code]
         parent = options[:parent]
 
         # If the class is already defined, then add code to it.
-        if other = @classtable[fqname]
+        if other = @classtable[name]
             # Make sure the parents match
             if parent and other.parentclass and (parent != other.parentclass)
-                @parser.error("Class %s is already defined at %s:%s; cannot redefine" % [fqname, other.file, other.line])
+                @parser.error("Class %s is already defined at %s:%s; cannot redefine" % [name, other.file, other.line])
             end
 
             # This might be dangerous...
@@ -551,7 +498,7 @@ class Puppet::Parser::Interpreter
 
             # This might just be an empty, stub class.
             if code
-                tmp = fqname
+                tmp = name
                 if tmp == ""
                     tmp = "main"
                 end
@@ -566,46 +513,43 @@ class Puppet::Parser::Interpreter
             end
         else
             # Define it anew.
-            ns, name = namesplit(fqname)
-
             # Note we're doing something somewhat weird here -- we're setting
             # the class's namespace to its fully qualified name.  This means
             # anything inside that class starts looking in that namespace first.
-            args = {:type => name, :namespace => fqname, :fqname => fqname, :interp => self}
+            args = {:namespace => name, :classname => name, :interp => self}
             args[:code] = code if code
             args[:parentclass] = parent if parent
-            @classtable[fqname] = @parser.ast AST::HostClass, args
+            @classtable[name] = @parser.ast AST::HostClass, args
         end
 
-        return @classtable[fqname]
+        return @classtable[name]
     end
 
     # Create a new definition.
-    def newdefine(fqname, options = {})
-        fqname = fqname.downcase
-        if @classtable.include?(fqname)
+    def newdefine(name, options = {})
+        name = name.downcase
+        if @classtable.include?(name)
             raise Puppet::ParseError, "Cannot redefine class %s as a definition" %
-                fqname
+                name
         end
         # Make sure our definition doesn't already exist
-        if other = @definetable[fqname]
-            @parser.error("%s is already defined at %s:%s; cannot redefine" % [fqname, other.file, other.line])
+        if other = @definetable[name]
+            @parser.error("%s is already defined at %s:%s; cannot redefine" % [name, other.file, other.line])
         end
 
-        ns, name = namesplit(fqname)
+        ns, whatever = namesplit(name)
         args = {
-            :type => name,
             :namespace => ns,
             :arguments => options[:arguments],
             :code => options[:code],
-            :fqname => fqname
+            :classname => name
         }
 
         [:code, :arguments].each do |param|
             args[param] = options[param] if options[param]
         end
 
-        @definetable[fqname] = @parser.ast AST::Component, args
+        @definetable[name] = @parser.ast AST::Component, args
     end
 
     # Create a new node.  Nodes are special, because they're stored in a global
@@ -628,8 +572,7 @@ class Puppet::Parser::Interpreter
                 args[:parentclass] = options[:parent]
             end
             @nodetable[name] = @parser.ast(AST::Node, args)
-            @nodetable[name].fqname = name
-            @nodetable[name]
+            @nodetable[name].classname = name
             @nodetable[name].interp = self
             @nodetable[name]
         end
@@ -649,21 +592,20 @@ class Puppet::Parser::Interpreter
     # Search for our node in the various locations.
     def nodesearch(*nodes)
         nodes = nodes.collect { |n| n.to_s.downcase }
-        # At this point, stop at the first source that defines
-        # the node
-        @nodesources.each do |source|
-            method = "nodesearch_%s" % source
-            if self.respond_to? method
-                # Do an inverse sort on the length, so the longest match always
-                # wins
-                nodes.sort { |a,b| b.length <=> a.length }.each do |node|
-                    node = node.to_s if node.is_a?(Symbol)
-                    if obj = self.send(method, node)
-                        nsource = obj.file || source
-                        Puppet.info "Found %s in %s" % [node, nsource]
-                        return obj
-                    end
+
+        method = "nodesearch_%s" % @nodesource
+        # Do an inverse sort on the length, so the longest match always
+        # wins
+        nodes.sort { |a,b| b.length <=> a.length }.each do |node|
+            node = node.to_s if node.is_a?(Symbol)
+            if obj = self.send(method, node)
+                if obj.is_a?(AST::Node)
+                    nsource = obj.file
+                else
+                    nsource = obj.source
                 end
+                Puppet.info "Found %s in %s" % [node, nsource]
+                return obj
             end
         end
 
@@ -699,41 +641,51 @@ class Puppet::Parser::Interpreter
             return nil
         end
         
-        if output =~ /\A\s+\Z/ # all whitespace
-            puts "empty response for %s" % name
+        if output =~ /\A\s*\Z/ # all whitespace
+            Puppet.debug "Empty response for %s from external node source" % name
             return nil
         end
-        
-        lines = output.split("\n")
-        
-        args = {}
-        parent = lines[0].gsub(/\s+/, '')
-        args[:parentnode] = parent unless parent == ""
-        
-        if lines[1]
-            classes = lines[1].sub(/^\s+/,'').sub(/\s+$/,'').split(/\s+/)
-            args[:classes] = classes unless classes.empty?
+
+        begin
+            result = YAML.load(output).inject({}) { |hash, data| hash[symbolize(data[0])] = data[1]; hash }
+        rescue => detail
+            raise Puppet::Error, "Could not load external node results for %s: %s" % [name, detail]
         end
-        
-        if args.empty?
-            Puppet.warning "Somehow got a node with no information"
-            return nil
+
+        node_args = {:source => "external node source", :name => name}
+        set = false
+        [:parameters, :classes].each do |param|
+            if value = result[param]
+                node_args[param] = value
+                set = true
+            end
+        end
+
+        if set
+            return NodeDef.new(node_args)
         else
-            return gennode(name, args, Puppet[:external_nodes])
+            return nil
         end
     end
 
     # Look for our node in ldap.
     def nodesearch_ldap(node)
-        parent, classes = ldapsearch(node)
-        if parent or classes
-            args = {}
-            args[:classes] = classes if classes
-            args[:parentnode] = parent if parent
-            return gennode(node, args, "ldap")
-        else
+        unless ary = ldapsearch(node)
             return nil
         end
+        parent, classes, parameters = ary
+
+        while parent
+            parent, tmpclasses, tmpparams = ldapsearch(parent)
+            classes += tmpclasses if tmpclasses
+            tmpparams.each do |param, value|
+                # Specifically test for whether it's set, so false values are handled
+                # correctly.
+                parameters[param] = value unless parameters.include?(param)
+            end
+        end
+
+        return NodeDef.new(:name => node, :classes => classes, :source => "ldap", :parameters => parameters)
     end
 
     def parsedate
@@ -746,15 +698,13 @@ class Puppet::Parser::Interpreter
         # We have to leave this for after initialization because there
         # seems to be a problem keeping ldap open after a fork.
         unless @setup
-            @nodesources.each { |source|
-                method = "setup_%s" % source.to_s
-                if respond_to? method
-                    exceptwrap :type => Puppet::Error,
-                            :message => "Could not set up node source %s" % source do
-                        self.send(method)
-                    end
+            method = "setup_%s" % @nodesource.to_s
+            if respond_to? method
+                exceptwrap :type => Puppet::Error,
+                        :message => "Could not set up node source %s" % @nodesource do
+                    self.send(method)
                 end
-            }
+            end
         end
         parsefiles()
 
@@ -893,4 +843,4 @@ class Puppet::Parser::Interpreter
     end
 end
 
-# $Id: interpreter.rb 2432 2007-04-30 15:38:06Z luke $
+# $Id: interpreter.rb 2626 2007-06-19 01:58:49Z luke $