puppet 0.18.4 → 0.22.4

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

@@ -0,0 +1,88 @@
+Puppet::Type.type(:package).provide :darwinport do
+    desc "Package management using DarwinPorts on OS X."
+
+    commands :port => "/opt/local/bin/port"
+    confine :operatingsystem => "Darwin"
+
+    def self.eachpkgashash
+        # list out all of the packages
+        open("| #{command(:port)} list installed") { |process|
+            regex = %r{(\S+)\s+@(\S+)\s+(\S+)}
+            fields = [:name, :ensure, :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[:provider] = self.name
+                    yield hash.dup
+                else
+                    raise Puppet::DevError,
+                        "Failed to match dpkg line %s" % line
+                end
+            }
+        }
+    end
+
+    def self.list
+        packages = []
+
+        eachpkgashash do |hash|
+            pkg = Puppet.type(:package).installedpkg(hash)
+            packages << pkg
+        end
+
+        return packages
+    end
+
+    def install
+        should = @model.should(:ensure)
+
+        # Seems like you can always say 'upgrade'
+        output = port "upgrade", @model[:name]
+        if output =~ /^Error: No port/
+            raise Puppet::ExecutionFailure, "Could not find package %s" % @model[:name]
+        end
+    end
+
+    def query
+        version = nil
+        self.class.eachpkgashash do |hash|
+            if hash[:name] == @model[:name]
+                return hash
+            end
+        end
+
+        return nil
+    end
+
+    def latest
+        info = port :search, "^#{@model[:name]}$"
+
+        if $? != 0 or info =~ /^Error/
+            return nil
+        end
+
+        ary = info.split(/\s+/)
+        version = ary[2].sub(/^@/, '')
+
+        return version
+    end
+
+    def uninstall
+        port :uninstall, @model[:name]
+    end
+
+    def update
+        return install()
+    end
+end
+
+# $Id: darwinport.rb 2052 2007-01-05 17:09:04Z luke $

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

@@ -0,0 +1,109 @@
+Puppet::Type.type(:package).provide :dpkg do
+    desc "Package management via ``dpkg``.  Because this only uses ``dpkg``
+        and not ``apt``, you must specify the source of any packages you want
+        to manage."
+
+    commands :dpkg => "/usr/bin/dpkg"
+    commands :dpkgquery => "/usr/bin/dpkg-query"
+    
+    def self.list
+        packages = []
+
+        # list out all of the packages
+        cmd = "#{command(:dpkgquery)} -W --showformat '${Status} ${Package} ${Version}\\n'"
+        Puppet.debug "Executing '%s'" % cmd
+        execpipe(cmd) do |process|
+            # our regex for matching dpkg output
+            regex = %r{^(\S+ +\S+ +\S+) (\S+) (\S*)$}
+            fields = [:status, :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
+                    Puppet.warning "Failed to match dpkg-query line %s" %
+                        line.inspect
+                end
+            }
+        end
+
+        return packages
+    end
+
+    def install
+        unless file = @model[:source]
+            raise ArgumentError, "You cannot install dpkg packages without a source"
+        end
+        dpkg "-i", file
+    end
+
+    def query
+        packages = []
+
+        fields = [:desired, :error, :status, :name, :ensure]
+
+        hash = {}
+
+        # list out our specific package
+        begin
+            output = dpkgquery("-W", "--showformat",
+                '${Status} ${Package} ${Version}\\n', @model[:name]
+            )
+        rescue Puppet::ExecutionFailure
+            # dpkg-query exits 1 if the package is not found.
+            return {:ensure => :absent, :status => 'missing',
+                :name => @model[:name], :error => 'ok'}
+
+        end
+        # Our regex for matching dpkg-query output.  We could probably just
+        # use split here, but I'm not positive that dpkg-query will never
+        # return whitespace.
+        regex = %r{^(\S+) (\S+) (\S+) (\S+) (\S*)$}
+
+        line = output.split("\n").shift.chomp
+        
+        if match = regex.match(line)
+            fields.zip(match.captures) { |field,value|
+                hash[field] = value
+            }
+        else
+            notice "Failed to handle dpkg-query line %s" % line.inspect
+            return {:ensure => :absent, :status => 'missing',
+                :name => @model[:name], :error => 'ok'}
+        end
+
+        if hash[:error] != "ok"
+            raise Puppet::PackageError.new(
+                "Package %s, version %s is in error state: %s" %
+                    [hash[:name], hash[:ensure], hash[:error]]
+            )
+        end
+
+        # DPKG can discuss packages that are no longer installed, so allow that.
+        if hash[:status] != "installed"
+            hash[:ensure] = :absent
+        end
+
+        return hash
+    end
+
+    def uninstall
+        dpkg "-r", @model[:name]
+    end
+
+    def purge
+        dpkg "--purge", @model[:name]
+	 end
+end
+
+# $Id: dpkg.rb 2224 2007-02-26 01:17:48Z mpalmer $

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

