puppet 0.22.4 → 0.23.0

data/lib/puppet/transaction/report.rb

@@ -48,6 +48,32 @@ class Puppet::Transaction::Report
     def record(metric, object)
         @records[metric] << object
     end
+
+    # Provide a summary of this report.
+    def summary
+        ret = ""
+
+        @metrics.sort { |a,b| a[1].label <=> b[1].label }.each do |name, metric|
+            ret += "%s:\n" % metric.label
+            metric.values.sort { |a,b|
+                # sort by label
+                if a[0] == :total
+                    1
+                elsif b[0] == :total
+                    -1
+                else
+                    a[1] <=> b[1]
+                end
+            }.each do |name, label, value|
+                next if value == 0
+                if value.is_a?(Float)
+                    value = "%0.2f" % value
+                end
+                ret += "   %15s %s\n" % [label + ":", value]
+            end
+        end
+        return ret
+    end
 end
 
-# $Id: report.rb 2246 2007-02-28 17:03:21Z luke $
+# $Id: report.rb 2459 2007-05-04 05:04:29Z luke $

data/lib/puppet/type.rb

@@ -106,40 +106,6 @@ class Type < Puppet::Element
         define_method(:validate, &block)
         #@validate = block
     end
-
-    # iterate across all children, and then iterate across properties
-    # we do children first so we're sure that all dependent objects
-    # are checked first
-    # we ignore parameters here, because they only modify how work gets
-    # done, they don't ever actually result in work specifically
-    def each
-        # we want to return the properties in the order that each type
-        # specifies it, because it may (as in the case of File#create)
-        # be important
-        if self.class.depthfirst?
-            @children.each { |child|
-                yield child
-            }
-        end
-        self.eachproperty { |property|
-            yield property
-        }
-        unless self.class.depthfirst?
-            @children.each { |child|
-                yield child
-            }
-        end
-    end
-
-    # Recurse deeply through the tree, but only yield types, not properties.
-    def delve(&block)
-        self.each do |obj|
-            if obj.is_a? Puppet::Type
-                obj.delve(&block)
-            end
-        end
-        block.call(self)
-    end
     
     # create a log at specified level
     def log(msg)
@@ -157,7 +123,6 @@ class Type < Puppet::Element
     public
 
     def initvars
-        @children = []
         @evalcount = 0
         @tags = []
 
@@ -381,20 +346,19 @@ class Type < Puppet::Element
 
     # Convert to a transportable object
     def to_trans(ret = true)
-        # Retrieve the object, if they tell use to.
-        if ret
-            retrieve()
-        end
-
         trans = TransObject.new(self.title, self.class.name)
 
-        properties().each do |property|
-            trans[property.name] = property.is
+        values = retrieve()
+        values.each do |name, value|
+            trans[name.name] = value
         end
 
         @parameters.each do |name, param|
             # Avoid adding each instance name as both the name and the namevar
             next if param.class.isnamevar? and param.value == self.title
+
+            # We've already got property values
+            next if param.is_a?(Puppet::Property)
             trans[name] = param.value
         end
 
@@ -417,4 +381,4 @@ require 'puppet/type/tidy'
 
 
 
-# $Id: type.rb 2329 2007-03-19 21:37:52Z luke $
+# $Id: type.rb 2577 2007-06-14 03:39:23Z luke $

data/lib/puppet/type/component.rb

@@ -7,153 +7,227 @@ require 'puppet/type'
 require 'puppet/transaction'
 require 'puppet/pgraph'
 
-module Puppet
-    newtype(:component) do
-        include Enumerable
-
-        newparam(:name) do
-            desc "The name of the component.  Generally optional."
-            isnamevar
+Puppet::Type.newtype(:component) do
+    include Enumerable
+    attr_accessor :children
+
+    newparam(:name) do
+        desc "The name of the component.  Generally optional."
+        isnamevar
+    end
+
+    newparam(:type) do
+        desc "The type that this component maps to.  Generally some kind of
+            class from the language."
+
+        defaultto "component"
+    end
+
+    # Remove a child from the component.
+    def delete(child)
+        if @children.include?(child)
+            @children.delete(child)
+            return true
+        else
+            return super
         end
