puppet 0.18.4 → 0.22.4

data/lib/puppet/type/notify.rb

@@ -0,0 +1,47 @@
+#
+# Simple module for logging messages on the client-side
+#
+
+module Puppet
+    newtype(:notify) do
+        @doc = "Sends an arbitrary message to the puppetd run-time log."
+
+        newproperty(:message) do
+            desc "The message to be sent to the log."
+            def sync
+                case @parent["withpath"]
+                when :true:
+                    log(self.should)
+                else  
+                    Puppet.send(@parent[:loglevel], self.should)
+                end
+                return
+            end
+
+            def retrieve
+                return
+            end
+
+            def insync?
+                false
+            end
+
+            defaultto { @parent[:name] }
+        end
+
+        newparam(:withpath) do 
+            desc "Whether to not to show the full object path.  Sends the
+                message at the current loglevel."
+            defaultto :false
+
+            newvalues(:true, :false) 
+        end
+
+        newparam(:name) do
+            desc "An arbitrary tag for your own reference; the name of the message."
+            isnamevar
+        end
+    end
+end
+
+# $Id: notify.rb 2317 2007-03-19 17:42:17Z luke $

data/lib/puppet/type/package.rb

@@ -3,7 +3,7 @@
 # This allows packages to exist on the same machine using different packaging
 # systems.
 
-require 'puppet/type/state'
+require 'puppet/type/property'
 
 module Puppet
     class PackageError < Puppet::Error; end
@@ -17,124 +17,62 @@ module Puppet
 
             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 parenttype = pkgtype(parent)
-                    raise Puppet::DevError,
-                        "No parent type %s for package type %s" %
-                        [parent, name]
-                end
-                mod.send(:include, parenttype)
-            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)
-
-            class << mod
-                include Puppet::Util
-            end
-
-            # It's at least conceivable that a module would not define this method
-            # "module_function" makes the :list method private, so if the parent
-            # method also called module_function, then it's already private
-            if mod.public_method_defined? :list or mod.private_method_defined? :list
-                mod.send(:module_function, :list)
-            end
-
-            # Add it to our list
-            @pkgtypes[name] = mod
-
-            # And mark it as a valid type
-            unless defined? @typeparam
-                @typeparam = @parameters.find { |p| p.name == :type }
-
-                unless @typeparam
-                    Puppet.warning @parameters.inspect
-                    raise Puppet::DevError, "Could not package type parameter"
-                end
-            end
-            @typeparam.newvalues(name)
-        end
-
-        # Autoload the package types, if they're not already defined.
-        def self.pkgtype(name)
-            #name = name[0] if name.is_a? Array
-            name = name.intern if name.is_a? String
-            @pkgtypes ||= {}
-            unless @pkgtypes.include? name
-                begin
-                    require "puppet/type/package/#{name}"
-
-                    unless @pkgtypes.include? name
-                        Puppet.warning @pkgtypes.keys
-                        raise Puppet::DevError,
-                            "Loaded %s but pkgtype was not created" % name.inspect
-                    end
-                rescue LoadError
-                    raise Puppet::Error, "Could not load package type %s" % name
-                end
-            end
-            @pkgtypes[name]
-        end
-
-        def self.pkgtypes
-            @pkgtypes.keys
-        end
+            using the ``provider`` parameter; each provider defines what it
+            requires in order to function, and you must meet those requirements
+            to use a given provider."
+
+        feature :installable, "The provider can install packages.",
+            :methods => [:install]
+        feature :uninstallable, "The provider can uninstall packages.",
+            :methods => [:uninstall]
+        feature :upgradeable, "The provider can upgrade to the latest version of a
+                package.  This feature is used by specifying ``latest`` as the
+                desired value for the package.",
+            :methods => [:update, :latest]
+        feature :purgeable, "The provider can purge packages.  This generally means
+                that all traces of the package are removed, including
+                existing configuration files.  This feature is thus destructive
+                and should be used with the utmost care.",
+            :methods => [:purge]
 
         ensurable do
             desc "What state the package should be in.
                 *latest* only makes sense for those packaging formats that can
                 retrieve new packages on their own and will throw an error on
-                those that cannot."
+                those that cannot.  For those packaging systems that allow you
+                to specify package versions, specify them here.  Similarly,
+                *purged* is only useful for packaging systems that support
+                the notion of managing configuration files separately from
+                'normal' system files."
 
             attr_accessor :latest
 
-            newvalue(:present) do
-                @parent.install
+            newvalue(:present, :event => :package_installed) do
+                provider.install
             end
 
-            newvalue(:absent) do
-                @parent.uninstall
+            newvalue(:absent, :event => :package_removed) do
+                provider.uninstall
+            end
+            
+            newvalue(:purged, :event => :package_purged) do
+                unless provider.purgeable?
+                    self.fail(
+                        "Package provider %s does not purging" %
+                        @parent[:provider]
+                    )
+                end
+                provider.purge
             end
 
             # Alias the 'present' value.
             aliasvalue(:installed, :present)
 
             newvalue(:latest) do
