puppet 0.9.2 → 0.13.0

data/lib/puppet/type.rb

@@ -4,15 +4,21 @@ require 'puppet/element'
 require 'puppet/event'
 require 'puppet/metric'
 require 'puppet/type/state'
+require 'puppet/parameter'
+require 'puppet/util'
 # see the bottom of the file for the rest of the inclusions
 
-module Puppet # :nodoc:
-# This class is the abstract base class for the mechanism for organizing
-# work.  No work is actually done by this class or its subclasses; rather,
-# the subclasses include states which do the actual work.
-#   See state.rb for how work is actually done.
+module Puppet
 class Type < Puppet::Element
-    attr_accessor :children, :parameters, :parent
+    # Types (which map to elements in the languages) are entirely composed of
+    # attribute value pairs.  Generally, Puppet calls any of these things an
+    # 'attribute', but these attributes always take one of three specific
+    # forms:  parameters, metaparams, or states.
+
+    # 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 :file, :line, :tags
 
     attr_writer :implicit
@@ -36,123 +42,105 @@ class Type < Puppet::Element
     # 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
-    @name = :puppet
+    #@name = :puppet
 
     # set it to something to silence the tests, but otherwise not used
-    @namevar = :notused
+    #@namevar = :notused
 
     # again, silence the tests; the :notused has to be there because it's
     # the namevar
-    @states = []
-    @parameters = [:notused]
     
-    # @paramdoc = Hash.new
-
-    # the parameters that all instances will accept
-    @@metaparams = [
-        :onerror,
-        :noop,
-        :schedule,
-        :check,
-        :subscribe,
-        :require,
-        :loglevel
-    ]
-    
-    @@metaparamdoc = Hash.new { |hash,key|
-        if key.is_a?(String)
-            key = key.intern
-        end
-        if hash.include?(key)
-            hash[key]
-        else
-            "Metaparam Documentation for %s not found" % key
-        end
-    }
-
-    @@metaparamdoc[:onerror] = "How to handle errors -- roll back innermost
-        transaction, roll back entire transaction, ignore, etc.  Currently
-        non-functional."
-    @@metaparamdoc[:noop] = "Boolean flag indicating whether work should actually
-        be done."
-    @@metaparamdoc[:schedule] = "On what schedule the object should be managed.
-        Currently non-functional."
-    @@metaparamdoc[:check] = "States which should have their values retrieved
-        but which should not actually be modified.  This is currently used
-        internally, but will eventually be used for querying."
-    @@metaparamdoc[:require] = "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."
-    @@metaparamdoc[:subscribe] = "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)."
-    @@metaparamdoc[:loglevel] = "Sets the level that information will be logged:
-         debug, info, verbose, notice, warning, err, alert, emerg or crit"
-
     # class methods dealing with Type management
 
     public
 
-    # these objects are used for mapping type names (e.g., 'file')
-    # to actual object classes; because Type.inherited is
-    # called before the <subclass>.name method is defined, we need
-    # to store each class in an array, and then later actually iterate
-    # across that array and make a map
-    @@typeary = [self] # so that the allowedmethods stuff works
-    @@typehash = Hash.new { |hash,key|
-        if key.is_a?(String)
-            key = key.intern
+    # the Type class attribute accessors
+    class << self
+        attr_reader :name, :states
+
+        include Enumerable
+
+        def inspect
+            Puppet.info "inspecting class with name %s" % self.name
+            "Type(%s)" % self.name
         end
-        if hash.include?(key)
-            hash[key]
-        else
-            raise TypeError.new("Object type %s not found" % key)
+
+        # This class is aggregatable, meaning that instances are defined on
+        # one system but instantiated on another
+        def isaggregatable
+            @aggregatable = true
         end
-    }
 
-    # the Type class attribute accessors
-    class << self
-        attr_reader :name, :namevar, :states, :parameters
-    end
-
-    # Create @@typehash from @@typeary.  This is meant to be run
-    # multiple times -- whenever it is discovered that the two
-    # objects have differents lengths.
-    def self.buildtypehash
-        @@typeary.each { |otype|
-            if @@typehash.include?(otype.name)
-                if @@typehash[otype.name] != otype
-                    Puppet.warning("Object type %s is already defined (%s vs %s)" %
-                        [otype.name,@@typehash[otype.name],otype])
-                end
+        # Is this one aggregatable?
+        def aggregatable?
+            if defined? @aggregatable
+                return @aggregatable
             else
-                @@typehash[otype.name] = otype
+                return false
             end
-        }
+        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
-        @@typeary.each { |type| yield type }
+        @types.each do |name, type|
+            # Only consider types that have names
+            #if ! type.parameters.empty? or ! type.validstates.empty?
+                yield type 
+            #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
+        # ensurable.
+        #ens = [:create, :destroy].inject { |set, method|
+        ens = [:exists?, :create, :destroy].inject { |set, method|
+            set &&= self.public_method_defined?(method)
+        }
+
+        #puts "%s ensurability: %s" % [self.name, ens]
+
+        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
+    #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
+        #@@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
         @objects = Hash.new
+        @aliases = Hash.new
+
+        unless defined? @parameters
+            @parameters = []
+        end
 
         @validstates = {}
 
@@ -177,24 +165,93 @@ class Type < Puppet::Element
 
     end
 
-    # return a Type instance by name
-    def self.type(type)
-        unless @@typeary.length == @@typehash.length
-            # call bulidtypehash if types have been added since it
-            # was last called
-            Type.buildtypehash
+    # Define a new type.
+    def self.newtype(name, parent = nil, &block)
+        parent ||= Puppet::Type
+        Puppet::Util.symbolize(name)
+
+
+        # Create the class, with the correct name.
+        t = Class.new(parent) do
+            @name = name
+        end
+        const_set(name.to_s.capitalize,t)
+
+        # Initialize any necessary variables.
+        t.initvars
+
+        # Evaluate the passed block.  This should usually define all of the work.
+        t.class_eval(&block)
+
+        # If they've got all the necessary methods defined and they haven't
+        # already added the state, then do so now.
+        if t.ensurable? and ! t.validstate?(:ensure)
+            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)
+        else
+            self.newstate(:ensure, Puppet::State::Ensure) do
+                self.defaultvalues
+            end
+        end
+    end
+
+    # Return a Type instance by name.
+    def self.type(name)
+        @types ||= {}
+
+        if name.is_a?(String)
+            name = name.intern
         end
