puppet 0.18.4 → 0.22.4

data/lib/puppet/provider/package/portage.rb

@@ -0,0 +1,112 @@
+Puppet::Type.type(:package).provide :portage do
+    desc "Provides packaging support for Gentoo's portage system."
+
+    commands :emerge => "/usr/bin/emerge", :eix => "/usr/bin/eix"
+
+    defaultfor :operatingsystem => :gentoo
+
+    def self.list
+        result_format = /(\S+) (\S+) \[(.*)\] \[[^0-9]*([^\s:]*)(:\S*)?\] ([\S]*) (.*)/
+        result_fields = [:category, :name, :ensure, :version_available, :slot, :vendor, :description]
+
+        search_format = "{installedversionsshort}<category> <name> [<installedversionsshort>] [<best>] <homepage> <description>{}"
+
+        begin
+            search_output = eix "--nocolor", "--format", search_format
+
+            packages = []
+            search_output.each do |search_result|
+                match = result_format.match( search_result )
+
+                if match
+                    package = {}
+                    result_fields.zip(match.captures) { |field, value|
+                        package[field] = value unless !value or value.empty?
+                    }
+                    package[:provider] = :portage
+                    package[:ensure] = package[:ensure].split.last
+
+                    packages.push(Puppet.type(:package).installedpkg(package))
+                end
+            end
+
+            return packages
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::PackageError.new(detail)
+        end
+    end
+
+    def install
+        should = @model.should(:ensure)
+        name = package_name
+        unless should == :present or should == :latest
+            # We must install a specific version
+            name = "=%s-%s" % [name, should]
+        end
+        emerge name
+    end
+
+    # The common package name format.
+    def package_name
+        "%s/%s" % [@model[:category], @model[:name]]
+    end
+
+    def uninstall
+        emerge "--unmerge", package_name
+    end
+
+    def update
+        self.install
+    end
+
+    def query
+        result_format = /(\S+) (\S+) \[(.*)\] \[[^0-9]*([^\s:]*)(:\S*)?\] ([\S]*) (.*)/
+        result_fields = [:category, :name, :ensure, :version_available, :slot, :vendor, :description]
+
+        search_field = @model[:category] ? "--category-name" : "--name"
+        search_value = @model[:category] ? package_name : @model[:name]
+        search_format = "<category> <name> [<installedversionsshort>] [<best>] <homepage> <description>"
+
+        begin
+            search_output = eix "--nocolor", "--format", search_format, "--exact", search_field, search_value
+
+            packages = []
+            search_output.each do |search_result|
+                match = result_format.match( search_result )
+
+                if( match )
+                    package = {}
+                    result_fields.zip( match.captures ) { |field, value| package[field] = value unless !value or value.empty? }
+                    if package[:ensure]
+                        package[:ensure] = package[:ensure].split.last
+                    else
+                        package[:ensure] = :absent
+                    end
+                    packages << package
+                end
+            end
+
+            case packages.size
+                when 0
+		    not_found_value = "%s/%s" % [@model[:category] ? @model[:category] : "<unspecified category>", @model[:name]]
+                    raise Puppet::PackageError.new("No package found with the specified name [#{not_found_value}]")
+                when 1
+                    return packages[0]
+                else
+                    raise Puppet::PackageError.new("More than one package with the specified name [#{search_value}], please use the category parameter to disambiguate")
+            end
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::PackageError.new(detail)
+        end
+    end
+
+    def latest
+        return self.query[:version_available]
+    end
+
+    def versionable?
+        true
+    end
+end
+
+# $Id: portage.rb 2216 2007-02-20 00:35:12Z luke $

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