@@ -0,0 +1,43 @@
+Puppet::Type.type(:package).provide :freebsd, :parent => :openbsd do
+    desc "The specific form of package management on FreeBSD.  This is an
+        extremely quirky packaging system, in that it freely mixes between
+        ports and packages.  Apparently all of the tools are written in Ruby,
+        so there are plans to rewrite this support to directly use those
+        libraries."
+
+    commands :pkginfo => "/usr/sbin/pkg_info",
+             :pkgadd => "/usr/sbin/pkg_add",
+             :pkgdelete => "/usr/sbin/pkg_delete"
+    
+    confine :operatingsystem => :freebsd
+
+    def self.listcmd
+        command(:pkginfo)
+    end
+
+    def install
+        should = @model.should(:ensure)
+
+        if @model[:source]
+            return super
+        end
+
+        pkgadd "-r", @model[:name]
+    end
+
+    def query
+        self.class.list
+
+        if @model.is(:ensure)
+            return :listed
+        else
+            return nil
+        end
+    end
+
+    def uninstall
+        pkgdelete "%s-%s" % [@model[:name], @model.should(:ensure)]
+    end
+end
+
+# $Id: freebsd.rb 1979 2006-12-28 08:06:46Z luke $

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

@@ -0,0 +1,104 @@
+# Ruby gems support.
+Puppet::Type.type(:package).provide :gem do
+    desc "Ruby Gem support.  By default uses remote gems, but you can specify
+        the path to a local gem via ``source``."
+
+    commands :gemcmd => "gem"
+
+    def self.gemlist(hash)
+        command = [command(:gemcmd), "list"]
+
+        if hash[:local]
+            command << "--local"
+        else
+            command << "--remote"
+        end
+
+        if name = hash[:justme]
+            command << name
+        end
+
+        begin
+            list = execute(command).split("\n\n").collect do |set|
+                if gemhash = gemsplit(set)
+                    gemhash[:provider] = :gem
+                    gemhash
+                else
+                    nil
+                end
+            end.reject { |p| p.nil? }
+        rescue Puppet::ExecutionFailure => detail
+            raise Puppet::Error, "Could not list gems: %s" % detail
+        end
+
+        if hash[:justme]
+            return list.shift
+        else
+            return list
+        end
+    end
+
+    def self.gemsplit(desc)
+        case desc
+        when /^\*\*\*/: return nil
+        when /^(\S+)\s+\((.+)\)\n/
+            name = $1
+            version = $2.split(/,\s*/)[0]
+            return {
+                :name => name,
+                :ensure => version
+            }
+        else
+            Puppet.warning "Could not match %s" % desc
+            nil
+        end
+    end
+
+    def self.list(justme = false)
+        gemlist(:local => true).collect do |hash|
+            Puppet::Type.type(:package).installedpkg(hash)
+        end
+    end
+
+    def install(useversion = true)
+        command = ["install"]
+        if (! @model.should(:ensure).is_a? Symbol) and useversion
+            command << "-v" << @model.should(:ensure)
+        end
+        # Always include dependencies
+        command << "--include-dependencies"
+
+        if source = @model[:source]
+            command << source
+        else
+            command << @model[:name]
+        end
+
+        gemcmd(*command)
+    end
+
+    def latest
+        # This always gets the latest version available.
+        hash = self.class.gemlist(:justme => @model[:name])
+
+        return hash[:ensure]
+    end
+
+    def query
+        self.class.gemlist(:justme => @model[:name], :local => true)
+    end
+
+    def uninstall
+        gemcmd "uninstall", "-x", "-a", @model[:name]
+    end
+
+    def update
+        self.install(false)
+    end
+
+    def versionable?
+        true
+    end
+end
+
+# $Id: gem.rb 2355 2007-03-27 18:06:50Z luke $

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

@@ -0,0 +1,93 @@
+# Packaging on OpenBSD.  Doesn't work anywhere else that I know of.
+Puppet::Type.type(:package).provide :openbsd do
+    desc "OpenBSD's form of ``pkg_add`` support."
+
+    commands :pkginfo => "pkg_info", :pkgadd => "pkg_add", :pkgdelete => "pkg_delete"
+
+    defaultfor :operatingsystem => :openbsd
+    confine :operatingsystem => :openbsd
+
+    def self.list
+        packages = []
+
+        begin
+            execpipe(listcmd()) do |process|
+                # our regex for matching pkg_info output
+                regex = %r{^(\S+)-([^-\s]+)\s+(.+)}
+                fields = [:name, :ensure, :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[:provider] = self.name
+
+                        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
+                }
+            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
+        rescue Puppet::ExecutionFailure
+            return nil
+        end
+    end
+
+    def self.listcmd
+        [command(:info), "-a"]
+    end
+
+    def install
+        should = @model.should(:ensure)
+
+        unless @model[:source]
+            raise Puppet::Error,
+                "You must specify a package source for BSD packages"
+        end
+
+        pkgadd @model[:source]
+    end
+
+    def query
+        hash = {}
+        info = pkginfo @model[:name]
+
+        # Search for the version info
+        if info =~ /Information for #{@model[:name]}-(\S+)/
+            hash[:ensure] = $1
+        else
+            return nil
+        end
+
+        # And the description
+        if info =~ /Comment:\s*\n(.+)/
+            hash[:description] = $1
+        end
+
+        return hash
+    end
+
+    def uninstall
+        pkgdelete @model[:name]
+    end
+end
+
+# $Id: openbsd.rb 1979 2006-12-28 08:06:46Z luke $

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