-        @@typehash[type]
+
+        @types[name]
     end
 
     # class methods dealing with type instance management
 
     public
 
+    # Create an alias.  We keep these in a separate hash so that we don't encounter
+    # the objects multiple times when iterating over them.
+    def self.alias(name, obj)
+        if @objects.include?(name)
+            unless @objects[name] == obj
+                raise Puppet::Error.new(
+                    "Cannot create alias %s: object already exists" %
+                    [name]
+                )
+            end
+        end
+
+        if @aliases.include?(name)
+            unless @aliases[name] == obj
+                raise Puppet::Error.new(
+                    "Object %s already has alias %s" %
+                    [@aliases[name].name, name]
+                )
+            end
+        end
+
+        @aliases[name] = obj
+    end
+
     # retrieve a named instance of the current type
     def self.[](name)
         if @objects.has_key?(name)
             return @objects[name]
+        elsif @aliases.has_key?(name)
+            return @aliases[name]
         else
             return nil
         end
@@ -209,16 +266,16 @@ class Type < Puppet::Element
             raise Puppet::DevError, "must pass a Puppet::Type object"
         end
 
-        if @objects.has_key?(newobj.name) and self.isomorphic?
+        if @objects.has_key?(name) and self.isomorphic?
             raise Puppet::Error.new(
                 "Object '%s' of type '%s' already exists with id '%s' vs. '%s'" %
-                [newobj.name,newobj.class.name,
-                    @objects[newobj.name].object_id,newobj.object_id]
+                [name, newobj.class.name,
+                    @objects[name].object_id,newobj.object_id]
             )
         else
-            #debug("adding %s of type %s to class list" %
-            #    [object.name,object.class])
-            @objects[newobj.name] = newobj
+            #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
@@ -229,9 +286,10 @@ class Type < Puppet::Element
     def self.allclear
         @@allobjects.clear
         Puppet::Event::Subscription.clear
-        @@typeary.each { |subtype|
-            subtype.clear
+        @types.each { |name, type|
+            type.clear
         }
+        @finalized = false
     end
 
     # remove all of the instances of a single type
@@ -239,6 +297,9 @@ class Type < Puppet::Element
         if defined? @objects
             @objects.clear
         end
+        if defined? @aliases
+            @aliases.clear
+        end
     end
 
     # remove a specified object
@@ -260,6 +321,32 @@ class Type < Puppet::Element
         }
     end
 
+    # Perform any operations that need to be done between instance creation
+    # and instance evaluation.
+    def self.finalize
+        finished = {}
+        self.eachtype do |type|
+            type.each do |object|
+                unless finished.has_key?(object)
+                    object.finish
+                    finished[object] = true
+                end
+            end
+        end
+        self.mkdepends
+
+        @finalized = true
+    end
+
+    # Has the finalize method been called yet?
+    def self.finalized?
+        if defined? @finalized
+            return @finalized
+        else
+            return false
+        end
+    end
+
     # does the type have an object with the given name?
     def self.has_key?(name)
         return @objects.has_key?(name)
@@ -300,6 +387,7 @@ class Type < Puppet::Element
         unless defined? @validstates
             @validstates = Hash.new(false)
         end
+        return unless defined? @states
         @states.each { |stateklass|
             name = stateklass.name
             if @validstates.include?(name) 
@@ -315,19 +403,187 @@ class Type < Puppet::Element
         }
     end
 
