puppet 0.9.2 → 0.13.0

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

@@ -0,0 +1,105 @@
+class Puppet::Parser::AST
+    # Evaluate the stored parse tree for a given component.  This will
+    # receive the arguments passed to the component and also the type and
+    # name of the component.
+    class Component < AST::Branch
+        class << self
+            attr_accessor :name
+        end
+
+        # The class name
+        @name = :component
+
+        attr_accessor :name, :args, :code, :scope, :autoname, :keyword
+
+        def evaluate(scope,hash,objtype,objname)
+
+            scope = scope.newscope
+
+            # The type is the component or class name
+            scope.type = objtype
+
+            # The name is the name the user has chosen or that has
+            # been dynamically generated.  This is almost never used
+            scope.name = objname
+
+            scope.keyword = self.keyword
+
+            # Retain the fact that we were autonamed, if so
+            if self.autoname
+                scope.autoname = true
+            end
+
+            #if self.is_a?(Node)
+            #    scope.isnodescope
+            #end
+
+            # Additionally, add a tag for whatever kind of class
+            # we are
+            scope.tag(objtype)
+
+            unless objname =~ /-\d+/ # it was generated
+                scope.tag(objname)
+            end
+            #scope.base = self.class.name
+
+
+            # define all of the arguments in our local scope
+            if self.args
+
+                # Verify that all required arguments are either present or
+                # have been provided with defaults.
+                # FIXME This should probably also require each parent
+                # class's arguments...
+                self.args.each { |arg, default|
+                    unless hash.include?(arg)
+                        if defined? default and ! default.nil?
+                            hash[arg] = default
+                            #Puppet.debug "Got default %s for %s in %s" %
+                            #    [default.inspect, arg.inspect, objname.inspect]
+                        else
+                            error = Puppet::ParseError.new(
+                                "Must pass %s to %s of type %s" %
+                                    [arg.inspect,name,objtype]
+                            )
+                            error.line = self.line
+                            error.file = self.file
+                            raise error
+                        end
+                    end
+                }
+            end
+
+            # Set each of the provided arguments as variables in the
+            # component's scope.
+            hash["name"] = objname
+            hash.each { |arg,value|
+                begin
+                    scope.setvar(arg,hash[arg])
+                rescue Puppet::ParseError => except
+                    except.line = self.line
+                    except.file = self.file
+                    raise except
+                rescue Puppet::ParseError => except
+                    except.line = self.line
+                    except.file = self.file
+                    raise except
+                rescue => except
+                    error = Puppet::ParseError.new(except.message)
+                    error.line = self.line
+                    error.file = self.file
+                    error.backtrace = except.backtrace
+                    raise error
+                end
+            }
+
+            # Now just evaluate the code with our new bindings.
+            self.code.safeevaluate(scope)
+
+            # We return the scope, so that our children can make their scopes
+            # under ours.  This allows them to find our definitions.
+            return scope
+        end
+    end
+
+end

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

@@ -0,0 +1,82 @@
+class Puppet::Parser::AST
+    # The code associated with a class.  This is different from components
+    # in that each class is a singleton -- only one will exist for a given
+    # node.
+    class HostClass < AST::Component
+        @name = :class
+        attr_accessor :parentclass
+
+        def evaluate(scope,hash,objtype,objname)
+            if scope.lookupclass(@name)
+                Puppet.debug "%s class already evaluated" % @name
+                return nil
+            end
+
+            if tmp = self.evalparent(scope, hash, objname)
+                # Override our scope binding with the parent scope
+                # binding. This is quite hackish, but I can't think
+                # of another way to make sure our scopes end up under
+                # our parent scopes.
+                scope = tmp
+            end
+
+            # just use the Component evaluate method, but change the type
+            # to our own type
+            retval = super(scope,hash,@name,objname)
+
+            # Set the mark after we evaluate, so we don't record it but
+            # then encounter an error
+            scope.setclass(@name)
+            return retval
+        end
+
+        # Evaluate our parent class.  Parent classes are evaluated in the
+        # exact same scope as the children.  This is maybe not a good idea
+        # but, eh.
+        def evalparent(scope, args, name)
+            if @parentclass
+                parentobj = nil
+
+                begin
+                    parentobj = scope.lookuptype(@parentclass)
+                rescue Puppet::ParseError => except
+                    except.line = self.line
+                    except.file = self.file
+                    raise except
+                rescue => detail
+                    error = Puppet::ParseError.new(detail)
+                    error.line = self.line
+                    error.file = self.file
+                    raise error
+                end
+                unless parentobj
+                    error = Puppet::ParseError.new( 
+                        "Could not find parent '%s' of '%s'" %
+                            [@parentclass,@name])
+                    error.line = self.line
+                    error.file = self.file
+                    raise error
+                end
+
+                # Verify that the parent and child are of the same type
+                unless parentobj.class == self.class
+                    error = Puppet::ParseError.new(
+                        "Class %s has incompatible parent type, %s vs %s" %
+                        [@name, parentobj.class, self.class]
+                    )
+                    error.file = self.file
+                    error.line = self.line
+                    raise error
+                end
+                return parentobj.safeevaluate(scope,args,@parentclass,name)
+            end
+        end
+
+        def initialize(hash)
+            @parentclass = nil
+            super
+        end
+
+    end
+
+end

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

