puppet 0.18.4 → 0.22.4

data/lib/puppet/external/gratr/undirected_graph.rb

@@ -0,0 +1,153 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+require 'puppet/external/gratr/adjacency_graph'
+require 'puppet/external/gratr/search'
+require 'puppet/external/gratr/biconnected'
+require 'puppet/external/gratr/comparability'
+require 'set'
+
+module GRATR
+  class UndirectedGraph
+    include AdjacencyGraph
+    include Graph::Search
+    include Graph::Biconnected
+    include Graph::Comparability
+    
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
+      end if self.class == GRATR::UndirectedGraph
+      super(*params)
+    end 
+
+    # UndirectedGraph is by definition undirected, always returns false
+    def directed?()  false; end
+      
+    # Redefine degree (default was sum)
+    def degree(v)    in_degree(v); end
+      
+    # A vertex of an undirected graph is balanced by definition
+    def balanced?(v)  true;  end
+
+    # UndirectedGraph uses UndirectedEdge for the edge class.
+    def edge_class() @parallel_edges ? GRATR::MultiUndirectedEdge : GRATR::UndirectedEdge; end
+
+    def remove_edge!(u, v=nil)
+      unless u.kind_of? GRATR::Edge
+        raise ArgumentError if @parallel_edges 
+        u = edge_class[u,v]
+      end
+      super(u.reverse) unless u.source == u.target
+      super(u)
+    end
+    
+    # A triangulated graph is an undirected perfect graph that every cycle of length greater than
+    # three possesses a chord. They have also been called chordal, rigid circuit, monotone transitive,
+    # and perfect elimination graphs.
+    #
+    # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
+    # Perfect Graphs" pg. 90
+    def triangulated?
+      a = Hash.new {|h,k| h[k]=Set.new}; sigma=lexicograph_bfs
+      inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
+      sigma[0..-2].each do |v|
+        x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
+        unless x.empty?
+           u = sigma[x.map {|y| inv_sigma[y]}.min]
+           a[u].merge(x - [u])
+        end
+        return false unless a[v].all? {|z| adjacent?(v,z)}
+      end
+      true
+    end
+    
+    def chromatic_number
+      return triangulated_chromatic_number if triangulated?
+      raise NotImplementedError    
+    end
+    
+    # An interval graph can have its vertices into one-to-one
+    # correspondence with a set of intervals F of a linearly ordered
+    # set (like the real line) such that two vertices are connected
+    # by an edge of G if and only if their corresponding intervals
+    # have nonempty intersection.
+    def interval?() triangulated? and complement.comparability?; end
+    
+    # A permutation diagram consists of n points on each of two parallel
+    # lines and n straight line segments matchin the points. The intersection
+    # graph of the line segments is called a permutation graph.
+    def permutation?() comparability? and complement.comparability?; end
+    
+    # An undirected graph is defined to be split if there is a partition
+    # V = S + K of its vertex set into a stable set S and a complete set K.    
+    def split?() triangulated? and complement.triangulated?; end
+    
+   private
+   # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
+   # Perfect Graphs" pg. 99
+    def triangulated_chromatic_number
+      chi = 1; s= Hash.new {|h,k| h[k]=0}
+      sigma=lexicograph_bfs
+      inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
+      sigma.each do |v|
+        x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
+        unless x.empty?
+          u = sigma[x.map {|y| inv_sigma[y]}.min]
+          s[u] = [s[u], x.size-1].max
+          chi = [chi, x.size+1].max if s[v] < x.size
+        end
+      end; chi
+    end
+   
+  end # UndirectedGraph
+
+  # This is a UndirectedGraph that allows for parallel edges, but does not
+  # allow loops
+  class UndirectedPseudoGraph < UndirectedGraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, *params)
+    end 
+  end
+
+  # This is a UndirectedGraph that allows for parallel edges and loops
+  class UndirectedMultiGraph < UndirectedGraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, :loops, *params)
+    end 
+  end
+
+
+end # GRATR

data/lib/puppet/{lock.rb → external/lock.rb}

@@ -61,4 +61,4 @@ class File
     end
 end
 