-    # set the parameters for a type; probably only used by FileRecord
-    # objects
-    def self.parameters=(params)
-        Puppet.debug "setting parameters to [%s]" % params.join(" ")
-        @parameters = params.collect { |param|
-            if param.class == Symbol
-                param
-            else
-                param.intern
-            end
+    # Find the namevar
+    def self.namevar
+        unless defined? @namevar
+            return nil unless defined? @parameters and ! @parameters.empty?
+            @namevar = @parameters.find { |name, param|
+                param.isnamevar?
+                unless param
+                    raise Puppet::DevError, "huh? %s" % name
+                end
+            }[0].value
+        end
+        @namevar
+    end
+
+    # Copy an existing class parameter.  This allows other types to avoid
+    # duplicating a parameter definition, and is mostly used by subclasses
+    # of the File class.
+    def self.copyparam(klass, name)
+        param = klass.attrclass(name)
+
+        unless param
+            raise Puppet::DevError, "Class %s has no param %s" % [klass, name]
+        end
+        @parameters ||= []
+        @parameters << param
+
+        @paramhash ||= {}
+        @parameters.each { |p| @paramhash[name] = p }
+
+        if param.isnamevar?
+            @namevar = param.name
+        end
+    end
+
+    # 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)
+        param = Class.new(Puppet::Parameter) do
+            @name = name
+        end
+        param.ismetaparameter
+        param.class_eval(&block)
+        const_set("MetaParam" + name.to_s.capitalize,param)
+        @@metaparams ||= []
+        @@metaparams << param
+
+        @@metaparamhash ||= {}
+        @@metaparams.each { |p| @@metaparamhash[name] = p }
+    end
+
+    def self.eachmetaparam
+        @@metaparams.each { |p| yield p.name }
+    end
+
+    # 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)
+        param = Class.new(Puppet::Parameter) do
+            @name = name
+        end
+        param.element = self
+        param.class_eval(&block)
+        const_set("Parameter" + name.to_s.capitalize,param)
+        @parameters ||= []
+        @parameters << param
+
+        @paramhash ||= {}
+        @parameters.each { |p| @paramhash[name] = p }
+
+        # These might be enabled later.
+#        define_method(name) do
+#            @parameters[name].value
+#        end
+#
+#        define_method(name.to_s + "=") do |value|
+#            newparam(param, value)
+#        end
+
+        if param.isnamevar?
+            @namevar = param.name
+        end
+    end
+
+    # Create a new state.
+    def self.newstate(name, parent = nil, &block)
+        parent ||= Puppet::State
+        if @validstates.include?(name) 
+            raise Puppet::DevError, "Class %s already has a state named %s" %
+                [self.name, name]
+        end
+        s = Class.new(parent) do
+            @name = name
+        end
+        const_set("State" + name.to_s.capitalize,s)
+        s.class_eval(&block)
+        @states ||= []
+
+        # If it's the 'ensure' state, always put it first.
+        if name == :ensure
+            @states.unshift s
+        else
+            @states << s
+        end
+        @validstates[name] = s
+
+#        define_method(name) do
+#            @states[name].should
+#        end
+#
+#        define_method(name.to_s + "=") do |value|
+#            newstate(name, :should => value)
+#        end
+
+        return s
+    end
+
+    # Specify a block for generating a list of objects to autorequire.  This
+    # makes it so that you don't have to manually specify things that you clearly
+    # require.
+    def self.autorequire(name, &block)
+        @autorequires ||= {}
+        @autorequires[name] = block
+    end
+
+    # Yield each of those autorequires in turn, yo.
+    def self.eachautorequire
+        @autorequires ||= {}
+        @autorequires.each { |type, block|
+            yield(type, block)
         }
     end
 
+    # Return the parameter names
+    def self.parameters
+        return [] unless defined? @parameters
+        @parameters.collect { |klass| klass.name }
+    end
+
+    # Find the metaparameter class associated with a given metaparameter name.
+    def self.metaparamclass(name)
+        @@metaparamhash[name]
+    end
+
+    # Find the parameter class associated with a given parameter name.
+    def self.paramclass(name)
+        @paramhash[name]
+    end
+
+    # Find the class associated with any given attribute.
+    def self.attrclass(name)
+        @attrclasses ||= {}
+
+        # We cache the value, since this method gets called such a huge number
+        # of times (as in, hundreds of thousands in a given run).
+        unless @attrclasses.include?(name)
+            @attrclasses[name] = case self.attrtype(name)
+            when :state: @validstates[name]
+            when :meta: @@metaparamhash[name]
+            when :param: @paramhash[name]
+            end
+        end
+        @attrclasses[name]
+    end
+
+    def self.to_s
+        if defined? @name
+            "Puppet::Type::" + @name.to_s.capitalize
+        else
+            super
+        end
+    end
+
+    # Create a block to validate that our object is set up entirely.  This will
+    # be run before the object is operated on.
+    def self.validate(&block)
+        define_method(:validate, &block)
+        #@validate = block
+    end
+
     # does the name reflect a valid state?
     def self.validstate?(name)
         unless @validstates.length == @states.length
@@ -342,6 +598,7 @@ class Type < Puppet::Element
 
     # Return the list of validstates
     def self.validstates
+        return {} unless defined? @states
         unless @validstates.length == @states.length
             self.buildstatehash
         end
@@ -362,14 +619,75 @@ class Type < Puppet::Element
         unless defined? @parameters
             raise Puppet::DevError, "Class %s has not defined parameters" % self
         end
-        if @parameters.include?(name) or @@metaparams.include?(name)
+        if @paramhash.include?(name) or @@metaparamhash.include?(name)
             return true
         else
             return false
         end
     end
 
-    def self.validarg?(name)
+    # What type of parameter are we dealing with? Cache the results, because
+    # this method gets called so many times.
+    def self.attrtype(name)
+        @attrtypes ||= {}
+        unless @attrtypes.include?(name)
+            @attrtypes[name] = case
+                when @validstates.include?(name): :state
+                when @@metaparamhash.include?(name): :meta
+                when @paramhash.include?(name): :param
+                else
+                    raise Puppet::DevError, "Invalid attribute '%s' for class '%s'" %
+                        [name, self.name]
+                end
+        end
+
+        @attrtypes[name]
+    end
+
+    # All parameters, in the appropriate order.  The namevar comes first,
+    # then the states, then the params and metaparams in the order they
+    # were specified in the files.
+    def self.allattrs
+        # now get all of the arguments, in a specific order
+        # Cache this, since it gets called so many times
+        namevar = self.namevar
+
+        order = [namevar]
+        order << [self.states.collect { |state| state.name },
+            self.parameters,
+            self.metaparams].flatten.reject { |param|
+                # we don't want our namevar in there multiple times
+                param == namevar
+        }
+
+        order.flatten!
+
+        return order
+    end
+
+    # A similar function but one that yields the name, type, and class.
+    # This is mainly so that setdefaults doesn't call quite so many functions.
+    def self.eachattr(*ary)
+        # now get all of the arguments, in a specific order
+        # Cache this, since it gets called so many times
+
+        if ary.empty?
+            ary = nil
+        end
+        self.states.each { |state|
+            yield(state, :state) if ary.nil? or ary.include?(state.name)
+        }
+
+        @parameters.each { |param|
+            yield(param, :param) if ary.nil? or ary.include?(param.name)
+        }
+
+        @@metaparams.each { |param|
+            yield(param, :meta) if ary.nil? or ary.include?(param.name)
+        }
+    end
+
+    def self.validattr?(name)
         if name.is_a?(String)
             name = name.intern
         end
@@ -393,26 +711,35 @@ class Type < Puppet::Element
         if name == :name
             name = self.class.namevar
         end
-        if self.class.validstate?(name)
+        case self.class.attrtype(name)
+        when :state
             if @states.include?(name)
                 return @states[name].is
             else
                 return nil
             end
-        elsif Puppet::Type.metaparam?(name)
+        when :meta
             if @metaparams.include?(name)
-                return @metaparams[name]
+                return @metaparams[name].value
             else
-                return nil
+                if default = self.class.metaparamclass(name).default
+                    return default
+                else
+                    return nil
+                end
             end
-        elsif self.class.validparameter?(name)
+        when :param
             if @parameters.include?(name)
-                return @parameters[name]
+                return @parameters[name].value
             else
-                return nil
+                if default = self.class.paramclass(name).default
+                    return default
+                else
+                    return nil
+                end
             end
         else
-            raise TypeError.new("Invalid parameter %s" % [name])
+            raise TypeError.new("Invalid parameter %s(%s)" % [name, name.inspect])
         end
     end
 
@@ -430,11 +757,9 @@ class Type < Puppet::Element
         if value.nil?
             raise Puppet::Error.new("Got nil value for %s" % name)
         end
-        if Puppet::Type.metaparam?(name)
-            @parameters[name] = value
-            # call the metaparam method 
-            self.send(("meta" + name.id2name + "="),value)
-        elsif stateklass = self.class.validstate?(name) 
+
+        case self.class.attrtype(name)
+        when :state
             if value.is_a?(Puppet::State)
                 self.debug "'%s' got handed a state for '%s'" % [self,name]
                 @states[name] = value
@@ -450,15 +775,11 @@ class Type < Puppet::Element
                     end
                 end
             end
-        elsif self.class.validparameter?(name)
+        when :meta
+            self.newmetaparam(self.class.metaparamclass(name), value)
+        when :param
             # if they've got a method to handle the parameter, then do it that way
-            method = "param" + name.id2name + "="
-            if self.respond_to?(method)
-                self.send(method,value)
-            else
-                # else just set it
-                @parameters[name] = value
-            end
+            self.newparam(self.class.attrclass(name), value)
         else
             raise Puppet::Error, "Invalid parameter %s" % [name]
         end
@@ -475,8 +796,12 @@ class Type < Puppet::Element
         else
             if @states.has_key?(attr)
                 @states.delete(attr)
+            elsif @parameters.has_key?(attr)
+                @parameters.delete(attr)
+            elsif @metaparams.has_key?(attr)
+                @metaparams.delete(attr)
             else
-                raise Puppet::DevError.new("Undefined state '#{attr}' in #{self}")
+                raise Puppet::DevError.new("Undefined attribute '#{attr}' in #{self}")
             end
         end
     end
@@ -513,6 +838,32 @@ class Type < Puppet::Element
         }
     end
 
