puppet 0.16.0 → 0.18.4

data/lib/puppet/transaction/report.rb

@@ -0,0 +1,42 @@
+require 'puppet'
+
+# A class for reporting what happens on each client.  Reports consist of
+# two types of data:  Logs and Metrics.  Logs are the output that each
+# change produces, and Metrics are all of the numerical data involved
+# in the transaction.
+class Puppet::Transaction::Report
+    attr_accessor :logs, :metrics, :time, :host
+
+    def initialize
+        @metrics = {}
+        @logs = []
+
+        @records = Hash.new do |hash, key|
+            hash[key] = []
+        end
+
+        @host = [Facter.value("hostname"), Facter.value("domain")].join(".")
+    end
+
+    # Create a new metric.
+    def newmetric(name, hash)
+        metric = Puppet::Metric.new(name)
+
+        hash.each do |name, value|
+            metric.newvalue(name, value)
+        end
+
+        @metrics[metric.name] = metric
+    end
+
+    # Add a new log message.
+    def newlog(msg)
+        @logs << msg
+    end
+
+    def record(metric, object)
+        @records[metric] << object
+    end
+end
+
+# $Id: report.rb 1361 2006-07-04 16:43:16Z luke $

data/lib/puppet/transportable.rb

@@ -8,7 +8,7 @@ module Puppet
     # YAML.
     class TransObject
         include Enumerable
-        attr_accessor :type, :name, :file, :line
+        attr_accessor :type, :name, :file, :line, :collectable, :collected
 
         attr_writer :tags
 
@@ -25,8 +25,8 @@ module Puppet
         def initialize(name,type)
             @type = type
             @name = name
+            @collectable = false
             @params = {}
-            #self.class.add(self)
             @tags = []
         end
 
@@ -54,31 +54,26 @@ module Puppet
 
         def to_yaml_properties
             instance_variables
-            #%w{ @type @name @file @line @tags }.find_all { |v|
-            #}
         end
 
         def to_type(parent = nil)
             retobj = nil
-            if type = Puppet::Type.type(self.type)
-                unless retobj = type.create(self)
-                    #Puppet.notice "Could not create %s[%s]" %
-                    #    [self.type, self.name]
-                    return nil
+            if typeklass = Puppet::Type.type(self.type)
+                # FIXME This should really be done differently, but...
+                if retobj = typeklass[self.name]
+                    self.each do |param, val|
+                        retobj[param] = val
+                    end
+                else
+                    unless retobj = typeklass.create(self)
+                        return nil
+                    end
                 end
-                #retobj.file = @file
-                #retobj.line = @line
             else
                 raise Puppet::Error.new("Could not find object type %s" % self.type)
             end
 
-            #if defined? @tags and @tags
-            #    #Puppet.debug "%s(%s) tags: %s" % [@type, @name, @tags.join(" ")]
-            #    retobj.tags = @tags
-            #end
-
             if parent
-                self[:parent] = parent
                 parent.push retobj
             end
 
@@ -101,16 +96,52 @@ module Puppet
             end
         }
 
+        # Remove all collectable objects from our tree, since the client
+        # should not see them.
+        def collectstrip!
+            @children.dup.each do |child|
+                if child.is_a? self.class
+                    child.collectstrip!
+                else
+                    if child.collectable and ! child.collected
+                        @children.delete(child)
+                    end
+                end
+            end
+        end
+
+        # Recursively yield everything.
+        def delve(&block)
+            @children.each do |obj|
+                block.call(obj)
+                if obj.is_a? self.class
+                    obj.delve(&block)
+                else
+                    obj
+                end
+            end
+        end
+
         def each
             @children.each { |c| yield c }
         end
 
+        # Turn our heirarchy into a flat list
+        def flatten
+            @children.collect do |obj|
+                if obj.is_a? Puppet::TransBucket
+                    obj.flatten
+                else
+                    obj
+                end
+            end.flatten
+        end
+
         def initialize
             @children = []
         end
 
         def push(*args)
-            #Puppet.warning "calling push"
             args.each { |arg|
                 case arg
                 when Puppet::TransBucket, Puppet::TransObject
@@ -122,7 +153,6 @@ module Puppet
                 end
             }
             @children += args