@@ -0,0 +1,119 @@
+# Jeff McCune <mccune.jeff@gmail.com>
+# Mac OS X Package Installer which handles .pkg and .mpkg
+# bundles inside an Apple Disk Image.
+#
+# Motivation: DMG files provide a true HFS file system
+# and are easier to manage and .pkg bundles.
+#
+# Note: the 'apple' Provider checks for the package name
+# in /L/Receipts.  Since we install multiple pkg's from a single
+# source, we treat the source .pkg.dmg file as the package name.
+# As a result, we store installed .pkg.dmg file names
+# in /var/db/.puppet_pkgdmg_installed_<name>
+
+# require 'ruby-debug'
+# Debugger.start
+
+Puppet::Type.type(:package).provide :pkgdmg do
+    desc "Package management based on Apple's Installer.app and DiskUtility.app"
+
+    confine :exists => "/Library/Receipts"
+    commands :installer => "/usr/sbin/installer"
+    commands :hdiutil => "/usr/bin/hdiutil"
+    commands :curl => "/usr/bin/curl"
+
+    # JJM We store a cookie for each installed .pkg.dmg in /var/db
+    def self.listbyname
+        Dir.entries("/var/db").find_all { |f|
+            f =~ /^\.puppet_pkgdmg_installed_/
+        }.collect do |f|
+            name = f.sub(/^\.puppet_pkgdmg_installed_/, '')
+            yield name if block_given?
+            name
+        end
+    end
+
+    def self.list
+        listbyname.collect do |name|
+            Puppet.type(:package).installedpkg(
+                :name => name,
+                :provider => :pkgdmg,
+                :ensure => :installed
+            )
+        end
+    end
+
+    def self.installpkg(source, name, orig_source)
+      installer "-pkg", source, "-target", "/"
+      # Non-zero exit status will throw an exception.
+      File.open("/var/db/.puppet_pkgdmg_installed_#{name}", "w") do |t|
+          t.print "name: '#{name}'\n"
+          t.print "source: '#{orig_source}'\n"
+      end
+    end
+    
+    def self.installpkgdmg(source, name)
+        unless source =~ /\.dmg$/i
+            self.fail "Mac OS X PKG DMG's must specificy a source string ending in .dmg"
+        end
+        require 'open-uri'
+        require 'puppet/util/plist'
+        cached_source = source
+        if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
+            cached_source = "/tmp/#{name}"
+            begin
+                curl "-o", cached_source, "-C", "-", "-k", "-s", "--url", source
+                Puppet.debug "Success: curl transfered [#{name}]"
+            rescue Puppet::ExecutionFailure
+                Puppet.debug "curl did not transfer [#{name}].  Falling back to slower open-uri transfer methods."
+                cached_source = source
+            end
+        end
+        
+        begin
+            open(cached_source) do |dmg|
+                xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
+                ptable = Plist::parse_xml xml_str
+                # JJM Filter out all mount-paths into a single array, discard the rest.
+                mounts = ptable['system-entities'].collect { |entity|
+                    entity['mount-point']
+                }.select { |mountloc|; mountloc }
+                begin
+                    mounts.each do |fspath|
+                        Dir.entries(fspath).select { |f|
+                            f =~ /\.m{0,1}pkg$/i
+                            }.each do |pkg|
+                                installpkg("#{fspath}/#{pkg}", name, source)
+                            end
+                    end # mounts.each do
+                ensure
+                    hdiutil "eject", mounts[0]
+                end # begin
+            end # open() do
+        ensure
+            # JJM Remove the file if open-uri didn't already do so.
+            File.unlink(cached_source) if File.exist?(cached_source)
+        end # begin
+    end # def self.installpkgdmg
+
+    def query
+        if FileTest.exists?("/var/db/.puppet_pkgdmg_installed_#{@model[:name]}")
+            return {:name => @model[:name], :ensure => :present}
+        else
+            return nil
+        end
+    end
+
+    def install
+        source = nil
+        unless source = @model[:source]
+            self.fail "Mac OS X PKG DMG's must specify a package source."
+        end
+        unless name = @model[:name]
+            self.fail "Mac OS X PKG DMG's must specify a package name."
+        end
+        self.class.installpkgdmg(source,name)
+    end
+end
+
+# $Id: pkgdmg.rb 2187 2007-02-12 18:55:40Z luke $