-# $Id: lock.rb 897 2006-02-12 18:08:39Z luke $
+# $Id: lock.rb 2119 2007-01-30 05:27:56Z luke $

data/lib/puppet/feature/base.rb

@@ -0,0 +1,20 @@
+#  Created by Luke Kanies on 2006-04-30.
+#  Copyright (c) 2006. All rights reserved.
+
+require 'puppet/util/feature'
+
+# Add the simple features, all in one file.
+
+# We've got LDAP available.
+Puppet.features.add(:ldap, :libs => ["ldap"])
+
+# We have the Rdoc::Usage library.
+Puppet.features.add(:usage, :libs => %w{rdoc/ri/ri_paths rdoc/usage})
+
+# We have libshadow, useful for managing passwords.
+Puppet.features.add(:libshadow, :libs => ["shadow"])
+
+# We're running as root.
+Puppet.features.add(:root) { require 'puppet/util/suidmanager'; Puppet::Util::SUIDManager.uid == 0 }
+
+# $Id: base.rb 2441 2007-04-30 19:41:18Z luke $

data/lib/puppet/feature/rails.rb

@@ -0,0 +1,52 @@
+#  Created by Luke Kanies on 2006-11-07.
+#  Copyright (c) 2006. All rights reserved.
+
+require 'puppet/util/feature'
+
+Puppet.features.add(:rails) do
+    begin
+        require 'active_record'
+    rescue LoadError => detail
+        if Facter["operatingsystem"].value == "Debian" and
+            FileTest.exists?("/usr/share/rails")
+                count = 0
+                Dir.entries("/usr/share/rails").each do |dir|
+                    libdir = File.join("/usr/share/rails", dir, "lib")
+                    if FileTest.exists?(libdir) and ! $:.include?(libdir)
+                        count += 1
+                        $: << libdir
+                    end
+                end
+
+                if count > 0
+                    retry
+                end
+        else
+            #If ActiveRecord was installed only via rubygems this is required
+            require 'rubygems'
+            require 'active_record'
+        end
+    end
+
+    # If we couldn't find it the normal way, try using a Gem.
+    unless defined? ActiveRecord
+        begin
+            require 'rubygems'
+            require 'rails'
+        rescue LoadError
+            # Nothing
+        end
+    end
+
+    # We check a fairly specific class, so that we can be sure that we've
+    # loaded a new enough version of AR that will support the features we
+    # actually use.
+    if defined? ActiveRecord::Associations::BelongsToPolymorphicAssociation
+        require 'puppet/rails'
+        true
+    else
+        false
+    end
+end
+
+# $Id: rails.rb 2195 2007-02-15 22:36:38Z shadoi $

data/lib/puppet/metatype/attributes.rb

