puppet 0.9.2 → 0.13.0

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

@@ -1,70 +1,71 @@
 module Puppet
-    module PackagingType
+    Puppet.type(:package).newpkgtype(:apt, :dpkg) do
         # 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.
-        module APT
-            include DPKG
 
-            # Install a package using 'apt-get'.  This function needs to support
-            # installing a specific version.
-            def install
-                should = self.should(:install)
+        # Install a package using 'apt-get'.  This function needs to support
+        # installing a specific version.
+        def install
+            should = self.should(:ensure)
 
-                str = self.name
-                case should
-                when true, false, Symbol
-                    # pass
-                else
-                    # Add the package version
-                    str += "=%s" % should
-                end
-                cmd = "apt-get -q -y install %s" % str
+            str = self.name
+            case should
+            when true, false, Symbol
+                # pass
+            else
+                # Add the package version
+                str += "=%s" % should
+            end
+            cmd = "apt-get -q -y install %s" % str
 
-                self.info "Executing %s" % cmd.inspect
-                output = %x{#{cmd} 2>&1}
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
 
-                unless $? == 0
-                    raise Puppet::PackageError.new(output)
-                end
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
             end
+        end
 
-            # What's the latest package version available?
-            def latest
-                cmd = "apt-cache showpkg %s" % self.name 
-                output = %x{#{cmd} 2>&1}
-
-                unless $? == 0
-                    raise Puppet::PackageError.new(output)
-                end
+        # What's the latest package version available?
+        def latest
+            cmd = "apt-cache showpkg %s" % self.name 
+            output = %x{#{cmd} 2>&1}
 
-                if output =~ /Versions:\s*\n((\n|.)+)^$/
-                    versions = $1
-                    version = versions.split(/\n/).collect { |version|
-                        if version =~ /^([^\(]+)\(/
-                            $1
-                        else
-                            self.warning "Could not match version '%s'" % version
-                            nil
-                        end
-                    }.reject { |vers| vers.nil? }.sort[-1]
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
 
-                    unless version
-                        self.debug "No latest version"
-                        if Puppet[:debug]
-                            print output
-                        end
+            if output =~ /Versions:\s*\n((\n|.)+)^$/
+                versions = $1
+                version = versions.split(/\n/).collect { |version|
+                    if version =~ /^([^\(]+)\(/
+                        $1
+                    else
+                        self.warning "Could not match version '%s'" % version
+                        nil
                     end
+                }.reject { |vers| vers.nil? }.sort[-1]
 
-                    return version
-                else
-                    self.err "Could not match string"
+                unless version
+                    self.debug "No latest version"
+                    if Puppet[:debug]
+                        print output
+                    end
                 end
-            end
 
-            def update
-                self.install
+                return version
+            else
+                self.err "Could not match string"
             end
         end
+
+        def update
+            self.install
+        end
+
+        def versionable?
+            true
+        end
     end
 end

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

@@ -0,0 +1,82 @@
+module Puppet
+    Puppet.type(:package).newpkgtype(:bsd) do
+        def install
+            should = self.should(:ensure)
+
+            unless self[:source]
+                raise Puppet::Error,
+                    "You must specify a package source for BSD packages"
+            end
+
+            cmd = "pkg_add #{self[:source]}"
+
+            self.info "Executing %s" % cmd.inspect
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+
+        def query
+            hash = {}
+            # list out our specific package
+            info = %x{pkg_info #{self.name} 2>/dev/null}
+
+            # Search for the version info
+            if info =~ /Information for #{self.name}-(\S+)/
+                hash[:version] = $1
+                hash[:ensure] = :present
+            else
+                return nil
+            end
+
+            # And the description
+            if info =~ /Comment:\s*\n(.+)/
+                hash[:description] = $1
+            end
+
+            return hash
+        end
+
+        def list
+            packages = []
+
+            # list out all of the packages
+            open("| pkg_info -a") { |process|
+                # our regex for matching dpkg output
+                regex = %r{^(\S+)-(\d\S+)\s+(.+)}
+                fields = [:name, :version, :description]
+                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
+                        }
+                        packages.push Puppet.type(:package).installedpkg(hash)
+                    else
+                        raise Puppet::DevError,
+                            "Failed to match dpkg line %s" % line
+                    end
+                }
+            }
+            ENV["COLUMNS"] = oldcol
+
+            return packages
+        end
+
+        def uninstall
+            cmd = "pkg_delete %s" % self.name
+            output = %x{#{cmd} 2>&1}
+            if $? != 0
+                raise Puppet::PackageError.new(output)
+            end
+        end
+    end
+end
+
+# $Id: bsd.rb 836 2006-01-17 22:11:51Z luke $

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

@@ -1,108 +1,105 @@
 module Puppet
-    module PackagingType
-        # The packaging system for Debian systems.
-        module DPKG
-            def query
-                packages = []
-
-                # dpkg only prints as many columns as you have available
-                # which means we don't get all of the info
-                # stupid stupid
-                oldcol = ENV["COLUMNS"]
-                ENV["COLUMNS"] = "500"
-                fields = [:desired, :status, :error, :name, :version, :description]
+    Puppet.type(:package).newpkgtype(:dpkg) do
+        def query
+            packages = []
+
+            # dpkg only prints as many columns as you have available
+            # which means we don't get all of the info
+            # stupid stupid
+            oldcol = ENV["COLUMNS"]
+            ENV["COLUMNS"] = "500"
+            fields = [:desired, :status, :error, :name, :version, :description]
+
+            hash = {}
+            # list out our specific package
+            open("| dpkg -l %s 2>/dev/null" % self.name) { |process|
+                # our regex for matching dpkg output
+                regex = %r{^(.)(.)(.)\s(\S+)\s+(\S+)\s+(.+)$}
+
+                # we only want the last line
+                lines = process.readlines
+                # we've got four header lines, so we should expect all of those
+                # plus our output
+                if lines.length < 5
+                    return nil
+                end
+
+                line = lines[-1]
+
+                if match = regex.match(line)
+                    fields.zip(match.captures) { |field,value|
+                        hash[field] = value
+                    }
+                    #packages.push Puppet.type(:package).installedpkg(hash)
+                else
+                    raise Puppet::DevError,
+                        "failed to match dpkg line %s" % line
+                end
+            }
+            ENV["COLUMNS"] = oldcol
+
+            if hash[:error] != " "
+                raise Puppet::PackageError.new(
+                    "Package %s, version %s is in error state: %s" %
+                        [hash[:name], hash[:version], hash[:error]]
+                )
+            end
 
+            if hash[:status] == "i"
+                hash[:ensure] = :present
+            else
+                hash[:ensure] = :absent
+            end
+
+            return hash
+        end
+
+        def list
+            packages = []
+
+            # dpkg only prints as many columns as you have available
+            # which means we don't get all of the info
+            # stupid stupid
+            oldcol = ENV["COLUMNS"]
+            ENV["COLUMNS"] = "500"
+
+            # list out all of the packages
+            open("| dpkg -l") { |process|
+                # our regex for matching dpkg output
+                regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
+                fields = [:status, :name, :absent, :description]
                 hash = {}
-                # list out our specific package
-                open("| dpkg -l %s 2>/dev/null" % self.name) { |process|
-                    # our regex for matching dpkg output
-                    regex = %r{^(.)(.)(.)\s(\S+)\s+(\S+)\s+(.+)$}
-
-                    # we only want the last line
-                    lines = process.readlines
-                    # we've got four header lines, so we should expect all of those
-                    # plus our output
-                    if lines.length < 5
-                        return nil
-                    end
 
-                    line = lines[-1]
+                5.times { process.gets } # throw away the header
 
+                # 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
                         }
-                        #packages.push Puppet::Type::Package.installedpkg(hash)
+                        packages.push Puppet.type(:package).installedpkg(hash)
                     else
                         raise Puppet::DevError,
-                            "failed to match dpkg line %s" % line
+                            "Failed to match dpkg line %s" % line
                     end
                 }
-                ENV["COLUMNS"] = oldcol
-
-                if hash[:error] != " "
-                    raise Puppet::PackageError.new(
-                        "Package %s, version %s is in error state: %s" %
-                            [hash[:name], hash[:install], hash[:error]]
-                    )
-                end
-
-                if hash[:status] == "i"
-                    hash[:install] = hash[:version]
-                else
-                    hash[:install] = :notinstalled
-                end
-
-                return hash
-            end
-
-            def list
-                packages = []
-
-                # dpkg only prints as many columns as you have available
-                # which means we don't get all of the info
-                # stupid stupid
-                oldcol = ENV["COLUMNS"]
-                ENV["COLUMNS"] = "500"
-
-                # list out all of the packages
-                open("| dpkg -l") { |process|
-                    # our regex for matching dpkg output
-                    regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
-                    fields = [:status, :name, :install, :description]
-                    hash = {}
-
-                    5.times { process.gets } # throw away the header
-
-                    # 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
-                            }
-                            packages.push Puppet::Type::Package.installedpkg(hash)
-                        else
-                            raise Puppet::DevError,
-                                "Failed to match dpkg line %s" % line
-                        end
-                    }
-                }
-                ENV["COLUMNS"] = oldcol
+            }
+            ENV["COLUMNS"] = oldcol
 
-                return packages
-            end
+            return packages
+        end
 
-            def remove
-                cmd = "dpkg -r %s" % self.name
-                output = %x{#{cmd} 2>&1}
-                if $? != 0
-                    raise Puppet::PackageError.new(output)
-                end
+        def uninstall
+            cmd = "dpkg -r %s" % self.name
+            output = %x{#{cmd} 2>&1}
+            if $? != 0
+                raise Puppet::PackageError.new(output)
             end
         end
     end
 end
 
-# $Id: dpkg.rb 707 2005-09-27 19:59:36Z luke $
+# $Id: dpkg.rb 832 2006-01-17 07:11:50Z luke $

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

@@ -1,80 +1,84 @@
 module Puppet
-    module PackagingType
-        module RPM
-            def query
-                fields = {
-                    :name => "NAME",
-                    :install => "VERSION",
-                    :description => "DESCRIPTION"
-                }
-
-                cmd = "rpm -q #{self.name} --qf '%s\n'" %
-                    "%{NAME} %{VERSION}-%{RELEASE}"
+    Puppet.type(:package).newpkgtype(:rpm) do
+        def query
+            fields = {
+                :name => "NAME",
+                :version => "VERSION",
+                :description => "DESCRIPTION"
+            }
 
-                # list out all of the packages
-                output = %x{#{cmd} 2>/dev/null}.chomp
+            cmd = "rpm -q #{self.name} --qf '%s\n'" %
+                "%{NAME} %{VERSION}-%{RELEASE}"
 
-                if $? != 0
-                    return nil
-                end
+            self.debug "Executing %s" % cmd.inspect
+            # list out all of the packages
+            output = %x{#{cmd} 2>/dev/null}.chomp
 
-                regex = %r{^(\S+)\s+(\S+)}
-                #fields = [:name, :install, :description]
-                fields = [:name, :install]
-                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
+            if $? != 0
+                #if Puppet[:debug]
+                #    puts output
+                #end
+                return nil
+            end
 
-                return hash
+            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
 
-            def list
-                packages = []
+            hash[:ensure] = :present
 
-                # list out all of the packages
-                open("| rpm -q -a --qf '%{NAME} %{VERSION}\n'") { |process|
-                    # our regex for matching dpkg output
-                    regex = %r{^(\S+)\s+(\S+)}
-                    fields = [:name, :install]
-                    hash = {}
+            return hash
+        end
 
-                    # now turn each returned line into a package object
-                    process.each { |line|
-                        if match = regex.match(line)
-                            hash.clear
+        def list
+            packages = []
 
-                            fields.zip(match.captures) { |field,value|
-                                hash[field] = value
-                            }
-                            packages.push Puppet::Type::Package.installedpkg(hash)
-                        else
-                            raise "failed to match rpm line %s" % line
-                        end
-                    }
+            # list out all of the packages
+            open("| rpm -q -a --qf '%{NAME} %{VERSION}\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
+                        }
+                        packages.push Puppet.type(:package).installedpkg(hash)
+                    else
+                        raise "failed to match rpm line %s" % line
+                    end
                 }
+            }
 
-                return packages
-            end
+            return packages
+        end
 
-            # we need package retrieval mechanisms before we can have package
-            # installation mechanisms...
-            #type.install = proc { |pkg|
-            #    raise "installation not implemented yet"
-            #}
+        # we need package retrieval mechanisms before we can have package
+        # installation mechanisms...
+        #type.install = proc { |pkg|
+        #    raise "installation not implemented yet"
+        #}
 
-            def remove
-                cmd = "rpm -e %s" % self.name
-                output = %x{#{cmd}}
-                if $? != 0
-                    raise output
-                end
+        def uninstall
+            cmd = "rpm -e %s" % self.name
+            output = %x{#{cmd}}
+            if $? != 0
+                raise output
             end
         end
     end