-                unless @parent.respond_to?(:latest)
+                unless provider.upgradeable?
                     self.fail(
-                        "Package type %s does not support specifying 'latest'" %
-                        @parent[:type]
+                        "Package provider %s does not support specifying 'latest'" %
+                        @parent[:provider]
                     )
                 end
 
@@ -143,18 +81,39 @@ module Puppet
                 # to compare against later.
                 current = self.is
                 begin
-                    @parent.update
+                    provider.update
                 rescue => detail
                     self.fail "Could not update: %s" % detail
                 end
 
                 if current == :absent
-                    return :package_created
+                    :package_installed
                 else
-                    return :package_changed
+                    :package_changed
                 end
             end
 
+            newvalue(/./) do
+                unless provider.versionable?
+                    self.fail(
+                        "Package provider %s does not support specifying versions" %
+                        @parent[:provider]
+                     )
+                end
+                begin
+                    provider.install
+                rescue => detail
+                    self.fail "Could not update: %s" % detail
+                end
+
+                if self.is == :absent
+                    :package_installed
+                else
+                    :package_changed
+                end
+            end
+
+
             defaultto :installed
 
             # Override the parent method, because we've got all kinds of
@@ -178,10 +137,10 @@ module Puppet
                             return false
                         end
 
-                        unless @parent.respond_to?(:latest)
+                        unless provider.respond_to?(:latest)
                             self.fail(
                                 "Package type %s does not support specifying 'latest'" %
-                                @parent[:type]
+                                @parent[:provider]
                             )
                         end
 
@@ -190,25 +149,23 @@ module Puppet
                             #self.debug "Skipping latest check"
                         else
                             begin
-                                @latest = @parent.latest
+                                @latest = provider.latest
                                 @lateststamp = Time.now.to_i
                             rescue => detail
                                 self.fail "Could not get latest version: %s" % detail
                             end
                         end
+
                         case @is
                         when @latest:
                             return true
                         when :present:
-                            if @parent[:version] == @latest
-                                return true
-                            else
-                                self.debug "our version is %s and latest is %s" %
-                                    [@parent[:version], @latest]
-                            end
+                            # This will only happen on retarded packaging systems
+                            # that can't query versions.
+                            return true
                         else
                             self.debug "@is is %s, latest %s is %s" %
-                                [@is, @parent.name, @latest]
+                                [@is.inspect, @parent.name, @latest.inspect]
                         end
                     when :absent
                         if @is == :absent
@@ -222,37 +179,27 @@ module Puppet
                 return false
             end
 
-            # This retrieves the current state
+            # This retrieves the current state. LAK: I think this method is unused.
             def retrieve
-                @parent.retrieve
+                @is = @parent.retrieve
             end
 
-            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
+            # Provide a bit more information when logging upgrades.
+            def should_to_s
+                if @latest
+                    @latest.to_s
                 else
-                    #self.info "updating from %s" % value
-                    @parent.update
+                    super
                 end
             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:
+            a common name to packages::
 
                 # In the 'openssl' class
                 $ssl = $operationgsystem ? {
@@ -286,34 +233,10 @@ module Puppet
             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 }
-
-
-            validate do |value|
-                value = value[0] if value.is_a? Array
-                unless @parent.class.pkgtype(value)
-                    raise ArgumentError, "Invalid package type '%s'" % value
-                end
-            end
-
-
-            munge do |type|
-                type = type[0] if type.is_a? Array
-                if type.is_a? String
-                    type = type.intern
-                end
-                @parent.type2module(type)
-                type
-            end
-
-        end
-
         newparam(:source) do
-            desc "From where to retrieve the package."
+            desc "Where to find the actual package.  This must be a local file
+                (or on a network file system) or a URL that your specific
+                packaging type understands; Puppet will not retrieve files for you."
 
             validate do |value|
                 unless value =~ /^#{File::SEPARATOR}/ or value =~ /\w+:\/\//
@@ -330,6 +253,17 @@ module Puppet
             desc "A read-only parameter set by the package."
         end
 
+        newparam(:type) do
+            desc "Deprecated form of ``provider``."
+
+            munge do |value|
+                warning "'type' is deprecated; use 'provider' instead"
+                @parent[:provider] = value
+
+                @parent[:provider]
+            end
+        end
+
         newparam(:adminfile) do
             desc "A file containing package defaults for installing packages.
                 This is currently only used on Solaris.  The value will be
@@ -345,24 +279,15 @@ module Puppet
                 generally be a fully qualified path."
         end
 