+    end
 
-        newparam(:type) do
-            desc "The type that this component maps to.  Generally some kind of
-                class from the language."
-
-            defaultto "component"
+    # Recurse deeply through the tree, but only yield types, not properties.
+    def delve(&block)
+        self.each do |obj|
+            if obj.is_a?(self.class)
+                obj.delve(&block)
+            end
         end
-
-        # Remove a child from the component.
-        def delete(child)
-            if @children.include?(child)
-                @children.delete(child)
-                return true
+        block.call(self)
+    end
+
+    # Return each child in turn.
+    def each
+        @children.each { |child| yield child }
+    end
+
+    # flatten all children, sort them, and evaluate them in order
+    # this is only called on one component over the whole system
+    # this also won't work with scheduling, but eh
+    def evaluate
+        self.finalize unless self.finalized?
+        transaction = Puppet::Transaction.new(self)
+        transaction.component = self
+        return transaction
+    end
+
+    # Do all of the polishing off, mostly doing autorequires and making
+    # dependencies.  This will get run once on the top-level component,
+    # and it will do everything necessary.
+    def finalize
+        started = {}
+        finished = {}
+        
+        # First do all of the finish work, which mostly involves
+        self.delve do |object|
+            # Make sure we don't get into loops
+            if started.has_key?(object)
+                debug "Already finished %s" % object.title
+                next
             else
-                return false
+                started[object] = true
+            end
+            unless finished.has_key?(object)
+                object.finish
+                finished[object] = true
             end
         end
 
-        # Return each child in turn.
-        def each
-            @children.each { |child| yield child }
-        end
+        @finalized = true
+    end
 
-        # flatten all children, sort them, and evaluate them in order
-        # this is only called on one component over the whole system
-        # this also won't work with scheduling, but eh
-        def evaluate
-            self.finalize unless self.finalized?
-            transaction = Puppet::Transaction.new(self)
-            transaction.component = self
-            return transaction
+    def finalized?
+        if defined? @finalized
+            return @finalized
+        else
+            return false
         end
-
-        # Do all of the polishing off, mostly doing autorequires and making
-        # dependencies.  This will get run once on the top-level component,
-        # and it will do everything necessary.
-        def finalize
-            started = {}
-            finished = {}
-            
-            # First do all of the finish work, which mostly involves
-            self.delve do |object|
-                # Make sure we don't get into loops
-                if started.has_key?(object)
-                    debug "Already finished %s" % object.title
-                    next
-                else
-                    started[object] = true
-                end
-                unless finished.has_key?(object)
-                    object.finish
-                    finished[object] = true
-                end
-            end
-
-            @finalized = true
+    end
+
+    # Initialize a new component
+    def initialize(args)
+        @children = []
+        super(args)
+    end
+
+    def initvars
+        super
+        @children = []
+    end
+
+    def parent=(parent)
+        if self.parentof?(parent)
+            devfail "%s[%s] is already the parent of %s[%s]" %
+                [self.class.name, self.title, parent.class.name, parent.title]
         end
-
-        def finalized?
-            if defined? @finalized
-                return @finalized
-            else
-                return false
-            end
+        @parent = parent
+    end
+
+    # Add a hook for testing for recursion.
+    def parentof?(child)
+        if super(child)
+            return true
+        elsif @children.include?(child)
+            debug "child is already in children array"
+            return true
+        else
+            return false
         end
+    end
 
-        # Initialize a new component
-        def initialize(args)
+    def push(*childs)
+        unless defined? @children
             @children = []
-            super(args)
         end
