puppet 0.22.4 → 0.23.0

data/lib/puppet/parser/resource.rb

@@ -56,14 +56,15 @@ class Puppet::Parser::Resource
         end
     end
 
-    # Add any metaparams defined in our scope.  This actually adds any metaparams
+    # 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)
+                    set Param.new(:name => name, :value => val, 
+                                  :source => scope.source)
                 end
             end
         end
@@ -94,6 +95,7 @@ class Puppet::Parser::Resource
                                   :title => self.title,
                                   :arguments => self.to_hash,
                                   :scope => self.scope,
+                                  :virtual => self.virtual,
                                   :exported => self.exported
             )
         elsif builtin?
@@ -171,6 +173,48 @@ class Puppet::Parser::Resource
         end
     end
 
+    def modify_rails(db_resource)
+        args = rails_args
+        args.each do |param, value|
+            db_resource[param] = value unless db_resource[param] == value
+        end
+
+        # Handle file specially
+        if (self.file and  
+            (!db_resource.file or db_resource.file != self.file))
+            db_resource.file = self.file
+        end
+        
+        updated_params = @params.inject({}) do |hash, ary|
+            hash[ary[0].to_s] = ary[1]
+            hash
+        end
+        
+        db_resource.ar_hash_merge(db_resource.get_params_hash(db_resource.param_values), updated_params,
+                                  :create => Proc.new { |name, parameter|
+                                      parameter.to_rails(db_resource)
+                                  }, :delete => Proc.new { |values|
+                                      values.each { |value| db_resource.param_values.delete(value) }
+                                  }, :modify => Proc.new { |db, mem|
+                                      mem.modify_rails_values(db)
+                                  })
+        
+        updated_tags = tags.inject({}) { |hash, tag| 
+            hash[tag] = tag
+            hash
+        }
+            
+        db_resource.ar_hash_merge(db_resource.get_tag_hash(), 
+                                  updated_tags,
+                                  :create => Proc.new { |name, tag|
+                                      db_resource.add_resource_tag(tag)
+                                  }, :delete => Proc.new { |rt|
+                                      rt.each { |tag| db_resource.resource_tags.delete(tag) }
+                                  }, :modify => Proc.new { |db, mem|
+                                      # nothing here
+                                  })
+    end
+
     # This *significantly* reduces the number of calls to Puppet.[].
     def paramcheck?
         unless defined? @@paramcheck
@@ -179,13 +223,13 @@ 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.
+    # 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.
+        # 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
@@ -227,7 +271,8 @@ class Puppet::Parser::Resource
                 if Puppet[:trace]
                     puts caller
                 end
-                msg = "Parameter '%s' is already set on %s" % [param.name, self.to_s]
+                msg = "Parameter '%s' is already set on %s" % 
+                    [param.name, self.to_s]
                 if param.source.to_s != ""
                     msg += " by %s" % param.source
                 end
@@ -260,53 +305,30 @@ class Puppet::Parser::Resource
     def to_hash
         @params.inject({}) do |hash, ary|
             param = ary[1]
-            hash[param.name] = param.value
+            # Skip "undef" values.
+            if param.value != :undef
+                hash[param.name] = param.value
+            end
             hash
         end
     end
 
-    # Turn our parser resource into a Rails resource.
-    def to_rails(host, resource = nil)
-        args = {}
-        [:type, :title, :line, :exported].each do |param|
-            # 'type' isn't a valid column name, so we have to use something else.
-            if param == :type
-                to = :restype
-            else
-                to = param
-            end
-            if value = self.send(param)
-                args[to] = value
-            end
-        end
+    # Turn our parser resource into a Rails resource.  
+    def to_rails(host)
+        args = rails_args
 
-        # If we were passed an object, just make sure all of the attributes are correct.
-        if resource
-            # We exist
-            args.each do |param, value|
-                v = resource[param]
-                unless v == value
-                    resource[param] = value
-                end
-            end
-        else
-            # Else create it anew
-            resource = host.resources.build(args)
-        end
+        db_resource = host.resources.build(args)
 
-        # Handle file and tags specially
-        [:file, :tags].each do |param|
-            if self.send(param) and (!resource.send(param) or resource.send(param) != self.send(param))
-                resource.send(param.to_s + "=", self.send(param))
-            end
-        end
+        # Handle file specially
+        db_resource.file = self.file
 
-        # Either way, now add our parameters
-        updated_params = {}
-        @params.each { |name, p| updated_params[name.to_s] = p }
-        resource.collection_merge :param_names, :existing => resource.param_names, :updates => updated_params
+        @params.each { |name, param|
+            param.to_rails(db_resource)
+        }
+        
+        tags.each { |tag| db_resource.add_resource_tag(tag) }
 
-        return resource
+        return db_resource
     end
 
     def to_s
@@ -334,7 +356,16 @@ class Puppet::Parser::Resource
                     av
                 }
             end
-            obj[p.to_s] = v
+
+            # If the value is an array with only one value, then
+            # convert it to a single value.  This is largely so that
+            # the database interaction doesn't have to worry about
+            # whether it returns an array or a string.
+            obj[p.to_s] = if v.is_a?(Array) and v.length == 1
+                              v[0]
+                          else
+                              v
+                          end
         end
 
         obj.file = self.file
