puppet 0.25.5 → 2.6.0

data/lib/puppet/provider/package/urpmi.rb

@@ -1,60 +1,60 @@
 Puppet::Type.type(:package).provide :urpmi, :parent => :rpm, :source => :rpm do
-    desc "Support via ``urpmi``."
-    commands :urpmi => "urpmi", :urpmq => "urpmq", :rpm => "rpm"
-
-    if command('rpm')
-        confine :true => begin
-                rpm('-ql', 'rpm')
-           rescue Puppet::ExecutionFailure
-               false
-           else
-               true
-           end
+  desc "Support via ``urpmi``."
+  commands :urpmi => "urpmi", :urpmq => "urpmq", :rpm => "rpm"
+
+  if command('rpm')
+    confine :true => begin
+      rpm('-ql', 'rpm')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :operatingsystem => [:mandriva, :mandrake]
+
+  has_feature :versionable
+
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      wanted += "-#{should}"
     end
 
-    defaultfor :operatingsystem => [:mandriva, :mandrake]
+    output = urpmi "--auto", wanted
 
-    has_feature :versionable
-
-    def install
-        should = @resource.should(:ensure)
-        self.debug "Ensuring => #{should}"
-        wanted = @resource[:name]
-
-        # XXX: We don't actually deal with epochs here.
-        case should
-        when true, false, Symbol
-            # pass
-        else
-            # Add the package version
-            wanted += "-%s" % should
-        end
-
-        output = urpmi "--auto", wanted
-
-        unless self.query
-            raise Puppet::Error.new(
-                "Could not find package %s" % self.name
-            )
-        end
+    unless self.query
+      raise Puppet::Error.new(
+        "Could not find package #{self.name}"
+      )
     end
-
-    # What's the latest package version available?
-    def latest
-        output = urpmq "-S", @resource[:name]
-
-        if output =~ /^#{Regexp.escape @resource[:name]}\s+:\s+.*\(\s+(\S+)\s+\)/
-            return $1
-        else
-            # urpmi didn't find updates, pretend the current
-            # version is the latest
-            return @resource[:ensure]
-        end
+  end
+
+  # What's the latest package version available?
+  def latest
+    output = urpmq "-S", @resource[:name]
+
+    if output =~ /^#{Regexp.escape @resource[:name]}\s+:\s+.*\(\s+(\S+)\s+\)/
+      return $1
+    else
+      # urpmi didn't find updates, pretend the current
+      # version is the latest
+      return @resource[:ensure]
     end
+  end
 
-    def update
-        # Install in urpmi can be used for update, too
-        self.install
-    end
+  def update
+    # Install in urpmi can be used for update, too
+    self.install
+  end
 end
 

data/lib/puppet/provider/package/yum.rb

@@ -1,108 +1,100 @@
 Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
-    desc "Support via ``yum``."
-
-    has_feature :versionable
-
-    commands :yum => "yum", :rpm => "rpm", :python => "python"
-
-    YUMHELPER = File::join(File::dirname(__FILE__), "yumhelper.py")
-
-    attr_accessor :latest_info
-
-    if command('rpm')
-        confine :true => begin
-                rpm('--version')
-           rescue Puppet::ExecutionFailure
-               false
-           else
-               true
-           end
-    end
-
-    defaultfor :operatingsystem => [:fedora, :centos, :redhat]
-
-    def self.prefetch(packages)
-        if Process.euid != 0
-            raise Puppet::Error, "The yum provider can only be used as root"
+  desc "Support via ``yum``."
+
+  has_feature :versionable
+
+  commands :yum => "yum", :rpm => "rpm", :python => "python"
+
+  YUMHELPER = File::join(File::dirname(__FILE__), "yumhelper.py")
+
+  attr_accessor :latest_info
+
+  if command('rpm')
+    confine :true => begin
+      rpm('--version')
+      rescue Puppet::ExecutionFailure
+        false
+      else
+        true
+      end
+  end
+
+  defaultfor :operatingsystem => [:fedora, :centos, :redhat]
+
+  def self.prefetch(packages)
+    raise Puppet::Error, "The yum provider can only be used as root" if Process.euid != 0
+    super
+    return unless packages.detect { |name, package| package.should(:ensure) == :latest }
+
+    # collect our 'latest' info
+    updates = {}
+    python(YUMHELPER).each_line do |l|
+      l.chomp!
+      next if l.empty?
+      if l[0,4] == "_pkg"
+        hash = nevra_to_hash(l[5..-1])
+        [hash[:name], "#{hash[:name]}.#{hash[:arch]}"].each  do |n|
+          updates[n] ||= []
+          updates[n] << hash
         end