@@ -0,0 +1,86 @@
+class Puppet::Parser::AST
+    # The base class for all of the leaves of the parse trees.  These
+    # basically just have types and values.  Both of these parameters
+    # are simple values, not AST objects.
+    class Leaf < AST
+        attr_accessor :value, :type
+
+        # Return our value.
+        def evaluate(scope)
+            return @value
+        end
+
+        # Print the value in parse tree context.
+        def tree(indent = 0)
+            return ((@@indent * indent) + self.typewrap(self.value))
+        end
+
+        def to_s
+            return @value
+        end
+    end
+
+    # The boolean class.  True or false.  Converts the string it receives
+    # to a Ruby boolean.
+    class Boolean < AST::Leaf
+
+        # Use the parent method, but then convert to a real boolean.
+        def initialize(hash)
+            super
+
+            unless @value == 'true' or @value == 'false'
+                raise Puppet::DevError,
+                    "'%s' is not a boolean" % @value
+            end
+            if @value == 'true'
+                @value = true
+            else
+                @value = false
+            end
+        end
+    end
+
+    # The base string class.
+    class String < AST::Leaf
+        # Interpolate the string looking for variables, and then return
+        # the result.
+        def evaluate(scope)
+            return scope.strinterp(@value)
+        end
+    end
+    #---------------------------------------------------------------
+
+    # The 'default' option on case statements and selectors.
+    class Default < AST::Leaf; end
+
+    # Capitalized words; used mostly for type-defaults, but also
+    # get returned by the lexer any other time an unquoted capitalized
+    # word is found.
+    class Type < AST::Leaf; end
+
+    # Lower-case words.
+    class Name < AST::Leaf; end
+
+    # A simple variable.  This object is only used during interpolation;
+    # the VarDef class is used for assignment.
+    class Variable < Name
+        # Looks up the value of the object in the scope tree (does
+        # not include syntactical constructs, like '$' and '{}').
+        def evaluate(scope)
+            begin
+                return scope.lookupvar(@value)
+            rescue Puppet::ParseError => except
+                except.line = self.line
+                except.file = self.file
+                raise except
+            rescue => detail
+                error = Puppet::DevError.new(detail)
+                error.line = self.line
+                error.file = self.file
+                error.backtrace = detail.backtrace
+                raise error
+            end
+        end
+    end
+
+end

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