+    def devfail(msg)
+        self.fail(Puppet::DevError, msg)
+    end
+
+    # Throw an error, defaulting to a Puppet::Error
+    def fail(*args)
+        type = nil
+        if args[0].is_a?(Class)
+            type = args.shift
+        else
+            type = Puppet::Error
+        end
+
+        error = type.new(args.join(" "))
+
+        if defined? @line and @line
+            error.line = @line
+        end
+
+        if defined? @file and @file
+            error.file = @file
+        end
+
+        raise error
+    end
+
     # retrieve the 'is' value for a specified state
     def is(state)
         if @states.include?(state)
@@ -534,7 +885,7 @@ class Type < Puppet::Element
     # create a log at specified level
     def log(msg)
         Puppet::Log.create(
-            :level => @metaparams[:loglevel],
+            :level => @metaparams[:loglevel].value,
             :message => msg,
             :source => self
         )
@@ -558,10 +909,52 @@ class Type < Puppet::Element
         end
     end
 
+    # Create a new parameter.
+    def newparam(klass, value = nil)
+        newattr(:param, klass, value)
+    end
+
+    # Create a new parameter or metaparameter.  We'll leave the calling
+    # method to store it appropriately.
+    def newmetaparam(klass, value = nil)
+        newattr(:meta, klass, value)
+    end
+
+    # The base function that the others wrap.
+    def newattr(type, klass, value = nil)
+        # This should probably be a bit, um, different, but...
+        if type == :state
+            return newstate(klass)
+        end
+        param = klass.new
+        param.parent = self
+        if value
+            param.value = value
+        end
+
+        case type
+        when :meta
+            @metaparams[klass.name] = param
+        when :param
+            @parameters[klass.name] = param
+        else
+            self.devfail("Invalid param type %s" % type)
+        end
+
+        return param
+    end
+
     # create a new state
     def newstate(name, hash = {})
-        unless stateklass = self.class.validstate?(name) 
-            raise Puppet::Error, "Invalid parameter %s" % name
+        stateklass = nil
+        if name.is_a?(Class)
+            stateklass = name
+            name = stateklass.name
+        else
+            stateklass = self.class.validstate?(name) 
+            unless stateklass
+                self.fail("Invalid state %s" % name)
+            end
         end
         if @states.include?(name)
             hash.each { |var,value|
@@ -575,7 +968,7 @@ class Type < Puppet::Element
                 # make sure the state doesn't have any errors
                 newstate = stateklass.new(hash)
                 @states[name] = newstate
-                return true
+                return newstate
             rescue Puppet::Error => detail
                 # the state failed, so just ignore it
                 self.warning "State %s failed: %s" %
@@ -600,7 +993,7 @@ class Type < Puppet::Element
         unless name.is_a? Symbol
             name = name.intern
         end
-        return @parameters[name]
+        return @parameters[name].value
     end
 
     def push(*childs)
@@ -615,23 +1008,35 @@ class Type < Puppet::Element
 
     # Remove an object.  The argument determines whether the object's
     # subscriptions get eliminated, too.
-    def remove(rmdeps)
+    def remove(rmdeps = true)
         @children.each { |child|
-            child.remove
+            child.remove(rmdeps)
         }
-        self.class.delete(self)
 
         if rmdeps
             Puppet::Event::Subscription.dependencies(self).each { |dep|
-                self.unsubscribe(dep)
+                begin
+                    self.unsubscribe(dep)
+                rescue
+                    # ignore failed unsubscribes
+                end
             }
         end
+        self.class.delete(self)
 
         if defined? @parent and @parent
             @parent.delete(self)
         end
     end
 
+    # Is the named state defined?
+    def statedefined?(name)
+        unless name.is_a? Symbol
+            name = name.intern
+        end
+        return @states.include?(name)
+    end
+
     # return an actual type by name; to return the value, use 'inst[name]'
     # FIXME this method should go away
     def state(name)
@@ -652,8 +1057,9 @@ class Type < Puppet::Element
             end
         }
         unless tmpstates.length == @states.length
-            raise Puppet::DevError,
+            self.devfail(
                 "Something went very wrong with tmpstates creation"
+            )
         end
         return tmpstates
     end
@@ -697,7 +1103,7 @@ class Type < Puppet::Element
             else
                 # We will probably want to support merging of some kind in
                 # the future, but for now, just throw an error.
-                raise Puppet::Error, "%s %s is already being managed" %
+                raise Puppet::Error, "%s '%s' is already being managed" %
                     [self.name, name]
                 #retobj.merge(hash)
 
@@ -711,9 +1117,7 @@ class Type < Puppet::Element
             obj = new(hash)
         rescue => detail
             if Puppet[:debug]
-                if detail.respond_to?(:stack)
-                    puts detail.stack
-                end
+                puts detail.backtrace
             end
             Puppet.err "Could not create %s: %s" % [name, detail.to_s]
             if obj
@@ -757,8 +1161,7 @@ class Type < Puppet::Element
         private :new
     end
 
-    # initialize the type instance
-    def initialize(hash)
+    def initvars
         @children = []
         @evalcount = 0
 
@@ -782,72 +1185,245 @@ class Type < Puppet::Element
         unless defined? @metaparams
             @metaparams = Hash.new(false)
         end
-           
-        #unless defined? @paramdoc
-        #   @paramdoc = Hash.new { |hash,key|
-        #      if key.is_a?(String)
-        #         key = key.intern
-        #      end
-        #      if hash.include?(key)
-        #         hash[key]
-        #      else
-        #         "Param Documentation for %s not found" % key
-        #      end
-        #   }
-        #end
 
         # set defalts
         @noop = false
