puppet 0.9.2 → 0.13.0

data/lib/puppet/type/nameservice/objectadd.rb

@@ -1,16 +1,6 @@
 require 'puppet'
 
 module Puppet
-    class State
-        def self.objectaddflag
-            if defined? @objectaddflag and @objectaddflag
-                return @objectaddflag
-            else
-                return @name
-            end
-        end
-    end
-
     module NameService
         module ObjectAdd
             # Verify that we've got the commands necessary to manage flat files.
@@ -25,6 +15,7 @@ module Puppet
                 end
             end
 
+            # Does the object already exist?
             def self.exists?(obj)
                 if obj.getinfo
                     return true
@@ -33,16 +24,45 @@ module Puppet
                 end
             end
 
-            class ObjectAddGroup < POSIX::POSIXState
-                def self.allatonce?
-                    true
+            # The base state class for <object>add operations.
+            class ObjectAddState < Puppet::State::NSSState
+                class << self
+                    # Determine the flag to pass to our command.
+                    def objectaddflag
+                        unless defined? @objectaddflag
+                            # Else, return the first letter of the name.  I have to
+                            # user a range here, else the character will show up
+                            # as a number, rather than as a string, for some reason.
+                            @objectaddflag = "-" + self.name.to_s[0,1]
+                            Puppet.debug "Setting flag on %s to %s" %
+                                [self.name, @objectaddflag]
+                        end
+                        return @objectaddflag
+                    end
+
+                    # Set the flag manually.
+                    def setflag(value)
+                        @objectaddflag = value
+                    end
+                end
+            end
+
+            # The state class for doing group operations using groupadd or whatever.
+            # I could probably have abstracted the User and Group classes into
+            # a single class, but eh, it just didn't seem worth it.
+            class ObjectAddGroup < ObjectAddState
+                class << self
+                    # This is hackish, but hey, it works.
+                    def finish
+                        @allatonce = true
+                    end
                 end
 
                 def addcmd
                     cmd = ["groupadd"]
                     if gid = @parent.should(:gid)
                         unless gid == :auto
-                            cmd << "-g" << gid 
+                            cmd << self.class.objectaddflag << gid 
                         end
                     end
                     cmd << @parent.name
@@ -64,25 +84,27 @@ module Puppet
                 end
             end
 
-            class GroupGID       < ObjectAddGroup
-                @objectaddflag = "-g"
-                @autogen = true
-            end
-
-            class ObjectAddUser < POSIX::POSIXState
-                def self.allatonce?
-                    true
+            # The class for adding users using 'adduser'.
+            class ObjectAddUser < ObjectAddState
+                class << self
+                    # This is hackish, but hey, it works.
+                    def finish
+                        @allatonce = true
+                        case self.name
+                        when :home: setflag "-d"
+                        end
+                    end
                 end
-
                 def addcmd
                     cmd = ["useradd"]
                     @parent.eachstate { |state|
+                        next if state.name == :ensure
                         # the value needs to be quoted, mostly because -c might
                         # have spaces in it
                         cmd << state.class.objectaddflag << "'%s'" % state.should
                     }
                     # stupid fedora
-                    case Facter["distro"].value
+                    case Facter["operatingsystem"].value
                     when "Fedora", "RedHat":
                         cmd << "-M"
                     else
@@ -97,50 +119,14 @@ module Puppet
                 end
 
                 def modifycmd
-                cmd = [
-                    "usermod",
-                    self.class.objectaddflag,
-                    "'%s'" % self.should,
-                    @parent.name
-                ].join(" ")
+                    cmd = [
+                        "usermod",
+                        self.class.objectaddflag,
+                        "'%s'" % self.should,
+                        @parent.name
+                    ].join(" ")
                 end
             end
