puppet 0.16.0 → 0.18.4

data/lib/puppet/parser/scope.rb

@@ -10,17 +10,77 @@ module Puppet::Parser
             attr_accessor :file, :line, :type, :name
         end
 
+        # A simple wrapper for templates, so they don't have full access to
+        # the scope objects.
+        class TemplateWrapper
+            attr_accessor :scope, :file
+            include Puppet::Util
+            Puppet::Util.logmethods(self)
+
+            def initialize(scope, file)
+                @scope = scope
+                if file =~ /^#{File::SEPARATOR}/
+                    @file = file
+                else
+                    @file = File.join(Puppet[:templatedir], file)
+                end
+
+                unless FileTest.exists?(@file)
+                    raise Puppet::ParseError,
+                        "Could not find template %s" % file
+                end
+
+                # We'll only ever not have an interpreter in testing, but, eh.
+                if @scope.interp
+                    @scope.interp.newfile(@file)
+                end
+            end
+
+            def method_missing(name, *args)
+                if value = @scope.lookupvar(name.to_s) and value != :undefined and value != ""
+                    return value
+                else
+                    # Just throw an error immediately, instead of searching for
+                    # other missingmethod things or whatever.
+                    raise Puppet::ParseError,
+                        "Could not find value for '%s'" % name
+                end
+            end
+
+            def result
+                result = nil
+                benchmark(:info, "Interpolated template #{@file}") do
+                    template = ERB.new(File.read(@file))
+                    result = template.result(binding)
+                end
+
+                result
+            end
+
+            def to_s
+                "template[%s]" % @file
+            end
+        end
+
+        # This doesn't actually work right now.
+        Puppet.config.setdefaults(:puppet,
+            :lexical => [false, "Whether to use lexical scoping (vs. dynamic)."],
+            :templatedir => ["$vardir/templates",
+                "Where Puppet looks for template files."
+            ]
+        )
+
         Puppet::Util.logmethods(self)
 
         include Enumerable
         attr_accessor :parent, :level, :interp
         attr_accessor :name, :type, :topscope, :base, :keyword
 
-        attr_accessor :top, :context
+        attr_accessor :top, :context, :translated, :collectable
 
         # This is probably not all that good of an idea, but...
         # This way a parent can share its tables with all of its children.
-        attr_writer :nodetable, :classtable, :definedtable
+        attr_writer :nodetable, :classtable, :definedtable, :exportable
 
         # Whether we behave declaratively.  Note that it's a class variable,
         # so all scopes behave the same.
@@ -90,17 +150,23 @@ module Puppet::Parser
                 if typeklass and ! typeklass.isomorphic?
                     Puppet.info "Allowing duplicate %s" % type
                 else
+                    exobj = @definedtable[type][name]
+
                     # Either it's a defined type, which are never
                     # isomorphic, or it's a non-isomorphic type.
                     msg = "Duplicate definition: %s[%s] is already defined" %
                         [type, name]
-                    error = Puppet::ParseError.new(msg)
-                    if hash[:line]
-                        error.line = hash[:line]
+
+                    if exobj.file and exobj.line
+                        msg << " in file %s at line %s" %
+                            [exobj.file, exobj.line]
                     end
-                    if hash[:file]
-                        error.file = hash[:file]
+
+                    if hash[:line] or hash[:file]
+                        msg << "; cannot redefine"
                     end
+
+                    error = Puppet::ParseError.new(msg)
                     raise error
                 end
             end
@@ -146,6 +212,12 @@ module Puppet::Parser
                 raise Puppet::DevError, "No classtable has been defined"
             end
 
+            if defined? @exportable
+                scope.exportable = @exportable
+            else
+                raise Puppet::DevError, "No exportable has been defined"
+            end
+
             if defined? @definedtable
                 scope.definedtable = @definedtable
             else
@@ -174,12 +246,20 @@ module Puppet::Parser
             unless defined? @classtable
                 raise Puppet::DevError, "Scope did not receive class table"
             end
-            return @classtable.values
+            return @classtable.collect { |id, klass|
+                # The class table can contain scopes or strings as its values
+                # so support them accordingly.
+                if klass.is_a? Scope
+                    klass.type
+                else
+                    klass
+                end
+            }
         end
 
         # Yield each child scope in turn
         def each