-        super
-        return unless packages.detect { |name, package| package.should(:ensure) == :latest }
-
-         # collect our 'latest' info
-         updates = {}
-         python(YUMHELPER).each_line do |l|
-             l.chomp!
-             next if l.empty?
-             if l[0,4] == "_pkg"
-                 hash = nevra_to_hash(l[5..-1])
-                 [hash[:name], "#{hash[:name]}.#{hash[:arch]}"].each  do |n|
-                     updates[n] ||= []
-                     updates[n] << hash
-                 end
-             end
-         end
-
-         # Add our 'latest' info to the providers.
-         packages.each do |name, package|
-             if info = updates[package[:name]]
-                 package.provider.latest_info = info[0]
-             end
-         end
+      end
     end
 
-    def install
-        should = @resource.should(:ensure)
-        self.debug "Ensuring => #{should}"
-        wanted = @resource[:name]
-
-        # XXX: We don't actually deal with epochs here.
-        case should
-        when true, false, Symbol
-            # pass
-            should = nil
-        else
-            # Add the package version
-            wanted += "-%s" % should
-        end
-
-        output = yum "-d", "0", "-e", "0", "-y", :install, wanted
-
-        is = self.query
-        unless is
-            raise Puppet::Error, "Could not find package %s" % self.name
-        end
-
-        # FIXME: Should we raise an exception even if should == :latest
-        # and yum updated us to a version other than @param_hash[:ensure] ?
-        if should && should != is[:ensure]
-            raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead"
-        end
+    # Add our 'latest' info to the providers.
+    packages.each do |name, package|
+      if info = updates[package[:name]]
+        package.provider.latest_info = info[0]
+      end
     end
-
-    # What's the latest package version available?
-    def latest
-        upd = latest_info
-        unless upd.nil?
-            # FIXME: there could be more than one update for a package
-            # because of multiarch
-            return "#{upd[:version]}-#{upd[:release]}"
-        else
-            # Yum didn't find updates, pretend the current
-            # version is the latest
-            if properties[:ensure] == :absent
-                raise Puppet::DevError, "Tried to get latest on a missing package"
-            end
-            return properties[:ensure]
-        end
+  end
+
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+      should = nil
+    else
+      # Add the package version
+      wanted += "-#{should}"
     end
 
-    def update
-        # Install in yum can be used for update, too
-        self.install
+    output = yum "-d", "0", "-e", "0", "-y", :install, wanted
+
+    is = self.query
+    raise Puppet::Error, "Could not find package #{self.name}" unless is
+
+    # FIXME: Should we raise an exception even if should == :latest
+    # and yum updated us to a version other than @param_hash[:ensure] ?
+    raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should && should != is[:ensure]
+  end
+
+  # What's the latest package version available?
+  def latest
+    upd = latest_info
+    unless upd.nil?
+      # FIXME: there could be more than one update for a package
+      # because of multiarch
+      return "#{upd[:version]}-#{upd[:release]}"
+    else
+      # Yum didn't find updates, pretend the current
+      # version is the latest
+      raise Puppet::DevError, "Tried to get latest on a missing package" if properties[:ensure] == :absent
+      return properties[:ensure]
     end
+  end
 
-    def purge
-        yum "-y", :erase, @resource[:name]
-    end
- end
+  def update
+    # Install in yum can be used for update, too
+    self.install
+  end
+
+  def purge
+    yum "-y", :erase, @resource[:name]
+  end
+end
 

data/lib/puppet/provider/package/zypper.rb

