librarian-puppet 0.9.4 → 0.9.5

data/vendor/gems/ruby/1.8/gems/puppet-2.7.18/lib/puppet/transportable.rb

@@ -1,248 +0,0 @@
-require 'puppet'
-require 'yaml'
-
-module Puppet
-  # The transportable objects themselves.  Basically just a hash with some
-  # metadata and a few extra methods.  I used to have the object actually
-  # be a subclass of Hash, but I could never correctly dump them using
-  # YAML.
-  class TransObject
-    include Enumerable
-    attr_accessor :type, :name, :file, :line, :catalog
-
-    attr_writer :tags
-
-    %w{has_key? include? length delete empty? << [] []=}.each { |method|
-      define_method(method) do |*args|
-        @params.send(method, *args)
-      end
-    }
-
-    def each
-      @params.each { |p,v| yield p, v }
-    end
-
-    def initialize(name,type)
-      @type = type.to_s.downcase
-      @name = name
-      @params = {}
-      @tags = []
-    end
-
-    def longname
-      [@type,@name].join('--')
-    end
-
-    def ref
-      @ref ||= Puppet::Resource.new(@type, @name)
-      @ref.to_s
-    end
-
-    def tags
-      @tags
-    end
-
-    # Convert a defined type into a component.
-    def to_component
-      trans = TransObject.new(ref, :component)
-      @params.each { |param,value|
-        next unless Puppet::Type::Component.valid_parameter?(param)
-        Puppet.debug "Defining #{param} on #{ref}"
-        trans[param] = value
-      }
-      trans.catalog = self.catalog
-      Puppet::Type::Component.create(trans)
-    end
-
-    def to_hash
-      @params.dup
-    end
-
-    def to_s
-      "#{@type}(#{@name}) => #{super}"
-    end
-
-    def to_manifest
-      "%s { '%s':\n%s\n}" % [self.type.to_s, self.name,
-        @params.collect { |p, v|
-          if v.is_a? Array
-            "    #{p} => [\'#{v.join("','")}\']"
-          else
-            "    #{p} => \'#{v}\'"
-          end
-        }.join(",\n")
-        ]
-    end
-
-    # Create a normalized resource from our TransObject.
-    def to_resource
-      result = Puppet::Resource.new(type, name, :parameters => @params.dup)
-      result.tag(*tags)
-
-      result
-    end
-
-    def to_yaml_properties
-      instance_variables.reject { |v| %w{@ref}.include?(v) }
-    end
-
-    def to_ref
-      ref
-    end
-
-    def to_ral
-      to_resource.to_ral
-    end
-  end
-
-  # Just a linear container for objects.  Behaves mostly like an array, except
-  # that YAML will correctly dump them even with their instance variables.
-  class TransBucket
-    include Enumerable
-
-    attr_accessor :name, :type, :file, :line, :classes, :keyword, :top, :catalog
-
-    %w{delete shift include? length empty? << []}.each { |method|
-      define_method(method) do |*args|
-        #Puppet.warning "Calling #{method} with #{args.inspect}"
-        @children.send(method, *args)
-        #Puppet.warning @params.inspect
-      end
-    }
-
-    # Recursively yield everything.
-    def delve(&block)
-      @children.each do |obj|
-        block.call(obj)
-        if obj.is_a? self.class
-          obj.delve(&block)
-        else
-          obj
-        end
-      end
-    end
-
-    def each
-      @children.each { |c| yield c }
-    end
-
-    # Turn our heirarchy into a flat list
-    def flatten
-      @children.collect do |obj|
-        if obj.is_a? Puppet::TransBucket
-          obj.flatten
-        else
-          obj
-        end
-      end.flatten
-    end
-
-    def initialize(children = [])
-      @children = children
-    end
-
-    def push(*args)
-      args.each { |arg|
-        case arg
-        when Puppet::TransBucket, Puppet::TransObject
-          # nada
-        else
-          raise Puppet::DevError,
-            "TransBuckets cannot handle objects of type #{arg.class}"
-        end
-      }
-      @children += args
-    end
-
-    # Convert to a parseable manifest
-    def to_manifest
-      unless self.top
-        raise Puppet::DevError, "No keyword; cannot convert to manifest" unless @keyword
-      end
-
-      str = "#{@keyword} #{@name} {\n%s\n}"
-      str % @children.collect { |child|
-        child.to_manifest
-      }.collect { |str|
-        if self.top
-          str
-        else
-          str.gsub(/^/, "    ") # indent everything once
-        end
-      }.join("\n\n") # and throw in a blank line
-    end
-
-    def to_yaml_properties
-      instance_variables
-    end
-
-    # Create a resource graph from our structure.
-    def to_catalog(clear_on_failure = true)
-      catalog = Puppet::Resource::Catalog.new(Facter.value("hostname"))
-
-      # This should really use the 'delve' method, but this
-      # whole class is going away relatively soon, hopefully,
-      # so it's not worth it.
-      delver = proc do |obj|
-        obj.catalog = catalog
-        unless container = catalog.resource(obj.to_ref)
-          container = obj.to_ral
-          catalog.add_resource container
-        end
-        obj.each do |child|
-          child.catalog = catalog
-          unless resource = catalog.resource(child.to_ref)
-            resource = child.to_ral
-            catalog.add_resource resource
-          end
-
-          catalog.add_edge(container, resource)
-          delver.call(child) if child.is_a?(self.class)
-        end
-      end
-
-      begin
-        delver.call(self)
-        catalog.finalize
-      rescue => detail
-        # This is important until we lose the global resource references.
-        catalog.clear if (clear_on_failure)
-        raise
-      end
-
-      catalog
-    end
-
-    def to_ref
-      unless defined?(@ref)
-        if self.type and self.name
-          @ref = Puppet::Resource.new(self.type, self.name)
-        elsif self.type and ! self.name # This is old-school node types
-          @ref = Puppet::Resource.new("node", self.type)
-        elsif ! self.type and self.name
-          @ref = Puppet::Resource.new("component", self.name)
-        else
-          @ref = nil
-        end
-      end
-      @ref.to_s if @ref
-    end
-
-    def to_ral
-      to_resource.to_ral
-    end
-
-    # Create a normalized resource from our TransObject.
-    def to_resource
-      params = defined?(@parameters) ? @parameters.dup : {}
-      Puppet::Resource.new(type, name, :parameters => params)
-    end
-
-    def param(param,value)
-      @parameters ||= {}
-      @parameters[param] = value
-    end
-
-  end
-end
-