@@ -0,0 +1,103 @@
+class Puppet::Parser::AST
+    # The specific code associated with a host.  Nodes are annoyingly unlike
+    # other objects.  That's just the way it is, at least for now.
+    class Node < AST::HostClass
+        @name = :node
+        attr_accessor :name, :args, :code, :parentclass
+
+        def evaluate(scope, facts = {})
+            scope = scope.newscope
+
+            # nodes are never instantiated like a normal object,
+            # but we need the type to be the name users would use for
+            # instantiation, otherwise tags don't work out
+
+            # The name has already been evaluated, so it's a normal
+            # string.
+            scope.type = @name
+            scope.name = @name
+            scope.keyword = @keyword
+
+            # Mark this scope as a nodescope, so that classes will be
+            # singletons within it
+            scope.isnodescope
+
+            # Now set all of the facts inside this scope
+            facts.each { |var, value|
+                scope.setvar(var, value)
+            }
+
+            if tmp = self.evalparent(scope)
+                # Again, override our scope with the parent scope, if
+                # there is one.
+                scope = tmp
+            end
+
+            #scope.tag(@name)
+
+            # We never pass the facts to the parent class, because they've
+            # already been defined at this top-level scope.
+            #super(scope, facts, @name, @name)
+
+            # And then evaluate our code.
+            @code.safeevaluate(scope)
+
+            return scope
+        end
+
+        # Evaluate our parent class.
+        def evalparent(scope)
+            if @parentclass
+                # This is pretty messed up.  I don't know if this will
+                # work in the long term, but we need to evaluate the node
+                # in our own scope, even though our parent node has
+                # a scope associated with it, because otherwise we 1) won't
+                # get our facts defined, and 2) we won't actually get the
+                # objects returned, based on how nodes work.
+
+                # We also can't just evaluate the node itself, because
+                # it would create a node scope within this scope,
+                # and that would cause mass havoc.
+                node = nil
+
+                # The 'node' method just returns a hash of the node
+                # code and name.  It's used here, and in 'evalnode'.
+                unless hash = scope.node(@parentclass)
+                    raise Puppet::ParseError,
+                        "Could not find parent node %s" %
+                        @parentclass
+                end
+
+                node = hash[:node]
+                # Tag the scope with the parent's name/type.
+                name = node.name
+                #Puppet.info "Tagging with parent node %s" % name
+                scope.tag(name)
+
+                begin
+                    code = node.code
+                    code.safeevaluate(scope)
+                rescue Puppet::ParseError => except
+                    except.line = self.line
+                    except.file = self.file
+                    raise except
+                rescue => detail
+                    error = Puppet::ParseError.new(detail)
+                    error.line = self.line
+                    error.file = self.file
+                    raise error
+                end
+
+                if node.parentclass
+                    node.evalparent(scope)
+                end
+            end
+        end
+
+        def initialize(hash)
+            @parentclass = nil
+            super
+
+        end
+    end
+end

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

@@ -0,0 +1,68 @@
+class Puppet::Parser::AST
+    # Define a node.  The node definition stores a parse tree for each
+    # specified node, and this parse tree is only ever looked up when
+    # a client connects.
+    class NodeDef < AST::Branch
+        attr_accessor :names, :code, :parentclass, :keyword
+
+        def each
+            [@names,@code].each { |child| yield child }
+        end
+
+        # Do implicit iteration over each of the names passed.
+        def evaluate(scope)
+            names = @names.safeevaluate(scope)
+
+            unless names.is_a?(Array)
+                names = [names]
+            end
+            
+            names.each { |name|
+                #Puppet.debug("defining host '%s' in scope %s" %
+                #    [name, scope.object_id])
+                arghash = {
+                    :name => name,
+                    :code => @code
+                }
+
+                if @parentclass
+                    arghash[:parentclass] = @parentclass.safeevaluate(scope)
+                end
+
+                begin
+                    node = Node.new(arghash)
+                    node.keyword = true
+                    scope.setnode(name, node)
+                rescue Puppet::ParseError => except
+                    except.line = self.line
+                    except.file = self.file
+                    raise except
+                rescue => detail
+                    error = Puppet::ParseError.new(detail)
+                    error.line = self.line
+                    error.file = self.file
+                    raise error
+                end
+            }
+        end
+
+        def initialize(hash)
+            @parentclass = nil
+            @keyword = "node"
+            super
+        end
+
+        def tree(indent = 0)
+            return [
+                @names.tree(indent + 1),
+                ((@@indline * 4 * indent) + self.typewrap("node")),
+                @code.tree(indent + 1),
+            ].join("\n")
+        end
+
+        def to_s
+            return "node %s {\n%s }" % [@name, @code]
+        end
+    end
+
+end

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