-            #Puppet.warning @children.inspect
         end
 
         # Convert to a parseable manifest
@@ -167,15 +197,15 @@ module Puppet
             usetrans = true
 
             if usetrans
-                name = nil
+                tmpname = nil
 
                 # Nodes have the same name and type
                 if self.name
-                    name = "%s[%s]" % [@type, self.name]
+                    tmpname = "%s[%s]" % [@type, self.name]
                 else
-                    name = @type
+                    tmpname = @type
                 end
-                trans = TransObject.new(name, :component)
+                trans = TransObject.new(tmpname, :component)
                 if defined? @parameters
                     @parameters.each { |param,value|
                         Puppet.debug "Defining %s on %s of type %s" %
@@ -186,12 +216,6 @@ module Puppet
                     #Puppet.debug "%s[%s] has no parameters" % [@type, @name]
                 end
                 container = Puppet.type(:component).create(trans)
-
-                if parent
-                    container.parent = parent
-                    #Puppet.warning "parent is of type %s" % parent.class
-                    #trans[:parent] = parent
-                end
             else
                 hash = {
                     :name => self.name,
@@ -207,9 +231,9 @@ module Puppet
                     #Puppet.debug "%s[%s] has no parameters" % [@type, @name]
                 end
 
-                if parent
-                    hash[:parent] = parent
-                end
+                #if parent
+                #    hash[:parent] = parent
+                #end
                 container = Puppet.type(:component).create(hash)
             end
             #Puppet.info container.inspect
@@ -258,4 +282,4 @@ module Puppet
     #------------------------------------------------------------
 end
 
-# $Id: transportable.rb 953 2006-02-27 22:25:59Z luke $
+# $Id: transportable.rb 1256 2006-06-13 15:57:06Z luke $

data/lib/puppet/type.rb

@@ -21,9 +21,9 @@ class Type < Puppet::Element
     # In naming methods, I have tried to consistently name the method so
     # that it is clear whether it operates on all attributes (thus has 'attr' in
     # the method name, or whether it operates on a specific type of attributes.
-    attr_accessor :children, :parent
+    attr_accessor :children
     attr_accessor :file, :line
-    attr_reader :tags
+    attr_reader :tags, :parent
 
     attr_writer :implicit
     def implicit?
@@ -36,13 +36,6 @@ class Type < Puppet::Element
 
     include Enumerable
 
-    # this is currently unused, but I expect to use it for metrics eventually
-    @@retrieved = Hash.new(0)
-
-    # an array to contain all instances of Type
-    # also currently unused
-    @@allobjects = Array.new
-
     # a little fakery, since Puppet itself isn't a type
     # I don't think this is used any more, now that the language can't
     # call methods
@@ -64,9 +57,9 @@ class Type < Puppet::Element
 
         include Enumerable
 
-        def inspect
-            "Type(%s)" % self.name
-        end
+        #def inspect
+        #    "Type(%s)" % self.name
+        #end
 
         # This class is aggregatable, meaning that instances are defined on
         # one system but instantiated on another
@@ -84,20 +77,6 @@ class Type < Puppet::Element
         end
     end
 
-    def inspect
-        str = "Type(%s)" % self.name
-        if defined? @states
-            str += " States(" + @states.inspect + ")"
-        end
-        if defined? @parameters
-            str += " Parameters(" + @parameters.inspect + ")"
-        end
-        if defined? @metaparams
-            str += " Metaparams(" + @metaparams.inspect + ")"
-        end
-        str
-    end
-
     # iterate across all of the subclasses of Type
     def self.eachtype
         @types.each do |name, type|
@@ -108,6 +87,18 @@ class Type < Puppet::Element
         end
     end
 
+    # Create the 'ensure' class.  This is a separate method so other types
+    # can easily call it and create their own 'ensure' values.
+    def self.ensurable(&block)
+        if block_given?
+            self.newstate(:ensure, Puppet::State::Ensure, &block)
+        else
+            self.newstate(:ensure, Puppet::State::Ensure) do
+                self.defaultvalues
+            end
+        end
+    end
+
     # Should we add the 'ensure' state to this class?
     def self.ensurable?
         # If the class has all three of these methods defined, then it's
@@ -122,19 +113,6 @@ class Type < Puppet::Element
         return ens
     end
 
-    # The work that gets done for every subclass of Type
-    # this is an implicit method called by Ruby for us
-    #def self.inherited(sub)
-    #    sub.initvars
-
-        #debug("subtype %s(%s) just created" % [sub,sub.superclass])
-        # add it to the master list
-        # unfortunately we can't yet call sub.name, because the #inherited
-        # method gets called before any commands in the class definition
-        # get executed, which, um, sucks
-        #@@typeary.push(sub)
-    #end
-
     # all of the variables that must be initialized for each subclass
     def self.initvars
         # all of the instances of this class
@@ -168,16 +146,56 @@ class Type < Puppet::Element
 
     end
 
+    # Do an on-demand plugin load
+    def self.loadplugin(name)
+        unless Puppet[:pluginpath].split(":").include?(Puppet[:plugindest])
+            Puppet.notice "Adding plugin destination %s to plugin search path" %
+                Puppet[:plugindest]
+            Puppet[:pluginpath] += ":" + Puppet[:plugindest]
+        end
+        Puppet[:pluginpath].split(":").each do |dir|
+            file = ::File.join(dir, name.to_s + ".rb")
+            if FileTest.exists?(file)
+                begin
+                    load file
+                    Puppet.info "loaded %s" % file
+                    return true
+                rescue LoadError => detail
+                    Puppet.info "Could not load %s: %s" %
+                        [file, detail]
+                    return false
+                end
+            end
+        end
+    end
+
     # Define a new type.
     def self.newtype(name, parent = nil, &block)
         parent ||= Puppet::Type
-        Puppet::Util.symbolize(name)
-
+        name = Puppet::Util.symbolize(name)
 
         # Create the class, with the correct name.
         t = Class.new(parent) do
             @name = name
         end
+
+        # Used for method manipulation.
+        selfobj = class << self; self; end
+
+        const = name.to_s.capitalize
+        newmethod = "new#{name.to_s}"
+
+        @types ||= {}
+
+        if @types.include?(name) and const_defined?(const)
+            Puppet.info "Redefining %s" % name
+            remove_const(const)
+
+            if self.respond_to?(newmethod)
+                # Remove the old newmethod, too
+                selfobj.send(:remove_method,newmethod)
+            end
+        end
         const_set(name.to_s.capitalize,t)
 
         # Initialize any necessary variables.
@@ -192,22 +210,20 @@ class Type < Puppet::Element
             t.ensurable
         end
 
-        @types ||= {}
-
         # And add it to our bucket.
         @types[name] = t
-    end
 
-    # Create the 'ensure' class.  This is a separate method so other types
-    # can easily call it and create their own 'ensure' values.
-    def self.ensurable(&block)
-        if block_given?
-            self.newstate(:ensure, Puppet::State::Ensure, &block)
+        # Now define a "new<type>" method for convenience.
+        if self.respond_to? newmethod
+            # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
+            Puppet.warning "'new#{name.to_s}' method already exists; skipping"
         else
-            self.newstate(:ensure, Puppet::State::Ensure) do
-                self.defaultvalues
+            selfobj.send(:define_method, newmethod) do |*args|
+                t.create(*args)
             end
         end
+
+        t
     end
 
     # Return a Type instance by name.
@@ -224,8 +240,9 @@ class Type < Puppet::Element
                 unless @types.include? name
                     Puppet.warning "Loaded puppet/type/#{name} but no class was created"
                 end
-            rescue LoadError
-                # nothing
+            rescue LoadError => detail
+                # If we can't load it from there, try loading it as a plugin.
+                loadplugin(name)
             end
         end
 
@@ -280,25 +297,28 @@ class Type < Puppet::Element
             raise Puppet::DevError, "must pass a Puppet::Type object"
         end
 
-        if @objects.has_key?(name) and self.isomorphic?
-            raise Puppet::Error.new(
-                "Object '%s' of type '%s' already exists with id '%s' vs. '%s'" %
-                [name, newobj.class.name,
-                    @objects[name].object_id,newobj.object_id]
-            )
+        if exobj = @objects.has_key?(name) and self.isomorphic?
+            msg = "Object '%s[%s]' already exists" %
+                [name, newobj.class.name]
+
+            if exobj.file and exobj.line
+                msg += ("in file %s at line %s" %
+                    [object.file, object.line])
+            end
+            if object.file and object.line
+                msg += ("and cannot be redefined in file %s at line %s" %
+                    [object.file, object.line])
+            end
+            error = Puppet::Error.new(msg)
         else
             #Puppet.info("adding %s of type %s to class list" %
             #    [name,object.class])
             @objects[name] = newobj
         end
-
-        # and then add it to the master list
-        Puppet::Type.push(object)
     end
 
     # remove all type instances; this is mostly only useful for testing
     def self.allclear
-        @@allobjects.clear
         Puppet::Event::Subscription.clear
         @types.each { |name, type|
             type.clear
@@ -308,6 +328,9 @@ class Type < Puppet::Element
     # remove all of the instances of a single type
     def self.clear
         if defined? @objects
+            @objects.each do |name, obj|
+                obj.remove(true)
+            end
             @objects.clear
         end
         if defined? @aliases
@@ -317,9 +340,6 @@ class Type < Puppet::Element
 
     # remove a specified object
     def self.delete(object)
-        if @@allobjects.include?(object)
-            @@allobjects.delete(object)
-        end
         return unless defined? @objects
         if @objects.include?(object.name)
             @objects.delete(object.name)
@@ -357,14 +377,6 @@ class Type < Puppet::Element
         end
     end
 
-    # add an object to the master list of Type instances
-    # I'm pretty sure this is currently basically unused
-    def self.push(object)
-        @@allobjects.push object
-        #debug("adding %s of type %s to master list" %
-        #    [object.name,object.class])
-    end
-
     # class and instance methods dealing with parameters and states
 
     public
@@ -427,7 +439,7 @@ class Type < Puppet::Element
     # Create a new metaparam.  Requires a block and a name, stores it in the
     # @parameters array, and does some basic checking on it.
     def self.newmetaparam(name, &block)
-        Puppet::Util.symbolize(name)
+        name = Puppet::Util.symbolize(name)
         param = Class.new(Puppet::Parameter) do
             @name = name
         end
@@ -453,7 +465,7 @@ class Type < Puppet::Element
     # Create a new parameter.  Requires a block and a name, stores it in the
     # @parameters array, and does some basic checking on it.
     def self.newparam(name, &block)
-        Puppet::Util.symbolize(name)
+        name = Puppet::Util.symbolize(name)
         param = Class.new(Puppet::Parameter) do
             @name = name
         end
@@ -778,8 +790,9 @@ class Type < Puppet::Element
         when :meta
             self.newmetaparam(self.class.metaparamclass(name), value)
         when :param
+            klass = self.class.attrclass(name)
             # if they've got a method to handle the parameter, then do it that way
-            self.newparam(self.class.attrclass(name), value)
+            self.newparam(klass, value)
         else
             raise Puppet::Error, "Invalid parameter %s" % [name]
         end
@@ -1011,11 +1024,46 @@ class Type < Puppet::Element
         return @parameters[name].value
     end
 
+    def parent=(parent)
+        if self.parentof?(parent)
+            devfail "%s[%s] is already the parent of %s[%s]" %
+                [self.class.name, self.name, parent.class.name, parent.name]
+        end
+        @parent = parent
+    end
+
+    # Add a hook for testing for recursion.
+    def parentof?(child)
+        if (self == child)
+            debug "parent is equal to child"
+            return true
+        elsif defined? @parent and @parent.parentof?(child)
+            debug "My parent is parent of child"
+            return true
+        elsif @children.include?(child)
+            debug "child is already in children array"
+            return true
+        else
+            return false
+        end
+    end
+
     def push(*childs)
         unless defined? @children
             @children = []
         end
         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.name]
+            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
         }
@@ -1032,8 +1080,21 @@ class Type < Puppet::Element
             child.remove(rmdeps)
         }
 