@@ -0,0 +1,52 @@
+Puppet::Type.type(:package).provide :zypper, :parent => :rpm do
+  desc "Support for SuSE ``zypper`` package manager. Found in SLES10sp2+ and SLES11"
+
+  has_feature :versionable
+
+  commands :zypper => "/usr/bin/zypper"
+  commands :rpm    => "rpm"
+
+  confine    :operatingsystem => [:suse, :sles, :sled, :opensuse]
+
+  # Install a package using 'zypper'.
+  def install
+    should = @resource.should(:ensure)
+    self.debug "Ensuring => #{should}"
+    wanted = @resource[:name]
+
+    # XXX: We don't actually deal with epochs here.
+    case should
+    when true, false, Symbol
+      # pass
+    else
+      # Add the package version
+      wanted = "#{wanted}-#{should}"
+    end
+    output = zypper "--quiet", :install, "-l", "-y", wanted
+
+    unless self.query
+      raise Puppet::ExecutionFailure.new(
+        "Could not find package #{self.name}"
+      )
+    end
+  end
+
+  # What's the latest package version available?
+  def latest
+    #zypper can only get a list of *all* available packages?
+    output = zypper "list-updates"
+
+    if output =~ /#{Regexp.escape @resource[:name]}\s*\|\s*([^\s\|]+)/
+      return $1
+    else
+      # zypper didn't find updates, pretend the current
+      # version is the latest
+      return @property_hash[:ensure]
+    end
+  end
+
+  def update
+    # zypper install can be used for update, too
+    self.install
+  end
+end

data/lib/puppet/provider/parsedfile.rb

@@ -11,385 +11,362 @@ require 'puppet/util/fileparsing'
 # Once the provider prefetches the data, it's the resource's job to copy
 # that data over to the @is variables.
 class Puppet::Provider::ParsedFile < Puppet::Provider
-    extend Puppet::Util::FileParsing
+  extend Puppet::Util::FileParsing
 
-    class << self
-        attr_accessor :default_target, :target
-    end
-
-    attr_accessor :property_hash
+  class << self
+    attr_accessor :default_target, :target
+  end
 
-    def self.clean(hash)
-        newhash = hash.dup
-        [:record_type, :on_disk].each do |p|
-            if newhash.include?(p)
-                newhash.delete(p)
-            end
-        end
+  attr_accessor :property_hash
 
-        return newhash
+  def self.clean(hash)
+    newhash = hash.dup
+    [:record_type, :on_disk].each do |p|
+      newhash.delete(p) if newhash.include?(p)
     end
 
-    def self.clear
-        @target_objects.clear
-        @records.clear
-    end
+    newhash
+  end
 
-    def self.filetype
-        unless defined? @filetype
-            @filetype = Puppet::Util::FileType.filetype(:flat)
-        end
-        return @filetype
-    end
+  def self.clear
+    @target_objects.clear
+    @records.clear
+  end
 
-    def self.filetype=(type)
-        if type.is_a?(Class)
-            @filetype = type
-        elsif klass = Puppet::Util::FileType.filetype(type)
-            @filetype = klass
-        else
-            raise ArgumentError, "Invalid filetype %s" % type
-        end
+  def self.filetype
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+  end
+
+  def self.filetype=(type)
+    if type.is_a?(Class)
+      @filetype = type
+    elsif klass = Puppet::Util::FileType.filetype(type)
+      @filetype = klass
+    else
+      raise ArgumentError, "Invalid filetype #{type}"
     end
+  end
 
-    # Flush all of the targets for which there are modified records.  The only
-    # reason we pass a record here is so that we can add it to the stack if
-    # necessary -- it's passed from the instance calling 'flush'.
-    def self.flush(record)
-        # Make sure this record is on the list to be flushed.
-        unless record[:on_disk]
-            record[:on_disk] = true
-            @records << record
-
-            # If we've just added the record, then make sure our
-            # target will get flushed.
-            modified(record[:target] || default_target)
-        end
+  # Flush all of the targets for which there are modified records.  The only
+  # reason we pass a record here is so that we can add it to the stack if
+  # necessary -- it's passed from the instance calling 'flush'.
+  def self.flush(record)
+    # Make sure this record is on the list to be flushed.
+    unless record[:on_disk]
+      record[:on_disk] = true
+      @records << record
 
