puppet 0.16.0 → 0.18.4

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

@@ -1,14 +1,41 @@
 module Puppet
     Puppet.type(:package).newpkgtype(:apt, :dpkg) do
+        ENV['DEBIAN_FRONTEND'] = "noninteractive"
+
+
+
         # A derivative of DPKG; this is how most people actually manage
         # Debian boxes, and the only thing that differs is that it can
         # install packages from remote sites.
 
+        def checkforcdrom
+            unless defined? @@checkedforcdrom
+                if FileTest.exists? "/etc/apt/sources.list"
+                    if File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/
+                        @@checkedforcdrom = true
+                    else
+                        @@checkedforcdrom = false
+                    end
+                else
+                    # This is basically a pathalogical case, but we'll just
+                    # ignore it
+                    @@checkedforcdrom = false
+                end
+            end
+
+            if @@checkedforcdrom and self[:allowcdrom] != :true
+                raise Puppet::Error,
+                    "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
+            end
+        end
+
         # Install a package using 'apt-get'.  This function needs to support
         # installing a specific version.
         def install
             should = self.should(:ensure)
 
+            checkforcdrom()
+
             str = self[:name]
             case should
             when true, false, Symbol
@@ -17,7 +44,7 @@ module Puppet
                 # Add the package version
                 str += "=%s" % should
             end