-        @metaparams[:loglevel] = :notice
         # keeping stats for the total number of changes, and how many were
         # completely sync'ed
-        # this isn't really sufficient either, because it adds lots of special cases
-        # such as failed changes
+        # this isn't really sufficient either, because it adds lots of special
+        # cases such as failed changes
         # it also doesn't distinguish between changes from the current transaction
         # vs. changes over the process lifetime
         @totalchanges = 0
         @syncedchanges = 0
         @failedchanges = 0
 
+        @inited = true
+    end
+
+    # initialize the type instance
+    def initialize(hash)
+        unless defined? @inited
+            self.initvars
+        end
+
+        # If we got passed a transportable object, we just pull a bunch of info
+        # directly from it.
+        if hash.is_a?(Puppet::TransObject)
+            #self[:name] = hash[:name]
+            [:file, :line, :tags].each { |getter|
+                if hash.respond_to?(getter)
+                    setter = getter.to_s + "="
+                    if val = hash.send(getter)
+                        self.send(setter, val)
+                    end
+                end
+            }
+            hash = hash.to_hash
+        end
+
         # Before anything else, set our parent if it was included
         if hash.include?(:parent)
             @parent = hash[:parent]
             hash.delete(:parent)
         end
 
+        # Convert all args to symbols
         hash = self.argclean(hash)
 