@@ -348,6 +379,18 @@ class Puppet::Parser::Resource
     def virtual?
         self.virtual
     end
+    
+    private
+    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.
+            to = (param == :type) ? :restype : param
+            if value = self.send(param)
+                hash[to] = value 
+            end
+            hash
+        end
+    end
 end
 
-# $Id: resource.rb 2439 2007-04-30 19:21:59Z luke $
+# $Id: resource.rb 2597 2007-06-17 21:41:50Z luke $

data/lib/puppet/parser/resource/param.rb

@@ -1,4 +1,4 @@
-# The parameters we stick in Resources.
+ # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
     attr_accessor :name, :value, :source, :line, :file
     include Puppet::Util
@@ -15,43 +15,66 @@ class Puppet::Parser::Resource::Param
         "#<#{self.class} @name => #{self.name}, @value => #{self.value}, @source => #{self.source.type}>"
     end
 
-    # Store this parameter in a Rails db.
-    def to_rails(res, pn = nil)
+    def line_to_i
+        return line ? Integer(line) : nil
+    end
+    
+    # Store a new parameter in a Rails db.
+    def to_rails(db_resource)
         values = value.is_a?(Array) ? value : [value]
+        values = values.map { |v| v.to_s }
 
-        values = values.collect { |v| v.to_s }
-
-        unless pn
-            # We're creating it anew.
-            pn = res.param_names.build(:name => self.name.to_s)
-        end
-        
-        value_objects = []
+        param_name = Puppet::Rails::ParamName.find_or_create_by_name(self.name.to_s)
+        line_number = line_to_i()
 
-        if l = self.line
-            pn.line = Integer(l)
-        end
-
-        oldvals = []
-
-        if pv = pn.param_values
-            oldvals = pv.collect { |val| val.value }
+        return values.collect do |v|
+            db_resource.param_values.create(:value => v.to_s,
+                                           :line => line_number,
+                                           :param_name => param_name)
         end
+    end
 
-        if oldvals != values
-            #pn.param_values = values.collect { |v| pn.param_values.build(:value => v.to_s) }
-            objects = values.collect do |v|
-                pn.param_values.build(:value => v.to_s)
-            end
-            pn.param_values = objects
-        end
+    def modify_rails_values(db_values)
+        #dev_warn if db_values.nil? || db_values.empty? 
 
-        return pn
+        values_to_remove(db_values).each { |remove_me|
+            Puppet::Rails::ParamValue.delete(remove_me)
+        }
+        line_number = line_to_i()
+        values_to_add(db_values).each { |add_me| 
+            db_resource = db_values[0].resource
+            db_param_name = db_values[0].param_name
+            db_resource.param_values.create(:value => add_me.to_s,
+                                           :line => line_number,
+                                           :param_name => db_param_name)
+        }
     end
-
+    
     def to_s
         "%s => %s" % [self.name, self.value]
     end
+    
+    def values_to_remove(db_values)
+        values = value.is_a?(Array) ? value : [value]
+        values = values.map { |v| v.to_s }
+        line_number = line_to_i()
+        db_values.collect do |db|
+            db unless (db.line == line_number && 
+                       values.find { |v| 
+                         v == db.value 
+                       } )
+        end.compact
+    end
+
+    def values_to_add(db_values)
+        values = value.is_a?(Array) ? value : [value]
+        values = values.map { |v| v.to_s }
+        line_number = line_to_i()
+        values.collect do |v|
+            v unless db_values.find { |db| (v == db.value && 
+                                         line_number == db.line) }
+        end.compact
+    end
 end
 
-# $Id: param.rb 2439 2007-04-30 19:21:59Z luke $
+# $Id: param.rb 2597 2007-06-17 21:41:50Z luke $

data/lib/puppet/parser/scope.rb

@@ -11,21 +11,13 @@ class Puppet::Parser::Scope
 
     AST = Puppet::Parser::AST
 
-    # 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
     include Puppet::Util::Errors
     attr_accessor :parent, :level, :interp, :source, :host
     attr_accessor :name, :type, :topscope, :base, :keyword
-    attr_accessor :top, :translated, :exported
+    attr_accessor :top, :translated, :exported, :virtual
 
     # Whether we behave declaratively.  Note that it's a class variable,
     # so all scopes behave the same.
@@ -56,7 +48,7 @@ class Puppet::Parser::Scope
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     def self.true?(value)
-        if value == false or value == ""
+        if value == false or value == "" or value == :undef
             return false
         else
             return true
@@ -123,8 +115,8 @@ class Puppet::Parser::Scope
     # that subclasses can set their parent scopes to be the scope of
     # their parent class.
     def class_scope(klass)
-        if klass.respond_to?(:fqname)
-            @classtable[klass.fqname]
+        if klass.respond_to?(:classname)
+            @classtable[klass.classname]
         else
             @classtable[klass]
         end
@@ -379,9 +371,7 @@ class Puppet::Parser::Scope
         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.
