puppet 0.22.4 → 0.23.0

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

@@ -1,5 +1,6 @@
+require 'puppet/provider/package'
 # RPM packaging.  Should work anywhere that has rpm installed.
-Puppet::Type.type(:package).provide :rpm do
+Puppet::Type.type(:package).provide :rpm, :source => :rpm, :parent => Puppet::Provider::Package do
     desc "RPM packaging support; should work anywhere with a working ``rpm``
         binary."
 
@@ -10,7 +11,7 @@ Puppet::Type.type(:package).provide :rpm do
 
     commands :rpm => "rpm"
 
-    def self.list
+    def self.instances
         packages = []
 
         # list out all of the packages
@@ -30,7 +31,7 @@ Puppet::Type.type(:package).provide :rpm do
                             hash[field] = value
                         }
                         hash[:provider] = self.name
-                        packages.push Puppet.type(:package).installedpkg(hash)
+                        packages << new(hash)
                     else
                         raise "failed to match rpm line %s" % line
                     end
@@ -47,7 +48,7 @@ Puppet::Type.type(:package).provide :rpm do
     # a hash with entries :instance => fully versioned package name, and 
     # :ensure => version-release
     def query
-        cmd = ["-q", @model[:name], "--nosignature", "--nodigest", "--qf", "#{NVRFORMAT} #{VERSIONSTRING}\n"]
+        cmd = ["-q", @resource[:name], "--nosignature", "--nodigest", "--qf", "#{NVRFORMAT} #{VERSIONSTRING}\n"]
 
         begin
             output = rpm(*cmd)
@@ -57,10 +58,10 @@ Puppet::Type.type(:package).provide :rpm do
 
         regex = %r{^(\S+)\s+(\S+)}
         fields = [:instance, :ensure]
-        hash = {}
+        attrs = {}
         if match = regex.match(output)
             fields.zip(match.captures) { |field,value|
-                hash[field] = value
+                attrs[field] = value
             }
         else
             raise Puppet::DevError,
@@ -68,36 +69,36 @@ Puppet::Type.type(:package).provide :rpm do
                 output
         end
 
-        @nvr = hash[:instance]
+        @nvr = attrs[:instance]
 
-        return hash
+        return attrs
     end
 
     # Here we just retrieve the version from the file specified in the source.
     def latest
-        unless source = @model[:source]
-            @model.fail "RPMs must specify a package source"
+        unless source = @resource[:source]
+            @resource.fail "RPMs must specify a package source"
         end
         
-        cmd = [command(:rpm), "-q", "--qf", "#{VERSIONSTRING}", "-p", "#{@model[:source]}"]
+        cmd = [command(:rpm), "-q", "--qf", "#{VERSIONSTRING}", "-p", "#{@resource[:source]}"]
         version = execfail(cmd, Puppet::Error)
         return version
     end
 
     def install
         source = nil
-        unless source = @model[:source]
-            @model.fail "RPMs must specify a package source"
+        unless source = @resource[:source]
+            @resource.fail "RPMs must specify a package source"
         end
-        if @model.should(:ensure) == @model.is(:ensure) ||
-           @model.should(:ensure) == :latest && @model.is(:ensure) == latest
-            # RPM gets pissy if you try to install an already 
-            # installed package
+        # RPM gets pissy if you try to install an already 
+        # installed package
+        if @resource.should(:ensure) == @property_hash[:ensure] or
+            @resource.should(:ensure) == :latest && @property_hash[:ensure] == latest
             return
         end
 
         flag = "-i"
-        if @model.is(:ensure) != :absent
+        if @property_hash[:ensure] and @property_hash[:ensure] != :absent
             flag = "-U"
         end
 
@@ -112,14 +113,10 @@ Puppet::Type.type(:package).provide :rpm do
         self.install
     end
 
-    def versionable?
-        true
-    end
-
     def nvr
         query unless @nvr
         @nvr
     end
 end
 
-# $Id: rpm.rb 2292 2007-03-18 19:01:31Z luke $
+# $Id: rpm.rb 2595 2007-06-17 00:06:46Z luke $

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

