puppet 0.18.4 → 0.22.4

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

@@ -1,103 +0,0 @@
-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 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)
-            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 1133 2006-04-22 19:22:33Z luke $

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

@@ -1,121 +0,0 @@
-module Puppet
-    Puppet.type(:package).newpkgtype(:rpm) do
-        VERSIONSTRING = "%{VERSION}-%{RELEASE}"
-        def query
-            fields = {
-                :name => "NAME",
-                :version => "VERSION",
-                :description => "DESCRIPTION"
-            }
-
-            cmd = "rpm -q #{self[:name]} --qf '%s\n'" %
-                "%{NAME} #{VERSIONSTRING}"
-
-            self.debug "Executing %s" % cmd.inspect
-            # list out all of the packages
-            output = %x{#{cmd} 2>/dev/null}.chomp
-
-            if $? != 0
-                #if Puppet[:debug]
-                #    puts output
-                #end
-                return nil
-            end
-
-            regex = %r{^(\S+)\s+(\S+)}
-            #fields = [:name, :ensure, :description]
-            fields = [:name, :version]
-            hash = {}
-            if match = regex.match(output)
-                fields.zip(match.captures) { |field,value|
-                    hash[field] = value
-                }
-            else
-                raise Puppet::DevError,
-                    "Failed to match rpm output '%s'" %
-                    output
-            end
-
-            hash[:ensure] = :present
-
-            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 -q --qf '#{VERSIONSTRING}' -p #{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} #{VERSIONSTRING}\n'") { |process|
-                # our regex for matching dpkg output
-                regex = %r{^(\S+)\s+(\S+)}
-                fields = [:name, :ensure]
-                hash = {}
-
-                # now turn each returned line into a package object
-                process.each { |line|
-                    if match = regex.match(line)
-                        hash.clear
-
-                        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
-                    end
-                }
-            }
-
-            return packages
-        end
-
-        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]
-            output = %x{#{cmd}}
-            if $? != 0
-                raise output
-            end
-        end
-
-        def update
-            self.install
-        end
-    end
-end

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

@@ -1,174 +0,0 @@
-module Puppet
-    Puppet.type(:package).newpkgtype(:sun) do
-        # Get info on a package, optionally specifying a device.
-        def info2hash(device = nil)
-            names = {
-                "PKGINST" => :name,
-                "NAME" => nil,
-                "CATEGORY" => :category,
-                "ARCH" => :platform,
-                "VERSION" => :ensure,
-                "BASEDIR" => :root,
-                "HOTLINE" => nil,
-                "EMAIL" => nil,
-                "VSTOCK" => nil,
-                "VENDOR" => :vendor,
-                "DESC" => :description,
-                "PSTAMP" => nil,
-                "INSTDATE" => nil,
-                "STATUS" => nil,
-                "FILES" => nil
-            }
-
-            hash = {}
-            cmd = "pkginfo -l"
-            if device
-                cmd += " -d #{device}"
-            end
-            cmd += " #{self[:name]} 2>/dev/null"
-
-            # list out all of the packages
-            open("| #{cmd}") { |process|
-                # we're using the long listing, so each line is a separate
-                # piece of information
-                process.each { |line|
-                    case line
-                    when /^$/:  # ignore
-                    when /\s*([A-Z]+):\s+(.+)/:
-                        name = $1
-                        value = $2
-                        if names.include?(name)
-                            unless names[name].nil?
-                                hash[names[name]] = value
-                            end
-                        else
-                            self.notice "Ignoring unknown name %s" % name
-                        end
-                    when /\s+\d+.+/:
-                        # nothing; we're ignoring the FILES info
-                    end
-                }
-            }
-
-            if hash.empty?
-                return nil
-            else
-                return hash
-            end
-        end
-
-        def install
-            unless self[:source]
-                raise Puppet::Error, "Sun packages must specify a package source"
-            end
-            cmd = ["pkgadd"]
-            
-            if self[:adminfile]
-                cmd << " -a " + self[:adminfile]
-            end
-
-            if self[:responsefile]
-                cmd << " -r " + self[:responsefile]
-            end
-
-            cmd += ["-d", self[:source]]
-            cmd += ["-n", self[:name]]
-            cmd << "2>&1"
-            cmd = cmd.join(" ")
-
-            self.debug "Executing %s" % cmd.inspect
-            output = %x{#{cmd} 2>&1}
-
-            unless $? == 0
-                raise Puppet::PackageError.new(output)
-            end
-        end
-
-        # Retrieve the version from the current package file.
-        def latest
-            hash = info2hash(self[:source])
-            hash[:ensure]
-        end
-
-        def list
-            packages = []
-            hash = {}
-            names = {
-                "PKGINST" => :name,
-                "NAME" => nil,
-                "CATEGORY" => :category,
-                "ARCH" => :platform,
-                "VERSION" => :ensure,
-                "BASEDIR" => :root,
-                "HOTLINE" => nil,
-                "EMAIL" => nil,
-                "VENDOR" => :vendor,
-                "DESC" => :description,
-                "PSTAMP" => nil,
-                "INSTDATE" => nil,
-                "STATUS" => nil,
-                "FILES" => nil
-            }
-
-            # list out all of the packages
-            open("| pkginfo -l 2>&1") { |process|
-                # we're using the long listing, so each line is a separate
-                # piece of information
-                process.each { |line|
-                    case line
-                    when /^$/:
-                        hash[:type] = :sun
-
-                        packages.push Puppet.type(:package).installedpkg(hash)
-                        hash.clear
-                    when /\s*(\w+):\s+(.+)/:
-                        name = $1
-                        value = $2
-                        if names.include?(name)
-                            unless names[name].nil?
-                                hash[names[name]] = value
-                            end
-                        else
-                            raise "Could not find %s" % name
-                        end
-                    when /\s+\d+.+/:
-                        # nothing; we're ignoring the FILES info
-                    end
-                }
-            }
-            return packages
-        end
-
-        def query
-            info2hash()
-        end
-
-        def uninstall
-            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.  This will probably
-        # often fail.
-        def update
-            if @states[:ensure].is != :absent
-                self.uninstall
-            end
-            self.install
-        end
-    end
-end
-
-# $Id: sun.rb 1356 2006-07-04 05:45:28Z luke $

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

@@ -1,7 +0,0 @@
-module Puppet
-    # At this point, it's an exact copy of the Blastwave stuff.
-    Puppet.type(:package).newpkgtype(:sunfreeware, :blastwave) do
-    end
-end
-
-# $Id: sunfreeware.rb 1357 2006-07-04 06:06:09Z luke $

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

@@ -1,52 +0,0 @@
-module Puppet
-    Puppet.type(:package).newpkgtype(:yum, :rpm) do
-        include Puppet::Util
-        # Install a package using 'yum'.
-        def install
-            cmd = "yum -y install %s" % self[:name]
-
-            begin
-                output = execute(cmd)
-            rescue Puppet::ExecutionFailure => detail
-                raise Puppet::PackageError.new(detail)
-            end
-
-            @states[:ensure].retrieve
-            if @states[:ensure].is == :absent
-                raise Puppet::PackageError.new(
-                    "Could not find package %s" % self.name
-                )
-            end
-        end
-
-        # What's the latest package version available?
-        def latest
-            cmd = "yum list available %s" % self[:name] 
-
-            begin
-                output = execute(cmd)
-            rescue Puppet::ExecutionFailure => detail
-                raise Puppet::PackageError.new(detail)
-            end
-
-            if output =~ /#{self[:name]}\S+\s+(\S+)\s/
-                return $1
-            else
-                # Yum didn't find updates, pretend the current
-                # version is the latest
-                return self[:version]
-            end
-        end
-
-        def update
-            # Install in yum can be used for update, too
-            self.install
-        end
-
-        def versionable?
-            false
-        end
-    end
-end
-
-# $Id: yum.rb 1421 2006-07-21 23:12:51Z luke $