-            class UserUID       < ObjectAddUser
-                @objectaddflag = "-u"
-                @autogen = true
-            end
-
-            class UserGID       < ObjectAddUser
-                @objectaddflag = "-g"
-                @autogen = true
-            end
-
-            class UserComment   < ObjectAddUser
-                @objectaddflag = "-c"
-            end
-
-            class UserHome      < ObjectAddUser
-                @objectaddflag = "-d"
-                @autogen = true
-            end
-
-            class UserShell     < ObjectAddUser
-                @objectaddflag = "-s"
-                @autogen = true
-            end
-
-            class UserLocked    < ObjectAddUser
-            end
-
-            class UserExpire    < ObjectAddUser
-                @objectaddflag = "-e"
-                @autogen = true
-            end
-
-            class UserInactive  < ObjectAddUser
-                @objectaddflag = "-f"
-                @autogen = true
-            end
         end
     end
 end

data/lib/puppet/type/nameservice/posix.rb

@@ -1,200 +1,12 @@
 require 'puppet'
+require 'puppet/type/nameservice'
 
 module Puppet
-    class Type
-        def self.posixmethod
-            if defined? @posixmethod and @posixmethod
-                return @posixmethod
-            else
-                return @name
-            end
-        end
-    end
-
-    module NameService
-        # This is the base module for basically all of the NSS stuff.  It
-        # should be able to retrieve the info for almost any system, but
-        # it can't create any information on its own.  You need to define
-        # a subclass of these classes to actually modify the system.
-        module POSIX
-            class POSIXState < Puppet::State
-                class << self
-                    attr_accessor :extender
-
-                    def autogen?
-                        if defined? @autogen
-                            return @autogen
-                        else
-                            return false
-                        end
-                    end
-
-                    def optional?
-                        if defined? @optional
-                            return @optional
-                        else
-                            return false
-                        end
-                    end
-                end
-
-                def self.doc
-                    if defined? @extender
-                        @extender.doc
-                    else
-                        nil
-                    end
-                end
-
-                def self.complete
-                    mod = "Puppet::State::%s" %
-                        self.to_s.sub(/.+::/,'')
-                    begin
-                        modklass = eval(mod)
-                    rescue NameError
-                        raise Puppet::Error,
-                            "Could not find extender module %s for %s" %
-                                [mod, self.to_s]
-                    end
-                    include modklass
-
-                    self.extender = modklass
-                end
-
-                def self.posixmethod
-                    if defined? @extender
-                        if @extender.respond_to?(:posixmethod)
-                            return @extender.posixmethod
-                        else
-                            return @extender.name
-                        end
-                    else
-                        raise Puppet::DevError,
-                            "%s could not retrieve posixmethod" % self
-                    end
-                end
-
-                def self.name
-                    @extender.name
-                end
-
-                # we use the POSIX interfaces to retrieve all information,
-                # so we don't have to worry about abstracting that across
-                # the system
-                def retrieve
-                    if obj = @parent.getinfo(true)
-
-                        if method = self.class.posixmethod || self.class.name
-                            @is = obj.send(method)
-                        else
-                            raise Puppet::DevError,
-                                "%s has no posixmethod" % self.class
-                        end
-                    else
-                        @is = :notfound
-                    end
-                end
-
-                def sync
-                    event = nil
-                    # they're in sync some other way
-                    if self.insync?
-                        return nil
-                    end
-                    if @is == :notfound
-                        self.retrieve
-                        if self.insync?
-                            return nil
-                        end
-                    end
-                    # if the object needs to be created or deleted,
-                    # depend on another method to do it all at once
-                    if @is == :notfound or self.should == :notfound
-                        event = syncname()
-
-                        return event
-                        # if the whole object is created at once, just return
-                        # an event saying so
-                        #if self.class.allatonce?
-                        #    return event
-                        #end
-                    end
-
-                    unless @parent.exists?
-                        raise Puppet::DevError,
-                            "%s %s does not exist; cannot set %s" %
-                            [@parent.class.name, @parent.name, self.class.name]
-                    end
-
-                    # this needs to be set either by the individual state
-                    # or its parent class
-                    cmd = self.modifycmd
-
-                    self.debug "Executing %s" % cmd.inspect
-
-                    output = %x{#{cmd} 2>&1}
-
-
-                    unless $? == 0
-                        raise Puppet::Error, "Could not modify %s on %s %s: %s" %
-                            [self.class.name, @parent.class.name,
-                                @parent.name, output]
-                    end
-
-                    if event
-                        return event
-                    else
-                        return "#{@parent.class.name}_modified".intern
-                    end
-                end
-
-                private
-                def syncname
-                    cmd = nil
-                    event = nil
-                    if self.should == :notfound
-                        # we need to remove the object...
-                        unless @parent.exists?
-                            # the group already doesn't exist
-                            return nil
-                        end
-
-                        # again, needs to be set by the ind. state or its
-                        # parent
-                        cmd = self.deletecmd
-                        type = "delete"
-                    else
-                        if @parent.exists?
-                            return nil
-                        end
-
-                        # blah blah, define elsewhere, blah blah
-                        cmd = self.addcmd
-                        type = "create"
-                    end
-                    self.debug "Executing %s" % cmd.inspect
-
-                    output = %x{#{cmd} 2>&1}
-
-                    unless $? == 0
-                        raise Puppet::Error, "Could not %s %s %s: %s" %
-                            [type, @parent.class.name, @parent.name, output]
-                    end
-
-                    # we want object creation to show up as one event, 
-                    # not many
-                    unless self.class.allatonce?
-                        if type == "create"
-                            @parent.eachstate { |state|
-                                state.sync
-                                state.retrieve
-                            }
-                        end
-                    end
-
-                    return "#{@parent.class.name}_#{type}d".intern
-                end
-            end
+    class State
+        # The lowest-level state class for managing NSS/POSIX information.  It
+        # at least knows how to retrieve information, but it does not know how
+        # to sync anything.
+        class POSIXState < NSSState
         end
     end
 end

data/lib/puppet/type/package.rb

@@ -4,43 +4,175 @@
 # systems.
 
 require 'puppet/type/state'
-require 'puppet/type/package/dpkg.rb'
-require 'puppet/type/package/apt.rb'
-require 'puppet/type/package/rpm.rb'
-require 'puppet/type/package/yum.rb'
-require 'puppet/type/package/sun.rb'
 
 module Puppet
     class PackageError < Puppet::Error; end
-    class State
-        class PackageInstalled < Puppet::State
-            @name = :install
+    newtype(:package) do
+        @doc = "Manage packages.  There is a basic dichotomy in package
+            support right now:  Some package types (e.g., yum and apt) can
+            retrieve their own package files, while others (e.g., rpm and
+            sunpkg) cannot.  For those package formats that cannot retrieve
+            their own files, you can use the ``source`` parameter to point to
+            the correct file.
+
+            Puppet will automatically guess the packaging format that you are
+            using based on the platform you are on, but you can override it
+            using the ``type`` parameter; obviously, if you specify that you
+            want to use ``rpm`` then the ``rpm`` tools must be available."
+
+        # Create a new packaging type
+        def self.newpkgtype(name, parent = nil, &block)
+            @pkgtypes ||= {}
+
+            if @pkgtypes.include?(name)
+                raise Puppet::DevError, "Package type %s already defined" % name
+            end
+
+            mod = Module.new
+            const_set("PkgType" + name.to_s.capitalize,mod)
+
+            # Add our parent, if it exists
+            if parent
+                unless @pkgtypes.include?(parent)
+                    raise Puppet::DevError,
+                        "No parent type %s for package type %s" %
+                        [parent, name]
+                end
+                mod.send(:include, @pkgtypes[parent])
+            end
+
+            # And now define the support methods
+            code = %{
+                def self.name
+                    "#{name}"
+                end
+
+                def self.to_s
+                    "PkgType(#{name})"
+                end
+
+                def pkgtype
+                    "#{name}"
+                end
+            }
+
+            mod.module_eval(code)
+
+            mod.module_eval(&block)
 
-            @doc = "What state the package should be in.  Specifying *true* will
-                only result in a change if the package is not installed at all; use
-                *latest* to keep the package (and, depending on the package system, its
-                prerequisites) up to date.  Specifying *false* will uninstall the
-                package if it is installed.  *true*/*false*/*latest*/``version``"
+            @pkgtypes[name] = mod
+        end
+
+        def self.pkgtype(name)
+            @pkgtypes[name]
+        end
+
+        def self.pkgtypes
+            @pkgtypes.keys
+        end
+
+        ensurable do
+            desc "What state the package should be in.  The primary options
+                are *installed* (also called *present*), *uninstalled* (also
+                called *absent*), and *latest*.  *latest* only makes sense for
+                those packaging formats that can retrieve new packages on
+                their own."
+
+            #munge do |value|
+            #    # possible values are: true, false, and a version number
+            #    case value
+            #    when "latest":
+            #        unless @parent.respond_to?(:latest)
+            #            self.err @parent.inspect
+            #            raise Puppet::Error,
+            #                "Package type %s cannot install later versions" %
+            #                @parent[:type].name
+            #        end
+            #        return :latest
+            #    when true, :present:
+            #        return :present
+            #    when false, :absent:
+            #        return :absent
+            #    else
+            #        # We allow them to set a should value however they want,
+            #        # but only specific package types will be able to use this
+            #        # value
+            #        return value
+            #    end
+            #end
+
+            newvalue(:present) do
+                @parent.install
+            end
+
+            newvalue(:absent) do
+                @parent.uninstall
+            end
+
+            # Alias the 'present' value.
+            aliasvalue(:installed, :present)
+            #newvalue(:installed) do
+            #    self.set(:present)
+            #end
+
+            newvalue(:latest) do
+                unless @parent.respond_to?(:latest)
+                    self.fail(
+                        "Package type %s does not support specifying 'latest'" %
+                        @parent[:type]
+                    )
+                end
+                begin
+                    @parent.update
+                rescue => detail
+                    self.fail "Could not update: %s" % detail
+                end
+
+                if self.is == :absent
+                    return :package_created
+                else
+                    return :package_changed
+                end
+            end
 
             # Override the parent method, because we've got all kinds of
             # funky definitions of 'in sync'.
             def insync?
-                # Iterate across all of the should values, and see how they turn out.
+                @should ||= []
+                # Iterate across all of the should values, and see how they
+                # turn out.
                 @should.each { |should|
                     case should
-                    when :installed
-                        unless @is == :notinstalled
+                    when :present
+                        unless @is == :absent
                             return true
                         end
                     when :latest
-                        latest = @parent.latest
-                        if @is == latest
+                        unless @parent.respond_to?(:latest)
+                            self.fail(
+                                "Package type %s does not support specifying 'latest'" %
+                                @parent[:type]
+                            )
+                        end
+
+                        begin
+                            latest = @parent.latest
+                        rescue => detail
+                            self.fail "Could not get latest version: %s" % detail
+                        end
+                        case @is
+                        when latest:
                             return true
+                        when :present:
+                            if @parent[:version] == latest
+                                return true
+                            end
                         else
-                            self.debug "latest %s is %s" % [@parent.name, latest]
+                            self.debug "@is is %s, latest %s is %s" %
+                                [@is, @parent.name, latest]
                         end
-                    when :notinstalled
-                        if @is == :notinstalled
+                    when :absent
+                        if @is == :absent
                             return true
                         end
                     when @is
@@ -53,324 +185,336 @@ module Puppet
 
             # This retrieves the current state
             def retrieve
-                unless defined? @is
-                    @parent.retrieve
-                end
+                #unless defined? @is
+                @parent.retrieve
+                #end
             end
 
-            def shouldprocess(value)
-                # possible values are: true, false, and a version number
-                case value
-                when "latest":
-                    unless @parent.respond_to?(:latest)
-                        self.err @parent.inspect
-                        raise Puppet::Error,
-                            "Package type %s does not support querying versions" %
-                            @parent[:type]
-                    end
-                    return :latest
-                when true, :installed:
-                    return :installed
-                when false, :notinstalled:
-                    return :notinstalled
+            def sync
+                value = self.should
+                unless value.is_a?(Symbol)
+                    value = value.intern
+                end
+                # If we're a normal value, then just pass to the parent method
+                if self.class.values.include?(value)
+                    #self.info "setting %s" % value
+                    super
                 else
-                    # We allow them to set a should value however they want,
-                    # but only specific package types will be able to use this
-                    # value
-                    return value
+                    #self.info "updating from %s" % value
+                    @parent.update
                 end
             end
+        end
 
-            def sync
-                method = nil
-                event = nil
-                case @should[0]
-                when :installed:
-                    method = :install
-                    event = :package_installed
-                when :notinstalled:
-                    method = :remove
-                    event = :package_removed
-                when :latest
-                    if @is == :notinstalled
-                        method = :install
-                        event = :package_installed
-                    else
-                        method = :update
-                        event = :package_updated
-                    end
-                else
-                    unless ! @parent.respond_to?(:versionable?) or @parent.versionable?
-                        self.warning value
-                        raise Puppet::Error,
-                            "Package type %s does not support specifying versions" %
-                            @parent[:type]
-                    else
-                        method = :install
-                        event = :package_installed
-                    end
-                end
+        # Packages are complicated because each package format has completely
+        # different commands.
+        attr_reader :pkgtype
+
+        newparam(:name) do
+            desc "The package name.  This is the name that the packaging
+            system uses internally, which is sometimes (especially on Solaris)
+            a name that is basically useless to humans.  If you want to
+            abstract package installation, then you can use aliases to provide
+            a common name to packages::
+
+                # In the 'openssl' class
+                $ssl = $operationgsystem ? {
+                    solaris => SMCossl,
+                    default => openssl
+                }
 
-                if @parent.respond_to?(method)
-                    begin
-                        @parent.send(method)
-                    rescue => detail
-                        self.err "Could not run %s: %s" % [method, detail.to_s]
-                        raise
-                    end
-                else
-                    raise Puppet::Error, "Packages of type %s do not support %s" %
-                        [@parent[:type], method]
-                end
+                # It is not an error to set an alias to the same value as the
+                # object name.
+                package { $ssl:
+                    ensure => installed,
+                    alias => openssl
+                }
 
-                return event
+                . etc. .
+
+                $ssh = $operationgsystem ? {
+                    solaris => SMCossh,
+                    default => openssh
+                }
+
+                # Use the alias to specify a dependency, rather than
+                # having another selector to figure it out again.
+                package { $ssh:
+                    ensure => installed,
+                    alias => openssh,
+                    require => package[openssl]
+                }
+            
+            "
+            isnamevar
+        end
+
+        newparam(:type) do
+            desc "The package format.  You will seldom need to specify this --
+                Puppet will discover the appropriate format for your platform."
+
+            defaultto { @parent.class.default }
+
+            # We cannot log in this routine, because this gets called before
+            # there's a name for the package.
+            munge do |type|
+                @parent.type2module(type)
             end
         end
-    end
 
-    class Type
-        # packages are complicated because each package format has completely
-        # different commands.  We need some way to convert specific packages
-        # into the general package object...
-        class Package < Type
-            attr_reader :version, :pkgtype
-
-            @pkgtypes = [
-                Puppet::PackagingType::APT,
-                Puppet::PackagingType::DPKG,
-                Puppet::PackagingType::RPM,
-                Puppet::PackagingType::Yum,
-                Puppet::PackagingType::Sun
-            ]
-
-            @pkgtypehash = {}
-
-            # Now collect the name of each type and store it thusly
-            @pkgtypes.each { |type|
-                if type.respond_to?(:typename)
-                    @pkgtypehash[type.typename] = type
-                else
-                    name = type.to_s.sub(/.+::/, '').downcase.intern
-                    @pkgtypehash[name] = type
+        newparam(:source) do
+            desc "From where to retrieve the package."
+
+            validate do |value|
+                unless value =~ /^#{File::SEPARATOR}/ or value =~ /\w+:\/\//
+                    self.fail(
+                        "Package sources must be fully qualified files or URLs, depending on the platform."
+                    )
                 end
-            }
+            end
+        end
+        newparam(:instance) do
+            desc "A read-only parameter set by the package."
+        end
+        newparam(:status) do
+            desc "A read-only parameter set by the package."
+        end
 
-            @states = [
-                Puppet::State::PackageInstalled
-            ]
-                #:version,
-            @parameters = [
-                :name,
-                :type,
-                :instance,
-                :status,
-                :category,
-                :platform,
-                :root,
-                :vendor,
-                :description
-            ]
-
-            @paramdoc[:name] = "The package name."
-            @paramdoc[:type] = "The package format.  Currently supports " +
-                @pkgtypes.collect {|t|
-                    "``" + t.name.to_s + "``"
-                }.join(", ") + "."
-            @paramdoc[:instance] = "A read-only parameter set by the package."
-            @paramdoc[:status] = "A read-only parameter set by the package."
-            #@paramdoc[:version] = "A read-only parameter set by the package."
-            @paramdoc[:category] = "A read-only parameter set by the package."
-            @paramdoc[:platform] = "A read-only parameter set by the package."
-            @paramdoc[:root] = "A read-only parameter set by the package."
-            @paramdoc[:vendor] = "A read-only parameter set by the package."
-            @paramdoc[:description] = "A read-only parameter set by the package."
-
-            @doc = "Manage packages.  Eventually will support retrieving packages
-                from remote sources but currently only supports packaging
-                systems which can retrieve their own packages, like ``apt``."
-            @name = :package
-            @namevar = :name
-            @listed = false
+        newparam(:answerfile) do
+            desc "A file containing any necessary answers to questions asked by
+                the package.  This is currently only used on Solaris.  The
+                value will be validated according to system rules, which in
+                the case of Solaris means that it should either be a fully qualified
+                path or it should be in /var/sadm/install/admin."
+        end
 
-            @allowedmethods = [:types]
+        # FIXME Version is screwy -- most package systems can't specify a
+        # version, but people will definitely want to query versions, so
+        # it almost seems like versions should be a read-only state,
+        # supporting syncing only in certain cases.
+        newparam(:version) do
+            desc "For some platforms this is a read-only parameter set by the
+                package, but for others, setting this parameter will cause
+                the package of that version to be installed.  It just depends
+                on the features of the packaging system."
+
+#            validate do |value|
+#                unless @parent.respond_to?(:versionable?) and @parent.versionable?
+#                    raise Puppet::Error,
+#                        "Package type %s does not support specifying versions." %
+#                            @parent.pkgtype
+#                end
+#            end
+        end
+        newparam(:category) do
+            desc "A read-only parameter set by the package."
+        end
+        newparam(:platform) do
+            desc "A read-only parameter set by the package."
+        end
+        newparam(:root) do
+            desc "A read-only parameter set by the package."
+        end
+        newparam(:vendor) do
+            desc "A read-only parameter set by the package."
+        end
+        newparam(:description) do
+            desc "A read-only parameter set by the package."
+        end
+        @listed = false
 
-            @default = nil
-            @platform = nil
+        @allowedmethods = [:types]
 
-            class << self
-                attr_reader :listed
-            end
+        @default = nil
+        @platform = nil
 
-            def self.clear
-                @listed = false
-                super
-            end
+        class << self
+            attr_reader :listed
+        end
 
-            # Cache and return the default package type for our current
-            # platform.
-            def self.default
-                if @default.nil?
-                    self.init
-                end
+        def self.clear
+            @listed = false
+            super
+        end
 
-                return @default
+        # Cache and return the default package type for our current
+        # platform.
+        def self.default
+            if @default.nil?
+                self.init
             end
 
-            # Figure out what the default package type is for the platform
-            # on which we're running.
-            def self.init
-                unless @platform = Facter["operatingsystem"].value.downcase
-                    raise Puppet::DevError.new(
-                        "Must know platform for package management"
-                    )
-                end
-                case @platform
-                when "sunos": @default = :sun
-                when "linux":
-                    case Facter["distro"].value.downcase
-                    when "gentoo":
-                        Puppet.notice "No support for gentoo yet"
-                        @default = nil
-                    when "debian": @default = :apt
-                    when "fedora": @default = :yum
-                    when "redhat": @default = :rpm
-                    else
-                        Puppet.warning "Using rpm as default type for %s" %
-                            Facter["distro"].value
-                        @default = :rpm
-                    end
+            return @default
+        end
+
+        # Figure out what the default package type is for the platform
+        # on which we're running.
+        def self.init
+            unless @platform = Facter["operatingsystem"].value.downcase
+                raise Puppet::DevError.new(
+                    "Must know platform for package management"
+                )
+            end
+            case @platform
+            when "solaris": @default = :sunpkg
+            when "gentoo":
+                Puppet.notice "No support for gentoo yet"
+                @default = nil
+            when "debian": @default = :apt
+            when "fedora": @default = :yum
+            when "redhat": @default = :rpm
+            when "openbsd": @default = :bsd
+            else
+                if Facter["kernel"] == "Linux"
+                    Puppet.warning "Defaulting to RPM for %s" %
+                        Facter["operatingsystem"].value
+                    @default = nil
                 else
+                    Puppet.warning "No default package system for %s" %
+                        Facter["operatingsystem"].value
                     @default = nil
                 end
             end
+        end
 
-            def self.getpkglist
-                if @types.nil?
-                    if @default.nil?
-                        self.init
-                    end
-                    @types = [@default]
+        def self.getpkglist
+            if @types.nil?
+                if @default.nil?
+                    self.init
                 end
+                @types = [@default]
+            end
 
-                list = @types.collect { |type|
-                    if typeobj = Puppet::PackagingType[type]
-                        # pull all of the objects
-                        typeobj.list
+            list = @types.collect { |type|
+                if typeobj = Puppet::PackagingType[type]
+                    # pull all of the objects
+                    typeobj.list
+                else
+                    raise Puppet::Error, "Could not find package type '%s'" % type
+                end
+            }.flatten
+            @listed = true
+            return list
+        end
+
+        def self.installedpkg(hash)
+            # this is from code, so we don't have to do as much checking
+            name = hash[:name]
+            hash.delete(:name)
+
+            # if it already exists, modify the existing one
+            if object = Package[name]
+                states = {}
+                object.eachstate { |state|
+                    Puppet.debug "Adding %s" % state.name.inspect
+                    states[state.name] = state
+                }
+                hash.each { |var,value|
+                    if states.include?(var)
+                        Puppet.debug "%s is a set state" % var.inspect
+                        states[var].is = value
                     else
-                        raise "Could not find package type '%s'" % type
-                    end
-                }.flatten
-                @listed = true
-                return list
-            end
+                        Puppet.debug "%s is not a set state" % var.inspect
+                        if object[var] and object[var] != value
+                            Puppet.warning "Overriding %s => %s on %s with %s" %
+                                [var,object[var],name,value]
+                        end
 
-            def Package.installedpkg(hash)
-                # this is from code, so we don't have to do as much checking
-                name = hash[:name]
-                hash.delete(:name)
-
-                # if it already exists, modify the existing one
-                if object = Package[name]
-                    states = {}
-                    object.eachstate { |state|
-                        Puppet.debug "Adding %s" % state.name.inspect
-                        states[state.name] = state
-                    }
-                    hash.each { |var,value|
+                        #object.state(var).is = value
+
+                        # swap the values if we're a state
                         if states.include?(var)
-                            Puppet.debug "%s is a set state" % var.inspect
+                            Puppet.debug "Swapping %s because it's a state" % var
                             states[var].is = value
+                            states[var].should = nil
                         else
-                            Puppet.debug "%s is not a set state" % var.inspect
-                            if object[var] and object[var] != value
-                                Puppet.warning "Overriding %s => %s on %s with %s" %
-                                    [var,object[var],name,value]
-                            end
-
-                            #object.state(var).is = value
-
-                            # swap the values if we're a state
-                            if states.include?(var)
-                                Puppet.debug "Swapping %s because it's a state" % var
-                                states[var].is = value
-                                states[var].should = nil
-                            else
-                                Puppet.debug "%s is not a state" % var.inspect
-                                Puppet.debug "States are %s" % states.keys.collect { |st|
-                                    st.inspect
-                                }.join(" ")
-                            end
+                            Puppet.debug "%s is not a state" % var.inspect
+                            Puppet.debug "States are %s" % states.keys.collect { |st|
+                                st.inspect
+                            }.join(" ")
                         end
-                    }
-                    return object
-                else # just create it
-                    obj = self.create(:name => name)
-                    hash.each { |var,value|
-                        obj.addis(var,value)
-                    }
-                    return obj
-                end
+                    end
+                }
+                return object
+            else # just create it
+                obj = self.create(:name => name)
+                hash.each { |var,value|
+                    obj.addis(var,value)
+                }
+                return obj
             end
+        end
 
-            # Retrieve a package type by name; names are symbols.
-            def self.pkgtype(pkgtype)
-                if pkgtype.is_a?(String)
-                    pkgtype = pkgtype.intern
+        # The 'query' method returns a hash of info if the package
+        # exists and returns nil if it does not.
+        def exists?
+            self.query
+        end
+
+        # okay, there are two ways that a package could be created...
+        # either through the language, in which case the hash's values should
+        # be set in 'should', or through comparing against the system, in which
+        # case the hash's values should be set in 'is'
+        def initialize(hash)
+            self.initvars
+            type = nil
+            [:type, "type"].each { |label|
+                if hash.include?(label)
+                    type = hash[label]
+                    hash.delete(label)
                 end
-                return @pkgtypehash[pkgtype]
+            }
+            if type
+                self[:type] = type
+            else
+                self.setdefaults(:type)
             end
 
-            # okay, there are two ways that a package could be created...
-            # either through the language, in which case the hash's values should
-            # be set in 'should', or through comparing against the system, in which
-            # case the hash's values should be set in 'is'
-            def initialize(hash)
-                type = hash["type"] || hash[:type] || self.class.default
-                self.type2module(type)
-
-                super
+            super
 
-                self.debug "Extending to package type %s" % [@type]
+            #unless @states.include?(:ensure)
+            #    self.debug "Defaulting to installing a package"
+            #    self[:ensure] = true
+            #end
 
-                unless @states.include?(:install)
-                    self.debug "Defaulting to installing a package"
-                    self[:install] = true
-                end
-
-                unless @parameters.include?(:type)
-                    self[:type] = self.class.default
-                end
+            unless @parameters.include?(:type)
+                self[:type] = self.class.default
             end
+        end
 
-            def retrieve
-                if hash = self.query
-                    hash.each { |param, value|
-                        unless self.class.validarg?(param)
-                            hash.delete(param)
-                        end
-                    }
+        def retrieve
+            # If the package is installed, then retrieve all of the information
+            # about it and set it appropriately.
+            #@states[:ensure].retrieve
+            if hash = self.query
+                hash.each { |param, value|
+                    unless self.class.validattr?(param)
+                        hash.delete(param)
+                    end
+                }
 
-                    hash.each { |param, value|
-                        self.is = [param, value]
-                    }
-                else
-                    self.class.validstates.each { |name|
-                        self.is = [name, :notinstalled]
-                    }
-                end
+                hash.each { |param, value|
+                    self.is = [param, value]
+                }
+            else
+                # Else just mark all of the states absent.
+                self.class.validstates.each { |name|
+                    self.is = [name, :absent]
+                }
             end
+        end
 
-            # Extend the package with the appropriate package type.
-            def type2module(typename)
-                if type = self.class.pkgtype(typename)
-                    @type = type
-                    self.extend(type)
-                else
-                    raise Puppet::Error, "Invalid package type %s" % typename
-                end
+        # Extend the package with the appropriate package type.
+        def type2module(typename)
+            if type = self.class.pkgtype(typename)
+                self.extend(type)
+
+                return type
+            else
+                self.fail "Invalid package type %s" % typename
             end
-        end # Puppet::Type::Package
-    end
+        end
+    end # Puppet.type(:package)
 
     # this is how we retrieve packages
     class PackageSource
@@ -385,7 +529,7 @@ module Puppet
             if source = @@sources[type]
                 return source.retrieve(file)
             else
-                raise "Unknown package source: %s" % type
+                raise Puppet::Error, "Unknown package source: %s" % type
             end
         end
 
@@ -411,10 +555,18 @@ module Puppet
             if FileTest.exists?(file)
                 return file
             else
-                raise "File %s does not exist" % file
+                raise Puppet::Error, "File %s does not exist" % file
             end
         }
     }
 end
 
-# $Id: package.rb 731 2005-10-26 04:44:25Z luke $
+# The order these are loaded is important.
+require 'puppet/type/package/dpkg.rb'
+require 'puppet/type/package/apt.rb'
+require 'puppet/type/package/rpm.rb'
+require 'puppet/type/package/yum.rb'
+require 'puppet/type/package/sun.rb'
+require 'puppet/type/package/bsd.rb'
+
+# $Id: package.rb 888 2006-02-08 22:57:07Z luke $