+        @children.clear
+
+        # This is hackish (mmm, cut and paste), but it works for now, and it's
+        # better than warnings.
+        [@states, @parameters, @metaparams].each do |hash|
+            hash.each do |name, obj|
+                obj.remove
+            end
+
+            hash.clear
+        end
+
         if rmdeps
             Puppet::Event::Subscription.dependencies(self).each { |dep|
+                #info "Deleting dependency %s" % dep
                 #begin
                 #    self.unsubscribe(dep)
                 #rescue
@@ -1042,6 +1103,7 @@ class Type < Puppet::Element
                 dep.delete
             }
             Puppet::Event::Subscription.subscribers(self).each { |dep|
+                #info "Unsubscribing from %s" % dep
                 begin
                     dep.unsubscribe(self)
                 rescue
@@ -1053,6 +1115,7 @@ class Type < Puppet::Element
 
         if defined? @parent and @parent
             @parent.delete(self)
+            @parent = nil
         end
     end
 
@@ -1101,7 +1164,6 @@ class Type < Puppet::Element
     # necessary.  FIXME This method should be responsible for most of the
     # error handling.
     def self.create(hash)
-        #Puppet.warning "Creating %s" % hash.inspect
         # Handle this new object being implicit
         implicit = hash[:implicit] || false
         if hash.include?(:implicit)
@@ -1116,6 +1178,8 @@ class Type < Puppet::Element
         end
         name = hash.name
 
+        #Puppet.debug "Creating %s[%s]" % [self.name, name]
+
         # if the object already exists
         if self.isomorphic? and retobj = self[name]
             # if only one of our objects is implicit, then it's easy to see
@@ -1378,13 +1442,6 @@ class Type < Puppet::Element
         if self.respond_to?(:validate)
             self.validate
         end
-
-        # Ensure defaults to present for managed objects, but not otherwise.
-        # Because of this complication, we can't use normal defaulting mechanisms
-#        if ! @states.include?(:ensure) and self.managed? and
-#                    self.class.validstate?(:ensure)
-#            self[:ensure] = :present
-#        end
     end
 
     # Figure out of there are any objects we can automatically add as
@@ -1405,7 +1462,6 @@ class Type < Puppet::Element
                 obj = nil
                 # Support them passing objects directly, to save some effort.
                 if dep.is_a? Puppet::Type
-                    self.info "requiring %s" % dep.name
                     type = dep.class.name
                     obj = dep
 
@@ -1418,10 +1474,11 @@ class Type < Puppet::Element
                         next
                     end
                 end
+
                 # Skip autorequires that we already require
                 next if self.requires?(obj)
-                #self.info "Auto-requiring %s %s" % [obj.class.name, obj.name]
 
+                debug "Autorequiring %s %s" % [obj.class.name, obj.name]
                 self[:require] = [type, dep]
             }
 
