puppet 0.23.2 → 0.24.0

data/lib/puppet/parser/parser_support.rb

@@ -1,3 +1,5 @@
+# I pulled this into a separate file, because I got
+# tired of rebuilding the parser.rb file all the time.
 class Puppet::Parser::Parser
     require 'puppet/parser/functions'
 
@@ -13,7 +15,7 @@ class Puppet::Parser::Parser
 
     AST = Puppet::Parser::AST
 
-    attr_reader :file, :interp
+    attr_reader :version, :environment
     attr_accessor :files
 
 
@@ -83,6 +85,10 @@ class Puppet::Parser::Parser
         raise except
     end
 
+    def file
+        @lexer.file
+    end
+
     def file=(file)
         unless FileTest.exists?(file)
             unless file =~ /\.pp$/
@@ -119,7 +125,7 @@ class Puppet::Parser::Parser
     # The recursive method used to actually look these objects up.
     def fqfind(namespace, name, table)
         namespace = namespace.downcase
-        name = name.downcase
+        name = name.to_s.downcase
         if name =~ /^::/ or namespace == ""
             classname = name.sub(/^::/, '')
             unless table[classname]
@@ -174,14 +180,14 @@ class Puppet::Parser::Parser
                "in file #{@lexer.file} at line #{@lexer.line}"
             )
         end
-        files = Puppet::Module::find_manifests(pat, dir)
+        files = Puppet::Module::find_manifests(pat, :cwd => dir)
         if files.size == 0
             raise Puppet::ImportError.new("No file(s) found for import " +
                                           "of '#{pat}'")
         end
 
         files.collect { |file|
-            parser = Puppet::Parser::Parser.new(@astset)
+            parser = Puppet::Parser::Parser.new(:astset => @astset, :environment => @environment)
             parser.files = self.files
             Puppet.debug("importing '%s'" % file)
 
@@ -200,11 +206,10 @@ class Puppet::Parser::Parser
         }
     end
 
-    def initialize(astset = nil)
+    def initialize(options = {})
+        @astset = options[:astset] || ASTSet.new({}, {}, {})
+        @environment = options[:environment]
         initvars()
-        if astset
-            @astset = astset
-        end
     end
 
     # Initialize or reset all of our variables.
@@ -212,15 +217,6 @@ class Puppet::Parser::Parser
         @lexer = Puppet::Parser::Lexer.new()
         @files = []
         @loaded = []
-
-        # This is where we store our classes and definitions and nodes.
-        # Clear each hash, just to help the GC a bit.
-        if defined?(@astset)
-            [:classes, :definitions, :nodes].each do |name|
-                @astset.send(name).clear
-            end
-        end
-        @astset = ASTSet.new({}, {}, {})
     end
 
     # Try to load a class, since we could not find it.
@@ -340,7 +336,7 @@ class Puppet::Parser::Parser
             args[param] = options[param] if options[param]
         end
 
-        @astset.definitions[name] = ast AST::Component, args
+        @astset.definitions[name] = ast AST::Definition, args
     end
 
     # Create a new node.  Nodes are special, because they're stored in a global
@@ -370,10 +366,12 @@ class Puppet::Parser::Parser
     end
 
     def on_error(token,value,stack)
-        #on '%s' at '%s' in\n'%s'" % [token,value,stack]
-        #error = "line %s: parse error after '%s'" %
-        #    [@lexer.line,@lexer.last]
-        error = "Syntax error at '%s'" % [value]
+        if token == 0 # denotes end of file
+            value = 'end of file'
+        else
+            value = "'%s'" % value
+        end
+        error = "Syntax error at %s" % [value]
 
         if brace = @lexer.expected
             error += "; expected '%s'" % brace
@@ -425,6 +423,7 @@ class Puppet::Parser::Parser
             # Store the results as the top-level class.
             newclass("", :code => main)
         end
+        @version = Time.now.to_i
         return @astset
     ensure
         @lexer.clear