+    # Look up all of the exported objects of a given type.
     def lookupexported(type)
         @definedtable.find_all do |name, r|
             r.type == type and r.exported?
@@ -406,7 +396,7 @@ class Puppet::Parser::Scope
             raise Puppet::ParseError, "Could not find class %s" % klassname
         end
         unless kscope = class_scope(klass)
-            raise Puppet::ParseError, "Class %s has not been evaluated so its variables cannot be referenced" % klass.fqname
+            raise Puppet::ParseError, "Class %s has not been evaluated so its variables cannot be referenced" % klass.classname
         end
         return kscope.lookupvar(shortname, usestring)
     end
@@ -422,7 +412,11 @@ class Puppet::Parser::Scope
         end
         # We can't use "if @symtable[name]" here because the value might be false
         if @symtable.include?(name)
-            return @symtable[name]
+            if usestring and @symtable[name] == :undef
+                return ""
+            else
+                return @symtable[name]
+            end
         elsif self.parent 
             return @parent.lookupvar(name, usestring)
         elsif usestring
@@ -459,8 +453,8 @@ class Puppet::Parser::Scope
     end
 
     def setclass?(obj)
-        if obj.respond_to?(:fqname)
-            @classtable.has_key?(obj.fqname)
+        if obj.respond_to?(:classname)
+            @classtable.has_key?(obj.classname)
         else
             @classtable[obj]
         end
@@ -472,11 +466,11 @@ class Puppet::Parser::Scope
     # can support multiple unrelated classes with the same name.
     def setclass(obj)
         if obj.is_a?(AST::HostClass)
-            unless obj.fqname
+            unless obj.classname
                 raise Puppet::DevError, "Got a %s with no fully qualified name" %
                     obj.class
             end
-            @classtable[obj.fqname] = self
+            @classtable[obj.classname] = self
         else
             raise Puppet::DevError, "Invalid class %s" % obj.inspect
         end
@@ -496,6 +490,13 @@ class Puppet::Parser::Scope
 
         @children << obj
 
+        # Mark the resource as virtual or exported, as necessary.
+        if self.exported?
+            obj.exported = true
+        elsif self.virtual?
+            obj.virtual = true
+        end
+
         # The global table
         @definedtable[obj.ref] = obj
 
@@ -633,7 +634,7 @@ class Puppet::Parser::Scope
                 Puppet.debug "got told to tag with %s" % tag.inspect
                 next
             end
-            unless tag =~ /^\w[-\w]+$/
+            unless tag =~ /^\w[-\w]*$/
                 fail Puppet::ParseError, "Invalid tag %s" % tag.inspect
             end
             tag = tag.to_s
@@ -721,6 +722,10 @@ class Puppet::Parser::Scope
             return ary
         end
     end
+
+    def virtual?
+        self.virtual || self.exported?
+    end
 end
 
-# $Id: scope.rb 2418 2007-04-26 19:09:24Z luke $
+# $Id: scope.rb 2562 2007-06-11 21:54:37Z luke $

data/lib/puppet/pgraph.rb

@@ -48,26 +48,6 @@ class Puppet::PGraph < GRATR::Digraph
         end
     end
 
-    # Fail in a somewhat informative way if the graph has become cyclic.
-    def check_cycle(sorted)
-        return true if sorted.size == size()
-
-        bad = []
-        vertices.each do |v|
-            bad << v unless sorted.include?(v)
-        end
-
-        if bad.length > 0
-            raise Puppet::Error,
-                "Found dependency cycle involving %s" % bad.collect do |v|
-                    v.to_s
-            end.join(", ")
-        else
-            raise Puppet::Error,
-                "Found dependency cycle but could not find the cause"
-        end
-    end
-
     # Which resources a given resource depends upon.
     def dependents(resource)
         tree_from_vertex2(resource).keys
@@ -185,6 +165,31 @@ class Puppet::PGraph < GRATR::Digraph
         end
     end
 
+    # Replace the default method, because we want to throw errors on back edges,
+    # not just skip them.
+    def topsort(start = nil, &block)
+        result  = []
+        go      = true 
+        cycles = []
+        back    = Proc.new { |e|
+            cycles << e
+            go = false
+        }
+        push    = Proc.new { |v| result.unshift(v) if go}
+        start   ||= vertices[0]
+        dfs({:exit_vertex => push, :back_edge => back, :start => start})
+        if block_given?
+            result.each {|v| yield(v) }
+        end
+
+        if cycles.length > 0
+            msg = "Found cycles in the following relationships:"
+            cycles.each { |edge| msg += " %s => %s" % [edge.source, edge.target] }
+            raise Puppet::Error, msg
+        end
+        return result
+    end
+
     # A different way of walking a tree, and a much faster way than the
     # one that comes with GRATR.
     def tree_from_vertex2(start, direction = :out)
@@ -205,4 +210,4 @@ class Puppet::PGraph < GRATR::Digraph
     end
 end
 
-# $Id: pgraph.rb 2308 2007-03-19 04:40:25Z luke $
+# $Id: pgraph.rb 2521 2007-05-17 20:57:24Z luke $