@@ -1779,7 +1836,6 @@ class Type < Puppet::Element
                 [self.name,self.class]
             @evalcount = 0
         end
-        @@retrieved[self] += 1
         @evalcount += 1
 
         changes = []
@@ -1795,12 +1851,6 @@ class Type < Puppet::Element
             changes += statechanges()
         end
 
-        if changes.length > 0
-            # add one to the number of out-of-sync instances
-            Puppet::Metric.add(self.class,self,:outofsync,1)
-        end
-        #end
-
         changes << @children.collect { |child|
             ch = child.evaluate
             child.cache(:checked, now)
@@ -1814,7 +1864,6 @@ class Type < Puppet::Element
         changes.flatten!
 
         # now record how many changes we've resulted in
-        Puppet::Metric.add(self.class,self,:changes,changes.length)
         if changes.length > 0
             self.debug "%s change(s)" %
                 [changes.length]
@@ -1871,12 +1920,20 @@ class Type < Puppet::Element
     def builddepends
         # Handle the requires
         if self[:require]
-            self.handledepends(self[:require], :NONE, nil)
+            self.handledepends(self[:require], :NONE, nil, true)
         end
 
         # And the subscriptions
         if self[:subscribe]
-            self.handledepends(self[:subscribe], :ALL_EVENTS, :refresh)
+            self.handledepends(self[:subscribe], :ALL_EVENTS, :refresh, true)
+        end
+
+        if self[:notify]
+            self.handledepends(self[:notify], :ALL_EVENTS, :refresh, false)
+        end
+
+        if self[:before]
+            self.handledepends(self[:before], :NONE, nil, false)
         end
     end
 
@@ -1894,7 +1951,7 @@ class Type < Puppet::Element
         }
     end
 
