puppet 0.18.4 → 0.22.4

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

@@ -1,97 +0,0 @@
-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

@@ -1,113 +0,0 @@
-module Puppet
-    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("| /usr/bin/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("| /usr/bin/dpkg -l") { |process|
-                # our regex for matching dpkg output
-                regex = %r{^(\S+)\s+(\S+)\s+(\S+)\s+(.+)$}
-                fields = [:status, :name, :version, :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
-                        }
-
-                        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,
-                            "Failed to match dpkg line %s" % line
-                    end
-                }
-            }
-            ENV["COLUMNS"] = oldcol
-
-            return packages
-        end
-
-        def uninstall
-            cmd = "/usr/bin/dpkg -r %s" % self[:name]
-            output = %x{#{cmd} 2>&1}
-            if $? != 0
-                raise Puppet::PackageError.new(output)
-            end
-        end
-    end
-end
-
-# $Id: dpkg.rb 1256 2006-06-13 15:57:06Z luke $

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

@@ -1,19 +0,0 @@
-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/gem.rb

@@ -1,119 +0,0 @@
-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

@@ -1,112 +0,0 @@
-module Puppet
-    Puppet.type(:package).newpkgtype(:openbsd) do
-        def listcmd
-            "pkg_info -a"
-        end
-
-        module_function :listcmd
-
-        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 = []
-
-            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("| #{listcmd()}") { |process|
-                # our regex for matching pkg_info output
-                regex = %r{^(\S+)-([^-\s]+)\s+(.+)}
-                fields = [:name, :version, :description]
-                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
-                        }
-                        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
-                        # 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 as absent any packages we didn't find
-            Puppet.type(:package).each do |pkg|
-                unless packages.include? pkg
-                    pkg.is = [:ensure, :absent] 
-                end
-            end
-
-            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: openbsd.rb 1182 2006-05-09 16:39:16Z luke $