data/vendor/gems/ruby/1.8/gems/puppet-2.7.18/lib/puppet/type.rb

@@ -1,1974 +0,0 @@
-require 'puppet'
-require 'puppet/util/log'
-require 'puppet/util/metric'
-require 'puppet/property'
-require 'puppet/parameter'
-require 'puppet/util'
-require 'puppet/util/autoload'
-require 'puppet/metatype/manager'
-require 'puppet/util/errors'
-require 'puppet/util/log_paths'
-require 'puppet/util/logging'
-require 'puppet/file_collection/lookup'
-require 'puppet/util/tagging'
-
-# see the bottom of the file for the rest of the inclusions
-
-module Puppet
-class Type
-  include Puppet::Util
-  include Puppet::Util::Errors
-  include Puppet::Util::LogPaths
-  include Puppet::Util::Logging
-  include Puppet::FileCollection::Lookup
-  include Puppet::Util::Tagging
-
-  ###############################
-  # Comparing type instances.
-  include Comparable
-  def <=>(other)
-    # We only order against other types, not arbitrary objects.
-    return nil unless other.is_a? Puppet::Type
-    # Our natural order is based on the reference name we use when comparing
-    # against other type instances.
-    self.ref <=> other.ref
-  end
-
-  ###############################
-  # Code related to resource type attributes.
-  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 key_attributes come first, then
-  # the provider, then the properties, and finally the params and metaparams
-  # in the order they were specified in the files.
-  def self.allattrs
-    key_attributes | (parameters & [:provider]) | properties.collect { |property| property.name } | parameters | metaparams
-  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
-        end
-    end
-
-    @attrtypes[attr]
-  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.
-    [:exists?, :create, :destroy].all? { |method|
-      self.public_method_defined?(method)
-    }
-  end
-
-  # These `apply_to` methods are horrible.  They should really be implemented
-  # as part of the usual system of constraints that apply to a type and
-  # provider pair, but were implemented as a separate shadow system.
-  #
-  # We should rip them out in favour of a real constraint pattern around the
-  # target device - whatever that looks like - and not have this additional
-  # magic here. --daniel 2012-03-08
-  def self.apply_to_device
-    @apply_to = :device
-  end
-
-  def self.apply_to_host
-    @apply_to = :host
-  end
-
-  def self.apply_to_all
-    @apply_to = :both
-  end
-
-  def self.apply_to
-    @apply_to ||= :host
-  end
-
-  def self.can_apply_to(target)
-    [ target == :device ? :device : :host, :both ].include?(apply_to)
-  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
-  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.
-    param.required_features = options[:required_features] if options[:required_features]
-
-    handle_param_options(name, options)
-
-    param.metaparam = true
-
-    param
-  end
-
-  def self.key_attribute_parameters
-    @key_attribute_parameters ||= (
-      params = @parameters.find_all { |param|
-        param.isnamevar? or param.name == :name
-      }
-    )
-  end
-
-  def self.key_attributes
-    key_attribute_parameters.collect { |p| p.name }
-  end
-
-  def self.title_patterns
-    case key_attributes.length
-    when 0; []
-    when 1;
-      identity = lambda {|x| x}
-      [ [ /(.*)/m, [ [key_attributes.first, identity ] ] ] ]
-    else
-      raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
-    end
-  end
-
-  def uniqueness_key
-    self.class.key_attributes.sort_by { |attribute_name| attribute_name.to_s }.map{ |attribute_name| self[attribute_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, options = {}, &block)
-    options[:attributes] ||= {}
-
-    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.
-    param.required_features = options[:required_features] if options[:required_features]
-
-    param.isnamevar if options[:namevar]
-
-    param
-  end
-
-  def self.newstate(name, options = {}, &block)
-    Puppet.warning "newstate() has been deprecrated; use newproperty(#{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 #{options.inspect}"
-    end
-
-    raise Puppet::DevError, "Class #{self.name} already has a property named #{name}" if @validproperties.include?(name)
-
-    if parent = options[:parent]
-      options.delete(:parent)
-    else
-      parent = Puppet::Property
-    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 => parent, :hash => @validproperties, :attributes => options) do
-      # If they've passed a retrieve method, then override the retrieve
-      # method on the class.
-      if options[:retrieve]
-        define_method(:retrieve) do
-          provider.send(options[:retrieve])
-        end
-      end
-
-      class_eval(&block) if block
-    end
-
-    # If it's the 'ensure' property, always put it first.
-    if name == :ensure
-      @properties.unshift prop
-    else
-      @properties << prop
-    end
-
-    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)
-      @validattrs[name] = !!(self.validproperty?(name) or self.validparameter?(name) or self.metaparam?(name))
-    end
-
-    @validattrs[name]
-  end
-
-  # does the name reflect a valid property?
-  def self.validproperty?(name)
-    name = symbolize(name)
-    @validproperties.include?(name) && @validproperties[name]
-  end
-
-  # Return the list of validproperties
-  def self.validproperties
-    return {} unless defined?(@parameters)
-
-    @validproperties.keys
-  end
-
-  # does the name reflect a valid parameter?
-  def self.validparameter?(name)
-    raise Puppet::DevError, "Class #{self} has not defined parameters" unless defined?(@parameters)
-    !!(@paramhash.include?(name) or @@metaparamhash.include?(name))
-  end
-
-  # This is a forward-compatibility method - it's the validity interface we'll use in Puppet::Resource.
-  def self.valid_parameter?(name)
-    validattr?(name)
-  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
-
-  # Create a new property if it is valid but doesn't exist
-  # Returns: true if a new parameter was added, false otherwise
-  def add_property_parameter(prop_name)
-    if self.class.validproperty?(prop_name) && !@parameters[prop_name]
-      self.newattr(prop_name)
-      return true
-    end
-    false
-  end
-
-  #
-  # The name_var is the key_attribute in the case that there is only one.
-  #
-  def name_var
-    key_attributes = self.class.key_attributes
-    (key_attributes.length == 1) && key_attributes.first
-  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)
-
-    fail("Invalid parameter #{name}(#{name.inspect})") unless self.class.validattr?(name)
-
-    if name == :name && nv = name_var
-      name = nv
-    end
-
-    if obj = @parameters[name]
-      # Note that if this is a property, then the value is the "should" value,
-      # not the current value.
-      obj.value
-    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)
-
-    fail("Invalid parameter #{name}") unless self.class.validattr?(name)
-
-    if name == :name && nv = name_var
-      name = nv
-    end
-    raise Puppet::Error.new("Got nil value for #{name}") if value.nil?
-
-    property = self.newattr(name)
-
-    if property
-      begin
-        # make sure the parameter doesn't have any errors
-        property.value = value
-      rescue => detail
-        error = Puppet::Error.new("Parameter #{name} failed: #{detail}")
-        error.set_backtrace(detail.backtrace)
-        raise error
-      end
-    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)
-    if @parameters.has_key?(attr)
-      @parameters.delete(attr)
-    else
-      raise Puppet::DevError.new("Undefined attribute '#{attr}' in #{self}")
-    end
-  end
-
-  # iterate across the existing properties
-  def eachproperty
-    # properties is a private method
-    properties.each { |property|
-      yield property
-    }
-  end
-
-  # Create a transaction event.  Called by Transaction or by
-  # a property.
-  def event(options = {})
-    Puppet::Transaction::Event.new({:resource => self, :file => file, :line => line, :tags => tags}.merge(options))
-  end
-
-  # retrieve the 'should' value for a specified property
-  def should(name)
-    name = attr_alias(name)
-    (prop = @parameters[name] and prop.is_a?(Puppet::Property)) ? prop.should : nil
-  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)
-    if name.is_a?(Class)
-      klass = name
-      name = klass.name
-    end
-
-    unless klass = self.class.attrclass(name)
-      raise Puppet::Error, "Resource type #{self.class.name} does not support parameter #{name}"
-    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
-
-    return @parameters[name] if @parameters.include?(name)
-
-    @parameters[name] = klass.new(:resource => self)
-  end
-
-  # return the value of a parameter
-  def parameter(name)
-    @parameters[name.to_sym]
-  end
-
-  def parameters
-    @parameters.dup
-  end
-
-  # Is the named property defined?
-  def propertydefined?(name)
-    name = name.intern unless name.is_a? Symbol
-    @parameters.include?(name)
-  end
-
-  # Return an actual property instance by name; to return the value, use 'resource[param]'
-  # LAK:NOTE(20081028) Since the 'parameter' method is now a superset of this method,
-  # this one should probably go away at some point.
-  def property(name)
-    (obj = @parameters[symbolize(name)] and obj.is_a?(Puppet::Property)) ? obj : nil
-  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 set_default(attr)
-    return unless klass = self.class.attrclass(attr)
-    return unless klass.method_defined?(:default)
-    return if @parameters.include?(klass.name)
-
-    return unless parameter = newattr(klass.name)
-
-    if value = parameter.default and ! value.nil?
-      parameter.value = value
-    else
-      @parameters.delete(parameter.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
-
-  def type
-    self.class.name
-  end
-
-  # Return a specific value for an attribute.
-  def value(name)
-    name = attr_alias(name)
-
-    (obj = @parameters[name] and obj.respond_to?(:value)) ? obj.value : nil
-  end
-
-  def version
-    return 0 unless catalog
-    catalog.version
-  end
-
-  # Return all of the property objects, in the order specified in the
-  # class.
-  def properties
-    self.class.properties.collect { |prop| @parameters[prop.name] }.compact
-  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
-
-  def isomorphic?
-    self.class.isomorphic?
-  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?
-    # Once an object is managed, it always stays managed; but an object
-    # that is listed as unmanaged might become managed later in the process,
-    # so we have to check that every time
-    if @managed
-      return @managed
-    else
-      @managed = false
-      properties.each { |property|
-        s = property.should
-        if s and ! property.class.unmanaged
-          @managed = true
-          break
-        end
-      }
-      return @managed
-    end
-  end
-
-  ###############################
-  # Code related to the container behaviour.
-
-  def depthfirst?
-    false
-  end
-
-  # Remove an object.  The argument determines whether the object's
-  # subscriptions get eliminated, too.
-  def remove(rmdeps = true)
-    # This is hackish (mmm, cut and paste), but it works for now, and it's
-    # better than warnings.
-    @parameters.each do |name, obj|
-      obj.remove
-    end
-    @parameters.clear
-
-    @parent = nil
-
-    # Remove the reference to the provider.
-    if self.provider
-      @provider.clear
-      @provider = nil
-    end
-  end
-
-  ###############################
-  # Code related to evaluating the resources.
-
-  def ancestors
-    []
-  end
-
-  # Flush the provider, if it supports it.  This is called by the
-  # transaction.
-  def flush
-    self.provider.flush if self.provider and self.provider.respond_to?(:flush)
-  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?(is)
-    insync = true
-
-    if property = @parameters[:ensure]
-      unless is.include? property
-        raise Puppet::DevError,
-          "The is value is not in the is array for '#{property.name}'"
-      end
-      ensureis = is[property]
-      if property.safe_insync?(ensureis) and property.should == :absent
-        return true
-      end
-    end
-
-    properties.each { |property|
-      unless is.include? property
-        raise Puppet::DevError,
-          "The is value is not in the is array for '#{property.name}'"
-      end
-
-      propis = is[property]
-      unless property.safe_insync?(propis)
-        property.debug("Not in sync: #{propis.inspect} vs #{property.should.inspect}")
-        insync = false
-      #else
-      #    property.debug("In sync")
-      end
-    }
-
-    #self.debug("#{self} sync status is #{insync}")
-    insync
-  end
-
-  # retrieve the current value of all contained properties
-  def retrieve
-    fail "Provider #{provider.class.name} is not functional on this host" if self.provider.is_a?(Puppet::Provider) and ! provider.class.suitable?
-
-    result = Puppet::Resource.new(type, title)
-
-    # Provide the name, so we know we'll always refer to a real thing
-    result[:name] = self[:name] unless self[:name] == title
-
-    if ensure_prop = property(:ensure) or (self.class.validattr?(:ensure) and ensure_prop = newattr(:ensure))
-      result[:ensure] = ensure_state = ensure_prop.retrieve
-    else
-      ensure_state = nil
-    end
-
-    properties.each do |property|
-      next if property.name == :ensure
-      if ensure_state == :absent
-        result[property] = :absent
-      else
-        result[property] = property.retrieve
-      end
-    end
-
-    result
-  end
-
-  def retrieve_resource
-    resource = retrieve
-    resource = Resource.new(type, title, :parameters => resource) if resource.is_a? Hash
-    resource
-  end
-
-  # Get a hash of the current properties.  Returns a hash with
-  # the actual property instance as the key and the current value
-  # as the, um, value.
-  def currentpropvalues
-    # It's important to use the 'properties' method here, as it follows the order
-    # in which they're defined in the class.  It also guarantees that 'ensure'
-    # is the first property, which is important for skipping 'retrieve' on
-    # all the properties if the resource is absent.
-    ensure_state = false
-    return properties.inject({}) do | prophash, property|
-      if property.name == :ensure
-        ensure_state = property.retrieve
-        prophash[property] = ensure_state
-      else
-        if ensure_state == :absent
-          prophash[property] = :absent
-        else
-          prophash[property] = property.retrieve
-        end
-      end
-      prophash
-    end
-  end
-
-  # Are we running in noop mode?
-  def noop?
-    # If we're not a host_config, we're almost certainly part of
-    # Settings, and we want to ignore 'noop'
-    return false if catalog and ! catalog.host_config?
-
-    if defined?(@noop)
-      @noop
-    else
-      Puppet[:noop]
-    end
-  end
-
-  def noop
-    noop?
-  end
-
-  ###############################
-  # Code related to managing resource instances.
-  require 'puppet/transportable'
-
-  # retrieve a named instance of the current type
-  def self.[](name)
-    raise "Global resource access is deprecated"
-    @objects[name] || @aliases[name]
-  end
-
-  # add an instance by name to the class list of instances
-  def self.[]=(name,object)
-    raise "Global resource storage is deprecated"
-    newobj = nil
-    if object.is_a?(Puppet::Type)
-      newobj = object
-    else
-      raise Puppet::DevError, "must pass a Puppet::Type object"
-    end
-
-    if exobj = @objects[name] and self.isomorphic?
-      msg = "Object '#{newobj.class.name}[#{name}]' already exists"
-
-      msg += ("in file #{object.file} at line #{object.line}") if exobj.file and exobj.line
-      msg += ("and cannot be redefined in file #{object.file} at line #{object.line}") if object.file and object.line
-      error = Puppet::Error.new(msg)
-      raise error
-    else
-      #Puppet.info("adding %s of type %s to class list" %
-      #    [name,object.class])
-      @objects[name] = newobj
-    end
-  end
-
-  # 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)
-    raise "Global resource aliasing is deprecated"
-    if @objects.include?(name)
-      unless @objects[name] == obj
-        raise Puppet::Error.new(
-          "Cannot create alias #{name}: object already exists"
-        )
-      end
-    end
-
-    if @aliases.include?(name)
-      unless @aliases[name] == obj
-        raise Puppet::Error.new(
-          "Object #{@aliases[name].name} already has alias #{name}"
-        )
-      end
-    end
-
-    @aliases[name] = obj
-  end
-
-  # remove all of the instances of a single type
-  def self.clear
-    raise "Global resource removal is deprecated"
-    if defined?(@objects)
-      @objects.each do |name, obj|
-        obj.remove(true)
-      end
-      @objects.clear
-    end
-    @aliases.clear if defined?(@aliases)
-  end
-
-  # Force users to call this, so that we can merge objects if
-  # necessary.
-  def self.create(args)
-    # LAK:DEP Deprecation notice added 12/17/2008
-    Puppet.warning "Puppet::Type.create is deprecated; use Puppet::Type.new"
-    new(args)
-  end
-
-  # remove a specified object
-  def self.delete(resource)
-    raise "Global resource removal is deprecated"
-    return unless defined?(@objects)
-    @objects.delete(resource.title) if @objects.include?(resource.title)
-    @aliases.delete(resource.title) if @aliases.include?(resource.title)
-    if @aliases.has_value?(resource)
-      names = []
-      @aliases.each do |name, otherres|
-        if otherres == resource
-          names << name
-        end
-      end
-      names.each { |name| @aliases.delete(name) }
-    end
-  end
-
-  # iterate across each of the type's instances
-  def self.each
-    raise "Global resource iteration is deprecated"
-    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)
-    raise "Global resource access is deprecated"
-    @objects.has_key?(name)
-  end
-
-  # Retrieve all known instances.  Either requires providers or must be overridden.
-  def self.instances
-    raise Puppet::DevError, "#{self.name} has no providers and has not overridden 'instances'" if provider_hash.empty?
-
-    # Put the default provider first, then the rest of the suitable providers.
-    provider_instances = {}
-    providers_by_source.collect do |provider|
-      all_properties = self.properties.find_all do |property|
-        provider.supports_parameter?(property)
-      end.collect do |property|
-        property.name
-      end
-
-      provider.instances.collect do |instance|
-        # We always want to use the "first" provider instance we find, unless the resource
-        # is already managed and has a different provider set
-        if other = provider_instances[instance.name]
-          Puppet.warning "%s %s found in both %s and %s; skipping the %s version" %
-            [self.name.to_s.capitalize, instance.name, other.class.name, instance.class.name, instance.class.name]
-          next
-        end
-        provider_instances[instance.name] = instance
-
-        result = new(:name => instance.name, :provider => instance)
-        properties.each { |name| result.newattr(name) }
-        result
-      end
-    end.flatten.compact
-  end
-
-  # Return a list of one suitable provider per source, with the default provider first.
-  def self.providers_by_source
-    # Put the default provider first (can be nil), then the rest of the suitable providers.
-    sources = []
-    [defaultprovider, suitableprovider].flatten.uniq.collect do |provider|
-      next if provider.nil?
-      next if sources.include?(provider.source)
-
-      sources << provider.source
-      provider
-    end.compact
-  end
-
-  # Convert a simple hash into a Resource instance.
-  def self.hash2resource(hash)
-    hash = hash.inject({}) { |result, ary| result[ary[0].to_sym] = ary[1]; result }
-
-    title = hash.delete(:title)
-    title ||= hash[:name]
-    title ||= hash[key_attributes.first] if key_attributes.length == 1
-
-    raise Puppet::Error, "Title or name must be provided" unless title
-
-    # Now create our resource.
-    resource = Puppet::Resource.new(self.name, title)
-    [:catalog].each do |attribute|
-      if value = hash[attribute]
-        hash.delete(attribute)
-        resource.send(attribute.to_s + "=", value)
-      end
-    end
-
-    hash.each do |param, value|
-      resource[param] = value
-    end
-    resource
-  end
-
-  # Create the path for logging and such.
-  def pathbuilder
-    if p = parent
-      [p.pathbuilder, self.ref].flatten
-    else
-      [self.ref]
-    end
-  end
-
-  ###############################
-  # Add all of the meta parameters.
-  newmetaparam(:noop) do
-    desc "Boolean flag indicating whether work should actually
-      be done."
-
-    newvalues(:true, :false)
-    munge do |value|
-      case value
-      when true, :true, "true"; @resource.noop = true
-      when false, :false, "false"; @resource.noop = false
-      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."
-  end
-
-  newmetaparam(:audit) do
-    desc "Marks a subset of this resource's unmanaged attributes for auditing. Accepts an
-      attribute name, an array of attribute names, or `all`.
-
-      Auditing a resource attribute has two effects: First, whenever a catalog
-      is applied with puppet apply or puppet agent, Puppet will check whether
-      that attribute of the resource has been modified, comparing its current
-      value to the previous run; any change will be logged alongside any actions
-      performed by Puppet while applying the catalog.
-
-      Secondly, marking a resource attribute for auditing will include that
-      attribute in inspection reports generated by puppet inspect; see the
-      puppet inspect documentation for more details.
-
-      Managed attributes for a resource can also be audited, but note that
-      changes made by Puppet will be logged as additional modifications. (I.e.
-      if a user manually edits a file whose contents are audited and managed,
-      puppet agent's next two runs will both log an audit notice: the first run
-      will log the user's edit and then revert the file to the desired state,
-      and the second run will log the edit made by Puppet.)"
-
-    validate do |list|
-      list = Array(list).collect {|p| p.to_sym}
-      unless list == [:all]
-        list.each do |param|
-          next if @resource.class.validattr?(param)
-          fail "Cannot audit #{param}: not a valid attribute for #{resource}"
-        end
-      end
-    end
-
-    munge do |args|
-      properties_to_audit(args).each do |param|
-        next unless resource.class.validproperty?(param)
-        resource.newattr(param)
-      end
-    end
-
-    def all_properties
-      resource.class.properties.find_all do |property|
-        resource.provider.nil? or resource.provider.class.supports_parameter?(property)
-      end.collect do |property|
-        property.name
-      end
-    end
-
-    def properties_to_audit(list)
-      if !list.kind_of?(Array) && list.to_sym == :all
-        list = all_properties
-      else
-        list = Array(list).collect { |p| p.to_sym }
-      end
-    end
-  end
-
-  newmetaparam(:check) do
-    desc "Audit specified attributes of resources over time, and report if any have changed.
-      This parameter has been deprecated in favor of 'audit'."
-
-    munge do |args|
-      resource.warning "'check' attribute is deprecated; use 'audit' instead"
-      resource[:audit] = args
-    end
-  end
-
-  newmetaparam(:loglevel) do
-    desc "Sets the level that information will be logged.
-      The log levels have the biggest impact when logs are sent to
-      syslog (which is currently the default)."
-    defaultto :notice
-
-    newvalues(*Puppet::Util::Log.levels)
-    newvalues(:verbose)
-
-    munge do |loglevel|
-      val = super(loglevel)
-      if val == :verbose
-        val = :info
-      end
-      val
-    end
-  end
-
-  newmetaparam(:alias) do
-    desc "Creates an alias for the object.  Puppet uses this internally when you
-      provide a symbolic title:
-
-          file { 'sshdconfig':
-            path => $operatingsystem ? {
-              solaris => \"/usr/local/etc/ssh/sshd_config\",
-              default => \"/etc/ssh/sshd_config\"
-            },
-            source => \"...\"
-          }
-
-          service { 'sshd':
-            subscribe => File['sshdconfig']
-          }
-
-      When you use this feature, the parser sets `sshdconfig` as the title,
-      and the library sets that as an alias for the file so the dependency
-      lookup in `Service['sshd']` works.  You can use this metaparameter yourself,
-      but note that only the library can use these aliases; for instance,
-      the following code will not work:
-
-          file { \"/etc/ssh/sshd_config\":
-            owner => root,
-            group => root,
-            alias => 'sshdconfig'
-          }
-
-          file { 'sshdconfig':
-            mode => 644
-          }
-
-      There's no way here for the Puppet parser to know that these two stanzas
-      should be affecting the same file.
-
-      See the [Language Guide](http://docs.puppetlabs.com/guides/language_guide.html) for more information.
-
-      "
-
-    munge do |aliases|
-      aliases = [aliases] unless aliases.is_a?(Array)
-
-      raise(ArgumentError, "Cannot add aliases without a catalog") unless @resource.catalog
-
-      aliases.each do |other|
-        if obj = @resource.catalog.resource(@resource.class.name, other)
-          unless obj.object_id == @resource.object_id
-            self.fail("#{@resource.title} can not create alias #{other}: object already exists")
-          end
-          next
-        end
-
-        # Newschool, add it to the catalog.
-        @resource.catalog.alias(@resource, other)
-      end
-    end
-  end
-
-  newmetaparam(:tag) do
-    desc "Add the specified tags to the associated resource.  While all resources
-      are automatically tagged with as much information as possible
-      (e.g., each class and definition containing the resource), it can
-      be useful to add your own tags to a given resource.
-
-      Multiple tags can be specified as an array:
-
-          file {'/etc/hosts':
-            ensure => file,
-            source => 'puppet:///modules/site/hosts',
-            mode   => 0644,
-            tag    => ['bootstrap', 'minimumrun', 'mediumrun'],
-          }
-
-      Tags are useful for things like applying a subset of a host's configuration
-      with [the `tags` setting](/references/latest/configuration.html#tags):
-
-          puppet agent --test --tags bootstrap
-
-      This way, you can easily isolate the portion of the configuration you're
-      trying to test."
-
-    munge do |tags|
-      tags = [tags] unless tags.is_a? Array
-
-      tags.each do |tag|
-        @resource.tag(tag)
-      end
-    end
-  end
-
-  class RelationshipMetaparam < Puppet::Parameter
-    class << self
-      attr_accessor :direction, :events, :callback, :subclasses
-    end
-
-    @subclasses = []
-
-    def self.inherited(sub)
-      @subclasses << sub
-    end
-
-    def munge(references)
-      references = [references] unless references.is_a?(Array)
-      references.collect do |ref|
-        if ref.is_a?(Puppet::Resource)
-          ref
-        else
-          Puppet::Resource.new(ref)
-        end
-      end
-    end
-
-    def validate_relationship
-      @value.each do |ref|
-        unless @resource.catalog.resource(ref.to_s)
-          description = self.class.direction == :in ? "dependency" : "dependent"
-          fail "Could not find #{description} #{ref} for #{resource.ref}"
-        end
-      end
-    end
-
-    # Create edges from each of our relationships.    :in
-    # relationships are specified by the event-receivers, and :out
-    # relationships are specified by the event generator.  This
-    # way 'source' and 'target' are consistent terms in both edges
-    # and events -- that is, an event targets edges whose source matches
-    # the event's source.  The direction of the relationship determines
-    # which resource is applied first and which resource is considered
-    # to be the event generator.
-    def to_edges
-      @value.collect do |reference|
-        reference.catalog = resource.catalog
-
-        # Either of the two retrieval attempts could have returned
-        # nil.
-        unless related_resource = reference.resolve
-          self.fail "Could not retrieve dependency '#{reference}' of #{@resource.ref}"
-        end
-
-        # Are we requiring them, or vice versa?  See the method docs
-        # for futher info on this.
-        if self.class.direction == :in
-          source = related_resource
-          target = @resource
-        else
-          source = @resource
-          target = related_resource
-        end
-
-        if method = self.class.callback
-          subargs = {
-            :event => self.class.events,
-            :callback => method
-          }
-          self.debug("subscribes to #{related_resource.ref}")
-        else
-          # If there's no callback, there's no point in even adding
-          # a label.
-          subargs = nil
-          self.debug("requires #{related_resource.ref}")
-        end
-
-        rel = Puppet::Relationship.new(source, target, subargs)
-      end
-    end
-  end
-
-  def self.relationship_params
-    RelationshipMetaparam.subclasses
-  end
-
-
-  # Note that the order in which the relationships params is defined
-  # matters.  The labelled params (notify and subcribe) must be later,
-  # so that if both params are used, those ones win.  It's a hackish
-  # solution, but it works.
-
-  newmetaparam(:require, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :NONE}) do
-    desc "References to 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\"]
-          }
-
-      Multiple dependencies can be specified by providing a comma-separated list
-      of resources, enclosed in square brackets:
-
-          require => [ File[\"/usr/local\"], 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 resources 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 resources 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.
-      "
-  end
-
-  newmetaparam(:subscribe, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :ALL_EVENTS, :callback => :refresh}) do
-    desc "References to one or more objects that this object depends on. This
-      metaparameter creates a dependency relationship like **require,**
-      and also causes the dependent object to be refreshed when the
-      subscribed object is changed. For instance:
-
-          class nagios {
-            file { 'nagconf':
-              path   => \"/etc/nagios/nagios.conf\"
-              source => \"puppet://server/module/nagios.conf\",
-            }
-            service { 'nagios':
-              ensure    => running,
-              subscribe => File['nagconf']
-            }
-          }
-
-      Currently the `exec`, `mount` and `service` types support
-      refreshing.
-      "
-  end
-
-  newmetaparam(:before, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :NONE}) do
-    desc %{References to one or more objects that depend on this object. This
-      parameter is the opposite of **require** --- it guarantees that
-      the specified object is applied later than the specifying object:
-
-          file { "/var/nagios/configuration":
-            source  => "...",
-            recurse => true,
-            before  => Exec["nagios-rebuid"]
-          }
-
-          exec { "nagios-rebuild":
-            command => "/usr/bin/make",
-            cwd     => "/var/nagios/configuration"
-          }
-
-      This will make sure all of the files are up to date before the
-      make command is run.}
-  end
-
-  newmetaparam(:notify, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :ALL_EVENTS, :callback => :refresh}) do
-    desc %{References to one or more objects that depend on this object. This
-    parameter is the opposite of **subscribe** --- it creates a
-    dependency relationship like **before,** and also causes the
-    dependent object(s) to be refreshed when this object is changed. For
-    instance:
-
-          file { "/etc/sshd_config":
-            source => "....",
-            notify => Service['sshd']
-          }
-
-          service { 'sshd':
-            ensure => running
-          }
-
-      This will restart the sshd service if the sshd config file changes.}
-  end
-
-  newmetaparam(:stage) do
-    desc %{Which run stage a given resource should reside in.  This just creates
-      a dependency on or from the named milestone.  For instance, saying that
-      this is in the 'bootstrap' stage creates a dependency on the 'bootstrap'
-      milestone.
-
-      By default, all classes get directly added to the
-      'main' stage.  You can create new stages as resources:
-
-          stage { ['pre', 'post']: }
-
-      To order stages, use standard relationships:
-
-          stage { 'pre': before => Stage['main'] }
-
-      Or use the new relationship syntax:
-
-          Stage['pre'] -> Stage['main'] -> Stage['post']
-
-      Then use the new class parameters to specify a stage:
-
-          class { 'foo': stage => 'pre' }
-
-      Stages can only be set on classes, not individual resources.  This will
-      fail:
-
-          file { '/foo': stage => 'pre', ensure => file }
-    }
-  end
-
-  ###############################
-  # All of the provider plumbing for the resource types.
-  require 'puppet/provider'
-  require 'puppet/util/provider_features'
-
-  # Add the feature handling module.
-  extend Puppet::Util::ProviderFeatures
-
-  attr_reader :provider
-
-  # the Type class attribute accessors
-  class << self
-    attr_accessor :providerloader
-    attr_writer :defaultprovider
-  end
-
-  # Find the default provider.
-  def self.defaultprovider
-    return @defaultprovider if @defaultprovider
-
-    suitable = suitableprovider
-
-    # Find which providers are a default for this system.
-    defaults = suitable.find_all { |provider| provider.default? }
-
-    # If we don't have any default we use suitable providers
-    defaults = suitable if defaults.empty?
-    max = defaults.collect { |provider| provider.specificity }.max
-    defaults = defaults.find_all { |provider| provider.specificity == max }
-
-    if defaults.length > 1
-      Puppet.warning(
-        "Found multiple default providers for #{self.name}: #{defaults.collect { |i| i.name.to_s }.join(", ")}; using #{defaults[0].name}"
-      )
-    end
-
-    @defaultprovider = defaults.shift unless defaults.empty?
-  end
-
-  def self.provider_hash_by_type(type)
-    @provider_hashes ||= {}
-    @provider_hashes[type] ||= {}
-  end
-
-  def self.provider_hash
-    Puppet::Type.provider_hash_by_type(self.name)
-  end
-
-  # Retrieve a provider by name.
-  def self.provider(name)
-    name = Puppet::Util.symbolize(name)
-
-    # If we don't have it yet, try loading it.
-    @providerloader.load(name) unless provider_hash.has_key?(name)
-    provider_hash[name]
-  end
-
-  # Just list all of the providers.
-  def self.providers
-    provider_hash.keys
-  end
-
-  def self.validprovider?(name)
-    name = Puppet::Util.symbolize(name)
-
-    (provider_hash.has_key?(name) && provider_hash[name].suitable?)
-  end
-
-  # Create a new provider of a type.  This method must be called
-  # directly on the type that it's implementing.
-  def self.provide(name, options = {}, &block)
-    name = Puppet::Util.symbolize(name)
-
-    if unprovide(name)
-      Puppet.debug "Reloading #{name} #{self.name} provider"
-    end
-
-    parent = if pname = options[:parent]
-      options.delete(:parent)
-      if pname.is_a? Class
-        pname
-      else
-        if provider = self.provider(pname)
-          provider
-        else
-          raise Puppet::DevError,
-            "Could not find parent provider #{pname} of #{name}"
-        end
-      end
-    else
-      Puppet::Provider
-    end
-
-    options[:resource_type] ||= self
-
-    self.providify
-
-    provider = genclass(
-      name,
-      :parent     => parent,
-      :hash       => provider_hash,
-      :prefix     => "Provider",
-      :block      => block,
-      :include    => feature_module,
-      :extend     => feature_module,
-      :attributes => options
-    )
-
-    provider
-  end
-
-  # Make sure we have a :provider parameter defined.  Only gets called if there
-  # are providers.
-  def self.providify
-    return if @paramhash.has_key? :provider
-
-    newparam(:provider) do
-      # We're using a hacky way to get the name of our type, since there doesn't
-      # seem to be a correct way to introspect this at the time this code is run.
-      # We expect that the class in which this code is executed will be something
-      # like Puppet::Type::Ssh_authorized_key::ParameterProvider.
-      desc <<-EOT
-        The specific backend to use for this `#{self.to_s.split('::')[2].downcase}`
-        resource. You will seldom need to specify this --- Puppet will usually
-        discover the appropriate provider for your platform.
-      EOT
-
-      # This is so we can refer back to the type to get a list of
-      # providers for documentation.
-      class << self
-        attr_accessor :parenttype
-      end
-
-      # We need to add documentation for each provider.
-      def self.doc
-        # Since we're mixing @doc with text from other sources, we must normalize
-        # its indentation with scrub. But we don't need to manually scrub the
-        # provider's doc string, since markdown_definitionlist sanitizes its inputs.
-        scrub(@doc) + "Available providers are:\n\n" + parenttype.providers.sort { |a,b|
-          a.to_s <=> b.to_s
-        }.collect { |i|
-          markdown_definitionlist( i, scrub(parenttype().provider(i).doc) )
-        }.join
-      end
-
-      defaultto {
-        prov = @resource.class.defaultprovider
-        prov.name if prov
-      }
-
-      validate do |provider_class|
-        provider_class = provider_class[0] if provider_class.is_a? Array
-        provider_class = provider_class.class.name if provider_class.is_a?(Puppet::Provider)
-
-        unless provider = @resource.class.provider(provider_class)
-          raise ArgumentError, "Invalid #{@resource.class.name} provider '#{provider_class}'"
-        end
-      end
-
-      munge do |provider|
-        provider = provider[0] if provider.is_a? Array
-        provider = provider.intern if provider.is_a? String
-        @resource.provider = provider
-
-        if provider.is_a?(Puppet::Provider)
-          provider.class.name
-        else
-          provider
-        end
-      end
-    end.parenttype = self
-  end
-
-  def self.unprovide(name)
-    if @defaultprovider and @defaultprovider.name == name
-      @defaultprovider = nil
-    end
-
-    rmclass(name, :hash => provider_hash, :prefix => "Provider")
-  end
-
-  # Return an array of all of the suitable providers.
-  def self.suitableprovider
-    providerloader.loadall if provider_hash.empty?
-    provider_hash.find_all { |name, provider|
-      provider.suitable?
-    }.collect { |name, provider|
-      provider
-    }.reject { |p| p.name == :fake } # For testing
-  end
-
-  def suitable?
-    # If we don't use providers, then we consider it suitable.
-    return true unless self.class.paramclass(:provider)
-
-    # We have a provider and it is suitable.
-    return true if provider && provider.class.suitable?
-
-    # We're using the default provider and there is one.
-    if !provider and self.class.defaultprovider
-      self.provider = self.class.defaultprovider.name
-      return true
-    end
-
-    # We specified an unsuitable provider, or there isn't any suitable
-    # provider.
-    false
-  end
-
-  def provider=(name)
-    if name.is_a?(Puppet::Provider)
-      @provider = name
-      @provider.resource = self
-    elsif klass = self.class.provider(name)
-      @provider = klass.new(self)
-    else
-      raise ArgumentError, "Could not find #{name} provider of #{self.class.name}"
-    end
-  end
-
-  ###############################
-  # All of the relationship code.
-
-  # 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
-
-  # Figure out of there are any objects we can automatically add as
-  # dependencies.
-  def autorequire(rel_catalog = nil)
-    rel_catalog ||= catalog
-    raise(Puppet::DevError, "You cannot add relationships without a catalog") unless rel_catalog
-
-    reqs = []
-    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(type)
-
-      # Retrieve the list of names from the block.
-      next unless list = self.instance_eval(&block)
-      list = [list] unless list.is_a?(Array)
-
-      # Collect the current prereqs
-      list.each { |dep|
-        # Support them passing objects directly, to save some effort.
-        unless dep.is_a? Puppet::Type
-          # Skip autorequires that we aren't managing
-          unless dep = rel_catalog.resource(type, dep)
-            next
-          end
-        end
-
-        reqs << Puppet::Relationship.new(dep, self)
-      }
-    }
-
-    reqs
-  end
-
-  # Build the dependencies associated with an individual object.
-  def builddepends
-    # Handle the requires
-    self.class.relationship_params.collect do |klass|
-      if param = @parameters[klass.name]
-        param.to_edges
-      end
-    end.flatten.reject { |r| r.nil? }
-  end
-
-  # Define the initial list of tags.
-  def tags=(list)
-    tag(self.class.name)
-    tag(*list)
-  end
-
-  # Types (which map to resources 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 properties.
-
-  # 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_writer :title
-  attr_writer :noop
-
-  include Enumerable
-
-  # class methods dealing with Type management
-
-  public
-
-  # the Type class attribute accessors
-  class << self
-    attr_reader :name
-    attr_accessor :self_refresh
-    include Enumerable, Puppet::Util::ClassGen
-    include Puppet::MetaType::Manager
-
-    include Puppet::Util
-    include Puppet::Util::Logging
-  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
-
-    @defaults = {}
-
-    @parameters ||= []
-
-    @validproperties = {}
-    @properties = []
-    @parameters = []
-    @paramhash = {}
-
-    @attr_aliases = {}
-
-    @paramdoc = Hash.new { |hash,key|
-      key = key.intern if key.is_a?(String)
-      if hash.include?(key)
-        hash[key]
-      else
-        "Param Documentation for #{key} not found"
-      end
-    }
-
-    @doc ||= ""
-
-  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
-
-  # The catalog that this resource is stored in.
-  attr_accessor :catalog
-
-  # is the resource exported
-  attr_accessor :exported
-
-  # is the resource virtual (it should not :-))
-  attr_accessor :virtual
-
-  # create a log at specified level
-  def log(msg)
-
-    Puppet::Util::Log.create(
-
-      :level => @parameters[:loglevel].value,
-      :message => msg,
-
-      :source => self
-    )
-  end
-
-
-  # instance methods related to instance intrinsics
-  # e.g., initialize and name
-
-  public
-
-  attr_reader :original_parameters
-
-  # initialize the type instance
-  def initialize(resource)
-    raise Puppet::DevError, "Got TransObject instead of Resource or hash" if resource.is_a?(Puppet::TransObject)
-    resource = self.class.hash2resource(resource) unless resource.is_a?(Puppet::Resource)
-
-    # The list of parameter/property instances.
-    @parameters = {}
-
-    # Set the title first, so any failures print correctly.
-    if resource.type.to_s.downcase.to_sym == self.class.name
-      self.title = resource.title
-    else
-      # This should only ever happen for components
-      self.title = resource.ref
-    end
-
-    [:file, :line, :catalog, :exported, :virtual].each do |getter|
-      setter = getter.to_s + "="
-      if val = resource.send(getter)
-        self.send(setter, val)
-      end
-    end
-
-    @tags = resource.tags
-
-    @original_parameters = resource.to_hash
-
-    set_name(@original_parameters)
-
-    set_default(:provider)
-
-    set_parameters(@original_parameters)
-
-    self.validate if self.respond_to?(:validate)
-  end
-
-  private
-
-  # Set our resource's name.
-  def set_name(hash)
-    self[name_var] = hash.delete(name_var) if name_var
-  end
-
-  # Set all of the parameters from a hash, in the appropriate order.
-  def set_parameters(hash)
-    # Use the order provided by allattrs, but add in any
-    # extra attributes from the resource so we get failures
-    # on invalid attributes.
-    no_values = []
-    (self.class.allattrs + hash.keys).uniq.each do |attr|
-      begin
-        # Set any defaults immediately.  This is mostly done so
-        # that the default provider is available for any other
-        # property validation.
-        if hash.has_key?(attr)
-          self[attr] = hash[attr]
-        else
-          no_values << attr
-        end
-      rescue ArgumentError, Puppet::Error, TypeError
-        raise
-      rescue => detail
-        error = Puppet::DevError.new( "Could not set #{attr} on #{self.class.name}: #{detail}")
-        error.set_backtrace(detail.backtrace)
-        raise error
-      end
-    end
-    no_values.each do |attr|
-      set_default(attr)
-    end
-  end
-
-  public
-
-  # Set up all of our autorequires.
-  def finish
-    # Make sure all of our relationships are valid.  Again, must be done
-    # when the entire catalog is instantiated.
-    self.class.relationship_params.collect do |klass|
-      if param = @parameters[klass.name]
-        param.validate_relationship
-      end
-    end.flatten.reject { |r| r.nil? }
-  end
-
-  # For now, leave the 'name' method functioning like it used to.  Once 'title'
-  # works everywhere, I'll switch it.
-  def name
-    self[:name]
-  end
-
-  # Look up our parent in the catalog, if we have one.
-  def parent
-    return nil unless catalog
-
-    unless defined?(@parent)
-      if parents = catalog.adjacent(self, :direction => :in)
-        # We should never have more than one parent, so let's just ignore
-        # it if we happen to.
-        @parent = parents.shift
-      else
-        @parent = nil
-      end
-    end
-    @parent
-  end
-
-  # Return the "type[name]" style reference.
-  def ref
-    "#{self.class.name.to_s.capitalize}[#{self.title}]"
-  end
-
-  def self_refresh?
-    self.class.self_refresh
-  end
-
-  # Mark that we're purging.
-  def purging
-    @purging = true
-  end
-
-  # Is this resource being purged?  Used by transactions to forbid
-  # deletion when there are dependencies.
-  def purging?
-    if defined?(@purging)
-      @purging
-    else
-      false
-    end
-  end
-
-  # Retrieve the title of an object.  If no title was set separately,
-  # then use the object's name.
-  def title
-    unless @title
-      if self.class.validparameter?(name_var)
-        @title = self[:name]
-      elsif self.class.validproperty?(name_var)
-        @title = self.should(name_var)
-      else
-        self.devfail "Could not find namevar #{name_var} for #{self.class.name}"
-      end
-    end
-
-    @title
-  end
-
-  # convert to a string
-  def to_s
-    self.ref
-  end
-
-  # Convert to a transportable object
-  def to_trans(ret = true)
-    trans = TransObject.new(self.title, self.class.name)
-
-    values = retrieve_resource
-    values.each do |name, value|
-      name = name.name if name.respond_to? :name
-      trans[name] = value
-    end
-
-    @parameters.each do |name, param|
-      # Avoid adding each instance name twice
-      next if param.class.isnamevar? and param.value == self.title
-
-      # We've already got property values
-      next if param.is_a?(Puppet::Property)
-      trans[name] = param.value
-    end
-
-    trans.tags = self.tags
-
-    # FIXME I'm currently ignoring 'parent' and 'path'
-
-    trans
-  end
-
-  def to_resource
-    # this 'type instance' versus 'resource' distinction seems artificial
-    # I'd like to see it collapsed someday ~JW
-    self.to_trans.to_resource
-  end
-
-  def virtual?;  !!@virtual;  end
-  def exported?; !!@exported; end
-
-  def appliable_to_device?
-    self.class.can_apply_to(:device)
-  end
-
-  def appliable_to_host?
-    self.class.can_apply_to(:host)
-  end
-end
-end
-
-require 'puppet/provider'
-
-# Always load these types.
-Puppet::Type.type(:component)