puppet 0.16.0 → 0.18.4

data/lib/puppet/server/runner.rb

@@ -0,0 +1,62 @@
+module Puppet
+class Server
+    class MissingMasterError < RuntimeError # Cannot find the master client
+    end
+    # A simple server for triggering a new run on a Puppet client.
+    class Runner < Handler
+        @interface = XMLRPC::Service::Interface.new("puppetrunner") { |iface|
+            iface.add_method("string run(string, string)")
+        }
+
+        # Run the client configuration right now, optionally specifying
+        # tags and whether to ignore schedules
+        def run(tags = [], ignoreschedules = false, fg = true, client = nil, clientip = nil)
+            # We need to retrieve the client
+            master = Puppet::Client::MasterClient.instance
+
+            unless master
+                raise MissingMasterError, "Could not find the master client"
+            end
+
+            if master.locked?
+                Puppet.notice "Could not trigger run; already running"
+                return "running"
+            end
+
+            if tags == ""
+                tags = nil
+            end
+
+            if ignoreschedules == ""
+                ignoreschedules == nil
+            end
+
+            if client
+                msg = "%s(%s) triggered run" % [client, clientip]
+                if tags
+                    msg += " with tags %s" % tags.join(", ")
+                end
+
+                if ignoreschedules
+                    msg += " without schedules"
+                end
+
+                Puppet.notice msg
+            end
+
+            # And then we need to tell it to run, with this extra info.
+            if fg
+                master.run(tags, ignoreschedules)
+            else
+                Puppet.newthread do
+                    master.run(tags, ignoreschedules)
+                end
+            end
+
+            return "success"
+        end
+    end
+end
+end
+
+# $Id: runner.rb 1325 2006-06-28 15:17:56Z luke $

data/lib/puppet/server/servlet.rb

@@ -38,25 +38,44 @@ class Server
         def authorize(request, method)
             namespace = method.sub(/\..+/, '')
             client = request.peeraddr[2]
+            if defined? @client and @client
+                client = @client
+            end
             ip = request.peeraddr[3]
             if request.client_cert
+                begin
                 if @puppetserver.authconfig.exists?
-                    return @puppetserver.authconfig.allowed?(method, client, ip)
+                    allowed = @puppetserver.authconfig.allowed?(method, client, ip)
+
+                    if allowed
+                        Puppet.info "Allowing %s(%s) trusted access to %s" %
+                            [client, ip, method]
+                        return true
+                    else
+                        Puppet.info "Denying %s(%s) trusted access to %s" %
+                            [client, ip, method]
+                        return false
+                    end
                 else
                     # This is pretty hackish, but...
                     # This means we can't actually test this method at this point.
                     # The next release of Puppet will almost definitely require
                     # this file to exist or will default to denying all access.
                     if Puppet.name == "puppetmasterd" or defined? Test::Unit::TestCase
-                        Servlet.log "Allowing %s(%s) trusted access to %s" %
+                        Puppet.info "Allowing %s(%s) trusted access to %s" %
                             [client, ip, method]
                         return true
                     else
-                        Servlet.log "Denying %s(%s) trusted access to %s on %s" %
+                        Puppet.info "Denying %s(%s) trusted access to %s on %s" %
                             [client, ip, method, Puppet.name]
                         return false
                     end
                 end
+                rescue => detail
+                    puts detail
+                    puts detail.backtrace
+                    raise
+                end
             else
                 if method =~ /^puppetca\./
                     Puppet.notice "Allowing %s(%s) untrusted access to CA methods" %
@@ -84,6 +103,7 @@ class Server
 
         def initialize(server, handlers)
             @puppetserver = server
+            @notified = {}
             # the servlet base class does not consume any arguments
             # and its BasicServer base class only accepts a 'class_delim'
             # option which won't change in Puppet at all