@@ -442,6 +441,16 @@ class Puppet::Parser::Parser
     def string=(string)
         @lexer.string = string
     end
-end
 
-# $Id: parser_support.rb 2744 2007-08-04 20:00:19Z luke $
+    # Add a new file to be checked when we're checking to see if we should be
+    # reparsed.  This is basically only used by the TemplateWrapper to let the
+    # parser know about templates that should be parsed.
+    def watch_file(*files)
+        files.each do |file|
+            unless file.is_a? Puppet::Util::LoadedFile
+                file = Puppet::Util::LoadedFile.new(file)
+            end
+            @files << file
+        end
+    end
+end

data/lib/puppet/parser/resource.rb

@@ -3,19 +3,26 @@
 class Puppet::Parser::Resource
     require 'puppet/parser/resource/param'
     require 'puppet/parser/resource/reference'
-    ResParam = Struct.new :name, :value, :source, :line, :file
     include Puppet::Util
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
     include Puppet::Util::Logging
 
     attr_accessor :source, :line, :file, :scope, :rails_id
-    attr_accessor :virtual, :override, :params, :translated
+    attr_accessor :virtual, :override, :translated
 
-    attr_reader :exported
+    attr_reader :exported, :evaluated, :params
 
     attr_writer :tags
 
+    # Determine whether the provided parameter name is a relationship parameter.
+    def self.relationship_parameter?(name)
+        unless defined?(@relationship_names)
+            @relationship_names = Puppet::Type.relationship_params.collect { |p| p.name }
+        end
+        @relationship_names.include?(name)
+    end
+
     # Proxy a few methods to our @ref object.
     [:builtin?, :type, :title].each do |method|
         define_method(method) do
@@ -24,7 +31,7 @@ class Puppet::Parser::Resource
     end
 
     # Set up some boolean test methods
-    [:exported, :translated, :override].each do |method|
+    [:exported, :translated, :override, :virtual, :evaluated].each do |method|
         newmeth = (method.to_s + "?").intern
         define_method(newmeth) do
             self.send(method)
@@ -43,44 +50,6 @@ class Puppet::Parser::Resource
         end
     end
 
-    # Add default values from our definition.
-    def adddefaults
-        defaults = scope.lookupdefaults(self.type)
-
-        defaults.each do |name, param|
-            unless @params.include?(param.name)
-                self.debug "Adding default for %s" % param.name
-
-                @params[param.name] = param
-            end
-        end
-    end
-
-    # Add any metaparams defined in our scope. This actually adds any metaparams
-    # from any parent scope, and there's currently no way to turn that off.
-    def addmetaparams
-        Puppet::Type.eachmetaparam do |name|
-            next if self[name]
-            if val = scope.lookupvar(name.to_s, false)
-                unless val == :undefined
-                    set Param.new(:name => name, :value => val, 
-                                  :source => scope.source)
-                end
-            end
-        end
-    end
-
-    # Add any overrides for this object.
-    def addoverrides
-        overrides = scope.lookupoverrides(self)
-
-        overrides.each do |over|
-            self.merge(over)
-        end
-
-        overrides.clear
-    end
-
     def builtin=(bool)
         @ref.builtin = bool
     end
@@ -89,15 +58,8 @@ class Puppet::Parser::Resource
     def evaluate
         if klass = @ref.definedtype
             finish()
-            scope.deleteresource(self)
-            return klass.evaluate(:scope => scope,
-                                  :type => self.type,
-                                  :title => self.title,
-                                  :arguments => self.to_hash,
-                                  :scope => self.scope,
-                                  :virtual => self.virtual,
-                                  :exported => self.exported
-            )
+            scope.compile.delete_resource(self)
+            return klass.evaluate(:scope => scope, :resource => self)
         elsif builtin?
             devfail "Cannot evaluate a builtin type"
         else
@@ -107,6 +69,8 @@ class Puppet::Parser::Resource
         @evaluated = true
     end
 
+    # Mark this resource as both exported and virtual,
+    # or remove the exported mark.
     def exported=(value)
         if value
             @virtual = true