@@ -0,0 +1,94 @@
+Puppet::Type.type(:package).provide :ports, :parent => :freebsd do
+    desc "Support for FreeBSD's ports.  Again, this still mixes packages
+        and ports."
+    commands :portupgrade => "/usr/local/sbin/portupgrade",
+             :portversion => "/usr/local/sbin/portversion",
+             :portuninstall => "/usr/local/sbin/pkg_deinstall",
+             :portinfo => "/usr/sbin/pkg_info"
+
+    defaultfor :operatingsystem => :freebsd
+
+    # 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 = %w{-p -N -P} << @model[:name]
+
+        output = portupgrade(*cmd)
+        if output =~ /\*\* No such /
+            raise Puppet::ExecutionFailure, "Could not find package %s" % @model[:name]
+        end
+    end
+
+    # If there are multiple packages, we only use the last one
+    def latest
+        cmd = ["-v", @model[:name]]
+
+        begin
+            output = portversion(*cmd)
+        rescue Puppet::ExecutionFailure
+            raise Puppet::PackageError.new(output)
+        end
+        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 query
+        self.class.list
+
+        if @model.is(:ensure) and @model.is(:ensure) != :absent
+            return :listed
+        else
+            return nil
+        end
+    end
+
+    def uninstall
+        portuninstall @model[:name]
+    end
+
+    def update
+        install()
+    end
+end
+
+# $Id: ports.rb 1979 2006-12-28 08:06:46Z luke $

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

@@ -0,0 +1,125 @@
+# RPM packaging.  Should work anywhere that has rpm installed.
+Puppet::Type.type(:package).provide :rpm do
+    desc "RPM packaging support; should work anywhere with a working ``rpm``
+        binary."
+
+    # The query format by which we identify installed packages
+    NVRFORMAT = "%{NAME}-%{VERSION}-%{RELEASE}"
+
+    VERSIONSTRING = "%{VERSION}-%{RELEASE}"
+
+    commands :rpm => "rpm"
+
+    def self.list
+        packages = []
+
+        # list out all of the packages
+        begin
+            execpipe("#{command(:rpm)} -qa --nosignature --nodigest --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
+                        }
+                        hash[:provider] = self.name
+                        packages.push Puppet.type(:package).installedpkg(hash)
+                    else
+                        raise "failed to match rpm line %s" % line
+                    end
+                }
+            }
+        rescue Puppet::ExecutionFailure
+            raise Puppet::Error, "Failed to list packages"
+        end
+
+        return packages
+    end
+
+    # Find the fully versioned package name and the version alone. Returns
+    # a hash with entries :instance => fully versioned package name, and 
+    # :ensure => version-release
+    def query
+        cmd = ["-q", @model[:name], "--nosignature", "--nodigest", "--qf", "#{NVRFORMAT} #{VERSIONSTRING}\n"]
+
+        begin
+            output = rpm(*cmd)
+        rescue Puppet::ExecutionFailure
+            return nil
+        end
+
+        regex = %r{^(\S+)\s+(\S+)}
+        fields = [:instance, :ensure]
+        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
+
+        @nvr = hash[:instance]
+
+        return hash
+    end
+
+    # Here we just retrieve the version from the file specified in the source.
+    def latest
+        unless source = @model[:source]
+            @model.fail "RPMs must specify a package source"
+        end
+        
+        cmd = [command(:rpm), "-q", "--qf", "#{VERSIONSTRING}", "-p", "#{@model[:source]}"]
+        version = execfail(cmd, Puppet::Error)
+        return version
+    end
+
+    def install
+        source = nil
+        unless source = @model[:source]
+            @model.fail "RPMs must specify a package source"
+        end
+        if @model.should(:ensure) == @model.is(:ensure) ||
+           @model.should(:ensure) == :latest && @model.is(:ensure) == latest
+            # RPM gets pissy if you try to install an already 
+            # installed package
+            return
+        end
+
+        flag = "-i"
+        if @model.is(:ensure) != :absent
+            flag = "-U"
+        end
+
+        rpm flag, "--oldpackage", source
+    end
+
+    def uninstall
+        rpm "-e", nvr
+    end
+
+    def update
+        self.install
+    end
+
+    def versionable?
+        true
+    end
+
+    def nvr
+        query unless @nvr
+        @nvr
+    end
+end
+
+# $Id: rpm.rb 2292 2007-03-18 19:01:31Z luke $