@@ -1,15 +1,17 @@
 Puppet.type(:package).provide :rug, :parent => :rpm do
     desc "Support for suse ``rug`` package manager."
 
+    has_feature :versionable
+
     commands :rug => "/usr/bin/rug"
     defaultfor :operatingsystem => :suse 
     confine    :operatingsystem => :suse
 
     # Install a package using 'rug'.
     def install
-        should = @model.should(:ensure)
+        should = @resource.should(:ensure)
         self.debug "Ensuring => #{should}"
-        wanted = @model[:name]
+        wanted = @resource[:name]
 
         # XXX: We don't actually deal with epochs here.
         case should
@@ -33,12 +35,12 @@ Puppet.type(:package).provide :rug, :parent => :rpm do
         #rug can only get a list of *all* available packages?
         output = rug "list-updates"
 
-        if output =~ /#{@model[:name]}\s*\|\s*([0-9\.\-]+)/
+        if output =~ /#{@resource[:name]}\s*\|\s*([0-9\.\-]+)/
             return $1
         else
             # rug didn't find updates, pretend the current
             # version is the latest
-            return @model.is(:ensure)
+            return @property_hash[:ensure]
         end
     end
 
@@ -46,8 +48,4 @@ Puppet.type(:package).provide :rug, :parent => :rpm do
         # rug install can be used for update, too
         self.install
     end
-
-    def versionable?
-        true
-    end
 end

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

@@ -1,6 +1,8 @@
-# Sun packaging.  No one else uses these package tools, AFAIK.
+# Sun packaging.
 
-Puppet::Type.type(:package).provide :sun do
+require 'puppet/provider/package'
+
+Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package do
     desc "Sun's packaging system.  Requires that you specify the source for
         the packages you're managing."
     commands :pkginfo => "/usr/bin/pkginfo",
@@ -9,7 +11,7 @@ Puppet::Type.type(:package).provide :sun do
 
     defaultfor :operatingsystem => :solaris
 