-        # now get all of the arguments, in a specific order
-        order = [self.class.namevar]
-        order << [self.class.states.collect { |state| state.name },
-            self.class.parameters,
-            self.class.eachmetaparam { |param| param }].flatten.reject { |param|
-                # we don't want our namevar in there multiple times
-                param == self.class.namevar
-        }
-  
-        order.flatten.each { |name|
+        # Let's do the name first, because some things need to happen once
+        # we have the name but before anything else
+
+        attrs = self.class.allattrs
+        namevar = self.class.namevar
+
+        if hash.include?(namevar)
+            #self.send(namevar.to_s + "=", hash[namevar])
+            self[namevar] = hash[namevar]
+            hash.delete(namevar)
+            if attrs.include?(namevar)
+                attrs.delete(namevar)
+            else
+                self.devfail "My namevar isn't a valid attribute...?"
+            end
+        else
+            self.devfail "I was not passed a namevar"
+        end
+
+        # The information to cache to disk.  We have to do this after
+        # the name is set because it uses the name and/or path, but before
+        # everything else is set because the states need to be able to
+        # retrieve their stored info.
+        #@cache = Puppet::Storage.cache(self)
+
+        # This is all of our attributes except the namevar.
+        attrs.each { |name|
             if hash.include?(name)
                 begin
                     self[name] = hash[name]
                 rescue => detail
-                    raise Puppet::DevError.new( 
-                        "Could not set %s on %s: %s" % [name, self.class.name, detail]
+                    self.devfail(
+                        "Could not set %s on %s: %s" %
+                            [name, self.class.name, detail]
                     )
                 end
                 hash.delete name
             end
         }
 
+        # While this could theoretically be set after all of the objects are
+        # created, it seems to make more sense to set them immediately.
+        self.setdefaults
+
         if hash.length > 0
             self.debug hash.inspect
-            raise Puppet::Error.new("Class %s does not accept argument(s) %s" %
+            self.fail("Class %s does not accept argument(s) %s" %
                 [self.class.name, hash.keys.join(" ")])
         end
 
         # add this object to the specific class's list of objects
         #puts caller
         self.class[self.name] = self
+
+        if self.respond_to?(:validate)
+            self.validate
+        end
+    end
+
+    # Figure out of there are any objects we can automatically add as
+    # dependencies.
+    def autorequire
+        self.class.eachautorequire { |type, block|
+            # Ignore any types we can't find, although that would be a bit odd.
+            next unless typeobj = Puppet.type(type)
+
+            # Retrieve the list of names from the block.
+            next unless list = self.instance_eval(&block)
+            unless list.is_a?(Array)
+                list = [list]
+            end
+
+            # Collect the current prereqs
+            list.each { |dep|
+                # Skip autorequires that we aren't managing
+                next unless obj = typeobj[dep]
+
+                # Skip autorequires that we already require
+                next if self.requires?(obj)
+                self.info "Auto-requiring %s" % obj.name
+
+                self[:require] = [type, dep]
+            }
+
+            #self.info reqs.inspect
+            #self[:require] = reqs
+        }
+    end
+
+    # Set up all of our autorequires.
+    def finish
+        self.autorequire
+
+        # Scheduling has to be done when the whole config is instantiated, so
+        # that file order doesn't matter in finding them.
+        self.schedule
+    end
+
+    # Return a cached value
+    def cached(name)
+        Puppet::Storage.cache(self)[name]
+        #@cache[name] ||= nil
+    end
+
+    # Cache a value
+    def cache(name, value)
+        Puppet::Storage.cache(self)[name] = value
+        #@cache[name] = value
+    end
+
+    # Look up the schedule and set it appropriately.  This is done after
+    # the instantiation phase, so that the schedule can be anywhere in the
+    # file.
+    def schedule
+
+        # If we've already set the schedule, then just move on
+        return if self[:schedule].is_a?(Puppet.type(:schedule))
+
+        return unless self[:schedule]
+
+        # Schedules don't need to be scheduled
+        #return if self.is_a?(Puppet.type(:schedule))
+
+        # Nor do components
+        #return if self.is_a?(Puppet.type(:component))
+
+        if sched = Puppet.type(:schedule)[self[:schedule]]
+            self[:schedule] = sched
+        else
+            self.fail "Could not find schedule %s" % self[:schedule]
+        end
+#        if self[:schedule]
+#        elsif Puppet[:schedule] and ! Puppet[:ignoreschedules]
+#            # We handle schedule defaults here mostly because otherwise things
+#            # will behave very very erratically during testing.
+#            if sched = Puppet.type(:schedule)[Puppet[:schedule]]
+#                self[:schedule] = sched
+#            else
+#                self.fail "Could not find default schedule %s" % Puppet[:schedule]
+#            end
+#        else
+#            # While it's unlikely we won't have any schedule (since there's a
+#            # default), it's at least possible during testing
+#            return true
+#        end
+    end
+
+    # Check whether we are scheduled to run right now or not.
+    def scheduled?
+        return true if Puppet[:ignoreschedules]
+        return true unless schedule = self[:schedule]
+
+        # We use 'checked' here instead of 'synced' because otherwise we'll
+        # end up checking most elements most times, because they will generally
+        # have been synced a long time ago (e.g., a file only gets updated
+        # once a month on the server and its schedule is daily; the last sync time
+        # will have been a month ago, so we'd end up checking every run).
+        return schedule.match?(self.cached(:checked).to_i)
+    end
+
+    # Is the specified parameter set?
+    def attrset?(type, attr)
+        case type
+        when :state: return @states.include?(attr)
+        when :param: return @parameters.include?(attr)
+        when :meta: return @metaparams.include?(attr)
+        else
+            self.devfail "Invalid set type %s" % [type]
+        end
+    end
+
+#    def set(name, value)
+#        send(name.to_s + "=", value)
+#    end
+#
+#    def get(name)
+#        send(name)
+#    end
+
+    # For any parameters or states that have defaults and have not yet been
+    # set, set them now.
+    def setdefaults(*ary)
+        self.class.eachattr(*ary) { |klass, type|
+            # not many attributes will have defaults defined, so we short-circuit
+            # those away
+            next unless klass.method_defined?(:default)
+            next if self.attrset?(type, klass.name)
+
+            obj = self.newattr(type, klass)
+            #self.debug "defaulting %s to %s" % [obj.name, obj.default]
+            obj.value = obj.default
+        }
+
     end
 
     # Merge new information with an existing object, checking for conflicts
@@ -880,10 +1456,10 @@ class Type < Puppet::Element
                 # take the intersection
                 newvals = oldvals & value
                 if newvals.empty?
-                    raise Puppet::Error, "No common values for %s on %s(%s)" %
+                    self.fail "No common values for %s on %s(%s)" %
                         [param, self.class.name, self.name]
                 elsif newvals.length > 1
-                    raise Puppet::Error, "Too many values for %s on %s(%s)" %
+                    self.fail "Too many values for %s on %s(%s)" %
                         [param, self.class.name, self.name]
                 else
                     self.debug "Reduced old values %s and new values %s to %s" %
@@ -903,18 +1479,18 @@ class Type < Puppet::Element
         unless defined? @name and @name
             namevar = self.class.namevar
             if self.class.validparameter?(namevar)
-                @name = @parameters[namevar]
+                @name = self[:name]
             elsif self.class.validstate?(namevar)
                 @name = self.should(namevar)
             else
-                raise Puppet::DevError, "Could not find namevar %s for %s" %
+                self.devfail "Could not find namevar %s for %s" %
                     [namevar, self.class.name]
             end
         end
 
         unless @name
-            raise Puppet::DevError, "Could not find name %s for %s" %
-                [namevar, self.class.name]
+            self.devfail "Could not find namevar '%s' for %s" %
+                [self.class.namevar, self.class.name]
         end
 
         return @name
@@ -922,9 +1498,11 @@ class Type < Puppet::Element
 
     # fix any namevar => param translations
     def argclean(hash)
-        # we have to set the name of our object before anything else,
-        # because it might be used in creating the other states
-        hash = hash.dup
+        # We have to set the name of our object before anything else,
+        # because it might be used in creating the other states.  We dup and
+        # then convert to a hash here because TransObjects behave strangely
+        # here.
+        hash = hash.dup.to_hash
 
         if hash.include?(:parent)
             hash.delete(:parent)
@@ -960,28 +1538,11 @@ class Type < Puppet::Element
     def retrieve
         # it's important to use the method here, as it follows the order
         # in which they're defined in the object
-        states.each { |state|
+        states().each { |state|
             state.retrieve
         }
     end
 
-    # sync the changes to disk, and return the events generated by the changes
-    # FIXME this method is essentially obviated, but it's still used by tests
-    # and i don't feel like fixing it yet
-    def sync
-        #raise Puppet::DevError, "Type#sync called"
-        events = self.collect { |child|
-            child.sync
-        }.reject { |event|
-            ! (event.is_a?(Symbol) or event.is_a?(String))
-        }.flatten
-
-        #Puppet.notice "got events %s" % events.inspect
-
-        Puppet::Metric.addevents(self.class,self,events)
-        return events
-    end
-
     # convert to a string
     def to_s
         self.name
@@ -1001,12 +1562,42 @@ class Type < Puppet::Element
         end
     end
 
+    # Retrieve the changes associated with all of the states.
+    def statechanges
+        # If we are changing the existence of the object, then none of
+        # the other states matter.
+        if @states.include?(:ensure) and ! @states[:ensure].insync?
+            #self.info "ensuring %s from %s" %
+            #    [@states[:ensure].should, @states[:ensure].is]
+            return [Puppet::StateChange.new(@states[:ensure])]
+        # Else, if the 'ensure' state is correctly absent, then do
+        # nothing
+        elsif @states.include?(:ensure) and @states[:ensure].is == :absent
+            #self.info "Object is correctly absent"
+            return []
+        else
+            #if @states.include?(:ensure)
+            #    self.info "ensure: Is: %s, Should: %s" %
+            #        [@states[:ensure].is, @states[:ensure].should]
+            #else
+            #    self.info "no ensure state"
+            #end
+            return states().find_all { |state|
+                ! state.insync?
+            }.collect { |state|
+                Puppet::StateChange.new(state)
+            }
+        end
+    end
+
     # this method is responsible for collecting state changes
     # we always descend into the children before we evaluate our current
     # states
     # this returns any changes resulting from testing, thus 'collect'
     # rather than 'each'
     def evaluate
+        now = Time.now
+
         #Puppet.err "Evaluating %s" % self.path.join(":")
         unless defined? @evalcount
             self.err "No evalcount defined on '%s' of type '%s'" %
@@ -1040,11 +1631,7 @@ class Type < Puppet::Element
 
         # states() is a private method, returning an ordered list
         unless self.class.depthfirst?
-            changes << states().find_all { |state|
-                ! state.insync?
-            }.collect { |state|
-                Puppet::StateChange.new(state)
-            }
+            changes += statechanges()
         end
 
         if changes.length > 0
@@ -1054,7 +1641,9 @@ class Type < Puppet::Element
         #end
 
         changes << @children.collect { |child|
-            child.evaluate
+            ch = child.evaluate
+            child.cache(:checked, now)
+            ch
         }
         #unless self.class.depthfirst?
         #    changes << self.collect { |child|
@@ -1068,11 +1657,7 @@ class Type < Puppet::Element
         #}
 
         if self.class.depthfirst?
-            changes << states().find_all { |state|
-                ! state.insync?
-            }.collect { |state|
-                Puppet::StateChange.new(state)
-            }
+            changes += statechanges()
         end
 
         changes.flatten!
@@ -1086,6 +1671,7 @@ class Type < Puppet::Element
             #    self.debug "change: %s" % change.state.name
             #}
         end
+        self.cache(:checked, now)
         return changes.flatten
     end
 
@@ -1095,10 +1681,16 @@ class Type < Puppet::Element
     def insync?
         insync = true
 
+        if state = @states[:ensure]
+            if state.insync? and state.should == :absent
+                return true
+            end
+        end
+
         states.each { |state|
             unless state.insync?
                 self.debug("%s is not in sync: %s vs %s" %
-                    [state, state.is, state.should])
+                    [state, state.is.inspect, state.should.inspect])
                 insync = false
             end
         }
@@ -1110,95 +1702,57 @@ class Type < Puppet::Element
     # Meta-parameter methods:  These methods deal with the results
     # of specifying metaparameters
 
-    def self.eachmetaparam
-        @@metaparams.each { |param|
-            yield param
-        }
-    end
-
-    # This just marks states that we definitely want to retrieve values
-    # on.  There is currently no way to uncheck a parameter.
-    def metacheck=(args)
-        unless args.is_a?(Array)
-            args = [args]
-        end
-
-        # these are states that we might not have 'should'
-        # values for but we want to retrieve 'is' values for anyway
-        args.each { |state|
-            unless state.is_a?(Symbol)
-                state = state.intern
-            end
-            next if @states.include?(state)
-
-            stateklass = nil
-            self.newstate(state)
-        }
+    def self.metaparams
+        @@metaparams.collect { |param| param.name }
     end
 
     # Is the parameter in question a meta-parameter?
     def self.metaparam?(param)
-        @@metaparams.include?(param)
+        @@metaparamhash.include?(param)
     end
 
-    # for each object we require, subscribe to all events that it
-    # generates
-    # we might reduce the level of subscription eventually, but for now...
-    def metarequire=(requires)
-        self.handledepends(requires, :NONE, nil)
-    end
-
-    # for each object we require, subscribe to all events that it
-    # generates
-    # we might reduce the level of subscription eventually, but for now...
-    def metasubscribe=(requires)
-        self.handledepends(requires, :ALL_EVENTS, :refresh)
-    end
+    # Subscription and relationship methods
 
-    def metanoop=(noop)
-        if noop == "true" or noop == true
-            @noop = true
-        elsif noop == "false" or noop == false
-            @noop = false
-        else
-            raise Puppet::Error.new("Invalid noop value '%s'" % noop)
-        end
-    end
+    #def addcallback(object, event, method)
+    #    @callbacks[object][event] = method
+    #end
 
-    # Currently nonfunctional
-    def metaonerror=(response)
-        self.debug("Would have called metaonerror")
-        @onerror = response
+    # Build all of the dependencies for all of the different types.  This is called
+    # after all of the objects are instantiated, so that we don't depend on
+    # file order.  If we didn't use this (and instead just checked dependencies
+    # as we came across them), any required object would have to come before the
+    # requiring object in the file(s).
+    def self.mkdepends
+        @types.each { |name, type|
+            type.each { |obj|
+                obj.builddepends
+            }
+        }
     end
 
-    # Currently nonfunctional
-    def metaschedule=(schedule)
-        @schedule = schedule
+    # The per-type version of dependency building.  This actually goes through
+    # all of the objects themselves and builds deps.
+    def self.builddepends
+        return unless defined? @objects
+        @objects.each { |name, obj|
+            obj.builddepends
+        }
     end
 
-    # Determines what our objects log at.  Defaults to :notice.
-    def metaloglevel=(loglevel)
-        if loglevel.is_a?(String)
-            loglevel = loglevel.intern
+    # Build the dependencies associated with an individual object.
+    def builddepends
+        # Handle the requires
+        if self[:require]
+            self.handledepends(self[:require], :NONE, nil)
         end
-        if loglevel == :verbose
-            loglevel = :info 
-        end        
 
-        if Puppet::Log.validlevel?(loglevel)
-            @metaparams[:loglevel] = loglevel
-        else
-            raise Puppet::Error.new("Invalid loglevel '%s'" % loglevel)       
+        # And the subscriptions
+        if self[:subscribe]
+            self.handledepends(self[:subscribe], :ALL_EVENTS, :refresh)
         end
     end
 
-    # Subscription and relationship methods
-
-    #def addcallback(object, event, method)
-    #    @callbacks[object][event] = method
-    #end
-
-    # return all objects subscribed to the current object
+    # return all objects that we depend on
     def eachdependency
         Puppet::Event::Subscription.dependencies(self).each { |dep|
             yield dep.source
@@ -1225,11 +1779,11 @@ class Type < Puppet::Element
             object = nil
             tname = rname[0]
             unless type = Puppet::Type.type(tname)
-                raise Puppet::Error, "Could not find type %s" % tname
+                self.fail "Could not find type %s" % tname.inspect
             end
             name = rname[1]
             unless object = type[name]
-                raise Puppet::Error, "Could not retrieve object '%s' of type '%s'" %
+                self.fail "Could not retrieve object '%s' of type '%s'" %
                     [name,type]
             end
             self.debug("subscribes to %s" % [object])
@@ -1253,10 +1807,6 @@ class Type < Puppet::Element
                 subargs[:callback] = method
             end
             Puppet::Event::Subscription.new(subargs)
-            #if self.respond_to?(method)
-            #    self.addcallback(object, event, method)
-            #end
-            #object.addnotify(self)
         }
     end
 
@@ -1270,6 +1820,18 @@ class Type < Puppet::Element
         end
     end
 
+    def requires?(object)
+        req = false
+        self.eachdependency { |dep|
+            if dep == object
+                req = true
+                break
+            end
+        }
+
+        return req
+    end
+
     def subscribe(hash)
         hash[:source] = self
         Puppet::Event::Subscription.new(hash)
@@ -1291,15 +1853,6 @@ class Type < Puppet::Element
         }
     end
 
-    # return all of the subscriptions to a given event
-    #def subscribers?(event)
-    #    Puppet::Event::Subscription.subscriptions(self).find_all { |sub|
-    #        sub.match?(event)
-    #    }.collect { |sub|
-    #        sub.target
-    #    }
-    #end
-
     # we've received an event
     # we only support local events right now, so we can pass actual
     # objects around, including the transaction object
@@ -1327,10 +1880,239 @@ class Type < Puppet::Element
 
     # Documentation methods
     def self.paramdoc(param)
-        @paramdoc[param]
+        @paramhash[param].doc
     end
     def self.metaparamdoc(metaparam)
-        @@metaparamdoc[metaparam]
+        @@metaparamhash[metaparam].doc
+    end
+
+    # Add all of the meta parameters.
+    #newmetaparam(:onerror) do
+    #    desc "How to handle errors -- roll back innermost
+    #        transaction, roll back entire transaction, ignore, etc.  Currently
+    #        non-functional."
+    #end
+
+    newmetaparam(:noop) do
+        desc "Boolean flag indicating whether work should actually
+            be done.  *true*/**false**"
+        munge do |noop|
+            if noop == "true" or noop == true
+                return true
+            elsif noop == "false" or noop == false
+                return false
+            else
+                self.fail("Invalid noop value '%s'" % noop)
+            end
+        end
+    end
+
+    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 { daily:
+                    period => daily,
+                    range => \"2-4\"
+                }
+
+                exec { \"/usr/bin/apt-get update\":
+                    schedule => daily
+                }
+
+            The creation of the schedule object does not need to appear in the
+            configuration before objects that use it."
+
+        munge do |name|
+            if schedule = Puppet.type(:schedule)[name]
+                return schedule
+            else
+                return name
+            end
+        end
+    end
+
+    newmetaparam(:check) do
+        desc "States which should have their values retrieved
+            but which should not actually be modified.  This is currently used
+            internally, but will eventually be used for querying, so that you
+            could specify that you wanted to check the install state of all
+            packages, and then query the Puppet client daemon to get reports
+            on all packages."
+
+        munge do |args|
+            unless args.is_a?(Array)
+                args = [args]
+            end
+
+            unless defined? @parent
+                self.devfail "No parent for %s, %s?" %
+                    [self.class, self.name]
+            end
+
+            args.each { |state|
+                unless state.is_a?(Symbol)
+                    state = state.intern
+                end
+                next if @parent.statedefined?(state)
+
+                @parent.newstate(state)
+            }
+        end
+    end
+    # For each object we require, subscribe to all events that it generates. We
+    # might reduce the level of subscription eventually, but for now...
+    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::
+            
+                # Create the destination directory before you copy things down
+                file { \"/usr/local/scripts\":
+                    ensure => directory
+                }
+
+                file { \"/usr/local/scripts/myscript\":
+                    source => \"puppet://server/module/myscript\",
+                    mode => 755,
+                    require => file[\"/usr/local/scripts\"]
+                }
+
+            Note that Puppet will autorequire everything that it can, and
+            there are hooks in place so that it's easy for elements to add new
+            ways to autorequire objects, so if you think Puppet could be
+            smarter here, let us know.
+
+            In fact, the above code was redundant -- Puppet will autorequire
+            any parent directories that are being managed; it will
+            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
+            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
+            file down would be automatically listed as a requirement to the
+            ``exec`` code, so that you would always be running againts the
+            most recent version.
+            "
+
+        # Take whatever dependencies currently exist and add these.
+        # Note that this probably doesn't behave correctly with unsubscribe.
+        munge do |requires|
+            # We need to be two arrays deep...
+            unless requires.is_a?(Array)
+                requires = [requires]
+            end
+            unless requires[0].is_a?(Array)
+                requires = [requires]
+            end
+            if values = @parent[:require]
+                requires = values + requires
+            end
+            requires
+            #p @parent[:require]
+            #@parent.handledepends(requires, :NONE, nil)
+        end
+    end
+
+    # For each object we require, subscribe to all events that it generates.
+    # We might reduce the level of subscription eventually, but for now...
+    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::
+            
+                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]
+                    }
+                }
+            "
+
+        munge do |requires|
+            if values = @parent[:subscribe]
+                requires = values + requires
+            end
+            requires
+        #    @parent.handledepends(requires, :ALL_EVENTS, :refresh)
+        end
+    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)."
+        defaultto :notice
+
+        validate do |loglevel|
+            if loglevel.is_a?(String)
+                loglevel = loglevel.intern
+            end
+            unless Puppet::Log.validlevel?(loglevel)
+                self.fail "Invalid log level %s" % loglevel
+            end
+        end
+
+        munge do |loglevel|
+            if loglevel.is_a?(String)
+                loglevel = loglevel.intern
+            end
+            if loglevel == :verbose
+                loglevel = :info 
+            end        
+            loglevel
+        end
+    end
+
+    newmetaparam(:alias) do
+        desc "Creates an alias for the object.  This simplifies lookup of the
+            object so is useful in the language.  It is especially useful when
+            you are creating long commands using exec or when many different
+            systems call a given package_ different names::
+
+            
+                file { \"/usr/local/scripts/myscript\":
+                    source => \"puppet://server/module/myscript\",
+                    mode => 755,
+                    alias => myscript
+                }
+
+                exec { \"/usr/local/scripts/myscript\":
+                    require => file[myscript]
+                }
+            
+            Again, this is somewhat redundant, since any sane person would
+            just use a variable (unless the two statements were in different
+            scopes), and Puppet will autorequire the script anyway, but it
+            gets the point across."
+
+        munge do |aliases|
+            unless aliases.is_a?(Array)
+                aliases = [aliases]
+            end
+            @parent.info "Adding aliases %s" % aliases.join(", ")
+            aliases.each do |other|
+                if obj = @parent.class[other]
+                    unless obj == @parent
+                        self.fail(
+                            "%s an not create alias %s: object already exists" %
+                            [@parent.name, other]
+                        )
+                    end
+                    next
+                end
+                @parent.class.alias(other, @parent)
+            end
+        end
     end
 end # Puppet::Type
 end
@@ -1343,12 +2125,11 @@ require 'puppet/type/group'
 require 'puppet/type/package'
 require 'puppet/type/pfile'
 require 'puppet/type/pfilebucket'
+require 'puppet/type/schedule'
 require 'puppet/type/service'
 require 'puppet/type/symlink'
 require 'puppet/type/user'
 require 'puppet/type/tidy'
-#require 'puppet/type/typegen'
-#require 'puppet/type/typegen/filetype'
-#require 'puppet/type/typegen/filerecord'
+require 'puppet/type/parsedtype'
 
-# $Id: type.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: type.rb 886 2006-02-08 17:45:26Z luke $