puppet 0.9.2

data/lib/puppet/type.rb

@@ -0,0 +1,1354 @@
+require 'puppet'
+require 'puppet/log'
+require 'puppet/element'
+require 'puppet/event'
+require 'puppet/metric'
+require 'puppet/type/state'
+# 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.
+class Type < Puppet::Element
+    attr_accessor :children, :parameters, :parent
+    attr_accessor :file, :line, :tags
+
+    attr_writer :implicit
+    def implicit?
+        if defined? @implicit and @implicit
+            return true
+        else
+            return false
+        end
+    end
+
+    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
+    @name = :puppet
+
+    # set it to something to silence the tests, but otherwise not used
+    @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
+        end
+        if hash.include?(key)
+            hash[key]
+        else
+            raise TypeError.new("Object type %s not found" % key)
+        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
+            else
+                @@typehash[otype.name] = otype
+            end
+        }
+    end
+
+    # iterate across all of the subclasses of Type
+    def self.eachtype
+        @@typeary.each { |type| yield type }
+    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
+        @objects = Hash.new
+
+        @validstates = {}
+
+        @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
+        }
+
+        unless defined? @doc
+            @doc = ""
+        end
+
+        unless defined? @states
+            @states = []
+        end
+
+    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
+        end
+        @@typehash[type]
+    end
+
+    # class methods dealing with type instance management
+
+    public
+
+    # retrieve a named instance of the current type
+    def self.[](name)
+        if @objects.has_key?(name)
+            return @objects[name]
+        else
+            return nil
+        end
+    end
+
+    # add an instance by name to the class list of instances
+    def self.[]=(name,object)
+        newobj = nil
+        if object.is_a?(Puppet::Type)
+            newobj = object
+        else
+            raise Puppet::DevError, "must pass a Puppet::Type object"
+        end
+
+        if @objects.has_key?(newobj.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]
+            )
+        else
+            #debug("adding %s of type %s to class list" %
+            #    [object.name,object.class])
+            @objects[newobj.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
+        @@typeary.each { |subtype|
+            subtype.clear
+        }
+    end
+
+    # remove all of the instances of a single type
+    def self.clear
+        if defined? @objects
+            @objects.clear
+        end
+    end
+
+    # 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)
+        end
+    end
+
+    # iterate across each of the type's instances
+    def self.each
+        return unless defined? @objects
+        @objects.each { |name,instance|
+            yield instance
+        }
+    end
+
+    # does the type have an object with the given name?
+    def self.has_key?(name)
+        return @objects.has_key?(name)
+    end
+
+    # Allow an outside party to specify the 'is' value for a state.  The
+    # arguments are an array because you can't use parens with 'is=' calls.
+    # Most classes won't use this.
+    def is=(ary)
+        param, value = ary
+        if param.is_a?(String)
+            param = param.intern
+        end
+        if self.class.validstate?(param)
+            unless @states.include?(param)
+                self.newstate(param)
+            end
+            @states[param].is = value
+        else
+            self[param] = value
+        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
+
+    # build a per-Type hash, mapping the states to their names
+    def self.buildstatehash
+        unless defined? @validstates
+            @validstates = Hash.new(false)
+        end
+        @states.each { |stateklass|
+            name = stateklass.name
+            if @validstates.include?(name) 
+                if @validstates[name] != stateklass
+                    raise Puppet::Error.new("Redefining state %s(%s) in %s" %
+                        [name,stateklass,self])
+                else
+                    # it's already there, so don't bother
+                end
+            else
+                @validstates[name] = stateklass
+            end
+        }
+    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
+        }
+    end
+
+    # does the name reflect a valid state?
+    def self.validstate?(name)
+        unless @validstates.length == @states.length
+            self.buildstatehash
+        end
+        if @validstates.include?(name)
+            return @validstates[name]
+        else
+            return false
+        end
+    end
+
+    # Return the list of validstates
+    def self.validstates
+        unless @validstates.length == @states.length
+            self.buildstatehash
+        end
+
+        return @validstates.keys
+    end
+
+    # Return the state class associated with a name
+    def self.statebyname(name)
+        unless @validstates.length == @states.length
+            self.buildstatehash
+        end
+        @validstates[name]
+    end
+
+    # does the name reflect a valid parameter?
+    def self.validparameter?(name)
+        unless defined? @parameters
+            raise Puppet::DevError, "Class %s has not defined parameters" % self
+        end
+        if @parameters.include?(name) or @@metaparams.include?(name)
+            return true
+        else
+            return false
+        end
+    end
+
+    def self.validarg?(name)
+        if name.is_a?(String)
+            name = name.intern
+        end
+        if self.validstate?(name) or self.validparameter?(name) or self.metaparam?(name)
+            return true
+        else
+            return false
+        end
+    end
+
+    # abstract accessing parameters and states, and normalize
+    # access to always be symbols, not strings
+    # This returns a value, not an object.  It returns the 'is'
+    # value, but you can also specifically return 'is' and 'should'
+    # values using 'object.is(:state)' or 'object.should(:state)'.
+    def [](name)
+        if name.is_a?(String)
+            name = name.intern
+        end
+
+        if name == :name
+            name = self.class.namevar
+        end
+        if self.class.validstate?(name)
+            if @states.include?(name)
+                return @states[name].is
+            else
+                return nil
+            end
+        elsif Puppet::Type.metaparam?(name)
+            if @metaparams.include?(name)
+                return @metaparams[name]
+            else
+                return nil
+            end
+        elsif self.class.validparameter?(name)
+            if @parameters.include?(name)
+                return @parameters[name]
+            else
+                return nil
+            end
+        else
+            raise TypeError.new("Invalid parameter %s" % [name])
+        end
+    end
+
+    # Abstract setting parameters and states, and normalize
+    # access to always be symbols, not strings.  This sets the 'should'
+    # value on states, and otherwise just sets the appropriate parameter.
+    def []=(name,value)
+        if name.is_a?(String)
+            name = name.intern
+        end
+
+        if name == :name
+            name = self.class.namevar
+        end
+        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) 
+            if value.is_a?(Puppet::State)
+                self.debug "'%s' got handed a state for '%s'" % [self,name]
+                @states[name] = value
+            else
+                if @states.include?(name)
+                    @states[name].should = value
+                else
+                    # newstate returns true if it successfully created the state,
+                    # false otherwise; I just don't know what to do with that
+                    # fact.
+                    unless newstate(name, :should => value)
+                        #self.info "%s failed" % name
+                    end
+                end
+            end
+        elsif self.class.validparameter?(name)
+            # 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
+        else
+            raise Puppet::Error, "Invalid parameter %s" % [name]
+        end
+    end
+
+    # remove a state from the object; useful in testing or in cleanup
+    # when an error has been encountered
+    def delete(attr)
+        case attr
+        when Puppet::Type
+            if @children.include?(attr)
+                @children.delete(attr)
+            end
+        else
+            if @states.has_key?(attr)
+                @states.delete(attr)
+            else
+                raise Puppet::DevError.new("Undefined state '#{attr}' in #{self}")
+            end
+        end
+    end
+
+    # iterate across all children, and then iterate across states
+    # we do children first so we're sure that all dependent objects
+    # are checked first
+    # we ignore parameters here, because they only modify how work gets
+    # done, they don't ever actually result in work specifically
+    def each
+        # we want to return the states in the order that each type
+        # specifies it, because it may (as in the case of File#create)
+        # be important
+        if self.class.depthfirst?
+            @children.each { |child|
+                yield child
+            }
+        end
+        self.eachstate { |state|
+            yield state
+        }
+        unless self.class.depthfirst?
+            @children.each { |child|
+                yield child
+            }
+        end
+    end
+
+    # iterate across the existing states
+    def eachstate
+        # states() is a private method
+        states().each { |state|
+            yield state
+        }
+    end
+
+    # retrieve the 'is' value for a specified state
+    def is(state)
+        if @states.include?(state)
+            return @states[state].is
+        else
+            return nil
+        end
+    end
+
+    # retrieve the 'should' value for a specified state
+    def should(state)
+        if @states.include?(state)
+            return @states[state].should
+        else
+            return nil
+        end
+    end
+    
+    # create a log at specified level
+    def log(msg)
+        Puppet::Log.create(
+            :level => @metaparams[:loglevel],
+            :message => msg,
+            :source => self
+        )
+    end
+
+    # is the instance a managed instance?  A 'yes' here means that
+    # the instance was created from the language, vs. being created
+    # in order resolve other questions, such as finding a package
+    # in a list
+    def managed?
+        if defined? @managed
+            return @managed
+        else
+            @managed = false
+            states.each { |state|
+                if state.should and ! state.class.unmanaged
+                    @managed = true
+                end
+            }
+            return @managed
+        end
+    end
+
+    # create a new state
+    def newstate(name, hash = {})
+        unless stateklass = self.class.validstate?(name) 
+            raise Puppet::Error, "Invalid parameter %s" % name
+        end
+        if @states.include?(name)
+            hash.each { |var,value|
+                @states[name].send(var.to_s + "=", value)
+            }
+        else
+            #Puppet.warning "Creating state %s for %s" %
+            #    [stateklass.name,self.name]
+            begin
+                hash[:parent] = self
+                # make sure the state doesn't have any errors
+                newstate = stateklass.new(hash)
+                @states[name] = newstate
+                return true
+            rescue Puppet::Error => detail
+                # the state failed, so just ignore it
+                self.warning "State %s failed: %s" %
+                    [name, detail]
+                return false
+            rescue Puppet::DevError => detail
+                # the state failed, so just ignore it
+                self.err "State %s failed: %s" %
+                    [name, detail]
+                return false
+            rescue => detail
+                # the state failed, so just ignore it
+                self.err "State %s failed: %s (%s)" %
+                    [name, detail, detail.class]
+                return false
+            end
+        end
+    end
+
+    # return the value of a parameter
+    def parameter(name)
+        unless name.is_a? Symbol
+            name = name.intern
+        end
+        return @parameters[name]
+    end
+
+    def push(*childs)
+        unless defined? @children
+            @children = []
+        end
+        childs.each { |child|
+            @children.push(child)
+            child.parent = self
+        }
+    end
+
+    # Remove an object.  The argument determines whether the object's
+    # subscriptions get eliminated, too.
+    def remove(rmdeps)
+        @children.each { |child|
+            child.remove
+        }
+        self.class.delete(self)
+
+        if rmdeps
+            Puppet::Event::Subscription.dependencies(self).each { |dep|
+                self.unsubscribe(dep)
+            }
+        end
+
+        if defined? @parent and @parent
+            @parent.delete(self)
+        end
+    end
+
+    # return an actual type by name; to return the value, use 'inst[name]'
+    # FIXME this method should go away
+    def state(name)
+        unless name.is_a? Symbol
+            name = name.intern
+        end
+        return @states[name]
+    end
+
+    private
+
+    def states
+        #debug "%s has %s states" % [self,@states.length]
+        tmpstates = []
+        self.class.states.each { |state|
+            if @states.include?(state.name)
+                tmpstates.push(@states[state.name])
+            end
+        }
+        unless tmpstates.length == @states.length
+            raise Puppet::DevError,
+                "Something went very wrong with tmpstates creation"
+        end
+        return tmpstates
+    end
+
+
+    # instance methods related to instance intrinsics
+    # e.g., initialize() and name()
+
+    public
+
+    # Force users to call this, so that we can merge objects if
+    # necessary.  FIXME This method should be responsible for most of the
+    # error handling.
+    def self.create(hash)
+        # Handle this new object being implicit
+        implicit = hash[:implicit] || false
+        if hash.include?(:implicit)
+            hash.delete(:implicit)
+        end
+
+        name = nil
+        unless name =   hash["name"] || hash[:name] ||
+                    hash[self.namevar] || hash[self.namevar.to_s]
+            raise Puppet::Error, "You must specify a name for objects of type %s" %
+                self.to_s
+        end
+        # 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
+            # who wins -- the non-implicit one.
+            if retobj.implicit? and ! implicit
+                Puppet.notice "Removing implicit %s" % retobj.name
+                # Remove all of the objects, but do not remove their subscriptions.
+                retobj.remove(false)
+
+                # now pass through and create the new object
+            elsif implicit
+                Puppet.notice "Ignoring implicit %s" % name
+
+                return retobj
+            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" %
+                    [self.name, name]
+                #retobj.merge(hash)
+
+                #return retobj
+            end
+        end
+
+        # create it anew
+        # if there's a failure, destroy the object if it got that far
+        begin
+            obj = new(hash)
+        rescue => detail
+            if Puppet[:debug]
+                if detail.respond_to?(:stack)
+                    puts detail.stack
+                end
+            end
+            Puppet.err "Could not create %s: %s" % [name, detail.to_s]
+            if obj
+                obj.remove(true)
+            elsif obj = self[name]
+                obj.remove(true)
+            end
+            return nil
+        end
+
+        if implicit
+            obj.implicit = true
+        end
+
+        return obj
+    end
+
+    def self.implicitcreate(hash)
+        unless hash.include?(:implicit)
+            hash[:implicit] = true
+        end
+        obj = self.create(hash)
+        obj.implicit = true
+
+        return obj
+    end
+
+    # Is this type's name isomorphic with the object?  That is, if the
+    # name conflicts, does it necessarily mean that the objects conflict?
+    # Defaults to true.
+    def self.isomorphic?
+        if defined? @isomorphic
+            return @isomorphic
+        else
+            return true
+        end
+    end
+
+    # and then make 'new' private
+    class << self
+        private :new
+    end
+
+    # initialize the type instance
+    def initialize(hash)
+        @children = []
+        @evalcount = 0
+
+        # callbacks are per object and event
+        @callbacks = Hash.new { |chash, key|
+            chash[key] = {}
+        }
+
+        # states and parameters are treated equivalently from the outside:
+        # as name-value pairs (using [] and []=)
+        # internally, however, parameters are merely a hash, while states
+        # point to State objects
+        # further, the lists of valid states and parameters are defined
+        # at the class level
+        unless defined? @states
+            @states = Hash.new(false)
+        end
+        unless defined? @parameters
+            @parameters = Hash.new(false)
+        end
+        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
+        # it also doesn't distinguish between changes from the current transaction
+        # vs. changes over the process lifetime
+        @totalchanges = 0
+        @syncedchanges = 0
+        @failedchanges = 0
+
+        # Before anything else, set our parent if it was included
+        if hash.include?(:parent)
+            @parent = hash[:parent]
+            hash.delete(:parent)
+        end
+
+        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|
+            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]
+                    )
+                end
+                hash.delete name
+            end
+        }
+
+        if hash.length > 0
+            self.debug hash.inspect
+            raise Puppet::Error.new("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
+    end
+
+    # Merge new information with an existing object, checking for conflicts
+    # and such.  This allows for two specifications of the same object and
+    # the same values, but it's pretty limited right now.  The result of merging
+    # states is very different from the result of merging parameters or metaparams.
+    # This is currently unused.
+    def merge(hash)
+        hash.each { |param, value|
+            if param.is_a?(String)
+                param = param.intern
+            end
+            
+            # Of course names are the same, duh.
+            next if param == :name or param == self.class.namevar
+
+            unless value.is_a?(Array)
+                value = [value]
+            end
+
+            if oldvals = @states[param].shouldorig
+                unless oldvals.is_a?(Array)
+                    oldvals = [oldvals]
+                end
+                # If the values are exactly the same, order and everything,
+                # then it's okay.
+                if oldvals == value
+                    return true
+                end
+                # take the intersection
+                newvals = oldvals & value
+                if newvals.empty?
+                    raise Puppet::Error, "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)" %
+                        [param, self.class.name, self.name]
+                else
+                    self.debug "Reduced old values %s and new values %s to %s" %
+                        [oldvals.inspect, value.inspect, newvals.inspect]
+                    @states[param].should = newvals
+                    #self.should = newvals
+                    return true
+                end
+            else
+                self[param] = value
+            end
+        }
+    end
+
+    # derive the instance name based on class.namevar
+    def name
+        unless defined? @name and @name
+            namevar = self.class.namevar
+            if self.class.validparameter?(namevar)
+                @name = @parameters[namevar]
+            elsif self.class.validstate?(namevar)
+                @name = self.should(namevar)
+            else
+                raise Puppet::DevError, "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]
+        end
+
+        return @name
+    end
+
+    # 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
+
+        if hash.include?(:parent)
+            hash.delete(:parent)
+        end
+        namevar = self.class.namevar
+
+        hash.each { |var,value|
+            unless var.is_a? Symbol
+                hash[var.intern] = value
+                hash.delete(var)
+            end
+        }
+
+        # if they're not using :name for the namevar but we got :name (probably
+        # from the parser)
+        if namevar != :name and hash.include?(:name) and ! hash[:name].nil?
+            #self[namevar] = hash[:name]
+            hash[namevar] = hash[:name]
+            hash.delete(:name)
+        # else if we got the namevar
+        elsif hash.has_key?(namevar) and ! hash[namevar].nil?
+            #self[namevar] = hash[namevar]
+            #hash.delete(namevar)
+        # else something's screwy
+        else
+            # they didn't specify anything related to names
+        end
+
+        return hash
+    end
+
+    # retrieve the current value of all contained states
+    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|
+            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
+    end
+
+    # instance methods dealing with actually doing work
+
+    public
+
+    # this is a retarded hack method to get around the difference between
+    # component children and file children
+    def self.depthfirst?
+        if defined? @depthfirst
+            return @depthfirst
+        else
+            return false
+        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
+        #Puppet.err "Evaluating %s" % self.path.join(":")
+        unless defined? @evalcount
+            self.err "No evalcount defined on '%s' of type '%s'" %
+                [self.name,self.class]
+            @evalcount = 0
+        end
+        @@retrieved[self] += 1
+        # if we're a metaclass and we've already evaluated once...
+        #if self.metaclass and @evalcount > 0
+        #    return
+        #end
+        @evalcount += 1
+
+        #changes = @children.collect { |child|
+        #    child.evaluate
+        #}
+
+        changes = []
+        # collect all of the changes from children and states
+        #if self.class.depthfirst?
+        #    changes << self.collect { |child|
+        #        child.evaluate
+        #    }
+        #end
+
+        # this only operates on states, not states + children
+        # it's important that we call retrieve() on the type instance,
+        # not directly on the state, because it allows the type to override
+        # the method, like pfile does
+        self.retrieve
+
+        # 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)
+            }
+        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|
+            child.evaluate
+        }
+        #unless self.class.depthfirst?
+        #    changes << self.collect { |child|
+        #        child.evaluate
+        #    }
+        #end
+        # collect changes and return them
+        # these changes could be from child objects or from contained states
+        #self.collect { |child|
+        #    child.evaluate
+        #}
+
+        if self.class.depthfirst?
+            changes << states().find_all { |state|
+                ! state.insync?
+            }.collect { |state|
+                Puppet::StateChange.new(state)
+            }
+        end
+
+        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.info "%s change(s)" %
+                [changes.length]
+            #changes.each { |change|
+            #    self.debug "change: %s" % change.state.name
+            #}
+        end
+        return changes.flatten
+    end
+
+    # if all contained objects are in sync, then we're in sync
+    # FIXME I don't think this is used on the type instances any more,
+    # it's really only used for testing
+    def insync?
+        insync = true
+
+        states.each { |state|
+            unless state.insync?
+                self.debug("%s is not in sync: %s vs %s" %
+                    [state, state.is, state.should])
+                insync = false
+            end
+        }
+
+        #self.debug("%s sync status is %s" % [self,insync])
+        return insync
+    end
+
+    # 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)
+        }
+    end
+
+    # Is the parameter in question a meta-parameter?
+    def self.metaparam?(param)
+        @@metaparams.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
+
+    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
+
+    # Currently nonfunctional
+    def metaonerror=(response)
+        self.debug("Would have called metaonerror")
+        @onerror = response
+    end
+
+    # Currently nonfunctional
+    def metaschedule=(schedule)
+        @schedule = schedule
+    end
+
+    # Determines what our objects log at.  Defaults to :notice.
+    def metaloglevel=(loglevel)
+        if loglevel.is_a?(String)
+            loglevel = loglevel.intern
+        end
+        if loglevel == :verbose
+            loglevel = :info 
+        end        
+
+        if Puppet::Log.validlevel?(loglevel)
+            @metaparams[:loglevel] = loglevel
+        else
+            raise Puppet::Error.new("Invalid loglevel '%s'" % loglevel)       
+        end
+    end
+
+    # Subscription and relationship methods
+
+    #def addcallback(object, event, method)
+    #    @callbacks[object][event] = method
+    #end
+
+    # return all objects subscribed to the current object
+    def eachdependency
+        Puppet::Event::Subscription.dependencies(self).each { |dep|
+            yield dep.source
+        }
+    end
+
+    # return all objects subscribed to the current object
+    #def eachsubscriber
+    #    Puppet::Event::Subscriptions.subscribers?(self).each { |sub|
+    #        yield sub.targetobject
+    #    }
+    #end
+
+    def handledepends(requires, event, method)
+        # 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)
+            requires = [requires]
+        end
+        requires.each { |rname|
+            # we just have a name and a type, and we need to convert it
+            # to an object...
+            type = nil
+            object = nil
+            tname = rname[0]
+            unless type = Puppet::Type.type(tname)
+                raise Puppet::Error, "Could not find type %s" % tname
+            end
+            name = rname[1]
+            unless object = type[name]
+                raise Puppet::Error, "Could not retrieve object '%s' of type '%s'" %
+                    [name,type]
+            end
+            self.debug("subscribes to %s" % [object])
+
+            #unless @dependencies.include?(object)
+            #    @dependencies << object
+            #end
+
+            # pure requires don't call methods
+            #next if method.nil?
+
+            # 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
+            }
+            if method and self.respond_to?(method)
+                subargs[:callback] = method
+            end
+            Puppet::Event::Subscription.new(subargs)
+            #if self.respond_to?(method)
+            #    self.addcallback(object, event, method)
+            #end
+            #object.addnotify(self)
+        }
+    end
+
+    # Trigger any associated subscriptions, and then pass the event up to our
+    # parent.
+    def propagate(event, transaction)
+        Puppet::Event::Subscription.trigger(self, event, transaction)
+
+        if defined? @parent
+            @parent.propagate(event, transaction)
+        end
+    end
+
+    def subscribe(hash)
+        hash[:source] = self
+        Puppet::Event::Subscription.new(hash)
+
+        # add to the correct area
+        #@subscriptions.push sub
+    end
+
+    # Unsubscribe from a given object, possibly with a specific event.
+    def unsubscribe(object, event = nil)
+        Puppet::Event::Subscription.dependencies(self).find_all { |sub|
+            if event
+                sub.match?(event)
+            else
+                sub.source == object
+            end
+        }.each { |sub|
+            Puppet::Event::Subscription.delete(sub)
+        }
+    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
+    # the assumption here is that container objects will pass received
+    # methods on to contained objects
+    # i.e., we don't trigger our children, our refresh() method calls
+    # refresh() on our children
+    def trigger(event, source)
+        trans = event.transaction
+        if @callbacks.include?(source)
+            [:ALL_EVENTS, event.event].each { |eventname|
+                if method = @callbacks[source][eventname]
+                    if trans.triggered?(self, method) > 0
+                        next
+                    end
+                    if self.respond_to?(method)
+                        self.send(method)
+                    end
+
+                    trans.triggered(self, method)
+                end
+            }
+        end
+    end
+
+    # Documentation methods
+    def self.paramdoc(param)
+        @paramdoc[param]
+    end
+    def self.metaparamdoc(metaparam)
+        @@metaparamdoc[metaparam]
+    end
+end # Puppet::Type
+end
+
+require 'puppet/statechange'
+require 'puppet/type/component'
+require 'puppet/type/cron'
+require 'puppet/type/exec'
+require 'puppet/type/group'
+require 'puppet/type/package'
+require 'puppet/type/pfile'
+require 'puppet/type/pfilebucket'
+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'
+
+# $Id: type.rb 742 2005-11-16 17:12:11Z luke $