-    def self.list
+    def self.instances
         packages = []
         hash = {}
         names = {
@@ -40,7 +42,7 @@ Puppet::Type.type(:package).provide :sun do
                 when /^$/:
                     hash[:provider] = :sun
 
-                    packages.push Puppet.type(:package).installedpkg(hash)
+                    packages << new(hash)
                     hash.clear
                 when /\s*(\w+):\s+(.+)/:
                     name = $1
@@ -85,7 +87,7 @@ Puppet::Type.type(:package).provide :sun do
         if device
             cmd += " -d #{device}"
         end
-        cmd += " #{@model[:name]}"
+        cmd += " #{@resource[:name]}"
 
         begin
             # list out all of the packages
@@ -115,28 +117,28 @@ Puppet::Type.type(:package).provide :sun do
     end
 
     def install
-        unless @model[:source]
+        unless @resource[:source]
             raise Puppet::Error, "Sun packages must specify a package source"
         end
         cmd = []
         
-        if @model[:adminfile]
-            cmd << "-a" << @model[:adminfile]
+        if @resource[:adminfile]
+            cmd << "-a" << @resource[:adminfile]
         end
 
-        if @model[:responsefile]
-            cmd << "-r" << @model[:responsefile]
+        if @resource[:responsefile]
+            cmd << "-r" << @resource[:responsefile]
         end
 
-        cmd << "-d" << @model[:source]
-        cmd << "-n" << @model[:name]
+        cmd << "-d" << @resource[:source]
+        cmd << "-n" << @resource[:name]
 
         pkgadd cmd
     end
 
     # Retrieve the version from the current package file.
     def latest
-        hash = info2hash(@model[:source])
+        hash = info2hash(@resource[:source])
         hash[:ensure]
     end
 
@@ -147,22 +149,22 @@ Puppet::Type.type(:package).provide :sun do
     def uninstall
         command  = ["-n"]
 
-        if @model[:adminfile]
-            command << "-a" << @model[:adminfile]
+        if @resource[:adminfile]
+            command << "-a" << @resource[:adminfile]
         end
 
-        command << @model[:name]
+        command << @resource[:name]
         pkgrm command
     end
 
     # Remove the old package, and install the new one.  This will probably
     # often fail.
     def update
-        if @model.is(:ensure) != :absent
+        if (@property_hash[:ensure] || info2hash()[:ensure]) != :absent
             self.uninstall
         end
         self.install
     end
 end
 
-# $Id: sun.rb 1980 2006-12-28 19:14:11Z luke $
+# $Id: sun.rb 2581 2007-06-14 06:21:40Z luke $

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

@@ -1,9 +1,9 @@
 # At this point, it's an exact copy of the Blastwave stuff.
-Puppet::Type.type(:package).provide :sunfreeware, :parent => :blastwave do
+Puppet::Type.type(:package).provide :sunfreeware, :parent => :blastwave, :source => :sun do
     desc "Package management using sunfreeware.com's ``pkg-get`` command on Solaris.
         At this point, support is exactly the same as ``blastwave`` support and
         has not actually been tested."
     commands :pkgget => "pkg-get"
 end
 
-# $Id: sunfreeware.rb 1571 2006-09-06 04:49:45Z luke $
+# $Id: sunfreeware.rb 2555 2007-06-08 17:20:00Z luke $

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

@@ -1,4 +1,4 @@
-Puppet.type(:package).provide :up2date, :parent => :rpm do
+Puppet.type(:package).provide :up2date, :parent => :rpm, :source => :rpm do
     desc "Support for Red Hat's proprietary ``up2date`` package update
         mechanism."
 
@@ -9,7 +9,7 @@ Puppet.type(:package).provide :up2date, :parent => :rpm do
 
     # Install a package using 'up2date'.
     def install
-        up2date "-u", @model[:name]
+        up2date "-u", @resource[:name]
 
         unless self.query
             raise Puppet::ExecutionFailure.new(
@@ -21,14 +21,14 @@ Puppet.type(:package).provide :up2date, :parent => :rpm do
     # What's the latest package version available?
     def latest
         #up2date can only get a list of *all* available packages?
-        output = up2date "--show-available"
+        output = up2date "--showall"
 
-        if output =~ /#{@model[:name]}-(\d+.*)\.\w+/
+        if output =~ /^#{@resource[:name]}-(\d+.*)\.\w+/
             return $1
         else
             # up2date didn't find updates, pretend the current
             # version is the latest
-            return @model.is(:ensure)
+            return @property_hash[:ensure]
         end
     end
 
@@ -36,10 +36,6 @@ Puppet.type(:package).provide :up2date, :parent => :rpm do
         # Install in up2date can be used for update, too
         self.install
     end
-
-    def versionable?
-        false
-    end
 end
 
-# $Id: up2date.rb 2233 2007-02-27 23:16:54Z lutter $
+# $Id: up2date.rb 2582 2007-06-14 06:23:02Z luke $

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

@@ -0,0 +1,51 @@
+Puppet::Type.type(:package).provide :urpmi, :parent => :rpm, :source => :rpm do
+    desc "Support via ``urpmi``."
+    commands :urpmi => "urpmi", :rpm => "rpm"
+
+    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 += "-%s" % should
+        end
+
+        output = urpmi "--auto", wanted
+
+        unless self.query
+            raise Puppet::Error.new(
+                "Could not find package %s" % self.name
+            )
+        end
+    end
+
+    # What's the latest package version available?
+    def latest
+        output = urpmi "-S",  :available, @resource[:name]
+
+        if output =~ /^#{@resource[:name]}\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
+end
+
+# $Id: urpmi.rb 2618 2007-06-18 21:18:48Z luke $

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

@@ -1,16 +1,19 @@
-Puppet::Type.type(:package).provide :yum, :parent => :rpm do
+Puppet::Type.type(:package).provide :yum, :parent => :rpm, :source => :rpm do
     desc "Support via ``yum``."
+
+    has_feature :versionable
+
     commands :yum => "yum", :rpm => "rpm"
 
     defaultfor :operatingsystem => [:fedora, :centos, :redhat]
 
     def install
 
-        should = @model.should(:ensure)
-	self.debug "Ensuring => #{should}"
-	wanted = @model[:name]
+        should = @resource.should(:ensure)
+        self.debug "Ensuring => #{should}"
+        wanted = @resource[:name]
 
-	# XXX: We don't actually deal with epochs here.
+        # XXX: We don't actually deal with epochs here.
         case should
         when true, false, Symbol
             # pass
@@ -30,14 +33,17 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm do
 
     # What's the latest package version available?
     def latest
-        output = yum "-d", "0", "-e", "0", :list, :available, @model[:name]
+        output = yum "-d", "0", "-e", "0", :list, :available, @resource[:name]
 
-        if output =~ /^#{@model[:name]}\S+\s+(\S+)\s/
+        if output =~ /^#{@resource[:name]}\S+\s+(\S+)\s/
             return $1
         else
             # Yum didn't find updates, pretend the current
             # version is the latest
-            return @model[:ensure]
+            unless properties[:ensure] != :absent
+                raise Puppet::DevError, "Tried to get latest on a missing package"
+            end
+            return @property_hash[:ensure]
         end
     end
 
@@ -45,10 +51,6 @@ Puppet::Type.type(:package).provide :yum, :parent => :rpm do
         # Install in yum can be used for update, too
         self.install
     end
-
-    def versionable?
-	true
-    end
 end
 
-# $Id: yum.rb 2235 2007-02-27 23:18:52Z luke $
+# $Id: yum.rb 2618 2007-06-18 21:18:48Z luke $

data/lib/puppet/provider/parsedfile.rb

@@ -8,7 +8,7 @@ require 'puppet/util/fileparsing'
 # on the provider instance.  At this point, the file is written once
 # for every provider instance.
 #
-# Once the provider prefetches the data, it's the model's job to copy
+# 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
@@ -70,7 +70,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
         flushed = []
         @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
-            Puppet.debug "Flushing %s provider target %s" % [@model.name, target]
+            Puppet.debug "Flushing %s provider target %s" % [@resource_type.name, target]
             flush_target(target)
             flushed << target
         end
@@ -107,58 +107,54 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
     end
 
     # Return a list of all of the records we can find.
-    def self.list
+    def self.instances
         prefetch()
         @records.find_all { |r| r[:record_type] == self.name }.collect { |r|
-            clean(r)
+            new(clean(r))
         }
     end
 
-    def self.list_by_name
-        list.collect { |r| r[:name] }
-    end
-
     # Override the default method with a lot more functionality.
-    def self.mkmodelmethods
-        [model.validproperties, model.parameters].flatten.each do |attr|
+    def self.mk_resource_methods
+        [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
             attr = symbolize(attr)
             define_method(attr) do
                 # 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 model shuts up.
+                # 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
-                    @model.should(attr)
+                    @resource.should(attr)
                 end
             end
 
             define_method(attr.to_s + "=") do |val|
                 # Mark that this target was modified.
-                modeltarget = @model.should(:target) || self.class.default_target
+                resourcetarget = @resource.should(:target) || self.class.default_target
 
                 # If they're the same, then just mark that one as modified
-                if @property_hash[:target] and @property_hash[:target] == modeltarget
-                    self.class.modified(modeltarget)
+                if @property_hash[:target] and @property_hash[:target] == resourcetarget
+                    self.class.modified(resourcetarget)
                 else
-                    # Always mark the modeltarget as modified, and if there's
+                    # Always mark the resourcetarget as modified, and if there's
                     # and old property_hash target, mark it as modified and replace
                     # it.
-                    self.class.modified(modeltarget)
+                    self.class.modified(resourcetarget)
                     if @property_hash[:target]
                         self.class.modified(@property_hash[:target])
                     end
-                    @property_hash[:target] = modeltarget
+                    @property_hash[:target] = resourcetarget
                 end
                 @property_hash[attr] = val
             end
         end
     end
 
-    # Always make the model methods.
-    def self.model=(model)
+    # Always make the resource methods.
+    def self.resource_type=(resource)
         super
-        mkmodelmethods()
+        mk_resource_methods()
     end
 
     # Mark a target as modified so we know to flush it.  This only gets
@@ -169,17 +165,30 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
     end
 
     # Retrieve all of the data from disk.  There are three ways to know
-    # while files to retrieve:  We might have a list of file objects already
-    # set up, there might be instances of our associated model and they
+    # 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
-    # model instance.
-    def self.prefetch
+    # resource instance.
+    def self.prefetch(resources = nil)
         # Reset the record list.
         @records = []
-        targets().each do |target|
-            prefetch_target(target)
+        targets(resources).each do |target|
+            @records += prefetch_target(target)
+        end
+
+        if resources
+            @records.each do |record|
+                if name = record[:name] and resource = resources[name]
+                    resource.provider = new(record)
+                elsif respond_to?(:match)
+                    if instance = match(record, resources)
+                        record[:name] = instance[:name]
+                        instance.provider = new(record)
+                    end
+                end
+            end
         end
     end
 
@@ -196,25 +205,10 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         end
 
         unless target_records
-            raise Puppet::DevError, "Prefetch hook for provider %s returned nil" %
-                self.name
+            raise Puppet::DevError, "Prefetching %s for provider %s returned nil" % [target, self.name]
         end
 
-        @records += target_records
-
-        # Set current property on any existing resource instances.
-        target_records(target).find_all { |i| i.is_a?(Hash) }.each do |record|
-            # Find any model instances whose names match our instances.
-            if instance = self.model[record[:name]]
-                next unless instance.provider.is_a?(self)
-                instance.provider.property_hash = record
-            elsif respond_to?(:match)
-                if instance = match(record)
-                    record[:name] = instance[:name]
-                    instance.provider.property_hash = record
-                end
-            end
-        end
+        target_records
     end
 
     # Is there an existing record with this name?
@@ -256,7 +250,7 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
     # 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
+    def self.targets(resources = nil)
         targets = []
         # First get the default target
         unless self.default_target
@@ -267,18 +261,14 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         # Then get each of the file objects
         targets += @target_objects.keys
 
-        # Lastly, check the file from any model instances
-        self.model.each do |model|
-            targets << model.value(:target)
-
-            # This is only the case for properties, and targets should always
-            # be properties.
-            if model.respond_to?(:is)
-                targets << model.is(:target)
+        # Lastly, check the file from any resource instances
+        if resources
+            resources.each do |name, resource|
+                targets << resource.value(:target)
             end
         end
 
-        targets.uniq.reject { |t| t.nil? }
+        targets.uniq.compact
     end
 
     def self.to_file(records)
@@ -288,19 +278,19 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
 
 
     def create
-        @model.class.validproperties.each do |property|
-            if value = @model.should(property)
+        @resource.class.validproperties.each do |property|
+            if value = @resource.should(property)
                 @property_hash[property] = value
             end
         end
         self.class.modified(@property_hash[:target] || self.class.default_target)
-        return (@model.class.name.to_s + "_created").intern
+        return (@resource.class.name.to_s + "_created").intern
     end
 
     def destroy
         # We use the method here so it marks the target as modified.
         self.ensure = :absent
-        return (@model.class.name.to_s + "_deleted").intern
+        return (@resource.class.name.to_s + "_deleted").intern
     end
 
     def exists?
@@ -318,15 +308,15 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         # If the target isn't set, then this is our first modification, so
         # mark it for flushing.
         unless @property_hash[:target]
-            @property_hash[:target] = @model[:target] || self.class.default_target
+            @property_hash[:target] = @resource.should(:target) || self.class.default_target
             self.class.modified(@property_hash[:target])
         end
-        @property_hash[:name] ||= @model.name
+        @property_hash[:name] ||= @resource.name
 
         self.class.flush(@property_hash)
     end
 
-    def initialize(model)
+    def initialize(resource)
         super
 
         # See if there's already a matching property_hash in the records list;
@@ -334,9 +324,9 @@ class Puppet::Provider::ParsedFile < Puppet::Provider
         # We provide a default for 'ensure' here, because the provider will
         # override it if the thing exists, but it won't touch it if it doesn't
         # exist.
-        @property_hash = self.class.record?(model[:name]) ||
+        @property_hash = self.class.record?(resource[:name]) ||
             {:record_type => self.class.name, :ensure => :absent}
     end
 end
 
-# $Id: parsedfile.rb 2296 2007-03-18 22:48:57Z luke $
+# $Id: parsedfile.rb 2551 2007-06-04 20:37:14Z luke $