@@ -116,63 +80,80 @@ class Puppet::Parser::Resource
         end
     end
 
-    def evaluated?
-        if defined? @evaluated and @evaluated
-            true
-        else
-            false
-        end
-    end
-
     # Do any finishing work on this object, called before evaluation or
     # before storage/translation.
     def finish
-        addoverrides()
-        adddefaults()
-        addmetaparams()
+        add_overrides()
+        add_defaults()
+        add_metaparams()
+        validate()
     end
 
     def initialize(options)
+        # Set all of the options we can.
+        options.each do |option, value|
+            if respond_to?(option.to_s + "=")
+                send(option.to_s + "=", value)
+                options.delete(option)
+            end
+        end
+
+        unless self.scope
+            raise ArgumentError, "Resources require a scope"
+        end
+        @source ||= scope.source
+
         options = symbolize_options(options)
 
-        # Collect the options necessary to make the reference.
-        refopts = [:type, :title].inject({}) do |hash, param|
-            hash[param] = options[param]
-            options.delete(param)
-            hash
+        # Set up our reference.
+        if type = options[:type] and title = options[:title]
+            options.delete(:type)
+            options.delete(:title)
+        else
+            raise ArgumentError, "Resources require a type and title"
         end
 
+        @ref = Reference.new(:type => type, :title => title, :scope => self.scope)
+
         @params = {}
-        tmpparams = nil
-        if tmpparams = options[:params]
+
+        # Define all of the parameters
+        if params = options[:params]
             options.delete(:params)
+            params.each do |param|
+                set_parameter(param)
+            end
         end
 
-        # Now set the rest of the options.
-        set_options(options)
-
-        @ref = Reference.new(refopts)
-
-        requiredopts(:scope, :source)
+        # Throw an exception if we've got any arguments left to set.
+        unless options.empty?
+            raise ArgumentError, "Resources do not accept %s" % options.keys.collect { |k| k.to_s }.join(", ")
+        end
 
-        @ref.scope = self.scope
+        @tags = []
+        tag(@ref.type)
+        tag(@ref.title) if @ref.title.to_s =~ /^[-\w]+$/
 
-        if tmpparams
-            tmpparams.each do |param|
-                # We use the method here, because it does type-checking.
-                set(param)
-            end
+        if scope.resource
+            @tags += scope.resource.tags
         end
     end
 
-    # Merge an override resource in.
+    # Merge an override resource in.  This will throw exceptions if
+    # any overrides aren't allowed.
     def merge(resource)
+        # Test the resource scope, to make sure the resource is even allowed
+        # to override.
+        unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
+            raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
+        end
         # Some of these might fail, but they'll fail in the way we want.
         resource.params.each do |name, param|
-            set(param)
+            override_parameter(param)
         end
     end
 
+    # Modify this resource in the Rails database.  Poor design, yo.
     def modify_rails(db_resource)
         args = rails_args
         args.each do |param, value|
@@ -215,6 +196,15 @@ class Puppet::Parser::Resource
                                   })
     end
 
+    # Return the resource name, or the title if no name
+    # was specified.
+    def name
+        unless defined? @name
+            @name = self[:name] || self.title
+        end
+        @name
+    end
+
     # This *significantly* reduces the number of calls to Puppet.[].
     def paramcheck?
         unless defined? @@paramcheck
@@ -223,23 +213,6 @@ class Puppet::Parser::Resource
         @@paramcheck
     end
 
-    # Verify that all passed parameters are valid.  This throws an error if
-    #  there's a problem, so we don't have to worry about the return value.
-    def paramcheck(param)
-        param = param.to_s
-        # Now make sure it's a valid argument to our class.  These checks
-        # are organized in order of commonhood -- most types, it's a valid 
-        # argument and paramcheck is enabled.
-        if @ref.typeclass.validattr?(param)
-            true
-        elsif %w{name title}.include?(param) # always allow these
-            true
-        elsif paramcheck?
-            self.fail Puppet::ParseError, "Invalid parameter '%s' for type '%s'" %
-                    [param.inspect, @ref.type]
-        end
-    end
-
     # A temporary occasion, until I get paths in the scopes figured out.
     def path
         to_s
