puppet 0.13.6 → 0.16.0

data/lib/puppet/type/package/apple.rb

@@ -0,0 +1,27 @@
+module Puppet
+    # OS X Packaging sucks.  We can install packages, but that's about it.
+    Puppet.type(:package).newpkgtype(:apple) do
+        def query
+            if FileTest.exists?("/Library/Receipts/#{self[:name]}.pkg")
+                return {:name => self[:name], :ensure => :present}
+            else
+                return nil
+            end
+        end
+
+        def install
+            source = nil
+            unless source = self[:source]
+                self.fail "Mac OS X packages must specify a package source"
+            end
+
+            output = %x{/usr/sbin/installer -pkg #{source} -target / 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+    end
+end
+
+# $Id: apple.rb 1055 2006-04-03 17:08:21Z luke $

data/lib/puppet/type/package/apt.rb

@@ -30,6 +30,7 @@ module Puppet
         # What's the latest package version available?
         def latest
             cmd = "apt-cache showpkg %s" % self[:name] 
+            self.info "Executing %s" % cmd.inspect
             output = %x{#{cmd} 2>&1}
 
             unless $? == 0

data/lib/puppet/type/package/darwinport.rb

@@ -0,0 +1,97 @@
+module Puppet
+    Puppet.type(:package).newpkgtype(:darwinport) do
+        def port
+            "/opt/local/bin/port"
+        end
+
+        def eachpkgashash
+            # list out all of the packages
+            open("| #{port} list installed") { |process|
+                regex = %r{(\S+)\s+@(\S+)\s+(\S+)}
+                fields = [:name, :version, :location]
+                hash = {}
+
+                # now turn each returned line into a package object
+                process.each { |line|
+                    hash.clear
+
+                    if match = regex.match(line)
+                        fields.zip(match.captures) { |field,value|
+                            hash[field] = value
+                        }
+
+                        hash.delete :location
+                        hash[:ensure] = hash[:version]
+                        yield hash.dup
+                    else
+                        raise Puppet::DevError,
+                            "Failed to match dpkg line %s" % line
+                    end
+                }
+            }
+        end
+
+        def install
+            should = self.should(:ensure)
+
+            # Seems like you can always say 'upgrade'
+            cmd = "#{port()} upgrade #{self[:name]}"
+
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+
+        def list
+            packages = []
+
+            eachpkgashash do |hash|
+                pkg = Puppet.type(:package).installedpkg(hash)
+                packages << pkg
+            end
+
+            return packages
+        end
+
+        def query
+            version = nil
+            eachpkgashash do |hash|
+                if hash[:name] == self[:name]
+                    return hash
+                end
+            end
+
+            return nil
+        end
+
+        def latest
+            info = %x{#{port()} search '^#{self[:name]}$' 2>/dev/null}
+
+            if $? != 0 or info =~ /^Error/
+                return nil
+            end
+
+            ary = info.split(/\s+/)
+            version = ary[2].sub(/^@/, '')
+
+            return version
+        end
+
+        def uninstall
+            cmd = "#{port()} uninstall #{self[:name]}"
+            output = %x{#{cmd} 2>&1}
+            if $? != 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+
+        def update
+            return install()
+        end
+    end
+end
+
+# $Id: darwinport.rb 1080 2006-04-05 08:08:00Z luke $

data/lib/puppet/type/package/dpkg.rb

@@ -67,7 +67,7 @@ module Puppet
             open("| dpkg -l") { |process|
                 # our regex for matching dpkg output
                 regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
-                fields = [:status, :name, :absent, :description]
+                fields = [:status, :name, :version, :description]
                 hash = {}
 
                 5.times { process.gets } # throw away the header
@@ -80,6 +80,14 @@ module Puppet
                         fields.zip(match.captures) { |field,value|
                             hash[field] = value
                         }
+
+                        if self.is_a? Puppet::Type and type = self[:type]
+                            hash[:type] = type
+                        elsif self.is_a? Module and self.respond_to? :name
+                            hash[:type] = self.name
+                        else
+                            raise Puppet::DevError, "Cannot determine package type"
+                        end
                         packages.push Puppet.type(:package).installedpkg(hash)
                     else
                         raise Puppet::DevError,
@@ -102,4 +110,4 @@ module Puppet
     end
 end
 
-# $Id: dpkg.rb 922 2006-02-16 19:10:34Z luke $
+# $Id: dpkg.rb 1124 2006-04-20 07:00:10Z luke $

data/lib/puppet/type/package/freebsd.rb

@@ -0,0 +1,19 @@
+module Puppet
+    Puppet.type(:package).newpkgtype(:freebsd, :openbsd) do
+        def listcmd
+            "pkg_info"
+        end
+
+        def query
+            list
+
+            if self[:version]
+                return :listed
+            else
+                return nil
+            end
+        end
+    end
+end
+
+# $Id: freebsd.rb 1079 2006-04-05 06:54:13Z luke $

data/lib/puppet/type/package/{bsd.rb → openbsd.rb}

@@ -1,5 +1,11 @@
 module Puppet
-    Puppet.type(:package).newpkgtype(:bsd) do
+    Puppet.type(:package).newpkgtype(:openbsd) do
+        def listcmd
+            "pkg_info -a"
+        end
+
+        module_function :listcmd
+
         def install
             should = self.should(:ensure)
 
@@ -42,8 +48,13 @@ module Puppet
         def list
             packages = []
 
+            if self.is_a? Puppet::Type
+                debug "Executing %s" % listcmd().inspect
+            else
+                Puppet.debug "Executing %s" % listcmd().inspect
+            end
             # list out all of the packages
-            open("| pkg_info -a") { |process|
+            open("| #{listcmd()}") { |process|
                 # our regex for matching dpkg output
                 regex = %r{^(\S+)-(\d\S+)\s+(.+)}
                 fields = [:name, :version, :description]
@@ -51,20 +62,38 @@ module Puppet
 
                 # now turn each returned line into a package object
                 process.each { |line|
+                    hash.clear
                     if match = regex.match(line)
-                        hash.clear
-
                         fields.zip(match.captures) { |field,value|
                             hash[field] = value
                         }
-                        packages.push Puppet.type(:package).installedpkg(hash)
+                        yup = nil
+                        name = hash[:name]
+                        hash[:ensure] = :present
+
+                        if self.is_a? Puppet::Type and type = self[:type]
+                            hash[:type] = type
+                        elsif self.is_a? Module and self.respond_to? :name
+                            hash[:type] = self.name
+                        else
+                            raise Puppet::DevError, "Cannot determine package type"
+                        end
+
+                        pkg = Puppet.type(:package).installedpkg(hash)
+                        packages << pkg
                     else
                         raise Puppet::DevError,
                             "Failed to match dpkg line %s" % line
                     end
                 }
             }
-            ENV["COLUMNS"] = oldcol
+
+            # Mark any packages we didn't find as absent
+            Puppet.type(:package).each do |pkg|
+                unless packages.include? pkg
+                    pkg.is = [:ensure, :absent] 
+                end
+            end
 
             return packages
         end
@@ -79,4 +108,4 @@ module Puppet
     end
 end
 
-# $Id: bsd.rb 922 2006-02-16 19:10:34Z luke $
+# $Id: openbsd.rb 1128 2006-04-21 03:06:54Z luke $

data/lib/puppet/type/package/ports.rb

@@ -0,0 +1,98 @@
+module Puppet
+    Puppet.type(:package).newpkgtype(:ports, :openbsd) do
+        # I hate ports
+        %w{INTERACTIVE UNAME}.each do |var|
+            if ENV.include?(var)
+                ENV.delete(var)
+            end
+        end
+        def install
+            # -p: create a package
+            # -N: install if the package is missing, otherwise upgrade
+            # -P: prefer binary packages
+            cmd = "/usr/local/sbin/portupgrade -p -N -P #{self[:name]}"
+
+            self.debug "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+
+        # If there are multiple packages, we only use the last one
+        def latest
+            cmd = "/usr/local/sbin/portversion -v #{self[:name]}"
+
+            self.debug "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>/dev/null}.chomp
+            line = output.split("\n").pop
+
+            unless line =~ /^(\S+)\s+(\S)\s+(.+)$/
+                # There's no "latest" version, so just return a placeholder
+                return :latest
+            end
+
+            pkgstuff = $1
+            match = $2
+            info = $3
+
+            unless pkgstuff =~ /^(\w+)-([0-9].+)$/
+                raise Puppet::PackageError,
+                    "Could not match package info '%s'" % pkgstuff
+            end
+
+            name, version = $1, $2
+
+            if match == "=" or match == ">" 
+                # we're up to date or more recent
+                return version
+            end
+
+            # Else, we need to be updated; we need to pull out the new version
+
+            unless info =~ /\((\w+) has (.+)\)/
+                raise Puppet::PackageError,
+                    "Could not match version info '%s'" % info
+            end
+
+            source, newversion = $1, $2
+
+            debug "Newer version in %s" % source
+            return newversion
+        end
+
+        def listcmd
+            "pkg_info"
+        end
+
+        module_function :listcmd
+
+        def query
+            list
+
+            if self[:version] and @states[:ensure].is != :absent
+                return :listed
+            else
+                return nil
+            end
+        end
+
+        def uninstall
+            cmd = "/usr/local/sbin/pkg_deinstall #{self[:name]}"
+            self.debug "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+            
+        end
+
+        def update
+            install()
+        end
+    end
+end
+
+# $Id: ports.rb 1128 2006-04-21 03:06:54Z luke $

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

@@ -1,5 +1,6 @@
 module Puppet
     Puppet.type(:package).newpkgtype(:rpm) do
+        VERSIONSTRING = "%{VERSION}-%{RELEASE}"
         def query
             fields = {
                 :name => "NAME",
@@ -8,7 +9,7 @@ module Puppet
             }
 
             cmd = "rpm -q #{self[:name]} --qf '%s\n'" %
-                "%{NAME} %{VERSION}-%{RELEASE}"
+                "%{NAME} #{VERSIONSTRING}"
 
             self.debug "Executing %s" % cmd.inspect
             # list out all of the packages
@@ -40,11 +41,24 @@ module Puppet
             return hash
         end
 
+        # Here we just retrieve the version from the file specified in the source.
+        def latest
+            unless source = self[:source]
+                self.fail "RPMs must specify a package source"
+            end
+            
+            cmd = "rpm -p -q --qf '#{VERSIONSTRING}' #{self[:source]}"
+            self.debug "Executing %s" % cmd.inspect
+            version = %x{#{cmd}}
+
+            return version
+        end
+
         def list
             packages = []
 
             # list out all of the packages
-            open("| rpm -q -a --qf '%{NAME} %{VERSION}\n'") { |process|
+            open("| rpm -q -a --qf '%{NAME} #{VERSIONSTRING}\n'") { |process|
                 # our regex for matching dpkg output
                 regex = %r{^(\S+)\s+(\S+)}
                 fields = [:name, :ensure]
@@ -58,6 +72,13 @@ module Puppet
                         fields.zip(match.captures) { |field,value|
                             hash[field] = value
                         }
+                        if self.is_a? Puppet::Type and type = self[:type]
+                            hash[:type] = type
+                        elsif self.is_a? Module and self.respond_to? :name
+                            hash[:type] = self.name
+                        else
+                            raise Puppet::DevError, "Cannot determine package type"
+                        end
                         packages.push Puppet.type(:package).installedpkg(hash)
                     else
                         raise "failed to match rpm line %s" % line
@@ -68,11 +89,22 @@ module Puppet
             return packages
         end
 
-        # we need package retrieval mechanisms before we can have package
-        # installation mechanisms...
-        #type.install = proc { |pkg|
-        #    raise "installation not implemented yet"
-        #}
+        def install
+            source = nil
+            unless source = self[:source]
+                self.fail "RPMs must specify a package source"
+            end
+
+            flag = "-i"
+            if @states[:ensure].is != :absent
+                flag = "-U"
+            end
+            output = %x{rpm #{flag} #{source} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
 
         def uninstall
             cmd = "rpm -e %s" % self[:name]
@@ -81,5 +113,9 @@ module Puppet
                 raise output
             end
         end
+
+        def update
+            self.install
+        end
     end
 end