-            @children.reject { |child|
+            @children.each { |child|
                 yield child
             }
         end
@@ -189,11 +269,9 @@ module Puppet::Parser
             return unless classes
             classes.each do |klass|
                 if code = lookuptype(klass)
-                    code.safeevaluate(
-                        :scope => self,
-                        :facts => {},
-                        :type => klass
-                    )
+                    # Just reuse the 'include' function, since that's the equivalent
+                    # of what we're doing here.
+                    function_include(klass)
                 end
             end
         end
@@ -201,7 +279,6 @@ module Puppet::Parser
         # Evaluate a specific node's code.  This method will normally be called
         # on the top-level scope, but it actually evaluates the node at the
         # appropriate scope.
-        #def evalnode(names, facts, classes = nil, parent = nil)
         def evalnode(hash)
             objects = hash[:ast]
             names = hash[:names]  or
@@ -210,12 +287,20 @@ module Puppet::Parser
             classes = hash[:classes]
             parent = hash[:parent]
 
+            # Always add "default" to our name list, so we're always searching
+            # for a default node.
+            names << "default"
+
             scope = code = nil
             # Find a node that matches one of our names
             names.each { |node|
                 if nodehash = @nodetable[node]
                     code = nodehash[:node]
                     scope = nodehash[:scope]
+
+                    if node == "default"
+                        Puppet.info "Using default node"
+                    end
                     break
                 end
             }
@@ -240,17 +325,19 @@ module Puppet::Parser
             scope.evalclasses(classes)
         end
 
-        # Evaluate normally, with no node definitions.  This is a bit of a
-        # silly method, in that it just calls evaluate on the passed-in
-        # objects, and then calls to_trans on itself.  It just conceals
-        # a paltry amount of info from whomever's using the scope object.
+        # The top-level evaluate, used to evaluate a whole AST tree.  This is
+        # a strange method, in that it turns around and calls evaluate() on its
+        # :ast argument.
         def evaluate(hash)
             objects = hash[:ast]
             facts = hash[:facts] || {}
 
+            @@done = []
+
             unless objects
                 raise Puppet::DevError, "Evaluation requires an AST tree"
             end
+
             # Set all of our facts in the top-level scope.
             facts.each { |var, value|
                 self.setvar(var, value)
@@ -258,10 +345,11 @@ module Puppet::Parser
 
             # Evaluate all of our configuration.  This does not evaluate any
             # node definitions.
-            objects.safeevaluate(:scope => self)
+            result = objects.safeevaluate(:scope => self)
 
-            # If they've provided a name or a parent, we assume they're looking for nodes.
-            if hash.include? :parentnode
+            # If they've provided a name or a parent, we assume they're looking
+            # for nodes.
+            if hash[:searched]
                 # Specifying a parent node takes precedence, because it is assumed
                 # that this node was found in a remote repository like ldap.
                 gennode(hash)
@@ -277,15 +365,44 @@ module Puppet::Parser
                 # a cfengine module
             end
 
-            objects = self.to_trans
-            objects.top = true
+            bucket = self.to_trans
 
             # Add our class list
             unless self.classlist.empty?
-                objects.classes = self.classlist
+                bucket.classes = self.classlist
+            end
+
+            # Now clean up after ourselves
+            [@@done].each do |table|
+                table.clear
             end
 
-            return objects
+            return bucket
+        end
+
+        # Return the hash of objects that we specifically exported.  We return
+        # a hash to make it easy for the caller to deduplicate based on name.
+        def exported(type)
+            if @exportable.include?(type)
+                return @exportable[type].dup
+            else
+                return {}
+            end
+        end
+
+        # Store our object in the central export table.
+        def exportobject(obj)
+            if @exportable.include?(obj.type) and
+                @exportable[obj.type].include?(obj.name)
+                    raise Puppet::ParseError, "Object %s[%s] is already exported" %
+                        [obj.type, obj.name]
+            end
+
+            debug "Exporting %s[%s]" % [obj.type, obj.name]
+
+            @exportable[obj.type][obj.name] = obj
+
+            return obj
         end
 
         # Pull in all of the appropriate classes and evaluate them.  It'd
@@ -306,8 +423,8 @@ module Puppet::Parser
 
             #Puppet.notice "hash is %s" %
             #    hash.inspect
-            Puppet.notice "Classes are %s, parent is %s" %
-                [classes.inspect, parent.inspect]
+            #Puppet.notice "Classes are %s, parent is %s" %
+            #    [classes.inspect, parent.inspect]
 
             if parent
                 arghash[:parentclass] = parent
@@ -325,52 +442,6 @@ module Puppet::Parser
             scope.evalclasses(classes)
         end
 
-        # Take all of our objects and evaluate them.
-#        def finish
-#            self.info "finishing"
-#            @objectlist.each { |object|
-#                if object.is_a? ScopeObj
-#                    self.info "finishing %s" % object.name
-#                    if obj = finishobject(object)
-#                        @children << obj
-#                    end
-#                end
-#            }
-#
-#            @finished = true
-#
-#            self.info "finished"
-#        end
-#
-#        # If the object is defined in an upper scope, then add our
-#        # params to that upper scope; else, create a transobject
-#        # or evaluate the definition.
-#        def finishobject(object)
-#            type = object.type
-#            name = object.name
-#
-#            # It should be a defined type.
-#            definedtype = lookuptype(type)
-#
-#            unless definedtype
-#                error = Puppet::ParseError.new("No such type %s" % type)
-#                error.line = object.line
-#                error.file = object.file
-#                raise error
-#            end
-#
-#            return definedtype.safeevaluate(
-#                :scope => self,
-#                :arguments => object,
-#                :type => type,
-#                :name => name
-#            )
-#        end
-#
-#        def finished?
-#            @finished
-#        end
-
         # Initialize our new scope.  Defaults to having no parent and to
         # being declarative.
         def initialize(hash = {})
@@ -395,7 +466,10 @@ module Puppet::Parser
                 end
                 self.istop(hash[:declarative])
             else
+                # This is here, rather than in newchild(), so that all
+                # of the later variable initialization works.
                 @parent.child = self
+
                 @level = @parent.level + 1
                 @interp = @parent.interp
                 @topscope = @parent.topscope
@@ -425,9 +499,6 @@ module Puppet::Parser
                 typehash[typekey] = Hash.new(nil)
             }
 
-            # The list of simpler hash objects.
-            @objectlist = []
-
             # This is just for collecting statements locally, so we can
             # verify that there is no overlap within this specific scope
             @localobjectable = Hash.new { |typehash,typekey|
@@ -463,6 +534,11 @@ module Puppet::Parser
             # A table for storing nodes.
             @nodetable = Hash.new(nil)
 
+            # The list of objects that will available for export.
+            @exportable = Hash.new { |types, type|
+                types[type] = {}
+            }
+
             # Eventually, if we support sites, this will allow definitions
             # of nodes with the same name in different sites.  For now
             # the top-level scope is always the only site scope.
@@ -517,6 +593,30 @@ module Puppet::Parser
             return values
         end
 
+        # Look up all of the exported objects of a given type.  Just like
+        # lookupobject, this only searches up through parent classes, not
+        # the whole scope tree.
+        def lookupexported(type)
+            found = []
+            sub = proc { |table|
+                # We always return nil so that it will search all the way
+                # up the scope tree.
+                if table.has_key?(type)
+                    table[type].each do |name, obj|
+                        found << obj
+                    end
+                    nil
+                else
+                    info table.keys.inspect
+                    nil
+                end
+            }
+
+            value = lookup("object",sub, false)
+
+            return found
+        end
+
         # Look up a node by name
         def lookupnode(name)
             #Puppet.debug "Looking up type %s" % name
@@ -567,19 +667,18 @@ module Puppet::Parser
 
         # Look up a variable.  The simplest value search we do.
         def lookupvar(name)
-            #Puppet.debug "Looking up variable %s" % name
             value = lookup("variable", name)
             if value == :undefined
                 return ""
-                #error = Puppet::ParseError.new(
-                #    "Undefined variable '%s'" % name
-                #)
-                #raise error
             else
                 return value
             end
         end
 
+        def newcollection(coll)
+            @children << coll
+        end
+
         # Add a new object to our object table.
         def newobject(hash)
             if @objectable[hash[:type]].include?(hash[:name])
@@ -591,25 +690,14 @@ module Puppet::Parser
 
             obj = nil
 
-            # If it's a builtin type, then use a transobject, else use
-            # a ScopeObj, which will get replaced later.
-            if self.builtintype?(hash[:type])
-                obj = Puppet::TransObject.new(hash[:name], hash[:type])
+            obj = Puppet::TransObject.new(hash[:name], hash[:type])
 
-                @children << obj
-            else
-                obj = ScopeObj.new(nil)
-                obj.name = hash[:name]
-                obj.type = hash[:type]
-            end
+            @children << obj
 
             @objectable[hash[:type]][hash[:name]] = obj
 
             @definedtable[hash[:type]][hash[:name]] = obj
 
-            # Keep them in order, just for kicks
-            @objectlist << obj
-
             return obj
         end
 
@@ -631,15 +719,17 @@ module Puppet::Parser
         # hash.  We store the object ID, not class name, so that we
         # can support multiple unrelated classes with the same name.
         def setclass(id, name)
-            unless name =~ /^[a-z]\w*$/
+            unless name =~ /^[a-z][\w-]*$/
                 raise Puppet::ParseError, "Invalid class name '%s'" % name
             end
 
-            if self.topscope?
-                @classtable[id] = name
-            else
-                @parent.setclass(id, name)
-            end
+            @classtable[id] = name
+        end
+
+        # Store the scope for each class, so that other subclasses can look
+        # them up.
+        def setscope(id, scope)
+            @classtable[id] = scope
         end
 
         # Set defaults for a type.  The typename should already be downcased,
@@ -687,6 +777,7 @@ module Puppet::Parser
                 # We have to store both the scope that's setting the node and
                 # the node itself, so that the node gets evaluated in the correct
                 # scope.
+                code.scope = self
                 @nodetable[name] = {
                     :scope => self,
                     :node => code
@@ -701,6 +792,7 @@ module Puppet::Parser
                 raise Puppet::ParseError,
                     "%s is already defined" % name
             else
+                ltype.scope = self
                 @typetable[name] = ltype
             end
         end
@@ -722,6 +814,8 @@ module Puppet::Parser
             file = hash[:file]
             line = hash[:line]
 
+            collectable = hash[:collectable] || self.collectable
+
             # Verify that we're not overriding any already-set parameters.
             if localobj = @localobjectable[type][name]
                 params.each { |var, value|
@@ -737,48 +831,63 @@ module Puppet::Parser
                 }
             end
 
-            if objecttype = lookuptype(type)
-                # It's a defined type
-                objecttype.safeevaluate(
-                    :name => name,
-                    :type => type,
-                    :arguments => params,
-                    :scope => self
-                )
-            else
-                # First look for it in a parent scope
-                obj = lookupobject(:name => name, :type => type)
-
-                unless obj and obj != :undefined
-                    unless obj = @objectable[type][name]
-                        obj = self.newobject(
-                            :type => type,
-                            :name => name,
-                            :line => line,
-                            :file => file
-                        )
+            # First look for it in a parent scope
+            obj = lookupobject(:name => name, :type => type)
 
-                        # only set these if we've created the object,
-                        # which is the most common case
-                        # FIXME we eventually need to store the file
-                        # and line with each param, not the object
-                        # itself.
-                        obj.file = file
-                        obj.line = line
+            if obj
+                unless collectable == obj.collectable
+                    msg = nil
+                    if collectable
+                        msg = "Exported %s[%s] cannot override local objects"
+                            [type, name]
+                    else
+                        msg = "Local %s[%s] cannot override exported objects"
+                            [type, name]
                     end
+
+                    error = Puppet::ParseError.new(msg)
+                    error.line = line
+                    error.file = file
+                    raise error
                 end
+            end
 
-                # Now add our parameters.  This has the function of overriding
-                # existing values, which might have been defined in a higher
-                # scope.
-                params.each { |var,value|
-                    # Add it to our found object
-                    obj[var] = value
-                }
+            unless obj and obj != :undefined
+                unless obj = @objectable[type][name]
+                    obj = self.newobject(
+                        :type => type,
+                        :name => name,
+                        :line => line,
+                        :file => file
+                    )
+
+                    obj.collectable = collectable
+
+                    # only set these if we've created the object,
+                    # which is the most common case
+                    # FIXME we eventually need to store the file
+                    # and line with each param, not the object
+                    # itself.
+                    obj.file = file
+                    obj.line = line
+                end
             end
 
-            @localobjectable[type][name] ||= {}
+            # Now add our parameters.  This has the function of overriding
+            # existing values, which might have been defined in a higher
+            # scope.
+            params.each { |var,value|
+                # Add it to our found object
+                obj[var] = value
+            }
 
+            # This is only used for override verification -- the local object
+            # table does not have transobjects or whatever in it, it just has
+            # simple hashes.  This is necessary because setobject can modify
+            # our object table or a parent class's object table, and we
+            # still need to make sure param settings cannot be duplicated
+            # within our scope.
+            @localobjectable[type][name] ||= {}
             params.each { |var,value|
                 # And add it to the local table; mmm, hack
                 @localobjectable[type][name][var] = value
@@ -805,20 +914,16 @@ module Puppet::Parser
 
         # Return an interpolated string.
         def strinterp(string)
-            newstring = string.dup
-            regex = Regexp.new('\$\{(\w+)\}|\$(\w+)')
-            #Puppet.debug("interpreting '%s'" % string)
-            while match = regex.match(newstring) do
-                if match[1]
-                    newstring.sub!(regex,lookupvar(match[1]).to_s)
-                elsif match[2]
-                    newstring.sub!(regex,lookupvar(match[2]).to_s)
-                else
-                    raise Puppet::DevError, "Could not match variable in %s" %
-                        newstring
+            newstring = string.gsub(/\\\$|\$\{(\w+)\}|\$(\w+)/) do |value|
+                # If it matches the backslash, then just retun the dollar sign.
+                if value == '\\$'
+                    '$'
+                else # look the variable up
+                    var = $1 || $2
+                    lookupvar($1 || $2)
                 end
             end
-            #Puppet.debug("result is '%s'" % newstring)
+
             return newstring.gsub(/\\t/, "\t").gsub(/\\n/, "\n").gsub(/\\s/, "\s")
         end
 
@@ -845,6 +950,7 @@ module Puppet::Parser
                 tmp << @type.to_s
             end
             if @parent
+                #info "Looking for tags in %s" % @parent.type
                 @parent.tags.each { |tag|
                     if tag.nil? or tag == ""
                         Puppet.debug "parent returned tag %s" % tag.inspect
@@ -867,33 +973,36 @@ module Puppet::Parser
             end
         end
 
-        # Convert our scope to a list of Transportable objects.
+        # Convert our scope to a TransBucket.  Everything in our @localobjecttable
+        # gets converted to either an evaluated definition, or a TransObject
         def to_trans
-
             results = []
-            
-            # Iterate across our child scopes and call to_trans on them
-            @children.each { |child|
-                if child.is_a?(Scope)
-                    cresult = child.to_trans
-
-                    # Scopes normally result in a TransBucket, but they could
-                    # also result in a normal array; if that happens, get rid
-                    # of the array.
-                    unless cresult.is_a?(Puppet::TransBucket)
-                        cresult.each { |result|
-                            results.push(result)
-                        }
-                    else
-                        unless cresult.empty?
-                            # Otherwise, just add it to our list of results.
-                            results.push(cresult)
-                        end
-                    end
-                elsif child.is_a?(Puppet::TransObject)
-                    if child.empty?
-                        next
-                    end
+
+            # Set this on entry, just in case someone tries to get all weird
+            @translated = true
+
+            @children.dup.each do |child|
+                if @@done.include?(child)
+                    raise Puppet::DevError, "Already translated %s" %
+                        child.object_id
+                else
+                    @@done << child
+                end
+                #warning "Working on %s of type %s with id %s" %
+                #    [child.type, child.class, child.object_id]
+
+                # If it's a scope, then it can only be a subclass's scope, so
+                # convert it to a transbucket and store it in our results list
+                result = nil
+                case child
+                when Scope
+                    result = child.to_trans
+                when Puppet::TransObject
+                    # These objects can map to defined types or builtin types.
+                    # Builtin types should be passed out as they are, but defined
+                    # types need to be evaluated.  We have to wait until this
+                    # point so that subclass overrides can happen.
+
                     # Wait until the last minute to set tags, although this
                     # probably should not matter
                     child.tags = self.tags
@@ -905,16 +1014,57 @@ module Puppet::Parser
                     # central table.  This should maybe be in the evaluate
                     # methods, but, eh.
                     @topscope.addtags(child)
-                    results.push(child)
+
+                    # Now that all that is done, check to see what kind of object
+                    # it is.
+                    if objecttype = lookuptype(child.type)
+                        # It's a defined type, so evaluate it.  Retain whether
+                        # the object is collectable.  If the object is collectable,
+                        # then it will store all of its contents into the
+                        # @exportable table, rather than returning them.
+                        result = objecttype.safeevaluate(
+                            :name => child.name,
+                            :type => child.type,
+                            :arguments => child.to_hash,
+                            :scope => self,
+                            :collectable => child.collectable
+                        )
+                    else
+                        # If it's collectable, then store it.  It will be
+                        # stripped out in the interpreter using the collectstrip
+                        # method.  If we don't do this, then these objects
+                        # don't get stored in the DB.
+                        if child.collectable
+                            exportobject(child)
+                        end
+                        result = child
+                    end
+                # This is pretty hackish, but the collection has to actually
+                # be performed after all of the classes and definitions are
+                # evaluated, otherwise we won't catch objects that are exported
+                # in them.  I think this will still be pretty limited in some
+                # cases, especially those where you are both exporting and
+                # collecting, but it's the best I can do for now.
+                when Puppet::Parser::AST::Collection
+                    child.perform(self).each do |obj|
+                        results << obj
+                    end
                 else
                     raise Puppet::DevError,
                         "Puppet::Parse::Scope cannot handle objects of type %s" %
                             child.class
                 end
-            }
+
+                # Skip nil objects or empty transbuckets
+                if result
+                    unless result.is_a? Puppet::TransBucket and result.empty?
+                        results << result
+                    end
+                end
+            end
 
             # Get rid of any nil objects.
-            results = results.reject { |child|
+            results.reject! { |child|
                 child.nil?
             }
 
@@ -927,18 +1077,12 @@ module Puppet::Parser
                 if defined? @name and @name
                     bucket.name = @name
                 end
-
                 # it'd be nice not to have to do this...
                 results.each { |result|
                     #Puppet.warning "Result type is %s" % result.class
                     bucket.push(result)
                 }
-                if defined? @type
-                    bucket.type = @type
-                else
-                    raise Puppet::ParseError,
-                        "No type for scope %s" % @name
-                end
+                bucket.type = @type
 
                 if defined? @keyword
                     bucket.keyword = @keyword
@@ -961,11 +1105,18 @@ module Puppet::Parser
                 #    [bucket.name,self.object_id]
                 return bucket
             else
-                Puppet.debug "nameless scope; just returning a list"
+                Puppet.debug "typeless scope; just returning a list"
                 return results
             end
         end
 
+        # Undefine a variable; only used for testing.
+        def unsetvar(var)
+            if @symtable.include?(var)
+                @symtable.delete(var)
+            end
+        end
+
         protected
 
         # This method abstracts recursive searching.  It accepts the type
@@ -986,8 +1137,7 @@ module Puppet::Parser
             elsif table.include?(sub)
                 return table[sub]
             elsif ! @parent.nil?
-                #self.notice "Context is %s, parent %s is %s" %
-                #    [self.context, @parent.type, @parent.context]
+                # Context is used for retricting overrides.
                 if usecontext and self.context != @parent.context
                     return :undefined
                 else
@@ -1000,4 +1150,4 @@ module Puppet::Parser
     end
 end
 
-# $Id: scope.rb 1104 2006-04-11 17:48:14Z luke $
+# $Id: scope.rb 1401 2006-07-18 14:00:33Z luke $