-        return unless defined?(@modified) and ! @modified.empty?
+      # If we've just added the record, then make sure our
+      # target will get flushed.
+      modified(record[:target] || default_target)
+    end
 
-        flushed = []
-        @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
-            Puppet.debug "Flushing %s provider target %s" % [@resource_type.name, target]
-            flush_target(target)
-            flushed << target
-        end
+    return unless defined?(@modified) and ! @modified.empty?
 
-        @modified.reject! { |t| flushed.include?(t) }
+    flushed = []
+    @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
+      Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
+      flush_target(target)
+      flushed << target
     end
 
-    # Make sure our file is backed up, but only back it up once per transaction.
-    # We cheat and rely on the fact that @records is created on each prefetch.
-    def self.backup_target(target)
-        return nil unless target_object(target).respond_to?(:backup)
+    @modified.reject! { |t| flushed.include?(t) }
+  end
 
-        unless defined?(@backup_stats)
-            @backup_stats = {}
-        end
-        return nil if @backup_stats[target] == @records.object_id
+  # Make sure our file is backed up, but only back it up once per transaction.
+  # We cheat and rely on the fact that @records is created on each prefetch.
+  def self.backup_target(target)
+    return nil unless target_object(target).respond_to?(:backup)
 
-        target_object(target).backup
-        @backup_stats[target] = @records.object_id
-    end
+    @backup_stats ||= {}
+    return nil if @backup_stats[target] == @records.object_id
 
-    # Flush all of the records relating to a specific target.
-    def self.flush_target(target)
-        backup_target(target)
+    target_object(target).backup
+    @backup_stats[target] = @records.object_id
+  end
 
-        records = target_records(target).reject { |r|
-            r[:ensure] == :absent
-        }
-        target_object(target).write(to_file(records))
-    end
+  # Flush all of the records relating to a specific target.
+  def self.flush_target(target)
+    backup_target(target)
 