data/lib/puppet/provider/package/rug.rb

@@ -0,0 +1,53 @@
+Puppet.type(:package).provide :rug, :parent => :rpm do
+    desc "Support for suse ``rug`` package manager."
+
+    commands :rug => "/usr/bin/rug"
+    defaultfor :operatingsystem => :suse 
+    confine    :operatingsystem => :suse
+
+    # Install a package using 'rug'.
+    def install
+        should = @model.should(:ensure)
+        self.debug "Ensuring => #{should}"
+        wanted = @model[:name]
+
+        # XXX: We don't actually deal with epochs here.
+        case should
+        when true, false, Symbol
+            # pass
+        else
+            # Add the package version
+            wanted += "-%s" % should
+        end
+        output = rug "--quiet", :install, "-y", wanted
+
+        unless self.query
+            raise Puppet::ExecutionFailure.new(
+                "Could not find package %s" % self.name
+            )
+        end
+    end
+
+    # What's the latest package version available?
+    def latest
+        #rug can only get a list of *all* available packages?
+        output = rug "list-updates"
+
+        if output =~ /#{@model[:name]}\s*\|\s*([0-9\.\-]+)/
+            return $1
+        else
+            # rug didn't find updates, pretend the current
+            # version is the latest
+            return @model.is(:ensure)
+        end
+    end
+
+    def update
+        # rug install can be used for update, too
+        self.install
+    end
+
+    def versionable?
+        true
+    end
+end

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

@@ -0,0 +1,168 @@
+# Sun packaging.  No one else uses these package tools, AFAIK.
+
+Puppet::Type.type(:package).provide :sun do
+    desc "Sun's packaging system.  Requires that you specify the source for
+        the packages you're managing."
+    commands :pkginfo => "/usr/bin/pkginfo",
+             :pkgadd => "/usr/sbin/pkgadd",
+             :pkgrm => "/usr/sbin/pkgrm"
+
+    defaultfor :operatingsystem => :solaris
+
+    def self.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
+        }
+
+        cmd = "#{command(:pkginfo)} -l"
+
+        # list out all of the packages
+        execpipe(cmd) { |process|
+            # we're using the long listing, so each line is a separate
+            # piece of information
+            process.each { |line|
+                case line
+                when /^$/:
+                    hash[:provider] = :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
+
+    # 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 = "#{command(:pkginfo)} -l"
+        if device
+            cmd += " -d #{device}"
+        end
+        cmd += " #{@model[:name]}"
+
+        begin
+            # list out all of the packages
+            execpipe(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
+                        end
+                    when /\s+\d+.+/:
+                        # nothing; we're ignoring the FILES info
+                    end
+                }
+            }
+            return hash
+        rescue Puppet::ExecutionFailure
+            return nil
+        end
+    end
+
+    def install
+        unless @model[:source]
+            raise Puppet::Error, "Sun packages must specify a package source"
+        end
+        cmd = []
+        
+        if @model[:adminfile]
+            cmd << "-a" << @model[:adminfile]
+        end
+
+        if @model[:responsefile]
+            cmd << "-r" << @model[:responsefile]
+        end
+
+        cmd << "-d" << @model[:source]
+        cmd << "-n" << @model[:name]
+
+        pkgadd cmd
+    end
+
+    # Retrieve the version from the current package file.
+    def latest
+        hash = info2hash(@model[:source])
+        hash[:ensure]
+    end
+
+    def query
+        info2hash()
+    end
+
+    def uninstall
+        command  = ["-n"]
+
+        if @model[:adminfile]
+            command << "-a" << @model[:adminfile]
+        end
+
+        command << @model[:name]
+        pkgrm command
+    end
+
+    # Remove the old package, and install the new one.  This will probably
+    # often fail.
+    def update
+        if @model.is(:ensure) != :absent
+            self.uninstall
+        end
+        self.install
+    end
+end
+
+# $Id: sun.rb 1980 2006-12-28 19:14:11Z luke $