@@ -0,0 +1,336 @@
+class Puppet::Parser::AST
+    # Any normal puppet object declaration.  Can result in a class or a 
+    # component, in addition to builtin types.
+    class ObjectDef < AST::Branch
+        attr_accessor :name, :type
+        attr_reader :params
+
+        # probably not used at all
+        def []=(index,obj)
+            @params[index] = obj
+        end
+
+        # probably not used at all
+        def [](index)
+            return @params[index]
+        end
+
+        # Auto-generate a name
+        def autoname(type, object)
+            case object
+            when Puppet::Type:
+                raise Puppet::Error,
+                    "Built-in types must be provided with a name"
+            when HostClass:
+                return type
+            else
+                Puppet.info "Autogenerating name for object of type %s" %
+                    type
+                return [type, "-", self.object_id].join("")
+            end
+        end
+
+        # Iterate across all of our children.
+        def each
+            [@type,@name,@params].flatten.each { |param|
+                #Puppet.debug("yielding param %s" % param)
+                yield param
+            }
+        end
+
+        # Does not actually return an object; instead sets an object
+        # in the current scope.
+        def evaluate(scope)
+            hash = {}
+
+            # Get our type and name.
+            objtype = @type.safeevaluate(scope)
+
+            # If the type was a variable, we wouldn't have typechecked yet.
+            # Do it now, if so.
+            unless @checked
+                self.typecheck(objtype)
+            end
+
+            # See if our object type was defined
+            begin
+                object = scope.lookuptype(objtype)
+            rescue Puppet::ParseError => except
+                except.line = self.line
+                except.file = self.file
+                raise except
+            rescue => detail
+                error = Puppet::ParseError.new(detail)
+                error.line = self.line
+                error.file = self.file
+                error.backtrace = detail.backtrace
+                raise error
+            end
+
+            unless object
+                # If not, verify that it's a builtin type
+                object = Puppet::Type.type(objtype)
+
+                # Type.type returns nil on object types that aren't found
+                unless object
+                    error = Puppet::ParseError.new("Invalid type %s" % objtype)
+                    error.line = self.line
+                    error.file = self.file
+                    raise error
+                end
+            end
+
+
+            autonamed = false
+            # Autogenerate the name if one was not passed.
+            if defined? @name
+                objnames = @name.safeevaluate(scope)
+            else
+                objnames = self.autoname(objtype, object)
+                autonamed = true
+            end
+
+            # it's easier to always use an array, even for only one name
+            unless objnames.is_a?(Array)
+                objnames = [objnames]
+            end
+
+            # Retrieve the defaults for our type
+            hash = getdefaults(objtype, scope)
+
+            # then set all of the specified params
+            @params.each { |param|
+                ary = param.safeevaluate(scope)
+                hash[ary[0]] = ary[1]
+            }
+
+            # this is where our implicit iteration takes place;
+            # if someone passed an array as the name, then we act
+            # just like the called us many times
+            objnames.collect { |objname|
+                # If the object is a class, that means it's a builtin type, so
+                # we just store it in the scope
+                if object.is_a?(Class)
+                    begin
+                        #Puppet.debug(
+                        #    ("Setting object '%s' " +
+                        #    "in scope %s " +
+                        #    "with arguments %s") %
+                        #    [objname, scope.object_id, hash.inspect]
+                        #)
+                        obj = scope.setobject(
+                            objtype,
+                            objname,
+                            hash,
+                            @file,
+                            @line
+                        )
+                    rescue Puppet::ParseError => except
+                        except.line = self.line
+                        except.file = self.file
+                        raise except
+                    rescue => detail
+                        error = Puppet::ParseError.new(detail)
+                        error.line = self.line
+                        error.file = self.file
+                        error.backtrace = detail.backtrace
+                        raise error
+                    end
+                else
+                    # but things like components create a new type; if we find
+                    # one of those, evaluate that with our arguments
+                    #Puppet.debug("Calling object '%s' with arguments %s" %
+                    #    [object.name, hash.inspect])
+                    obj = object.safeevaluate(scope,hash,objtype,objname)
+
+                    # Retain any name generation stuff
+                    obj.autoname = autonamed
+
+                    # and pass the result on
+                    obj
+                end
+            }.reject { |obj| obj.nil? }
+        end
+
+        # Retrieve the defaults for our type
+        def getdefaults(objtype, scope)
+            # first, retrieve the defaults
+            begin
+                defaults = scope.lookupdefaults(objtype)
+                if defaults.length > 0
+                    #Puppet.debug "Got defaults for %s: %s" %
+                    #    [objtype,defaults.inspect]
+                end
+            rescue => detail
+                raise Puppet::DevError, 
+                    "Could not lookup defaults for %s: %s" %
+                        [objtype, detail.to_s]
+            end
+
+            hash = {}
+            # Add any found defaults to our argument list
+            defaults.each { |var,value|
+                Puppet.debug "Found default %s for %s" %
+                    [var,objtype]
+
+                hash[var] = value
+            }
+
+            return hash
+        end
+
+        # Create our ObjectDef.  Handles type checking for us.
+        def initialize(hash)
+            @checked = false
+            super
+
+            if @type.is_a?(Variable)
+                Puppet.debug "Delaying typecheck"
+                return
+            else
+                self.typecheck(@type.value)
+
+                objtype = @type.value
+            end
+
+        end
+
+        # Verify that all passed parameters are valid
+        def paramcheck(builtin, objtype)
+            # This defaults to true
+            unless Puppet[:paramcheck]
+                return
+            end
+
+            @params.each { |param|
+                if builtin
+                    self.parambuiltincheck(builtin, param)
+                else
+                    self.paramdefinedcheck(objtype, param)
+                end
+            }
+        end
+
+        def parambuiltincheck(type, param)
+            unless param.is_a?(AST::ObjectParam)
+                raise Puppet::DevError,
+                    "Got something other than param"
+            end
+            begin
+                pname = param.param.value
+            rescue => detail
+                raise Puppet::DevError, detail.to_s
+            end
+            return if pname == "name" # always allow these
+            unless type.validattr?(pname)
+                error = Puppet::ParseError.new(
+                    "Invalid parameter '%s' for type '%s'" %
+                        [pname,type.name]
+                )
+                error.line = self.line
+                error.file = self.file
+                raise error
+            end
+        end
+
+        def paramdefinedcheck(objtype, param)
+            # FIXME we might need to do more here eventually...
+            if Puppet::Type.metaparam?(param.param.value.intern)
+                return
+            end
+
+            begin
+                pname = param.param.value
+            rescue => detail
+                raise Puppet::DevError, detail.to_s
+            end
+
+            unless @@settypes[objtype].validarg?(pname)
+                error = Puppet::ParseError.new(
+                    "Invalid parameter '%s' for type '%s'" %
+                        [pname,objtype]
+                )
+                error.line = self.line
+                error.file = self.file
+                raise error
+            end
+        end
+
+        # Set the parameters for our object.
+        def params=(params)
+            if params.is_a?(AST::ASTArray)
+                @params = params
+            else
+                @params = AST::ASTArray.new(
+                    :line => params.line,
+                    :file => params.file,
+                    :children => [params]
+                )
+            end
+        end
+
+        # Print this object out.
+        def tree(indent = 0)
+            return [
+                @type.tree(indent + 1),
+                @name.tree(indent + 1),
+                ((@@indline * indent) + self.typewrap(self.pin)),
+                @params.collect { |param|
+                    begin
+                        param.tree(indent + 1)
+                    rescue NoMethodError => detail
+                        Puppet.err @params.inspect
+                        error = Puppet::DevError.new(
+                            "failed to tree a %s" % self.class
+                        )
+                        error.backtrace = detail.backtrace
+                        raise error
+                    end
+                }.join("\n")
+            ].join("\n")
+        end
+
+        # Verify that the type is valid.  This throws an error if there's
+        # a problem, so the return value doesn't matter
+        def typecheck(objtype)
+            # This will basically always be on, but I wanted to make it at
+            # least simple to turn off if it came to that
+            unless Puppet[:typecheck]
+                return
+            end
+
+            builtin = false
+            begin
+                builtin = Puppet::Type.type(objtype)
+            rescue TypeError
+                # nothing; we've already set builtin to false
+            end
+
+            unless builtin or @@settypes.include?(objtype) 
+                error = Puppet::ParseError.new(
+                    "Unknown type '%s'" % objtype
+                )
+                error.line = self.line
+                error.file = self.file
+                raise error
+            end
+
+            #unless builtin
+            #    Puppet.debug "%s is a defined type" % objtype
+            #end
+
+            self.paramcheck(builtin, objtype)
+
+            @checked = true
+        end
+
+        def to_s
+            return "%s => { %s }" % [@name,
+                @params.collect { |param|
+                    param.to_s
+                }.join("\n")
+            ]
+        end
+    end
+
+end