puppet 0.18.4 → 0.22.4

data/lib/puppet/sslcertificates/certificate.rb

@@ -93,7 +93,7 @@ class Puppet::SSLCertificates::Certificate
             end
         }
 
-        @days = hash[:length] || 365
+        @ttl = hash[:ttl] || 365 * 24 * 60 * 60
         @selfsign = hash[:selfsign] || false
         @encrypt = hash[:encrypt] || false
         @replace = hash[:replace] || false
@@ -206,7 +206,7 @@ class Puppet::SSLCertificates::Certificate
 
         args = {
             :name => self.certname,
-            :days => @days,
+            :ttl => @ttl,
             :issuer => nil,
             :serial => 0x0,
             :publickey => @key.public_key
@@ -280,4 +280,4 @@ class Puppet::SSLCertificates::Certificate
     end
 end
 
-# $Id: certificate.rb 873 2006-02-07 23:12:33Z luke $
+# $Id: certificate.rb 1581 2006-09-13 16:50:43Z lutter $

data/lib/puppet/sslcertificates/inventory.rb

@@ -0,0 +1,53 @@
+# A module for keeping track of all the certificates issued by the CA, ever
+# Maintains the file "$cadir/inventory.txt"
+module Puppet::SSLCertificates
+    module Inventory
+
+        Puppet.config.setdefaults(:ca,
+            :cert_inventory => {
+                :default => "$cadir/inventory.txt",
+                :mode => 0644,
+                :owner => "$user",
+                :group => "$group",
+                :desc => "A Complete listing of all certificates"
+            }
+        )
+
+        # Add CERT to the inventory of issued certs in '$cadir/inventory.txt'
+        # If no inventory exists yet, build an inventory and list all the 
+        # certificates that have been signed so far
+        def self.add(cert)
+            unless FileTest.exists?(Puppet[:cert_inventory])
+                inited = false
+            end
+
+            Puppet.config.write(:cert_inventory, "a") do |f|
+                unless inited
+                    f.puts self.init
+                end
+                f.puts format(cert)
+            end
+        end
+
+        private
+
+        def self.init
+            inv = "# Inventory of signed certificates\n"
+            inv += "# SERIAL NOT_BEFORE NOT_AFTER SUBJECT\n"
+            Dir.glob(File::join(Puppet[:signeddir], "*.pem")) do |f|
+                inv += format(OpenSSL::X509::Certificate.new(File::read(f))) + "\n"
+            end
+            return inv
+        end
+
+        def self.format(cert)
+            iso = '%Y-%m-%dT%H:%M:%S%Z'
+            return "0x%04x %s %s %s" % [cert.serial,  
+                                        cert.not_before.strftime(iso), 
+                                        cert.not_after.strftime(iso),
+                                        cert.subject]
+        end
+    end
+end
+
+# $Id$

data/lib/puppet/sslcertificates/support.rb

@@ -0,0 +1,128 @@
+require 'puppet/sslcertificates'
+
+# A module to handle reading of certificates.
+module Puppet::SSLCertificates::Support
+    class MissingCertificate < Puppet::Error; end
+    class InvalidCertificate < Puppet::Error; end
+
+    attr_reader :cacert
+
+    # Some metaprogramming to create methods for retrieving and creating keys.
+    # This probably isn't fewer lines than defining each separately...
+    def self.keytype(name, options, &block)
+        var = "@%s" % name
+
+        maker = "mk_%s" % name
+        reader = "read_%s" % name
+
+        unless param = options[:param]
+            raise ArgumentError, "You must specify the parameter for the key"
+        end
+
+        unless klass = options[:class]
+            raise ArgumentError, "You must specify the class for the key"
+        end
+
+        # Define the method that creates it.
+        define_method(maker, &block)
+
+        # Define the reading method.
+        define_method(reader) do
+            return nil unless FileTest.exists?(Puppet[param])
+            begin
+                instance_variable_set(var,
+                    klass.new(File.read(Puppet[param])))
+            rescue => detail
+                raise InvalidCertificate, "Could not read %s: %s" %
+                    [param, detail]
+            end
+        end
+
+        # Define the overall method, which just calls the reader and maker
+        # as appropriate.
+        define_method(name) do
+            unless instance_variable_get(var)
+                unless cert = send(reader)
+                    cert = send(maker)
+                    Puppet.config.write(param) { |f| f.puts cert.to_pem }
+                end
+                instance_variable_set(var, cert)
+            end
+            instance_variable_get(var)
+        end
+    end
+
+    # The key pair.
+    keytype :key, :param => :hostprivkey, :class => OpenSSL::PKey::RSA do
+        Puppet.info "Creating a new SSL key at %s" % Puppet[:hostprivkey]
+        key = OpenSSL::PKey::RSA.new(Puppet[:keylength])
+
+        # Our key meta programming can only handle one file, so we have
+        # to separately write out the public key.
+        Puppet.config.write(:hostpubkey) do |f|
+            f.print key.public_key.to_pem
+        end
+        return key
+    end
+
+    # Our certificate request
+    keytype :csr, :param => :hostcsr, :class => OpenSSL::X509::Request do
+        Puppet.info "Creating a new certificate request for %s" %
+            Puppet[:certname]
+
+        csr = OpenSSL::X509::Request.new
+        csr.version = 0
+        csr.subject = OpenSSL::X509::Name.new([["CN", Puppet[:certname]]])
+        csr.public_key = key.public_key
+        csr.sign(key, OpenSSL::Digest::MD5.new)
+
+        return csr
+    end
+
+    keytype :cert, :param => :hostcert, :class => OpenSSL::X509::Certificate do
+        raise MissingCertificate, "No host certificate"
+    end
+
+    keytype :ca_cert, :param => :localcacert, :class => OpenSSL::X509::Certificate do
+        raise MissingCertificate, "No CA certificate"
+    end
+
+    # Request a certificate from the remote system.  This does all of the work
+    # of creating the cert request, contacting the remote system, and
+    # storing the cert locally.
+    def requestcert
+        begin
+            cert, cacert = caclient.getcert(@csr.to_pem)
+        rescue => detail
+            if Puppet[:trace]
+                puts detail.backtrace
+            end
+            raise Puppet::Error.new("Certificate retrieval failed: %s" %
+                detail)
+        end
+
+        if cert.nil? or cert == ""
+            return nil
+        end
+        Puppet.config.write(:hostcert) do |f| f.print cert end
+        Puppet.config.write(:localcacert) do |f| f.print cacert end
+        #File.open(@certfile, "w", 0644) { |f| f.print cert }
+        #File.open(@cacertfile, "w", 0644) { |f| f.print cacert }
+        begin
+            @cert = OpenSSL::X509::Certificate.new(cert)
+            @cacert = OpenSSL::X509::Certificate.new(cacert)
+            retrieved = true
+        rescue => detail
+            raise Puppet::Error.new(
+                "Invalid certificate: %s" % detail
+            )
+        end
+
+        unless @cert.check_private_key(@key)
+            raise Puppet::DevError, "Received invalid certificate"
+        end
+        return retrieved
+    end
+end
+
+# $Id: support.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/transaction.rb

@@ -1,19 +1,33 @@
-# the class that actually walks our object/state tree, collects the changes,
+# the class that actually walks our resource/property tree, collects the changes,
 # and performs them
 
 require 'puppet'
-require 'puppet/statechange'
+require 'puppet/propertychange'
 
 module Puppet
 class Transaction
-    attr_accessor :component, :objects, :tags, :ignoreschedules
+    attr_accessor :component, :resources, :ignoreschedules, :ignoretags
+    attr_accessor :relgraph, :sorted_resources, :configurator
+
+    attr_reader :report
+    
+    attr_writer :tags
 
     include Puppet::Util
 
+    Puppet.config.setdefaults(:puppet,
+        :graph => [false, "Whether to create dot graph files for the different
+            configuration graphs.  These dot files can be interpreted by tools
+            like OmniGraffle or dot (which is part of ImageMagick)."],
+        :graphdir => ["$statedir/graphs", "Where to store dot-outputted graphs."]
+    )
     Puppet.config.setdefaults(:transaction,
-        :tags => ["", "Tags to use to find objects.  If this is set, then
-            only objects tagged with the specified tags will be applied.
-            Values must be comma-separated."]
+        :tags => ["", "Tags to use to find resources.  If this is set, then
+            only resources tagged with the specified tags will be applied.
+            Values must be comma-separated."],
+        :evaltrace => [false, "Whether each resource should log when it is
+            being evaluated.  This allows you to interactively see exactly
+            what is being done."]
     )
 
     # Add some additional times for reporting
@@ -23,50 +37,78 @@ class Transaction
         end
     end
 
-    # Apply all changes for a child, returning a list of the events
-    # generated.
-    def apply(child)
-        # First make sure there are no failed dependencies
-        child.eachdependency do |dep|
-            skip = false
-            if @failures[dep] > 0
-                child.notice "Dependency %s[%s] has %s failures" %
-                    [dep.class.name, dep.name, @failures[dep]]
-                skip = true
-            end
-
-            if skip
-                child.warning "Skipping because of failed dependencies"
-                @objectmetrics[:skipped] += 1
-                return []
+    # Check to see if we should actually allow deleition.
+    def allow_processing?(resource, changes)
+        # If a resource is going to be deleted but it still has
+        # dependencies, then don't delete it unless it's implicit or the
+        # dependency is itself being deleted.
+        if resource.purging? and resource.deleting?
+            if deps = @relgraph.dependents(resource) and ! deps.empty? and deps.detect { |d| ! d.deleting? }
+                resource.warning "%s still depend%s on me -- not purging" %
+                    [deps.collect { |r| r.ref }.join(","), deps.length > 1 ? "":"s"] 
+                return false
             end
         end
 
+        return true
+    end
+
+    # Apply all changes for a resource, returning a list of the events
+    # generated.
+    def apply(resource)
         begin
-            changes = child.evaluate
+            changes = resource.evaluate
         rescue => detail
-            if Puppet[:debug]
+            if Puppet[:trace]
                 puts detail.backtrace
             end
 
-            child.err "Failed to retrieve current state: %s" % detail
+            resource.err "Failed to retrieve current state of resource: %s" % detail
 
             # Mark that it failed
-            @failures[child] += 1
+            @failures[resource] += 1
 
             # And then return
             return []
         end
 
-        unless changes.is_a? Array
-            changes = [changes]
-        end
+        changes = [changes] unless changes.is_a?(Array)
 
         if changes.length > 0
-            @objectmetrics[:out_of_sync] += 1
+            @resourcemetrics[:out_of_sync] += 1
         end
 
-        childevents = changes.collect { |change|
+        return [] if changes.empty? or ! allow_processing?(resource, changes)
+
+        resourceevents = apply_changes(resource, changes)
+
+        # If there were changes and the resource isn't in noop mode...
+        unless changes.empty? or changes.include?(:noop)
+            # Record when we last synced
+            resource.cache(:synced, Time.now)
+
+            # Flush, if appropriate
+            if resource.respond_to?(:flush)
+                resource.flush
+            end
+            
+            # And set a trigger for refreshing this resource if it's a
+            # self-refresher
+            if resource.self_refresh? and ! resource.deleting?
+                # Create an edge with this resource as both the source and
+                # target.  The triggering method treats these specially for
+                # logging.
+                events = resourceevents.collect { |e| e.event }
+                set_trigger(Puppet::Relationship.new(resource, resource, :callback => :refresh, :event => events))
+            end
+        end
+
+        resourceevents
+    end
+
+    # Apply each change in turn.
+    def apply_changes(resource, changes)
+        changes.collect { |change|
             @changes << change
             @count += 1
             change.transaction = self
@@ -76,9 +118,12 @@ class Transaction
                 # event if they want
                 events = [change.forward].flatten.reject { |e| e.nil? }
             rescue => detail
-                change.state.err "change from %s to %s failed: %s" %
-                    [change.state.is_to_s, change.state.should_to_s, detail]
-                @failures[child] += 1
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                change.property.err "change from %s to %s failed: %s" %
+                    [change.property.is_to_s, change.property.should_to_s, detail]
+                @failures[resource] += 1
                 next
                 # FIXME this should support using onerror to determine
                 # behaviour; or more likely, the client calling us
@@ -87,46 +132,164 @@ class Transaction
 
             # Mark that our change happened, so it can be reversed
             # if we ever get to that point
-            unless events.nil? or (events.is_a?(Array) and events.empty?)
+            unless events.nil? or (events.is_a?(Array) and (events.empty?) or events.include?(:noop))
                 change.changed = true
-                @objectmetrics[:applied] += 1
+                @resourcemetrics[:applied] += 1
             end
 
             events
         }.flatten.reject { |e| e.nil? }
-
-        unless changes.empty?
-            # Record when we last synced
-            child.cache(:synced, Time.now)
-        end
-
-        childevents
     end
 
-    # Find all of the changed objects.
+    # Find all of the changed resources.
     def changed?
         @changes.find_all { |change| change.changed }.collect { |change|
-            change.state.parent
+            change.property.parent
         }.uniq
     end
+    
+    # Do any necessary cleanup.  If we don't get rid of the graphs, the
+    # contained resources might never get cleaned up.
+    def cleanup
+        if defined? @generated
+            @generated.each do |resource|
+                resource.remove
+            end
+        end
+        if defined? @relgraph
+            @relgraph.clear
+        end
+        @resources.clear
+    end
+
+    # Copy an important relationships from the parent to the newly-generated
+    # child resource.
+    def copy_relationships(resource, children)
+        depthfirst = resource.depthfirst?
+        
+        children.each do |gen_child|
+            if depthfirst
+                edge = [gen_child, resource]
+            else
+                edge = [resource, gen_child]
+            end
+            unless @relgraph.edge?(edge[1], edge[0])
+                @relgraph.add_edge!(*edge)
+            else
+                @relgraph.add_vertex!(gen_child)
+                resource.debug "Skipping automatic relationship to %s" % gen_child
+            end
+        end
+    end
+
+    # Are we deleting this resource?
+    def deleting?(changes)
+        changes.detect { |change|
+            change.property.name == :ensure and change.should == :absent
+        }
+    end
+
+    # See if the resource generates new resources at evaluation time.
+    def eval_generate(resource)
+        if resource.respond_to?(:eval_generate)
+            begin
+                children = resource.eval_generate
+            rescue => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                resource.err "Failed to generate additional resources during transaction: %s" %
+                    detail
+                return nil
+            end
+            
+            if children
+                children.each do |child|
+                    child.finish
+                    # Make sure that the vertex is in the relationship graph.
+                    @relgraph.add_vertex!(child)
+                end
+                @generated += children
+                return children
+            end
+        end
+    end
+    
+    # Evaluate a single resource.
+    def eval_resource(resource, checkskip = true)
+        events = []
+        
+        if resource.is_a?(Puppet::Type::Component)
+            raise Puppet::DevError, "Got a component to evaluate"
+        end
+        
+        if checkskip and skip?(resource)
+            @resourcemetrics[:skipped] += 1
+        else
+            @resourcemetrics[:scheduled] += 1
+            
+            changecount = @changes.length
+            
+            # We need to generate first regardless, because the recursive
+            # actions sometimes change how the top resource is applied.
+            children = eval_generate(resource)
+            
+            if children and resource.depthfirst?
+                children.each do |child|
+                    # The child will never be skipped when the parent isn't
+                    events += eval_resource(child, false)
+                end
+            end
+
+            # Perform the actual changes
+            seconds = thinmark do
+                events += apply(resource)
+            end
 
-    # Collect all of the targets for the list of events.  This is an unintuitive
-    # method because it recurses up through the source the event.
-    def collecttargets(events)
-        events.each do |event|
-            source = event.source
-            start = source
-
-            while source
-                Puppet::Event::Subscription.targets_of(event, source) do |sub|
-                    start.info "Scheduling %s of %s[%s]" %
-                        [sub.callback, sub.target.class.name, sub.target.name]
-                    @targets[sub.target][event] = sub
+            if children and ! resource.depthfirst?
+                children.each do |child|
+                    events += eval_resource(child, false)
                 end
+            end
 
-                source = source.parent
+            # Create a child/parent relationship.  We do this after everything else because
+            # we want explicit relationships to be able to override automatic relationships,
+            # including this one.
+            if children
+                copy_relationships(resource, children)
+            end
+            
+            # A bit of hackery here -- if skipcheck is true, then we're the
+            # top-level resource.  If that's the case, then make sure all of
+            # the changes list this resource as a proxy.  This is really only
+            # necessary for rollback, since we know the generating resource
+            # during forward changes.
+            if children and checkskip
+                @changes[changecount..-1].each { |change| change.proxy = resource }
             end
+
+            # Keep track of how long we spend in each type of resource
+            @timemetrics[resource.class.name] += seconds
         end
+
+        # Check to see if there are any events for this resource
+        if triggedevents = trigger(resource)
+            events += triggedevents
+        end
+
+        # Collect the targets of any subscriptions to those events.  We pass
+        # the parent resource in so it will override the source in the events,
+        # since eval_generated children can't have direct relationships.
+        @relgraph.matching_edges(events, resource).each do |edge|
+            edge = edge.dup
+            label = edge.label
+            label[:event] = events.collect { |e| e.event }
+            edge.label = label
+            set_trigger(edge)
+        end
+
+        # And return the events for collection
+        events
     end
 
     # This method does all the actual work of running a transaction.  It
@@ -134,54 +297,33 @@ class Transaction
     # necessary events.
     def evaluate
         @count = 0
-
-        # Allow the tags to be overriden
-        tags = self.tags || Puppet[:tags]
-        if tags.nil? or tags == ""
-            tags = nil
-        else
-            tags = [tags] unless tags.is_a? Array
-            tags = tags.collect do |tag|
-                tag.split(/\s*,\s*/)
-            end.flatten
-        end
-
+        
+        graph(@resources, :resources)
+        
         # Start logging.
-        Puppet::Log.newdestination(@report)
+        Puppet::Util::Log.newdestination(@report)
+        
+        prepare()
 
         begin
-            allevents = @objects.collect { |child|
-                events = nil
-                if (tags.nil? or child.tagged?(tags))
-                    if self.ignoreschedules or child.scheduled?
-                        @objectmetrics[:scheduled] += 1
-                        # Perform the actual changes
-
-                        seconds = thinmark do
-                            events = apply(child)
-                        end
-
-                        # Keep track of how long we spend in each type of object
-                        @timemetrics[child.class.name] += seconds
-
-                        # Collect the targets of any subscriptions to those events
-                        collecttargets(events)
-                    else
-                        child.debug "Not scheduled"
-                    end
-                else
-                    child.debug "Not tagged with %s" % tags.join(", ")
+            allevents = @sorted_resources.collect { |resource|
+                if resource.is_a?(Puppet::Type::Component)
+                    Puppet.warning "Somehow left a component in the relationship graph"
+                    next
+                end
+                ret = nil
+                seconds = thinmark do
+                    ret = eval_resource(resource)
                 end
 
-                # Now check to see if there are any events for this child
-                trigger(child)
-
-                # And return the events for collection
-                events
+                if Puppet[:evaltrace]
+                    resource.info "Evaluated in %0.2f seconds" % seconds
+                end
+                ret
             }.flatten.reject { |e| e.nil? }
         ensure
             # And then close the transaction log.
-            Puppet::Log.close(@report)
+            Puppet::Util::Log.close(@report)
         end
 
         Puppet.debug "Finishing transaction %s with %s changes" %
@@ -190,54 +332,74 @@ class Transaction
         allevents
     end
 
-    # Determine whether a given object has failed.
+    # Determine whether a given resource has failed.
     def failed?(obj)
-        @failures[obj] > 0
+        if @failures[obj] > 0
+            return @failures[obj]
+        else
+            return false
+        end
     end
 
-    # this should only be called by a Puppet::Container object now
-    # and it should only receive an array
-    def initialize(objects)
-        @objects = objects
-
-        @objectmetrics = {
-            :total => @objects.length,
-            :out_of_sync => 0,    # The number of objects that had changes
-            :applied => 0,        # The number of objects fixed
-            :skipped => 0,      # The number of objects skipped
-            :restarted => 0,    # The number of objects triggered
-            :failed_restarts => 0, # The number of objects that fail a trigger
-            :scheduled => 0     # The number of objects scheduled
-        }
-
-        # Metrics for distributing times across the different types.
-        @timemetrics = Hash.new(0)
-
-        # The number of objects that were triggered in this run
-        @triggered = Hash.new { |hash, key|
-            hash[key] = Hash.new(0)
-        }
-
-        # Targets of being triggered.
-        @targets = Hash.new do |hash, key|
-            hash[key] = {}
+    # Does this resource have any failed dependencies?
+    def failed_dependencies?(resource)
+        # First make sure there are no failed dependencies.  To do this,
+        # we check for failures in any of the vertexes above us.  It's not
+        # enough to check the immediate dependencies, which is why we use
+        # a tree from the reversed graph.
+        skip = false
+        deps = @relgraph.dependencies(resource)
+        deps.each do |dep|
+            if fails = failed?(dep)
+                resource.notice "Dependency %s[%s] has %s failures" %
+                    [dep.class.name, dep.name, @failures[dep]]
+                skip = true
+            end
         end
-
-        # The changes we're performing
-        @changes = []
-
-        # The objects that have failed and the number of failures each.  This
-        # is used for skipping objects because of failed dependencies.
-        @failures = Hash.new do |h, key|
-            h[key] = 0
+        
+        return skip
+    end
+    
+    # Collect any dynamically generated resources.
+    def generate
+        list = @resources.vertices
+        
+        # Store a list of all generated resources, so that we can clean them up
+        # after the transaction closes.
+        @generated = []
+        
+        newlist = []
+        while ! list.empty?
+            list.each do |resource|
+                if resource.respond_to?(:generate)
+                    begin
+                        made = resource.generate
+                    rescue => detail
+                        resource.err "Failed to generate additional resources: %s" %
+                            detail
+                    end
+                    next unless made
+                    unless made.is_a?(Array)
+                        made = [made]
+                    end
+                    made.uniq!
+                    made.each do |res|
+                        @resources.add_vertex!(res)
+                        newlist << res
+                        @generated << res
+                        res.finish
+                    end
+                end
+            end
+            list.clear
+            list = newlist
+            newlist = []
         end
-
-        @report = Report.new
     end
 
     # Generate a transaction report.
-    def report
-        @objectmetrics[:failed] = @failures.find_all do |name, num|
+    def generate_report
+        @resourcemetrics[:failed] = @failures.find_all do |name, num|
             num > 0
         end.length
 
@@ -257,10 +419,10 @@ class Transaction
             end
         end
 
-        # Add all of the metrics related to object count and status
-        @report.newmetric(:objects, @objectmetrics)
+        # Add all of the metrics related to resource count and status
+        @report.newmetric(:resources, @resourcemetrics)
 
-        # Record the relative time spent in each object.
+        # Record the relative time spent in each resource.
         @report.newmetric(:time, @timemetrics)
 
         # Then all of the change-related metrics
@@ -273,6 +435,133 @@ class Transaction
         return @report
     end
 
+    # Produce the graph files if requested.
+    def graph(gr, name)
+        # We don't want to graph the configuration process.
+        return if self.configurator
+        
+        return unless Puppet[:graph]
+
+        file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s)
+        File.open(file, "w") { |f|
+            f.puts gr.to_dot("name" => name.to_s.capitalize)
+        }
+    end
+
+    # this should only be called by a Puppet::Type::Component resource now
+    # and it should only receive an array
+    def initialize(resources)
+        if resources.is_a?(Puppet::PGraph)
+            @resources = resources
+        else
+            @resources = resources.to_graph
+        end
+
+        @resourcemetrics = {
+            :total => @resources.vertices.length,
+            :out_of_sync => 0,    # The number of resources that had changes
+            :applied => 0,        # The number of resources fixed
+            :skipped => 0,      # The number of resources skipped
+            :restarted => 0,    # The number of resources triggered
+            :failed_restarts => 0, # The number of resources that fail a trigger
+            :scheduled => 0     # The number of resources scheduled
+        }
+
+        # Metrics for distributing times across the different types.
+        @timemetrics = Hash.new(0)
+
+        # The number of resources that were triggered in this run
+        @triggered = Hash.new { |hash, key|
+            hash[key] = Hash.new(0)
+        }
+
+        # Targets of being triggered.
+        @targets = Hash.new do |hash, key|
+            hash[key] = []
+        end
+
+        # The changes we're performing
+        @changes = []
+
+        # The resources that have failed and the number of failures each.  This
+        # is used for skipping resources because of failed dependencies.
+        @failures = Hash.new do |h, key|
+            h[key] = 0
+        end
+
+        @report = Report.new
+        @count = 0
+    end
+
+    # Prefetch any providers that support it.  We don't support prefetching
+    # types, just providers.
+    def prefetch
+        @resources.collect { |obj|
+            if pro = obj.provider
+                pro.class
+            else
+                nil
+            end
+        }.reject { |o| o.nil? }.uniq.each do |klass|
+            # XXX We need to do something special here in case of failure.
+            if klass.respond_to?(:prefetch)
+                klass.prefetch
+            end
+        end
+    end
+    
+    # Prepare to evaluate the elements in a transaction.
+    def prepare
+        prefetch()
+    
+        # Now add any dynamically generated resources
+        generate()
+    
+        # Create a relationship graph from our resource graph
+        @relgraph = relationship_graph
+        
+        @sorted_resources = @relgraph.topsort
+
+        # Now make sure no cycles crept into our graph.
+        @relgraph.check_cycle(@sorted_resources)
+    end
+    
+    # Create a graph of all of the relationships in our resource graph.
+    def relationship_graph
+        graph = Puppet::PGraph.new
+        
+        # First create the dependency graph
+        @resources.vertices.each do |vertex|
+            graph.add_vertex!(vertex)
+            vertex.builddepends.each do |edge|
+                graph.add_edge!(edge)
+            end
+        end
+        
+        # Lastly, add in any autorequires
+        graph.vertices.each do |vertex|
+            vertex.autorequire.each do |edge|
+                unless graph.edge?(edge)
+                    unless graph.edge?(edge.target, edge.source)
+                        vertex.debug "Autorequiring %s" % [edge.source]
+                        graph.add_edge!(edge)
+                    else
+                        vertex.debug "Skipping automatic relationship with %s" % (edge.source == vertex ? edge.target : edge.source)
+                    end
+                end
+            end
+        end
+        
+        graph(graph, :relationships)
+        
+        # Then splice in the container information
+        graph.splice!(@resources, Puppet::Type::Component)
+
+        graph(graph, :expanded_relationships)
+        
+        return graph
+    end
+
     # Roll all completed changes back.
     def rollback
         @targets.clear
@@ -287,92 +576,182 @@ class Transaction
                 events = change.backward
             rescue => detail
                 Puppet.err("%s rollback failed: %s" % [change,detail])
-                if Puppet[:debug]
+                if Puppet[:trace]
                     puts detail.backtrace
                 end
                 next
                 # at this point, we would normally do error handling
                 # but i haven't decided what to do for that yet
-                # so just record that a sync failed for a given object
-                #@@failures[change.state.parent] += 1
+                # so just record that a sync failed for a given resource
+                #@@failures[change.property.parent] += 1
                 # this still could get hairy; what if file contents changed,
                 # but a chmod failed?  how would i handle that error? dern
             end
-
-            collecttargets(events)
+            
+            # FIXME This won't work right now.
+            @relgraph.matching_edges(events).each do |edge|
+                @targets[edge.target] << edge
+            end
 
             # Now check to see if there are any events for this child.
             # Kind of hackish, since going backwards goes a change at a
             # time, not a child at a time.
-            trigger(change.state.parent)
+            trigger(change.property.parent)
 
             # And return the events for collection
             events
         }.flatten.reject { |e| e.nil? }
     end
+    
+    # Is the resource currently scheduled?
+    def scheduled?(resource)
+        self.ignoreschedules or resource.scheduled?
+    end
+
+    # Set an edge to be triggered when we evaluate its target.
+    def set_trigger(edge)
+        return unless method = edge.callback
+        return unless edge.target.respond_to?(method)
+        if edge.target.respond_to?(:ref)
+            unless edge.source == edge.target
+                edge.source.info "Scheduling %s of %s" % [edge.callback, edge.target.ref]
+            end
+        end
+        @targets[edge.target] << edge
+    end
+    
+    # Should this resource be skipped?
+    def skip?(resource)
+        skip = false
+        if ! tagged?(resource)
+            resource.debug "Not tagged with %s" % tags.join(", ")
+        elsif ! scheduled?(resource)
+            resource.debug "Not scheduled"
+        elsif failed_dependencies?(resource)
+            resource.warning "Skipping because of failed dependencies"
+        else
+            return false
+        end
+        return true
+    end
+    
+    # The tags we should be checking.
+    def tags
+        # Allow the tags to be overridden
+        unless defined? @tags
+            @tags = Puppet[:tags]
+        end
+        
+        unless defined? @processed_tags
+            if @tags.nil? or @tags == ""
+                @tags = []
+            else
+                @tags = [@tags] unless @tags.is_a? Array
+                @tags = @tags.collect do |tag|
+                    tag.split(/\s*,\s*/)
+                end.flatten
+            end
+            @processed_tags = true
+        end
+        
+        @tags
+    end
+    
+    # Is this resource tagged appropriately?
+    def tagged?(resource)
+        self.ignoretags or tags.empty? or resource.tagged?(tags)
+    end
+    
+    # Are there any edges that target this resource?
+    def targeted?(resource)
+        # The default value is a new array so we have to test the length of it.
+        @targets.include?(resource) and @targets[resource].length > 0
+    end
 
     # Trigger any subscriptions to a child.  This does an upwardly recursive
-    # search -- it triggers the passed object, but also the object's parent
+    # search -- it triggers the passed resource, but also the resource's parent
     # and so on up the tree.
-    def trigger(child)
-        obj = child
+    def trigger(resource)
+        return nil unless targeted?(resource)
         callbacks = Hash.new { |hash, key| hash[key] = [] }
-        sources = Hash.new { |hash, key| hash[key] = [] }
-
-        while obj
-            if @targets.include?(obj)
-                callbacks.clear
-                sources.clear
-                @targets[obj].each do |event, sub|
-                    # Collect all of the subs for each callback
-                    callbacks[sub.callback] << sub
-
-                    # And collect the sources for logging
-                    sources[event.source] << sub.callback
-                end
 
-                sources.each do |source, callbacklist|
-                    obj.debug "%s[%s] results in triggering %s" %
-                        [source.class.name, source.name, callbacklist.join(", ")]
+        trigged = []
+        @targets[resource].each do |edge|
+            # Collect all of the subs for each callback
+            callbacks[edge.callback] << edge
+        end
+
+        callbacks.each do |callback, subs|
+            noop = true
+            subs.each do |edge|
+                if edge.event.nil? or ! edge.event.include?(:noop)
+                    noop = false
                 end
+            end
 
-                callbacks.each do |callback, subs|
-                    obj.info "Triggering '%s' from %s dependencies" %
-                        [callback, subs.length]
-                    # At this point, just log failures, don't try to react
-                    # to them in any way.
-                    begin
-                        obj.send(callback)
-                        @objectmetrics[:restarted] += 1
-                    rescue => detail
-                        obj.err "Failed to call %s on %s: %s" %
-                            [callback, obj, detail]
+            if noop
+                resource.notice "Would have triggered %s from %s dependencies" %
+                    [callback, subs.length]
 
-                        @objectmetrics[:failed_restarts] += 1
+                # And then add an event for it.
+                return [Puppet::Event.new(
+                    :event => :noop,
+                    :transaction => self,
+                    :source => resource
+                )]
+            end
 
-                        if Puppet[:debug]
-                            puts detail.backtrace
-                        end
-                    end
+            if subs.length == 1 and subs[0].source == resource
+                message = "Refreshing self"
+            else
+                message = "Triggering '%s' from %s dependencies" %
+                    [callback, subs.length]
+            end
+            resource.notice message
+            
+            # At this point, just log failures, don't try to react
+            # to them in any way.
+            begin
+                resource.send(callback)
+                @resourcemetrics[:restarted] += 1
+            rescue => detail
+                resource.err "Failed to call %s on %s: %s" %
+                    [callback, resource, detail]
+
+                @resourcemetrics[:failed_restarts] += 1
 
-                    triggered(obj, callback)
+                if Puppet[:trace]
+                    puts detail.backtrace
                 end
             end
 
-            obj = obj.parent
+            # And then add an event for it.
+            trigged << Puppet::Event.new(
+                :event => :triggered,
+                :transaction => self,
+                :source => resource
+            )
+
+            triggered(resource, callback)
+        end
+
+        if trigged.empty?
+            return nil
+        else
+            return trigged
         end
     end
 
-    def triggered(object, method)
-        @triggered[object][method] += 1
+    def triggered(resource, method)
+        @triggered[resource][method] += 1
     end
 
-    def triggered?(object, method)
-        @triggered[object][method]
+    def triggered?(resource, method)
+        @triggered[resource][method]
     end
 end
 end
 
 require 'puppet/transaction/report'
 
-# $Id: transaction.rb 1351 2006-07-01 17:27:54Z luke $
+# $Id: transaction.rb 2372 2007-03-30 00:47:03Z luke $