-    def handledepends(requires, event, method)
+    def handledepends(requires, event, method, up)
         # Requires are specified in the form of [type, name], so they're always
         # an array.  But we want them to be an array of arrays.
         unless requires[0].is_a?(Array)
@@ -1916,22 +1973,26 @@ class Type < Puppet::Element
             end
             self.debug("subscribes to %s" % [object])
 
-            #unless @dependencies.include?(object)
-            #    @dependencies << object
-            #end
-
-            # pure requires don't call methods
-            #next if method.nil?
+            # Are we requiring them, or vice versa?
+            source = target = nil
+            if up
+                source = object
+                target = self
+            else
+                source = self
+                target = object
+            end
 
             # ok, both sides of the connection store some information
             # we store the method to call when a given subscription is 
             # triggered, but the source object decides whether 
             subargs = {
                 :event => event,
-                :source => object,
-                :target => self
+                :source => source,
+                :target => target
             }
-            if method and self.respond_to?(method)
+
+            if method and target.respond_to?(method)
                 subargs[:callback] = method
             end
             Puppet::Event::Subscription.new(subargs)
@@ -2039,8 +2100,8 @@ class Type < Puppet::Element
 
     newmetaparam(:schedule) do
         desc "On what schedule the object should be managed.  You must create a
-            schedule_ object, and then reference the name of that object to use
-            that for your schedule::
+            schedule object, and then reference the name of that object to use
+            that for your schedule:
 
                 schedule { daily:
                     period => daily,
@@ -2094,7 +2155,13 @@ class Type < Puppet::Element
                 end
                 next if @parent.statedefined?(state)
 
-                next unless @parent.class.validstate?(state).checkable?
+                stateklass = @parent.class.validstate?(state)
+
+                unless stateklass
+                    raise Puppet::Error, "%s is not a valid attribute for %s" %
+                        [state, self.class.name]
+                end
+                next unless stateklass.checkable?
 
                 @parent.newstate(state)
             }