@@ -250,65 +223,21 @@ class Puppet::Parser::Resource
         @ref.to_s
     end
 
-    # You have to pass a Resource::Param to this.
-    def set(param, value = nil, source = nil)
-        if value and source
-            param = Puppet::Parser::Resource::Param.new(
-                :name => param, :value => value, :source => source
-            )
-        elsif ! param.is_a?(Puppet::Parser::Resource::Param)
-            raise ArgumentError, "Must pass a parameter or all necessary values"
-        end
-        # Because definitions are now parse-time, I can paramcheck immediately.
-        paramcheck(param.name)
-
-        if current = @params[param.name]
-            # This is where we'd ignore any equivalent values if we wanted to,
-            # but that would introduce a lot of really bad ordering issues.
-            if param.source.child_of?(current.source)
-                if param.add
-                    # Merge with previous value.
-                    param.value = [ current.value, param.value ].flatten
-                end
-
-                # Replace it, keeping all of its info.
-                @params[param.name] = param
-            else
-                if Puppet[:trace]
-                    puts caller
-                end
-                msg = "Parameter '%s' is already set on %s" % 
-                    [param.name, self.to_s]
-                if current.source.to_s != ""
-                    msg += " by %s" % current.source
-                end
-                if current.file or current.line
-                    fields = []
-                    fields << current.file if current.file
-                    fields << current.line.to_s if current.line
-                    msg += " at %s" % fields.join(":")
-                end
-                msg += "; cannot redefine"
-                error = Puppet::ParseError.new(msg)
-                error.file = param.file if param.file
-                error.line = param.line if param.line
-                raise error
+    # Add a tag to our current list.  These tags will be added to all
+    # of the objects contained in this scope.
+    def tag(*ary)
+        ary.collect { |tag| tag.to_s.downcase }.collect { |tag| tag.split("::") }.flatten.each do |tag|
+            unless tag =~ /^\w[-\w]*$/
+                fail Puppet::ParseError, "Invalid tag %s" % tag.inspect
             end
-        else
-            if self.source == param.source or param.source.child_of?(self.source)
-                @params[param.name] = param
-            else
-                fail Puppet::ParseError, "Only subclasses can set parameters"
+            unless @tags.include?(tag)
+                @tags << tag
             end
         end
     end
 
     def tags
-        unless defined? @tags
-            @tags = scope.tags
-            @tags << self.type
-        end
-        @tags
+        @tags.dup
     end
 
     def to_hash
@@ -346,12 +275,26 @@ class Puppet::Parser::Resource
 
     # Translate our object to a transportable object.
     def to_trans
-        unless builtin?
-            devfail "Tried to translate a non-builtin resource"
+        return nil if virtual?
+
+        if builtin?
+            to_transobject
+        else
+            to_transbucket
         end
+    end
 
-        return nil if virtual?
+    def to_transbucket
+        bucket = Puppet::TransBucket.new([])
+
+        bucket.type = self.type
+        bucket.name = self.title
 
+        # TransBuckets don't support parameters, which is why they're being deprecated.
+        return bucket
+    end
+
+    def to_transobject
         # Now convert to a transobject
         obj = Puppet::TransObject.new(@ref.title, @ref.type)
         to_hash.each do |p, v|
@@ -384,12 +327,106 @@ class Puppet::Parser::Resource
 
         return obj
     end
-
-    def virtual?
-        self.virtual
-    end
     
     private