-    # Return the header placed at the top of each generated file, warning
-    # users that modifying this file manually is probably a bad idea.
-    def self.header
+    records = target_records(target).reject { |r|
+      r[:ensure] == :absent
+    }
+    target_object(target).write(to_file(records))
+  end
+
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  def self.header
 %{# HEADER: This file was autogenerated at #{Time.now}
 # HEADER: by puppet.  While it can still be managed manually, it
 # HEADER: is definitely not recommended.\n}
-    end
-
-    # Add another type var.
-    def self.initvars
-        @records = []
-        @target_objects = {}
-
-        @target = nil
-
-        # Default to flat files
-        @filetype ||= Puppet::Util::FileType.filetype(:flat)
-        super
-    end
-
-    # Return a list of all of the records we can find.
-    def self.instances
-        targets.collect do |target|
-            prefetch_target(target)
-        end.flatten.reject { |r| skip_record?(r) }.collect do |record|
-            new(record)
-        end
-    end
-
-    # Override the default method with a lot more functionality.
-    def self.mk_resource_methods
-        [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
-            attr = symbolize(attr)
-            define_method(attr) do
+  end
+
+  # Add another type var.
+  def self.initvars
+    @records = []
+    @target_objects = {}
+
+    @target = nil
+
+    # Default to flat files
+    @filetype ||= Puppet::Util::FileType.filetype(:flat)
+    super
+  end
+
+  # Return a list of all of the records we can find.
+  def self.instances
+    targets.collect do |target|
+      prefetch_target(target)
+    end.flatten.reject { |r| skip_record?(r) }.collect do |record|
+      new(record)
+    end
+  end
+
+  # Override the default method with a lot more functionality.
+  def self.mk_resource_methods
+    [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
+      attr = symbolize(attr)
+      define_method(attr) do
 #                if @property_hash.empty?
 #                    # Note that this swaps the provider out from under us.
-#                    prefetch()
+#                    prefetch
 #                    if @resource.provider == self
 #                        return @property_hash[attr]
 #                    else
 #                        return @resource.provider.send(attr)
 #                    end
 #                end
-                # If it's not a valid field for this record type (which can happen
-                # when different platforms support different fields), then just
-                # return the should value, so the resource shuts up.
-                if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
-                    @property_hash[attr] || :absent
-                else
-                    if defined? @resource
-                        @resource.should(attr)
-                    else
-                        nil
-                    end
-                end
-            end
-
-            define_method(attr.to_s + "=") do |val|
-                mark_target_modified
-                @property_hash[attr] = val
-            end
-        end
-    end
-
-    # Always make the resource methods.
-    def self.resource_type=(resource)
-        super
-        mk_resource_methods()
-    end
-
-    # Mark a target as modified so we know to flush it.  This only gets
-    # used within the attr= methods.
-    def self.modified(target)
-        @modified ||= []
-        @modified << target unless @modified.include?(target)
-    end
-
-    # Retrieve all of the data from disk.  There are three ways to know
-    # which files to retrieve:  We might have a list of file objects already
-    # set up, there might be instances of our associated resource and they
-    # will have a path parameter set, and we will have a default path
-    # set.  We need to turn those three locations into a list of files,
-    # prefetch each one, and make sure they're associated with each appropriate
-    # resource instance.
-    def self.prefetch(resources = nil)
-        # Reset the record list.
-        @records = prefetch_all_targets(resources)
-
-        match_providers_with_resources(resources)
-    end
-
-    def self.match_providers_with_resources(resources)
-        return unless resources
-        matchers = resources.dup
-        @records.each do |record|
-            # Skip things like comments and blank lines
-            next if skip_record?(record)
-
-            if name = record[:name] and resource = resources[name]
-                resource.provider = new(record)
-            elsif respond_to?(:match)
-                if resource = match(record, matchers)
-                    # Remove this resource from circulation so we don't unnecessarily try to match
-                    matchers.delete(resource.title)
-                    record[:name] = resource[:name]
-                    resource.provider = new(record)
-                end
-            end
-        end
-    end
-
-    def self.prefetch_all_targets(resources)
-        records = []
-        targets(resources).each do |target|
-            records += prefetch_target(target)
-        end
-        records
-    end
-
-    # Prefetch an individual target.
-    def self.prefetch_target(target)
-        target_records = retrieve(target).each do |r|
-            r[:on_disk] = true
-            r[:target] = target
-            r[:ensure] = :present
+        # If it's not a valid field for this record type (which can happen
+        # when different platforms support different fields), then just
+        # return the should value, so the resource shuts up.
+        if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
+          @property_hash[attr] || :absent
+        else
+          if defined?(@resource)
+            @resource.should(attr)
+          else
+            nil
+          end
         end
-
-        if respond_to?(:prefetch_hook)
-            target_records = prefetch_hook(target_records)
+      end
+
+      define_method(attr.to_s + "=") do |val|
+        mark_target_modified
+        @property_hash[attr] = val
+      end
+    end
+  end
+
+  # Always make the resource methods.
+  def self.resource_type=(resource)
+    super
+    mk_resource_methods
+  end
+
+  # Mark a target as modified so we know to flush it.  This only gets
+  # used within the attr= methods.
+  def self.modified(target)
+    @modified ||= []
+    @modified << target unless @modified.include?(target)
+  end
+
+  # Retrieve all of the data from disk.  There are three ways to know
+  # which files to retrieve:  We might have a list of file objects already
+  # set up, there might be instances of our associated resource and they
+  # will have a path parameter set, and we will have a default path
+  # set.  We need to turn those three locations into a list of files,
+  # prefetch each one, and make sure they're associated with each appropriate
+  # resource instance.
+  def self.prefetch(resources = nil)
+    # Reset the record list.
+    @records = prefetch_all_targets(resources)
+
+    match_providers_with_resources(resources)
+  end
+
+  def self.match_providers_with_resources(resources)
+    return unless resources
+    matchers = resources.dup
+    @records.each do |record|
+      # Skip things like comments and blank lines
+      next if skip_record?(record)
+
+      if name = record[:name] and resource = resources[name]
+        resource.provider = new(record)
+      elsif respond_to?(:match)
+        if resource = match(record, matchers)
+          # Remove this resource from circulation so we don't unnecessarily try to match
+          matchers.delete(resource.title)
+          record[:name] = resource[:name]
+          resource.provider = new(record)
         end
-
-        unless target_records
-            raise Puppet::DevError, "Prefetching %s for provider %s returned nil" % [target, self.name]
+      end
+    end
+  end
+
+  def self.prefetch_all_targets(resources)
+    records = []
+    targets(resources).each do |target|
+      records += prefetch_target(target)
+    end
+    records
+  end
+
+  # Prefetch an individual target.
+  def self.prefetch_target(target)
+    target_records = retrieve(target).each do |r|
+      r[:on_disk] = true
+      r[:target] = target
+      r[:ensure] = :present
+    end
+
+    target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)
+
+    raise Puppet::DevError, "Prefetching #{target} for provider #{self.name} returned nil" unless target_records
+
+    target_records
+  end
+
+  # Is there an existing record with this name?
+  def self.record?(name)
+    return nil unless @records
+    @records.find { |r| r[:name] == name }
+  end
+
+  # Retrieve the text for the file. Returns nil in the unlikely
+  # event that it doesn't exist.
+  def self.retrieve(path)
+    # XXX We need to be doing something special here in case of failure.
+    text = target_object(path).read
+    if text.nil? or text == ""
+      # there is no file
+      return []
+    else
+      # Set the target, for logging.
+      old = @target
+      begin
+        @target = path
+        return self.parse(text)
+      rescue Puppet::Error => detail
+        detail.file = @target
+        raise detail
+      ensure
+        @target = old
+      end
+    end
+  end
+
+  # Should we skip the record?  Basically, we skip text records.
+  # This is only here so subclasses can override it.
+  def self.skip_record?(record)
+    record_type(record[:record_type]).text?
+  end
+
+  # Initialize the object if necessary.
+  def self.target_object(target)
+    @target_objects[target] ||= filetype.new(target)
+
+    @target_objects[target]
+  end
+
+  # Find all of the records for a given target
+  def self.target_records(target)
+    @records.find_all { |r| r[:target] == target }
+  end
+
+  # Find a list of all of the targets that we should be reading.  This is
+  # used to figure out what targets we need to prefetch.
+  def self.targets(resources = nil)
+    targets = []
+    # First get the default target
+    raise Puppet::DevError, "Parsed Providers must define a default target" unless self.default_target
+    targets << self.default_target
+
+    # Then get each of the file objects
+    targets += @target_objects.keys
+
+    # Lastly, check the file from any resource instances
+    if resources
+      resources.each do |name, resource|
+        if value = resource.should(:target)
+          targets << value
         end
-
-        target_records
+      end
     end
 
-    # Is there an existing record with this name?
-    def self.record?(name)
-        return nil unless @records
-        @records.find { |r| r[:name] == name }
-    end
+    targets.uniq.compact
+  end
 
-    # Retrieve the text for the file. Returns nil in the unlikely
-    # event that it doesn't exist.
-    def self.retrieve(path)
-        # XXX We need to be doing something special here in case of failure.
-        text = target_object(path).read
-        if text.nil? or text == ""
-            # there is no file
-            return []
-        else
-            # Set the target, for logging.
-            old = @target
-            begin
-                @target = path
-                return self.parse(text)
-            rescue Puppet::Error => detail
-                detail.file = @target
-                raise detail
-            ensure
-                @target = old
-            end
-        end
-    end
+  def self.to_file(records)
+    text = super
+    header + text
+  end
 
-    # Should we skip the record?  Basically, we skip text records.
-    # This is only here so subclasses can override it.
-    def self.skip_record?(record)
-        record_type(record[:record_type]).text?
+  def create
+    @resource.class.validproperties.each do |property|
+      if value = @resource.should(property)
+        @property_hash[property] = value
+      end
     end
+    mark_target_modified
+    (@resource.class.name.to_s + "_created").intern
+  end
 
-    # Initialize the object if necessary.
-    def self.target_object(target)
-        @target_objects[target] ||= filetype.new(target)
+  def destroy
+    # We use the method here so it marks the target as modified.
+    self.ensure = :absent
+    (@resource.class.name.to_s + "_deleted").intern
+  end
 
-        @target_objects[target]
-    end
-
-    # Find all of the records for a given target
-    def self.target_records(target)
-        @records.find_all { |r| r[:target] == target }
-    end
+  def exists?
+    !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
+  end
 
-    # Find a list of all of the targets that we should be reading.  This is
-    # used to figure out what targets we need to prefetch.
-    def self.targets(resources = nil)
-        targets = []
-        # First get the default target
-        unless self.default_target
-            raise Puppet::DevError, "Parsed Providers must define a default target"
-        end
-        targets << self.default_target
-
-        # Then get each of the file objects
-        targets += @target_objects.keys
-
-        # Lastly, check the file from any resource instances
-        if resources
-            resources.each do |name, resource|
-                if value = resource.should(:target)
-                    targets << value
-                end
-            end
-        end
+  # Write our data to disk.
+  def flush
+    # Make sure we've got a target and name set.
 
-        targets.uniq.compact
+    # If the target isn't set, then this is our first modification, so
+    # mark it for flushing.
+    unless @property_hash[:target]
+      @property_hash[:target] = @resource.should(:target) || self.class.default_target
+      self.class.modified(@property_hash[:target])
     end
+    @property_hash[:name] ||= @resource.name
 
-    def self.to_file(records)
-        text = super
-        header + text
-    end
+    self.class.flush(@property_hash)
 
-    def create
-        @resource.class.validproperties.each do |property|
-            if value = @resource.should(property)
-                @property_hash[property] = value
-            end
-        end
-        mark_target_modified()
-        return (@resource.class.name.to_s + "_created").intern
-    end
+    #@property_hash = {}
+  end
 
-    def destroy
-        # We use the method here so it marks the target as modified.
-        self.ensure = :absent
-        return (@resource.class.name.to_s + "_deleted").intern
-    end
+  def initialize(record)
+    super
 
-    def exists?
-        if @property_hash[:ensure] == :absent or @property_hash[:ensure].nil?
-            return false
-        else
-            return true
-        end
-    end
-
-    # Write our data to disk.
-    def flush
-        # Make sure we've got a target and name set.
-
-        # If the target isn't set, then this is our first modification, so
-        # mark it for flushing.
-        unless @property_hash[:target]
-            @property_hash[:target] = @resource.should(:target) || self.class.default_target
-            self.class.modified(@property_hash[:target])
-        end
-        @property_hash[:name] ||= @resource.name
-
-        self.class.flush(@property_hash)
-
-        #@property_hash = {}
-    end
+    # The 'record' could be a resource or a record, depending on how the provider
+    # is initialized.  If we got an empty property hash (probably because the resource
+    # is just being initialized), then we want to set up some defualts.
+    @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent} if @property_hash.empty?
+  end
 
-    def initialize(record)
-        super
+  # Retrieve the current state from disk.
+  def prefetch
+    raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
+    self.class.prefetch(@resource[:name] => @resource)
+  end
 
-        # The 'record' could be a resource or a record, depending on how the provider
-        # is initialized.  If we got an empty property hash (probably because the resource
-        # is just being initialized), then we want to set up some defualts.
-        if @property_hash.empty?
-            @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent}
-        end
-    end
+  def record_type
+    @property_hash[:record_type]
+  end
 
-    # Retrieve the current state from disk.
-    def prefetch
-        unless @resource
-            raise Puppet::DevError, "Somehow got told to prefetch with no resource set"
-        end
-        self.class.prefetch(@resource[:name] => @resource)
-    end
+  private
 
-    def record_type
-        @property_hash[:record_type]
-    end
-
-    private
-
-    # Mark both the resource and provider target as modified.
-    def mark_target_modified
-        if defined? @resource and restarget = @resource.should(:target) and restarget != @property_hash[:target]
-            self.class.modified(restarget)
-        end
-        if @property_hash[:target] != :absent and @property_hash[:target]
-            self.class.modified(@property_hash[:target])
-        end
+  # Mark both the resource and provider target as modified.
+  def mark_target_modified
+    if defined?(@resource) and restarget = @resource.should(:target) and restarget != @property_hash[:target]
+      self.class.modified(restarget)
     end
+    self.class.modified(@property_hash[:target]) if @property_hash[:target] != :absent and @property_hash[:target]
+  end
 end