@@ -2105,7 +2172,7 @@ class Type < Puppet::Element
     newmetaparam(:require) do
         desc "One or more objects that this object depends on.
             This is used purely for guaranteeing that changes to required objects
-            happen before the dependent object.  For instance::
+            happen before the dependent object.  For instance:
             
                 # Create the destination directory before you copy things down
                 file { \"/usr/local/scripts\":
@@ -2128,7 +2195,7 @@ class Type < Puppet::Element
             automatically realize that the parent directory should be created
             before the script is pulled down.
             
-            Currently, exec_ elements will autorequire their CWD (if it is
+            Currently, exec elements will autorequire their CWD (if it is
             specified) plus any fully qualified paths that appear in the
             command.   For instance, if you had an ``exec`` command that ran
             the ``myscript`` mentioned above, the above code that pulls the
@@ -2151,8 +2218,6 @@ class Type < Puppet::Element
                 requires = values + requires
             end
             requires
-            #p @parent[:require]
-            #@parent.handledepends(requires, :NONE, nil)
         end
     end
 
@@ -2161,17 +2226,16 @@ class Type < Puppet::Element
     newmetaparam(:subscribe) do
         desc "One or more objects that this object depends on.  Changes in the
             subscribed to objects result in the dependent objects being
-            refreshed (e.g., a service will get restarted).  For instance::
+            refreshed (e.g., a service will get restarted).  For instance:
             
                 class nagios {
                     file { \"/etc/nagios/nagios.conf\":
                         source => \"puppet://server/module/nagios.conf\",
                         alias => nagconf # just to make things easier for me
                     }
-
                     service { nagios:
                         running => true,
-                        require => file[nagconf]
+                        subscribe => file[nagconf]
                     }
                 }
             "
@@ -2186,11 +2250,9 @@ class Type < Puppet::Element
     end
 
     newmetaparam(:loglevel) do
-        desc "Sets the level that information will be logged:
-             ``debug``, ``info``, ``verbose``, ``notice``, ``warning``,
-             ``err``, ``alert``, ``emerg`` or ``crit``.  The log levels have
-             the biggest impact when logs are sent to syslog (which is
-             currently the default)."
+        desc "Sets the level that information will be logged.
+             The log levels have the biggest impact when logs are sent to
+             syslog (which is currently the default)."
         defaultto :notice
 
         newvalues(*Puppet::Log.levels)
@@ -2207,7 +2269,7 @@ class Type < Puppet::Element
 
     newmetaparam(:alias) do
         desc "Creates an alias for the object.  Puppet uses this internally when you
-            provide a symbolic name::
+            provide a symbolic name:
             
                 file { sshdconfig:
                     path => $operatingsystem ? {
@@ -2225,7 +2287,7 @@ class Type < Puppet::Element
             and the library sets that as an alias for the file so the dependency
             lookup for ``sshd`` works.  You can use this parameter yourself,
             but note that only the library can use these aliases; for instance,
-            the following code will not work::
+            the following code will not work:
 
                 file { \"/etc/ssh/sshd_config\":
                     owner => root,
@@ -2240,7 +2302,9 @@ class Type < Puppet::Element
             There's no way here for the Puppet parser to know that these two stanzas
             should be affecting the same file.
 
-            See the `language tutorial <http://reductivelabs.com/projects/puppet/documentation/languagetutorial>`__ for more information.
+            See the [language tutorial][] for more information.
+
+            [language tutorial]: languagetutorial.html
             
             "
 
@@ -2273,7 +2337,7 @@ class Type < Puppet::Element
             Tags are currently useful for things like applying a subset of a
             host's configuration:
                 
-                puppetd -v --tag mytag --onetime
+                puppetd --test --tag mytag
 
             This way, when you're testing a configuration you can run just the
             portion you're testing."
@@ -2286,6 +2350,75 @@ class Type < Puppet::Element
             end
         end
     end
+
+    newmetaparam(:notify) do
+        desc %{This parameter is the opposite of **subscribe** -- it sends events
+            to the specified object:
+
+                file { "/etc/sshd_config":
+                    source => "....",
+                    notify => service[sshd]
+                }
+
+                service { sshd:
+                    ensure => running
+                }
+            
+            This will restart the sshd service if the sshd config file changes.}
+
+
+        # Take whatever dependencies currently exist and add these.
+        munge do |notifies|
+            # We need to be two arrays deep...
+            unless notifies.is_a?(Array)
+                notifies = [notifies]
+            end
+            unless notifies[0].is_a?(Array)
+                notifies = [notifies]
+            end
+            if values = @parent[:notify]
+                notifies = values + notifies
+            end
+            notifies
+        end
+        
+    end
+
+    newmetaparam(:before) do
+        desc %{This parameter is the opposite of **require** -- it guarantees
+            that the specified object is applied later than the specifying
+            object:
+
+                file { "/var/nagios/configuration":
+                    source  => "...",
+                    recurse => true,
+                    before => exec["nagios-rebuid"]
+                }
+
+                exec { "nagios-rebuild":
+                    command => "/usr/bin/make",
+                    cwd => "/var/nagios/configuration"
+                }
+            
+            This will make sure all of the files are up to date before the
+            make command is run.}
+
+        # Take whatever dependencies currently exist and add these.
+        munge do |notifies|
+            # We need to be two arrays deep...
+            unless notifies.is_a?(Array)
+                notifies = [notifies]
+            end
+            unless notifies[0].is_a?(Array)
+                notifies = [notifies]
+            end
+            if values = @parent[:notify]
+                notifies = values + notifies
+            end
+            notifies
+        end
+        
+    end
 end # Puppet::Type
 end
 
@@ -2304,4 +2437,4 @@ require 'puppet/type/user'
 require 'puppet/type/tidy'
 require 'puppet/type/parsedtype'
 
-# $Id: type.rb 1129 2006-04-21 19:14:59Z luke $
+# $Id: type.rb 1373 2006-07-06 04:39:59Z luke $