-        # 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
+        newparam(:configfiles) do
+            desc "Whether configfiles should be kept or replaced.  Most packages
+                types do not support this parameter."
+
+            defaultto :keep
+
+            newvalues(:keep, :replace)
         end
+
         newparam(:category) do
             desc "A read-only parameter set by the package."
         end
@@ -406,9 +331,6 @@ module Puppet
 
         @allowedmethods = [:types]
 
-        @default = nil
-        @platform = nil
-
         class << self
             attr_reader :listed
         end
@@ -418,53 +340,10 @@ module Puppet
             super
         end
 
-        # Cache and return the default package type for our current
-        # platform.
-        def self.default
-            if @default.nil?
-                self.init
-            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 = :sun
-            when "gentoo":
-                Puppet.notice "No support for gentoo yet"
-                @default = nil
-            when "debian": @default = :apt
-            when "centos": @default = :rpm
-            when "fedora": @default = :yum
-            when "redhat": @default = :rpm
-            when "freebsd": @default = :ports
-            when "openbsd": @default = :openbsd
-            when "darwin": @default = :apple
-            else
-                if Facter["kernel"] == "Linux"
-                    Puppet.warning "Defaulting to RPM for %s" %
-                        Facter["operatingsystem"].value
-                    @default = :rpm
-                else
-                    Puppet.warning "No default package system for %s" %
-                        Facter["operatingsystem"].value
-                    @default = nil
-                end
-            end
-        end
-
         # Create a new package object from listed information
         def self.installedpkg(hash)
-            unless hash.include? :type
-                raise Puppet::DevError, "Got installed package with no type"
+            unless hash.include? :provider
+                raise Puppet::DevError, "Got installed package with no provider"
             end
             # this is from code, so we don't have to do as much checking
             name = hash[:name]
@@ -478,7 +357,15 @@ module Puppet
 
         # List all package instances
         def self.list
-            pkgtype(default).list()
+            # XXX For now, just list the default provider, but we should list
+            # all suitables or something, but we need to not list a parent
+            # type if a child type gets listed.
+            #suitableprovider.each do |provider|
+            #    p provider.name
+            #    provider.list
+            #end
+
+            defaultprovider.list
 
             self.collect do |pkg|
                 pkg
@@ -490,7 +377,7 @@ module Puppet
         def self.markabsent(pkgtype, packages)
             # Mark any packages we didn't find as absent
             self.each do |pkg|
-                next unless packages[:type] == pkgtype
+                next unless packages[:provider] == pkgtype
                 unless packages.include? pkg
                     pkg.is = [:ensure, :absent] 
                 end
@@ -499,13 +386,15 @@ module Puppet
 
         # This only exists for testing.
         def clear
-            @states[:ensure].latest = nil
+            if obj = @parameters[:ensure]
+                obj.latest = nil
+            end
         end
 
         # The 'query' method returns a hash of info if the package
         # exists and returns nil if it does not.
         def exists?
-            self.query
+            @provider.query
         end
 
         # okay, there are two ways that a package could be created...
@@ -515,35 +404,29 @@ module Puppet
         def initialize(hash)
             self.initvars
             type = nil
-            [:type, "type"].each { |label|
+            [:provider, "use"].each { |label|
                 if hash.include?(label)
                     type = hash[label]
                     hash.delete(label)
                 end
             }
             if type
-                self[:type] = type
+                self[:provider] = type
             else
-                self.setdefaults(:type)
+                self.setdefaults(:provider)
             end
 
             super
 
-            #unless @states.include?(:ensure)
-            #    self.debug "Defaulting to installing a package"
-            #    self[:ensure] = true
-            #end
-
-            unless @parameters.include?(:type)
-                self[:type] = self.class.default
+            unless @parameters.include?(:provider)
+                raise Puppet::DevError, "No package type set"
             end
         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
+            if hash = @provider.query
                 if hash == :listed # Mmmm, hackalicious
                     return
                 end
@@ -555,37 +438,26 @@ module Puppet
 
                 setparams(hash)
             else
-                # Else just mark all of the states absent.
-                self.class.validstates.each { |name|
+                # Else just mark all of the properties absent.
+                self.class.validproperties.each { |name|
                     self.is = [name, :absent]
                 }
             end
         end
 
         # Set all of the params' "is" value.  Most are parameters, but some
-        # are states.
+        # are properties.
         def setparams(hash)
             # Everything on packages is a parameter except :ensure
             hash.each { |param, value|
-                if self.class.attrtype(param) == :state
+                if self.class.attrtype(param) == :property
                     self.is = [param, value]
                 else
                     self[param] = value
                 end
             }
         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
     end # Puppet.type(:package)
 end
 
-# $Id: package.rb 1417 2006-07-21 19:33:36Z luke $
+# $Id: package.rb 2430 2007-04-30 15:19:23Z luke $