-            cmd = "apt-get -q -y install %s" % str
+            cmd = "/usr/bin/apt-get -q -y install %s" % str
 
             self.info "Executing %s" % cmd.inspect
             output = %x{#{cmd} 2>&1}
@@ -29,7 +56,7 @@ module Puppet
 
         # What's the latest package version available?
         def latest
-            cmd = "apt-cache showpkg %s" % self[:name] 
+            cmd = "/usr/bin/apt-cache showpkg %s" % self[:name] 
             self.info "Executing %s" % cmd.inspect
             output = %x{#{cmd} 2>&1}
 
@@ -65,6 +92,14 @@ module Puppet
             self.install
         end
 
+        def uninstall
+            cmd = "/usr/bin/apt-get -y -q remove %s" % self[:name]
+            output = %x{#{cmd} 2>&1}
+            if $? != 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+
         def versionable?
             true
         end

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

@@ -0,0 +1,136 @@
+module Puppet
+    Puppet.type(:package).newpkgtype(:blastwave, :sun) do
+        if pkgget = %x{which pkg-get 2>/dev/null}.chomp and pkgget != ""
+            @@pkgget = pkgget
+        else
+            @@pkgget = nil
+        end
+
+        # This is so stupid
+        ENV["PAGER"] = "/usr/bin/cat"
+
+        def self.extended(mod)
+            unless @@pkgget
+                raise Puppet::Error,
+                    "The pkg-get command is missing; blastwave packaging unavailable"
+            end
+
+            unless FileTest.exists?("/var/pkg-get/admin")
+                Puppet.notice "It is highly recommended you create '/var/pkg-get/admin'."
+                Puppet.notice "See /var/pkg-get/admin-fullauto"
+            end
+        end
+
+        # Turn our blastwave listing into a bunch of hashes.
+        def blastlist(hash)
+            command = "#{@@pkgget} -c"
+
+            if hash[:justme]
+                command += " " + self[:name]
+            end
+
+            begin
+                output = execute(command)
+            rescue ExecutionFailure => detail
+                raise Puppet::Error, "Could not get package listing: %s" %
+                    detail
+            end
+
+            list = output.split("\n").collect do |line|
+                next if line =~ /^#/
+                next if line =~ /^WARNING/
+                next if line =~ /localrev\s+remoterev/
+
+                blastsplit(line)
+            end.reject { |h| h.nil? }
+
+            if hash[:justme]
+                return list[0]
+            else
+                list.reject! { |h|
+                    h[:ensure] == :absent
+                }
+                return list
+            end
+
+        end
+
+        # Split the different lines into hashes.
+        def blastsplit(line)
+            if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
+                hash = {}
+                hash[:name] = $1
+                hash[:ensure] = if $2 == "[Not installed]"
+                    :absent
+                else
+                    $2
+                end
+                hash[:avail] = $5
+
+                if hash[:avail] == "SAME"
+                    hash[:avail] = hash[:ensure]
+                end
+                hash[:type] = :blastwave
+
+                return hash
+            else
+                Puppet.warning "Cannot match %s" % line
+                return nil
+            end
+        end
+
+        module_function :blastlist, :blastsplit
+
+        def install
+            begin
+                execute("#{@@pkgget} -f install #{self[:name]}")
+            rescue ExecutionFailure => detail
+                raise Puppet::Error,
+                    "Could not install %s: %s" %
+                    [self[:name], detail]
+            end
+        end
+
+        # Retrieve the version from the current package file.
+        def latest
+            hash = blastlist(:justme => true)
+            hash[:avail]
+        end
+
+        def list(hash = {})
+            blastlist(hash).each do |bhash|
+                bhash.delete(:avail)
+                Puppet::Type.type(:package).installedpkg(bhash)
+            end
+        end
+
+        def query
+            hash = blastlist(:justme => true)
+
+            {:ensure => hash[:ensure]}
+        end
+
+        # Remove the old package, and install the new one
+        def update
+            begin
+                execute("#{@@pkgget} -f upgrade #{self[:name]}")
+            rescue ExecutionFailure => detail
+                raise Puppet::Error,
+                    "Could not upgrade %s: %s" %
+                    [self[:name], detail]
+            end
+        end
+
+        def uninstall
+            begin
+                execute("#{@@pkgget} -f remove #{self[:name]}")
+            rescue ExecutionFailure => detail
+                raise Puppet::Error,
+                    "Could not remove %s: %s" %
+                    [self[:name], detail]
+            end
+        end
+    end
+end
+
+# $Id: blastwave.rb 1382 2006-07-11 16:27:42Z luke $

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

@@ -12,7 +12,7 @@ module Puppet
 
             hash = {}
             # list out our specific package
-            open("| dpkg -l %s 2>/dev/null" % self[:name]) { |process|
+            open("| /usr/bin/dpkg -l %s 2>/dev/null" % self[:name]) { |process|
                 # our regex for matching dpkg output
                 regex = %r{^(.)(.)(.)\s(\S+)\s+(\S+)\s+(.+)$}
 
@@ -64,7 +64,7 @@ module Puppet
             ENV["COLUMNS"] = "500"
 
             # list out all of the packages
-            open("| dpkg -l") { |process|
+            open("| /usr/bin/dpkg -l") { |process|
                 # our regex for matching dpkg output
                 regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
                 fields = [:status, :name, :version, :description]
@@ -101,7 +101,7 @@ module Puppet
         end
 
         def uninstall
-            cmd = "dpkg -r %s" % self[:name]
+            cmd = "/usr/bin/dpkg -r %s" % self[:name]
             output = %x{#{cmd} 2>&1}
             if $? != 0
                 raise Puppet::PackageError.new(output)
@@ -110,4 +110,4 @@ module Puppet
     end
 end
 
-# $Id: dpkg.rb 1124 2006-04-20 07:00:10Z luke $
+# $Id: dpkg.rb 1256 2006-06-13 15:57:06Z luke $

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

@@ -0,0 +1,119 @@
+module Puppet
+    Puppet.type(:package).newpkgtype(:gem) do
+        if gem = %x{which gem 2>/dev/null}.chomp and gem != "" and gem !~ /^no /
+            @@gem = gem
+        else
+            @@gem = nil
+        end
+        def self.extended(mod)
+            unless @@gem
+                raise Puppet::Error,
+                    "The gem command is missing; gems unavailable"
+            end
+        end
+
+        def gemlist(hash)
+            command = "#{@@gem} list "
+
+            if hash[:local]
+                command += "--local "
+            else
+                command += "--remote "
+            end
+
+            if hash[:justme]
+                command += self[:name]
+            end
+            begin
+                list = execute(command).split("\n\n").collect do |set|
+                    if gemhash = gemsplit(set)
+                        gemhash[:type] = :gem
+                        gemhash[:ensure] = gemhash[:version][0]
+                        gemhash
+                    else
+                        nil
+                    end
+                end.reject { |p| p.nil? }
+            rescue ExecutionFailure => detail
+                raise Puppet::Error, "Could not list gems: %s" % detail
+            end
+
+            if hash[:justme]
+                return list.shift
+            else
+                return list
+            end
+        end
+
+        module_function :gemlist
+
+        def gemsplit(desc)
+            case desc
+            when /^\*\*\*/: return nil
+            when /^(\S+)\s+\((.+)\)\n/
+                name = $1
+                version = $2.split(/,\s*/)
+                return {
+                    :name => name,
+                    :version => version
+                }
+            else
+                Puppet.warning "Could not match %s" % desc
+                nil
+            end
+        end
+
+        module_function :gemsplit
+
+        def install(useversion = true)
+            command = "#{@@gem} install "
+            if self[:version] and useversion
+                command += "-v %s " % self[:version]
+            end
+            if source = self[:source]
+                command += source
+            else
+                command += self[:name]
+            end
+            begin
+                execute(command)
+            rescue ExecutionFailure => detail
+                raise Puppet::Error, "Could not install %s: %s" %
+                    [self[:name], detail]
+            end
+        end
+
+        def latest
+            # This always gets the latest version available.
+            hash = gemlist(:justme => true)
+
+            return hash[:version][0]
+        end
+
+        def list(justme = false)
+            gemlist(:local => true).each do |hash|
+                Puppet::Type.type(:package).installedpkg(hash)
+            end
+        end
+
+        def query
+            gemlist(:justme => true, :local => true)
+        end
+
+        def uninstall
+            begin
+                # Remove everything, including the binaries.
+                execute("#{@@gem} uninstall -x -a #{self[:name]}")
+            rescue ExecutionFailure => detail
+                raise Puppet::Error, "Could not uninstall %s: %s" %
+                    [self[:name], detail]
+            end
+        end
+
+        def update
+            self.install(false)
+        end
+    end
+end
+
+# $Id: gem.rb 1422 2006-07-22 03:32:56Z luke $

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

@@ -55,8 +55,8 @@ module Puppet
             end
             # list out all of the packages
             open("| #{listcmd()}") { |process|
-                # our regex for matching dpkg output
-                regex = %r{^(\S+)-(\d\S+)\s+(.+)}
+                # our regex for matching pkg_info output
+                regex = %r{^(\S+)-([^-\s]+)\s+(.+)}
                 fields = [:name, :version, :description]
                 hash = {}
 
@@ -82,13 +82,14 @@ module Puppet
                         pkg = Puppet.type(:package).installedpkg(hash)
                         packages << pkg
                     else
-                        raise Puppet::DevError,
-                            "Failed to match dpkg line %s" % line
+                        # Print a warning on lines we can't match, but move
+                        # on, since it should be non-fatal
+                        warning("Failed to match line %s" % line)
                     end
                 }
             }
 
-            # Mark any packages we didn't find as absent
+            # Mark as absent any packages we didn't find
             Puppet.type(:package).each do |pkg|
                 unless packages.include? pkg
                     pkg.is = [:ensure, :absent] 
@@ -108,4 +109,4 @@ module Puppet
     end
 end
 
-# $Id: openbsd.rb 1128 2006-04-21 03:06:54Z luke $
+# $Id: openbsd.rb 1182 2006-05-09 16:39:16Z luke $

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

@@ -13,7 +13,12 @@ module Puppet
             cmd = "/usr/local/sbin/portupgrade -p -N -P #{self[:name]}"
 
             self.debug "Executing %s" % cmd.inspect
-            output = %x{#{cmd} 2>&1}
+            output = %x{#{cmd} 2>&1 1>/dev/null}
+
+            if output =~ /\*\* No such /
+                raise Puppet::PackageError, "Could not find package %s" % self[:name]
+            end
+            #output = %x{#{cmd} 2>&1}
 
             unless $? == 0
                 raise Puppet::PackageError.new(output)
@@ -95,4 +100,4 @@ module Puppet
     end
 end
 
-# $Id: ports.rb 1128 2006-04-21 03:06:54Z luke $
+# $Id: ports.rb 1133 2006-04-22 19:22:33Z luke $

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

@@ -47,7 +47,7 @@ module Puppet
                 self.fail "RPMs must specify a package source"
             end
             
-            cmd = "rpm -p -q --qf '#{VERSIONSTRING}' #{self[:source]}"
+            cmd = "rpm -q --qf '#{VERSIONSTRING}' -p #{self[:source]}"
             self.debug "Executing %s" % cmd.inspect
             version = %x{#{cmd}}
 

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

@@ -62,13 +62,13 @@ module Puppet
                 raise Puppet::Error, "Sun packages must specify a package source"
             end
             cmd = ["pkgadd"]
-
+            
             if self[:adminfile]
-                cmd += ["-a", self[:adminfile]]
+                cmd << " -a " + self[:adminfile]
             end
 
             if self[:responsefile]
-                cmd += ["-r", self[:responsefile]]
+                cmd << " -r " + self[:responsefile]
             end
 
             cmd += ["-d", self[:source]]
@@ -76,7 +76,7 @@ module Puppet
             cmd << "2>&1"
             cmd = cmd.join(" ")
 
-            self.info "Executing %s" % cmd.inspect
+            self.debug "Executing %s" % cmd.inspect
             output = %x{#{cmd} 2>&1}
 
             unless $? == 0
@@ -117,6 +117,8 @@ module Puppet
                 process.each { |line|
                     case line
                     when /^$/:
+                        hash[:type] = :sun
+
                         packages.push Puppet.type(:package).installedpkg(hash)
                         hash.clear
                     when /\s*(\w+):\s+(.+)/:
@@ -142,14 +144,24 @@ module Puppet
         end
 
         def uninstall
-            cmd = "pkgrm -n %s 2>&1" % self[:name]
-            output = %x{#{cmd}}
-            if $? != 0
-                raise Puppet::Error, "Removal of %s failed: %s" % [self.name, output]
+            command  = "/usr/sbin/pkgrm -n "
+
+            if self[:adminfile]
+                command += " -a " + self[:adminfile]
+            end
+
+            command += " " + self[:name]
+            begin
+                execute(command)
+            rescue ExecutionFailure => detail
+                raise Puppet::Error,
+                    "Could not uninstall %s: %s" %
+                    [self[:name], detail]
             end
         end
 
-        # Remove the old package, and install the new one
+        # Remove the old package, and install the new one.  This will probably
+        # often fail.
         def update
             if @states[:ensure].is != :absent
                 self.uninstall
@@ -158,3 +170,5 @@ module Puppet
         end
     end
 end
+
+# $Id: sun.rb 1356 2006-07-04 05:45:28Z luke $