-        
-        # Component paths are special because they function as containers.
-        def pathbuilder
-            tmp = []
-            if defined? @parent and @parent
-                tmp += [@parent.pathbuilder, self.title]
+        childs.each { |child|
+            # Make sure we don't have any loops here.
+            if parentof?(child)
+                devfail "Already the parent of %s[%s]" % [child.class.name, child.title]
+            end
+            unless child.is_a?(Puppet::Element)
+                self.debug "Got object of type %s" % child.class
+                self.devfail(
+                    "Containers can only contain Puppet::Elements, not %s" %
+                    child.class
+                )
+            end
+            @children.push(child)
+            child.parent = self
+        }
+    end
+    
+    # Component paths are special because they function as containers.
+    def pathbuilder
+        tmp = []
+        if defined? @parent and @parent
+            tmp += [@parent.pathbuilder, self.title]
+        else
+            # The top-level name is always main[top], so we don't bother with
+            # that.
+            if self.title == "main[top]"
+                tmp << "" # This empty field results in "//" in the path
             else
-                # The top-level name is always main[top], so we don't bother with
-                # that.
-                if self.title == "main[top]"
-                    tmp << "" # This empty field results in "//" in the path
-                else
-                    tmp << self.title
-                end
+                tmp << self.title
             end
-            
-            tmp
         end
-
-        # We have a different way of setting the title
-        def title
-            unless defined? @title
-                if self[:type] == self[:name] # this is the case for classes
-                    @title = self[:type]
-                elsif self[:name] =~ /\[.+\]/ # most components already have ref info in the name
-                    @title = self[:name]
-                else # else, set it up
-                    @title = "%s[%s]" % [self[:type].capitalize, self[:name]]
-                end
+        
+        tmp
+    end
+
+    # Remove an object.  The argument determines whether the object's
+    # subscriptions get eliminated, too.
+    def remove(rmdeps = true)
+        # Our children remove themselves from our @children array (else the object
+        # we called this on at the top would not be removed), so we duplicate the
+        # array and iterate over that.  If we don't do this, only half of the
+        # objects get removed.
+        @children.dup.each { |child|
+            child.remove(rmdeps)
+        }
+
+        @children.clear
+
+        # Get rid of params and provider, too.
+        super
+
+        @parent = nil
+    end
+
+    # We have a different way of setting the title
+    def title
+        unless defined? @title
+            if self[:type] == self[:name] # this is the case for classes
+                @title = self[:type]
+            elsif self[:name] =~ /\[.+\]/ # most components already have ref info in the name
+                @title = self[:name]
+            else # else, set it up
+                @title = "%s[%s]" % [self[:type].capitalize, self[:name]]
             end
-            return @title
-        end
-
-        def refresh
-            @children.collect { |child|
-                if child.respond_to?(:refresh)
-                    child.refresh
-                    child.log "triggering %s" % :refresh
-                end
-            }
         end
+        return @title
+    end
+
+    def refresh
+        @children.collect { |child|
+            if child.respond_to?(:refresh)
+                child.refresh
+                child.log "triggering %s" % :refresh
+            end
+        }
+    end
+    
+    # Convert to a graph object with all of the container info.
+    def to_graph
+        graph = Puppet::PGraph.new
         
-        # Convert to a graph object with all of the container info.
-        def to_graph
-            graph = Puppet::PGraph.new
-            
-            delver = proc do |obj|
-                obj.each do |child|
-                    if child.is_a?(Puppet::Type)
-                        graph.add_edge!(obj, child)
-                        delver.call(child)
-                    end
+        delver = proc do |obj|
+            obj.each do |child|
+                graph.add_edge!(obj, child)
+                if child.is_a?(self.class)
+                    delver.call(child)
                 end
             end
-            
-            delver.call(self)
-            
-            return graph
         end
-
-        def to_s
-            if self.title =~ /\[/
-                return self.title
-            else
-                return "component(%s)" % self.title
-            end
+        
+        delver.call(self)
+        
+        return graph
+    end
+
+    def to_s
+        if self.title =~ /\[/
+            return self.title
+        else
+            return "component(%s)" % self.title
         end
-	end
+    end
 end
 
-# $Id: component.rb 2052 2007-01-05 17:09:04Z luke $
+# $Id: component.rb 2499 2007-05-09 21:30:44Z luke $