@@ -106,10 +126,8 @@ class Server
             @clientip = nil
 
             self.set_service_hook { |obj, *args|
-                #raise "crap!"
                 if @client and @clientip
                     args.push(@client, @clientip)
-                    #obj.call(args, @request)
                 end
                 begin
                     obj.call(*args)
@@ -173,10 +191,6 @@ class Server
                     end
                 end
             end
-            #if request.server_cert
-            #    Puppet.info "server cert is %s" % @request.server_cert
-            #end
-            #p @request
             begin
                 super
             rescue => detail

data/lib/puppet/sslcertificates/ca.rb

@@ -70,6 +70,30 @@ class Puppet::SSLCertificates::CA
         @config[:cacert]
     end
 
+    # Remove all traces of a given host.  This is kind of hackish, but, eh.
+    def clean(host)
+        [:csrdir, :signeddir, :publickeydir, :privatekeydir, :certdir].each do |name|
+            dir = Puppet[name]
+
+            file = File.join(dir, host + ".pem")
+
+            if FileTest.exists?(file)
+                begin
+                    if Puppet.name == "puppetca"
+                        puts "Removing %s" % file
+                    else
+                        Puppet.info "Removing %s" % file
+                    end
+                    File.unlink(file)
+                rescue => detail
+                    raise Puppet::Error, "Could not delete %s: %s" %
+                        [file, detail]
+                end
+            end
+            
+        end
+    end
+
     def host2csrfile(hostname)
         File.join(Puppet[:csrdir], [hostname, "pem"].join("."))
     end
@@ -330,4 +354,4 @@ class Puppet::SSLCertificates::CA
     end
 end
 
-# $Id: ca.rb 1117 2006-04-19 15:35:04Z luke $
+# $Id: ca.rb 1145 2006-04-28 04:08:38Z luke $

data/lib/puppet/statechange.rb

@@ -7,6 +7,9 @@ module Puppet
     # including calling 'sync' on the states and producing events.
 	class StateChange
         attr_accessor :is, :should, :type, :path, :state, :transaction, :changed
+        
+        # The log file generated when this object was changed.
+        attr_reader :report
 
         def initialize(state)
             @state = state
@@ -32,7 +35,7 @@ module Puppet
             end
 
             if @state.noop
-                @state.log "is %s, should be %s" %
+                @state.log "is %s, should be %s (noop)" %
                     [state.is_to_s, state.should_to_s]
                 #@state.debug "%s is noop" % @state
                 return nil
@@ -41,64 +44,42 @@ module Puppet
             #@state.info "Is: %s, Should: %s" %
             #    [@state.is.inspect, @state.should.inspect]
 
-            begin
-                events = @state.sync
-                if events.nil?
-                    return nil
-                end
+            # The transaction catches any exceptions here.
+            events = @state.sync
+            if events.nil?
+                return nil
+            end
 
-                if events.is_a?(Array)
-                    if events.empty?
-                        return nil
-                    end
-                else
-                    events = [events]
+            if events.is_a?(Array)
+                if events.empty?
+                    return nil
                 end
-                
-                return events.collect { |event|
-                    # default to a simple event type
-                    if ! event.is_a?(Symbol)
-                        @state.warning("State '%s' returned invalid event '%s'; resetting to default" %
-                            [@state.class,event])
-
-                        event = @state.parent.class.name.id2name + "_changed"
-                    end
-
-                    # i should maybe include object type, but the event type
-                    # should basically point to that, right?
-                        #:state => @state,
-                        #:object => @state.parent,
-                    @state.log @state.change_to_s
-                    Puppet::Event.new(
-                        :event => event,
-                        :change => self,
-                        :transaction => @transaction,
-                        :source => @state.parent,
-                        :message => self.to_s
-                    )
-                }
-            rescue => detail
-                #@state.err "%s failed: %s" % [self.to_s,detail]
-                if Puppet[:debug]
-                    puts detail.backtrace
+            else
+                events = [events]
+            end
+            
+            return events.collect { |event|
+                # default to a simple event type
+                if ! event.is_a?(Symbol)
+                    @state.warning("State '%s' returned invalid event '%s'; resetting to default" %
+                        [@state.class,event])
+
+                    event = @state.parent.class.name.id2name + "_changed"
                 end
-                raise
-                # there should be a way to ask the state what type of event
-                # it would have generated, but...
-                pname = @state.parent.class.name.id2name
-                #if pname.is_a?(Symbol)
-                #    pname = pname.id2name
-                #end
+
+                # i should maybe include object type, but the event type
+                # should basically point to that, right?
                     #:state => @state,
-                @state.log "Failed: " + @state.change_to_s
-                return Puppet::Event.new(
-                    :event => pname + "_failed",
+                    #:object => @state.parent,
+                @report = @state.log(@state.change_to_s)
+                Puppet::Event.new(
+                    :event => event,
                     :change => self,
-                    :source => @state.parent,
                     :transaction => @transaction,
-                    :message => "Failed: " + self.to_s
+                    :source => @state.parent,
+                    :message => self.to_s
                 )
-            end
+            }
         end
 
         def forward
@@ -145,4 +126,4 @@ module Puppet
 	end
 end
 
-# $Id: statechange.rb 966 2006-03-02 17:12:26Z luke $
+# $Id: statechange.rb 1336 2006-06-29 16:05:52Z luke $

data/lib/puppet/storage.rb

@@ -42,7 +42,6 @@ module Puppet
             end
 
             unless File.exists?(Puppet[:statefile])
-                Puppet.info "Statefile %s does not exist" % Puppet[:statefile]
                 unless defined? @@state and ! @@state.nil?
                     self.init
                 end
@@ -96,4 +95,4 @@ module Puppet
     end
 end
 
-# $Id: storage.rb 1098 2006-04-10 22:13:10Z luke $
+# $Id: storage.rb 1408 2006-07-20 19:01:58Z luke $

data/lib/puppet/transaction.rb

@@ -6,195 +6,365 @@ require 'puppet/statechange'
 
 module Puppet
 class Transaction
-    attr_accessor :toplevel, :component, :objects
+    attr_accessor :component, :objects, :tags, :ignoreschedules
 
+    include Puppet::Util
 
     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."]
+            only objects tagged with the specified tags will be applied.
+            Values must be comma-separated."]
     )
 
-    # a bit of a gross hack; a global list of objects that have failed to sync,
-    # so that we can verify during later syncs that our dependencies haven't
-    # failed
-    def Transaction.init
-        @@failures = Hash.new(0)
-        Puppet::Metric.init
+    # Add some additional times for reporting
+    def addtimes(hash)
+        hash.each do |name, num|
+            @timemetrics[name] = num
+        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 []
+            end
+        end
+
+        begin
+            changes = child.evaluate
+        rescue => detail
+            if Puppet[:debug]
+                puts detail.backtrace
+            end
+
+            child.err "Failed to retrieve current state: %s" % detail
+
+            # Mark that it failed
+            @failures[child] += 1
+
+            # And then return
+            return []
+        end
+
+        unless changes.is_a? Array
+            changes = [changes]
+        end
+
+        if changes.length > 0
+            @objectmetrics[:out_of_sync] += 1
+        end
+
+        childevents = changes.collect { |change|
+            @changes << change
+            @count += 1
+            change.transaction = self
+            events = nil
+            begin
+                # use an array, so that changes can return more than one
+                # 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
+                next
+                # FIXME this should support using onerror to determine
+                # behaviour; or more likely, the client calling us
+                # should do so
+            end
+
+            # 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?)
+                change.changed = true
+                @objectmetrics[: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.
+    def changed?
+        @changes.find_all { |change| change.changed }.collect { |change|
+            change.state.parent
+        }.uniq
     end
 
-    # for now, just store the changes for executing linearly
-    # later, we might execute them as we receive them
-    def change(change)
-        @changes.push change
+    # 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
+                end
+
+                source = source.parent
+            end
+        end
     end
 
-    # okay, here's the deal:
-    # a given transaction maps directly to a component, and each transaction
-    # will only ever receive changes from its respective component
-    # so, when looking for subscribers, we need to first see if the object
-    # that actually changed had any direct subscribers
-    # then, we need to pass the event to the object's containing component,
-    # to see if it or any of its parents have subscriptions on the event
+    # This method does all the actual work of running a transaction.  It
+    # collects all of the changes, executes them, and responds to any
+    # necessary events.
     def evaluate
-        #Puppet.debug "Beginning transaction %s with %s changes" %
-        #    [self.object_id, @changes.length]
+        @count = 0
 
-        count = 0
-        now = Time.now
-        tags = Puppet[:tags]
-        if tags == ""
+        # Allow the tags to be overriden
+        tags = self.tags || Puppet[:tags]
+        if tags.nil? or tags == ""
             tags = nil
         else
-            tags = tags.split(/\s*,\s*/)
+            tags = [tags] unless tags.is_a? Array
+            tags = tags.collect do |tag|
+                tag.split(/\s*,\s*/)
+            end.flatten
         end
-        events = @objects.find_all { |child|
-            if tags
-                child.tagged?(tags)
-            else
-                true # match everything when there are no tags
-            end
-        }.find_all { |child|
-            child.scheduled?
-        }.collect { |child|
-            # these children are all Puppet::Type instances
-            # not all of the children will return a change, and Containers
-            # return transactions
-            #ary = child.evaluate
-            #ary
-            changes = child.evaluate
-            unless changes.is_a? Array
-                changes = [changes]
-            end
-            changes.collect { |change|
-                @changes << change
-                count += 1
-                change.transaction = self
+
+        # Start logging.
+        Puppet::Log.newdestination(@report)
+
+        begin
+            allevents = @objects.collect { |child|
                 events = nil
-                begin
-                    # use an array, so that changes can return more than one
-                    # 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]
-                    #Puppet.err("%s failed: %s" % [change.to_s,detail])
-                    if Puppet[:debug]
-                        puts detail.backtrace
+                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
-                    next
-                    # FIXME this should support using onerror to determine
-                    # behaviour; or more likely, the client calling us
-                    # should do so
+                else
+                    child.debug "Not tagged with %s" % tags.join(", ")
                 end
 
-                # This is kinda lame, because it can result in the same
-                # object being modified multiple times, but that's difficult
-                # to avoid as long as we're syncing each state individually.
-                change.state.parent.cache(:synced, now)
+                # Now check to see if there are any events for this child
+                trigger(child)
 
-                unless events.nil? or (events.is_a?(Array) and events.empty?)
-                    change.changed = true
-                end
+                # And return the events for collection
                 events
-            }
-        }.flatten.reject { |child|
-            child.nil? # remove empties
-        }
+            }.flatten.reject { |e| e.nil? }
+        ensure
+            # And then close the transaction log.
+            Puppet::Log.close(@report)
+        end
 
         Puppet.debug "Finishing transaction %s with %s changes" %
-            [self.object_id, count]
+            [self.object_id, @count]
 
-        self.propagate(events)
+        allevents
+    end
+
+    # Determine whether a given object has failed.
+    def failed?(obj)
+        @failures[obj] > 0
     end
 
     # this should only be called by a Puppet::Container object now
     # and it should only receive an array
     def initialize(objects)
         @objects = objects
-        @toplevel = false
 
+        @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)
         }
 
-        # of course, this won't work on the second run
-        unless defined? @@failures
-            @toplevel = true
-            self.class.init
+        # Targets of being triggered.
+        @targets = Hash.new do |hash, key|
+            hash[key] = {}
         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
+        end
+
+        @report = Report.new
     end
 
-    # Respond to each of the events.  This method walks up the parent tree,
-    # triggering each parent in turn.  It's important that the transaction
-    # itself know whether a given subscription fails, so that it can respond
-    # appropriately (when we get to the point where we're responding to events).
-    def propagate(events)
-        events.each do |event|
-            source = event.source
+    # Generate a transaction report.
+    def report
+        @objectmetrics[:failed] = @failures.find_all do |name, num|
+            num > 0
+        end.length
 
-            while source
-                Puppet::Event::Subscription.trigger(source, event) do |sub|
-                    begin
-                        sub.trigger(self)
-                    rescue => detail
-                        sub.target.err "Failed to respond to %s: %s" % [event, detail]
-                        if Puppet[:debug]
-                            puts detail.backtrace
-                        end
-                    end
-                end
+        # Get the total time spent
+        @timemetrics[:total] = @timemetrics.inject(0) do |total, vals|
+            total += vals[1]
+            total
+        end
 
-                # Reset the source if there's a parent obj
-                source = source.parent
+        # Unfortunately, RRD does not deal well with changing lists of values,
+        # so we have to pick a list of values and stick with it.  In this case,
+        # that means we record the total time, the config time, and that's about
+        # it.  We should probably send each type's time as a separate metric.
+        @timemetrics.dup.each do |name, value|
+            if Puppet::Type.type(name)
+                @timemetrics.delete(name)
             end
-            #Puppet::Event::Subscriptions.propagate(object, event, self)
         end
+
+        # Add all of the metrics related to object count and status
+        @report.newmetric(:objects, @objectmetrics)
+
+        # Record the relative time spent in each object.
+        @report.newmetric(:time, @timemetrics)
+
+        # Then all of the change-related metrics
+        @report.newmetric(:changes,
+            :total => @changes.length
+        )
+
+        @report.time = Time.now
+
+        return @report
     end
 
     # Roll all completed changes back.
     def rollback
-        events = @changes.reverse.collect { |change|
-            if change.is_a?(Puppet::StateChange)
-                # skip changes that were never actually run
-                unless change.changed
-                    Puppet.debug "%s was not changed" % change.to_s
-                    next
+        @targets.clear
+        @triggered.clear
+        allevents = @changes.reverse.collect { |change|
+            # skip changes that were never actually run
+            unless change.changed
+                Puppet.debug "%s was not changed" % change.to_s
+                next
+            end
+            begin
+                events = change.backward
+            rescue => detail
+                Puppet.err("%s rollback failed: %s" % [change,detail])
+                if Puppet[:debug]
+                    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
+                # this still could get hairy; what if file contents changed,
+                # but a chmod failed?  how would i handle that error? dern
+            end
+
+            collecttargets(events)
+
+            # 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)
+
+            # And return the events for collection
+            events
+        }.flatten.reject { |e| e.nil? }
+    end
+
+    # Trigger any subscriptions to a child.  This does an upwardly recursive
+    # search -- it triggers the passed object, but also the object's parent
+    # and so on up the tree.
+    def trigger(child)
+        obj = child
+        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(", ")]
                 end
-                #change.transaction = self
-                begin
-                    change.backward
-                rescue => detail
-                    Puppet.err("%s rollback failed: %s" % [change,detail])
-                    if Puppet[:debug]
-                        puts detail.backtrace
+
+                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]
+
+                        @objectmetrics[:failed_restarts] += 1
+
+                        if Puppet[:debug]
+                            puts detail.backtrace
+                        end
                     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
-                    # this still could get hairy; what if file contents changed,
-                    # but a chmod failed?  how would i handle that error? dern
+
+                    triggered(obj, callback)
                 end
-            elsif change.is_a?(Puppet::Transaction)
-                raise Puppet::DevError, "Got a sub-transaction"
-                # yay, recursion
-                change.rollback
-            else
-                raise Puppe::DevError,
-                    "Transactions cannot handle objects of type %s" % child.class
             end
-        }.flatten.reject { |e| e.nil? }
 
-        self.propagate(events)
+            obj = obj.parent
+        end
     end
 
     def triggered(object, method)
         @triggered[object][method] += 1
-        #@triggerevents << ("%s_%sed" % [object.class.name.to_s, method.to_s]).intern
     end
 
     def triggered?(object, method)
@@ -203,4 +373,6 @@ class Transaction
 end
 end
 
-# $Id: transaction.rb 1005 2006-03-11 22:18:59Z luke $
+require 'puppet/transaction/report'
+
+# $Id: transaction.rb 1351 2006-07-01 17:27:54Z luke $