@@ -0,0 +1,719 @@
+require 'puppet'
+require 'puppet/type'
+
+class Puppet::Type
+    class << self
+        include Puppet::Util::ClassGen
+        include Puppet::Util::Warnings
+        attr_reader :properties
+    end
+
+    def self.states
+        warnonce "The states method is deprecated; use properties"
+        properties()
+    end
+
+    # All parameters, in the appropriate order.  The namevar comes first,
+    # then the properties, 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]
+        if self.parameters.include?(:provider)
+            order << :provider
+        end
+        order << [self.properties.collect { |property| property.name },
+            self.parameters - [:provider],
+            self.metaparams].flatten.reject { |param|
+                # we don't want our namevar in there multiple times
+                param == namevar
+        }
+
+        order.flatten!
+
+        return order
+    end
+
+    # Retrieve an attribute alias, if there is one.
+    def self.attr_alias(param)
+        @attr_aliases[symbolize(param)]
+    end
+
+    # Create an alias to an existing attribute.  This will cause the aliased
+    # attribute to be valid when setting and retrieving values on the instance.
+    def self.set_attr_alias(hash)
+        hash.each do |new, old|
+            @attr_aliases[symbolize(new)] = symbolize(old)
+        end
+    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 :property: @validproperties[name]
+            when :meta: @@metaparamhash[name]
+            when :param: @paramhash[name]
+            end
+        end
+        @attrclasses[name]
+    end
+
+    # What type of parameter are we dealing with? Cache the results, because
+    # this method gets called so many times.
+    def self.attrtype(attr)
+        @attrtypes ||= {}
+        unless @attrtypes.include?(attr)
+            @attrtypes[attr] = case
+                when @validproperties.include?(attr): :property
+                when @paramhash.include?(attr): :param
+                when @@metaparamhash.include?(attr): :meta
+                else
+                    raise Puppet::DevError,
+                        "Invalid attribute '%s' for class '%s'" %
+                        [attr, self.name]
+                end
+        end
+
+        @attrtypes[attr]
+    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 << param
+        @parameters.each { |p| @paramhash[name] = p }
+
+        if param.isnamevar?
+            @namevar = param.name
+        end
+    end
+
+    # A similar function but one that yields the class and type.
+    # This is mainly so that setdefaults doesn't call quite so many functions.
+    def self.eachattr(*ary)
+        if ary.empty?
+            ary = nil
+        end
+
+        # We have to do this in a specific order, so that defaults are
+        # created in that order (e.g., providers should be set up before
+        # anything else).
+        allattrs.each do |name|
+            next unless ary.nil? or ary.include?(name)
+            if obj = @properties.find { |p| p.name == name }
+                yield obj, :property
+            elsif obj = @parameters.find { |p| p.name == name }
+                yield obj, :param
+            elsif obj = @@metaparams.find { |p| p.name == name }
+                yield obj, :meta
+            else
+                raise Puppet::DevError, "Could not find parameter %s" % name
+            end
+        end
+    end
+
+    def self.eachmetaparam
+        @@metaparams.each { |p| yield p.name }
+    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.newproperty(:ensure, :parent => Puppet::Property::Ensure, &block)
+        else
+            self.newproperty(:ensure, :parent => Puppet::Property::Ensure) do
+                self.defaultvalues
+            end
+        end
+    end
+
+    # Should we add the 'ensure' property to this class?
+    def self.ensurable?
+        # If the class has all three of these methods defined, then it's
+        # ensurable.
+        ens = [:exists?, :create, :destroy].inject { |set, method|
+            set &&= self.public_method_defined?(method)
+        }
+
+        return ens
+    end
+    
+    # Deal with any options passed into parameters.
+    def self.handle_param_options(name, options)
+        # If it's a boolean parameter, create a method to test the value easily
+        if options[:boolean]
+            define_method(name.to_s + "?") do
+                val = self[name]
+                if val == :true or val == true
+                    return true
+                end
+            end
+        end
+        
+        # If this param handles relationships, store that information
+    end
+
+    # Is the parameter in question a meta-parameter?
+    def self.metaparam?(param)
+        @@metaparamhash.include?(symbolize(param))
+    end
+
+    # Find the metaparameter class associated with a given metaparameter name.
+    def self.metaparamclass(name)
+        @@metaparamhash[symbolize(name)]
+    end
+
+    def self.metaparams
+        @@metaparams.collect { |param| param.name }
+    end
+
+    def self.metaparamdoc(metaparam)
+        @@metaparamhash[metaparam].doc
+    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, options = {}, &block)
+        @@metaparams ||= []
+        @@metaparamhash ||= {}
+        name = symbolize(name)
+
+        param = genclass(name,
+            :parent => options[:parent] || Puppet::Parameter,
+            :prefix => "MetaParam",
+            :hash => @@metaparamhash,
+            :array => @@metaparams,
+            :attributes => options[:attributes],
+            &block
+        )
+
+        # Grr.
+        if options[:required_features]
+            param.required_features = options[:required_features]
+        end
+        
+        handle_param_options(name, options)
+
+        param.metaparam = true
+
+        return param
+    end
+
+    # Find the namevar
+    def self.namevar
+        unless defined? @namevar
+            params = @parameters.find_all { |param|
+                param.isnamevar? or param.name == :name
+            }
+
+            if params.length > 1
+                raise Puppet::DevError, "Found multiple namevars for %s" % self.name
+            elsif params.length == 1
+                @namevar = params[0].name
+            else
+                raise Puppet::DevError, "No namevar for %s" % self.name
+            end
+        end
+        @namevar
+    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, options = {}, &block)
+        options[:attributes] ||= {}
+        options[:attributes][:element] = self
+        param = genclass(name,
+            :parent => options[:parent] || Puppet::Parameter,
+            :attributes => options[:attributes],
+            :block => block,
+            :prefix => "Parameter",
+            :array => @parameters,
+            :hash => @paramhash
+        )
+        
+        handle_param_options(name, options)
+
+        # Grr.
+        if options[:required_features]
+            param.required_features = options[:required_features]
+        end
+
+        # 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
+
+        return param
+    end
+
+    def self.newstate(name, options = {}, &block)
+        Puppet.warning "newstate() has been deprecrated; use newproperty(%s)" %
+            name
+        newproperty(name, options, &block)
+    end
+
+    # Create a new property. The first parameter must be the name of the property;
+    # this is how users will refer to the property when creating new instances.
+    # The second parameter is a hash of options; the options are:
+    # * <tt>:parent</tt>: The parent class for the property.  Defaults to Puppet::Property.
+    # * <tt>:retrieve</tt>: The method to call on the provider or @parent object (if
+    #   the provider is not set) to retrieve the current value.
+    def self.newproperty(name, options = {}, &block)
+        name = symbolize(name)
+
+        # This is here for types that might still have the old method of defining
+        # a parent class.
+        unless options.is_a? Hash
+            raise Puppet::DevError,
+                "Options must be a hash, not %s" % options.inspect
+        end
+
+        if @validproperties.include?(name) 
+            raise Puppet::DevError, "Class %s already has a property named %s" %
+                [self.name, name]
+        end
+
+        # We have to create our own, new block here because we want to define
+        # an initial :retrieve method, if told to, and then eval the passed
+        # block if available.
+        prop = genclass(name,
+            :parent => options[:parent] || Puppet::Property,
+            :hash => @validproperties
+        ) do
+            # If they've passed a retrieve method, then override the retrieve
+            # method on the class.
+            if options[:retrieve]
+                define_method(:retrieve) do
+                    instance_variable_set(
+                        "@is", provider.send(options[:retrieve])
+                    )
+                end
+            end
+
+            if block
+                class_eval(&block)
+            end
+        end
+
+        # If it's the 'ensure' property, always put it first.
+        if name == :ensure
+            @properties.unshift prop
+        else
+            @properties << prop
+        end
+
+        if options[:event]
+            prop.event = options[:event]
+        end
+
+        # Grr.
+        if options[:required_features]
+            prop.required_features = options[:required_features]
+        end
+
+#        define_method(name) do
+#            @parameters[name].should
+#        end
+#
+#        define_method(name.to_s + "=") do |value|
+#            newproperty(name, :should => value)
+#        end
+
+        return prop
+    end
+
+    def self.paramdoc(param)
+        @paramhash[param].doc
+    end
+
+    # Return the parameter names
+    def self.parameters
+        return [] unless defined? @parameters
+        @parameters.collect { |klass| klass.name }
+    end
+
+    # Find the parameter class associated with a given parameter name.
+    def self.paramclass(name)
+        @paramhash[name]
+    end
+
+    # Return the property class associated with a name
+    def self.propertybyname(name)
+        @validproperties[name]
+    end
+
+    def self.validattr?(name)
+        name = symbolize(name)
+        return true if name == :name
+        @validattrs ||= {}
+
+        unless @validattrs.include?(name)
+            if self.validproperty?(name) or self.validparameter?(name) or self.metaparam?(name)
+                @validattrs[name] = true
+            else
+                @validattrs[name] = false
+            end
+        end
+
+        @validattrs[name]
+    end
+
+    # does the name reflect a valid property?
+    def self.validproperty?(name)
+        name = symbolize(name)
+        if @validproperties.include?(name)
+            return @validproperties[name]
+        else
+            return false
+        end
+    end
+
+    # Return the list of validproperties
+    def self.validproperties
+        return {} unless defined? @parameters
+
+        return @validproperties.keys
+    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 @paramhash.include?(name) or @@metaparamhash.include?(name)
+            return true
+        else
+            return false
+        end
+    end
+
+    # fix any namevar => param translations
+    def argclean(oldhash)
+        # This duplication is here because it might be a transobject.
+        hash = oldhash.dup.to_hash
+
+        if hash.include?(:parent)
+            hash.delete(:parent)
+        end
+        namevar = self.class.namevar
+
+        # Do a simple translation for those cases where they've passed :name
+        # but that's not our namevar
+        if hash.include? :name and namevar != :name
+            if hash.include? namevar
+                raise ArgumentError, "Cannot provide both name and %s" % namevar
+            end
+            hash[namevar] = hash[:name]
+            hash.delete(:name)
+        end
+
+        # Make sure we have a name, one way or another
+        unless hash.include? namevar
+            if defined? @title and @title
+                hash[namevar] = @title
+            else
+                raise Puppet::Error,
+                    "Was not passed a namevar or title"
+            end
+        end
+
+        return hash
+    end
+
+    # Return either the attribute alias or the attribute.
+    def attr_alias(name)
+        name = symbolize(name)
+        if synonym = self.class.attr_alias(name)
+            return synonym
+        else
+            return name
+        end
+    end
+    
+    # Are we deleting this resource?
+    def deleting?
+        obj = @parameters[:ensure] and obj.should == :absent
+    end
+
+    # Allow an outside party to specify the 'is' value for a property.  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
+        param = attr_alias(param)
+        if self.class.validproperty?(param)
+            unless prop = @parameters[param]
+                prop = self.newattr(param)
+            end
+            prop.is = value
+        else
+            self[param] = value
+        end
+    end
+
+    # abstract accessing parameters and properties, 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(:property)' or 'object.should(:property)'.
+    def [](name)
+        name = attr_alias(name)
+
+        unless self.class.validattr?(name)
+            raise TypeError.new("Invalid parameter %s(%s)" % [name, name.inspect])
+        end
+
+        if name == :name
+            name = self.class.namevar
+        end
+
+        if obj = @parameters[name]
+            if obj.is_a?(Puppet::Type::Property)
+                return obj.is
+            else
+                return obj.value
+            end
+        else
+            return nil
+        end
+    end
+
+    # Abstract setting parameters and properties, and normalize
+    # access to always be symbols, not strings.  This sets the 'should'
+    # value on properties, and otherwise just sets the appropriate parameter.
+    def []=(name,value)
+        name = attr_alias(name)
+
+        unless self.class.validattr?(name)
+            raise TypeError.new("Invalid parameter %s" % [name])
+        end
+
+        if name == :name
+            name = self.class.namevar
+        end
+        if value.nil?
+            raise Puppet::Error.new("Got nil value for %s" % name)
+        end
+
+        if obj = @parameters[name]
+            obj.value = value
+            return nil
+        else
+            self.newattr(name, :value => value)
+        end
+
+        nil
+    end
+
+    # remove a property from the object; useful in testing or in cleanup
+    # when an error has been encountered
+    def delete(attr)
+        attr = symbolize(attr)
+        case attr
+        when Puppet::Type
+            if @children.include?(attr)
+                @children.delete(attr)
+            end
+        else
+            if @parameters.has_key?(attr)
+                @parameters.delete(attr)
+            else
+                raise Puppet::DevError.new("Undefined attribute '#{attr}' in #{self}")
+            end
+        end
+    end
+
+    # iterate across the existing properties
+    def eachproperty
+        # properties() is a private method
+        properties().each { |property|
+            yield property
+        }
+    end
+
+    # retrieve the 'is' value for a specified property
+    def is(name)
+        name = attr_alias(name)
+        if prop = @parameters[name] and prop.is_a?(Puppet::Type::Property)
+            return prop.is
+        else
+            return nil
+        end
+    end
+
+    # retrieve the 'should' value for a specified property
+    def should(name)
+        name = attr_alias(name)
+        if prop = @parameters[name] and prop.is_a?(Puppet::Type::Property)
+            return prop.should
+        else
+            return nil
+        end
+    end
+
+    # Create the actual attribute instance.  Requires either the attribute
+    # name or class as the first argument, then an optional hash of
+    # attributes to set during initialization.
+    def newattr(name, options = {})
+        if name.is_a?(Class)
+            klass = name
+            name = klass.name
+        end
+
+        unless klass = self.class.attrclass(name)
+            raise Puppet::Error, "Resource type %s does not support parameter %s" % [self.class.name, name]
+        end
+
+        if @parameters.include?(name)
+            raise Puppet::Error, "Parameter '%s' is already defined in %s" %
+                [name, self.ref]
+        end
+
+        if provider and ! provider.class.supports_parameter?(klass)
+            missing = klass.required_features.find_all { |f| ! provider.class.feature?(f) }
+            info "Provider %s does not support features %s; not managing attribute %s" % [provider.class.name, missing.join(", "), name]
+            return nil
+        end
+
+        # Add parent information at creation time, so it's available
+        # during validation.
+        options[:parent] = self
+        begin
+            # make sure the parameter doesn't have any errors
+            return @parameters[name] = klass.new(options)
+        rescue => detail
+            error = Puppet::Error.new("Parameter %s failed: %s" %
+                [name, detail])
+            error.set_backtrace(detail.backtrace)
+            raise error
+        end
+    end
+
+    # return the value of a parameter
+    def parameter(name)
+        unless name.is_a? Symbol
+            name = name.intern
+        end
+        return @parameters[name].value
+    end
+
+    # Is the named property defined?
+    def propertydefined?(name)
+        unless name.is_a? Symbol
+            name = name.intern
+        end
+        return @parameters.include?(name)
+    end
+
+    # return an actual type by name; to return the value, use 'inst[name]'
+    # FIXME this method should go away
+    def property(name)
+        if obj = @parameters[symbolize(name)] and obj.is_a?(Puppet::Type::Property)
+            return obj
+        else
+            return nil
+        end
+    end
+
+#    def set(name, value)
+#        send(name.to_s + "=", value)
+#    end
+#
+#    def get(name)
+#        send(name)
+#    end
+
+    # For any parameters or properties that have defaults and have not yet been
+    # set, set them now.  This method can be handed a list of attributes,
+    # and if so it will only set defaults for those attributes.
+    def setdefaults(*ary)
+        #self.class.eachattr(*ary) { |klass, type|
+        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 @parameters[klass.name]
+
+            next unless obj = self.newattr(klass)
+
+            # We have to check for nil values, not "truth", so we allow defaults
+            # to false.
+            value = obj.default and ! value.nil?
+            if ! value.nil?
+                obj.value = value
+            else
+                @parameters.delete(obj.name)
+            end
+        }
+    end
+
+    # Convert our object to a hash.  This just includes properties.
+    def to_hash
+        rethash = {}
+    
+        @parameters.each do |name, obj|
+            rethash[name] = obj.value
+        end
+
+        rethash
+    end
+
+    # Return a specific value for an attribute.
+    def value(name)
+        name = attr_alias(name)
+
+        if obj = @parameters[name] and obj.respond_to?(:value)
+            return obj.value
+        else
+            return nil
+        end
+    end
+
+    # Meta-parameter methods:  These methods deal with the results
+    # of specifying metaparameters
+
+    private
+
+    # Return all of the property objects, in the order specified in the
+    # class.
+    def properties
+        #debug "%s has %s properties" % [self,@parameters.length]
+        props = self.class.properties.collect { |prop|
+            @parameters[prop.name]
+        }.find_all { |p|
+            ! p.nil?
+        }.each do |prop|
+            unless prop.is_a?(Puppet::Type::Property)
+                raise Puppet::DevError, "got a non-property %s(%s)" %
+                    [prop.class, prop.class.name]
+            end
+        end
+
+        props
+    end
+end
+
+# $Id: attributes.rb 2444 2007-05-01 03:14:09Z luke $