+
+    # Add default values from our definition.
+    def add_defaults
+        scope.lookupdefaults(self.type).each do |name, param|
+            unless @params.include?(name)
+                self.debug "Adding default for %s" % name
+
+                @params[name] = param
+            end
+        end
+    end
+
+    # Add any metaparams defined in our scope. This actually adds any metaparams
+    # from any parent scope, and there's currently no way to turn that off.
+    def add_metaparams
+        Puppet::Type.eachmetaparam do |name|
+            # Skip metaparams that we already have defined, unless they're relationship metaparams.
+            # LAK:NOTE Relationship metaparams get treated specially -- we stack them, instead of
+            # overriding.
+            next if @params[name] and not self.class.relationship_parameter?(name)
+
+            # Skip metaparams for which we get no value.
+            next unless val = scope.lookupvar(name.to_s, false) and val != :undefined
+
+            # The default case: just set the value
+            return set_parameter(name, val) unless @params[name]
+
+            # For relationship params, though, join the values (a la #446).
+            @params[name].value = [@params[name].value, val].flatten
+        end
+    end
+
+    # Add any overrides for this object.
+    def add_overrides
+        if overrides = scope.compile.resource_overrides(self)
+            overrides.each do |over|
+                self.merge(over)
+            end
+
+            # Remove the overrides, so that the configuration knows there
+            # are none left.
+            overrides.clear
+        end
+    end
+
+    # Accept a parameter from an override.
+    def override_parameter(param)
+        # This can happen if the override is defining a new parameter, rather
+        # than replacing an existing one.
+        (@params[param.name] = param and return) unless current = @params[param.name]
+
+        # The parameter is already set.  Fail if they're not allowed to override it.
+        unless param.source.child_of?(current.source)
+            if Puppet[:trace]
+                puts caller
+            end
+            msg = "Parameter '%s' is already set on %s" % 
+                [param.name, self.to_s]
+            if current.source.to_s != ""
+                msg += " by %s" % current.source
+            end
+            if current.file or current.line
+                fields = []
+                fields << current.file if current.file
+                fields << current.line.to_s if current.line
+                msg += " at %s" % fields.join(":")
+            end
+            msg += "; cannot redefine"
+            raise Puppet::ParseError.new(msg, param.line, param.file)
+        end
+
+        # If we've gotten this far, we're allowed to override.
+
+        # Merge with previous value, if the parameter was generated with the +> syntax.
+        # It's important that we use the new param instance here, not the old one,
+        # so that the source is registered correctly for later overrides.
+        param.value = [current.value, param.value].flatten if param.add
+
+        @params[param.name] = param
+    end
+
+    # Verify that all passed parameters are valid.  This throws an error if
+    #  there's a problem, so we don't have to worry about the return value.
+    def paramcheck(param)
+        param = param.to_s
+        # Now make sure it's a valid argument to our class.  These checks
+        # are organized in order of commonhood -- most types, it's a valid 
+        # argument and paramcheck is enabled.
+        if @ref.typeclass.validattr?(param)
+            true
+        elsif %w{name title}.include?(param) # always allow these
+            true
+        elsif paramcheck?
+            self.fail Puppet::ParseError, "Invalid parameter '%s' for type '%s'" %
+                    [param, @ref.type]
+        end
+    end
+
     def rails_args
         return [:type, :title, :line, :exported].inject({}) do |hash, param|
             # 'type' isn't a valid column name, so we have to use another name.
@@ -400,6 +437,26 @@ class Puppet::Parser::Resource
             hash
         end
     end
-end
 
-# $Id: resource.rb 2693 2007-07-14 17:46:37Z luke $
+    # Define a parameter in our resource.
+    def set_parameter(param, value = nil)
+        if value
+            param = Puppet::Parser::Resource::Param.new(
+                :name => param, :value => value, :source => self.source
+            )
+        elsif ! param.is_a?(Puppet::Parser::Resource::Param)
+            raise ArgumentError, "Must pass a parameter or all necessary values"
+        end
+
+        # And store it in our parameter hash.
+        @params[param.name] = param
+    end
+
+    # Make sure the resource's parameters are all valid for the type.
+    def validate
+        @params.each do |name, param|
+            # Make sure it's a valid parameter.
+            paramcheck(name)
+        end
+    end
+end