puppet 0.18.4 → 0.22.4

data/lib/puppet/type/nameservice/objectadd.rb

@@ -1,146 +0,0 @@
-require 'puppet'
-
-module Puppet
-    module NameService
-        module ObjectAdd
-            # Verify that we've got the commands necessary to manage flat files.
-            def self.test
-                system("which groupadd > /dev/null 2>&1")
-
-                if $? == 0
-                    return true
-                else
-                    Puppet.err "Could not find groupadd"
-                    return false
-                end
-            end
-
-            # Does the object already exist?
-            def self.exists?(obj)
-                if obj.getinfo(true)
-                    return true
-                else
-                    return false
-                end
-            end
-
-            # The base state class for <object>add operations.
-            class ObjectAddState < Puppet::State::NSSState
-                class << self
-                    # Determine the flag to pass to our command.
-                    def objectaddflag
-                        unless defined? @objectaddflag
-                            # Else, return the first letter of the name.  I have to
-                            # user a range here, else the character will show up
-                            # as a number, rather than as a string, for some reason.
-                            @objectaddflag = "-" + self.name.to_s[0,1]
-                            Puppet.debug "Setting flag on %s to %s" %
-                                [self.name, @objectaddflag]
-                        end
-                        return @objectaddflag
-                    end
-
-                    # Set the flag manually.
-                    def setflag(value)
-                        @objectaddflag = value
-                    end
-                end
-            end
-
-            # The state class for doing group operations using groupadd or whatever.
-            # I could probably have abstracted the User and Group classes into
-            # a single class, but eh, it just didn't seem worth it.
-            class ObjectAddGroup < ObjectAddState
-                class << self
-                    # This is hackish, but hey, it works.
-                    def finish
-                        @allatonce = true
-                    end
-                end
-
-                def addcmd
-                    cmd = ["groupadd"]
-                    if gid = @parent.should(:gid)
-                        unless gid == :auto
-                            cmd << @parent.state(:gid).class.objectaddflag << gid 
-                        end
-                    end
-                    if @parent[:allowdupe] == :true
-                        cmd << "-o"
-                    end
-                    cmd << @parent[:name]
-
-                    return cmd.join(" ")
-                end
-
-                def deletecmd
-                    "groupdel %s" % @parent[:name]
-                end
-
-                def modifycmd
-                    cmd = ["groupmod",
-                        self.class.objectaddflag,
-                        "'%s'" % self.should]
-                    if @parent[:allowdupe]  == :true
-                        cmd << "-o"
-                    end
-                    cmd << @parent[:name]
-
-                    return cmd.join(" ")
-                end
-            end
-
-            # The class for adding users using 'adduser'.
-            class ObjectAddUser < ObjectAddState
-                class << self
-                    # This is hackish, but hey, it works.
-                    def finish
-                        @allatonce = true
-                        case self.name
-                        when :home: setflag "-d"
-                        when :groups: setflag "-G"
-                        end
-                    end
-                end
-                def addcmd
-                    cmd = ["useradd"]
-                    @parent.eachstate { |state|
-                        next if state.name == :ensure
-                        # the value needs to be quoted, mostly because -c might
-                        # have spaces in it
-                        cmd << state.class.objectaddflag << "'%s'" % state.should
-                    }
-                    # stupid fedora
-                    case Facter["operatingsystem"].value
-                    when "Fedora", "RedHat":
-                        cmd << "-M"
-                    else
-                    end
-                    if @parent[:allowdupe]  == :true
-                        cmd << "-o"
-                    end
-
-                    cmd << @parent[:name]
-
-                    cmd.join(" ")
-                end
-                
-                def deletecmd
-                    ["userdel", @parent[:name]].join(" ")
-                end
-
-                def modifycmd
-                    cmd = ["usermod",
-                        self.class.objectaddflag,
-                        "'%s'" % self.should]
-                    if @parent[:allowdupe]  == :true
-                        cmd << "-o"
-                    end
-                    cmd << @parent[:name]
-
-                    return cmd.join(" ")
-                end
-            end
-        end
-    end
-end

data/lib/puppet/type/nameservice/posix.rb

@@ -1,12 +0,0 @@
-require 'puppet'
-require 'puppet/type/nameservice'
-
-module Puppet
-    class State
-        # The lowest-level state class for managing NSS/POSIX information.  It
-        # at least knows how to retrieve information, but it does not know how
-        # to sync anything.
-        class POSIXState < NSSState
-        end
-    end
-end

data/lib/puppet/type/nameservice/pw.rb

@@ -1,107 +0,0 @@
-require 'puppet'
-require 'puppet/type/nameservice/objectadd'
-
-module Puppet
-    module NameService
-        module PW
-            # Verify that we've got the commands necessary to manage flat files.
-            def self.test
-                system("which pw > /dev/null 2>&1")
-
-                if $? == 0
-                    return true
-                else
-                    Puppet.err "Could not find pw"
-                    return false
-                end
-            end
-
-            # Does the object already exist?
-            def self.exists?(obj)
-                if obj.getinfo(true)
-                    return true
-                else
-                    return false
-                end
-            end
-
-            # The state class for doing group operations using groupadd or whatever.
-            # I could probably have abstracted the User and Group classes into
-            # a single class, but eh, it just didn't seem worth it.
-            class PWGroup < ObjectAdd::ObjectAddGroup
-                def addcmd
-                    cmd = ["pw", "groupadd", @parent[:name]]
-                    if gid = @parent.should(:gid)
-                        unless gid == :auto
-                            cmd << @parent.state(:gid).class.objectaddflag << gid 
-                        end
-                    end
-
-                    # Apparently, contrary to the man page, groupadd does
-                    # not accept -o.
-                    #if @parent[:allowdupe] == :true
-                    #    cmd << "-o"
-                    #end
-
-                    return cmd.join(" ")
-                end
-
-                def deletecmd
-                    "pw groupdel %s" % @parent[:name]
-                end
-
-                def modifycmd
-                    cmd = [
-                        "pw",
-                        "groupmod",
-                        @parent[:name],
-                        self.class.objectaddflag,
-                        "'%s'" % self.should
-                    ]
-                    return cmd.join(" ")
-                end
-            end
-
-            # The class for adding users using 'adduser'.
-            class PWUser < ObjectAdd::ObjectAddUser
-                def addcmd
-                    cmd = ["pw", "useradd", @parent[:name], "-w", "no"]
-                    @parent.eachstate { |state|
-                        next if state.name == :ensure
-                        # the value needs to be quoted, mostly because -c might
-                        # have spaces in it
-                        cmd << state.class.objectaddflag << "'%s'" % state.should
-                    }
-                    # stupid fedora
-                    case Facter["operatingsystem"].value
-                    when "Fedora", "RedHat":
-                        cmd << "-M"
-                    end
-
-                    if @parent[:allowdupe] == :true
-                        cmd << "-o"
-                    end
-
-                    cmd.join(" ")
-                end
-                
-                def deletecmd
-                    ["pw", "userdel", @parent[:name]].join(" ")
-                end
-
-                def modifycmd
-                    cmd = [
-                        "pw",
-                        "usermod",
-                        @parent[:name],
-                        "-w", "no",
-                        self.class.objectaddflag,
-                        "'%s'" % self.should
-                    ]
-
-                    return cmd.join(" ")
-                end
-            end
-        end
-    end
-end

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

@@ -1,41 +0,0 @@
-module Puppet
-    # OS X Packaging sucks.  We can install packages, but that's about it.
-    Puppet.type(:package).newpkgtype(:apple) do
-        def query
-            if FileTest.exists?("/Library/Receipts/#{self[:name]}.pkg")
-                return {:name => self[:name], :ensure => :present}
-            else
-                return nil
-            end
-        end
-
-        def install
-            source = nil
-            unless source = self[:source]
-                self.fail "Mac OS X packages must specify a package source"
-            end
-
-            output = %x{/usr/sbin/installer -pkg #{source} -target / 2>&1}
-
-            unless $? == 0
-                raise Puppet::PackageError.new(output)
-            end
-        end
-
-        def list
-            packages = []
-
-            Dir.entries("/Library/Receipts").find { |f|
-                f =~ /\.pkg$/
-            }.collect { |f|
-                Puppet.type(:package).installedpkg(
-                    :name => f.sub(/\.pkg/, ''),
-                    :type => :apple,
-                    :ensure => :installed
-                )
-            }
-        end
-    end
-end
-
-# $Id: apple.rb 1156 2006-05-01 01:07:47Z luke $

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

@@ -1,107 +0,0 @@
-module Puppet
-    Puppet.type(:package).newpkgtype(:apt, :dpkg) do
-        ENV['DEBIAN_FRONTEND'] = "noninteractive"
-
-
-
-        # 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.
-
-        def checkforcdrom
-            unless defined? @@checkedforcdrom
-                if FileTest.exists? "/etc/apt/sources.list"
-                    if File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/
-                        @@checkedforcdrom = true
-                    else
-                        @@checkedforcdrom = false
-                    end
-                else
-                    # This is basically a pathalogical case, but we'll just
-                    # ignore it
-                    @@checkedforcdrom = false
-                end
-            end
-
-            if @@checkedforcdrom and self[:allowcdrom] != :true
-                raise Puppet::Error,
-                    "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
-            end
-        end
-
-        # Install a package using 'apt-get'.  This function needs to support
-        # installing a specific version.
-        def install
-            should = self.should(:ensure)
-
-            checkforcdrom()
-
-            str = self[:name]
-            case should
-            when true, false, Symbol
-                # pass
-            else
-                # Add the package version
-                str += "=%s" % should
-            end
-            cmd = "/usr/bin/apt-get -q -y install %s" % str
-
-            self.info "Executing %s" % cmd.inspect
-            output = %x{#{cmd} 2>&1}
-
-            unless $? == 0
-                raise Puppet::PackageError.new(output)
-            end
-        end
-
-        # What's the latest package version available?
-        def latest
-            cmd = "/usr/bin/apt-cache showpkg %s" % self[:name] 
-            self.info "Executing %s" % cmd.inspect
-            output = %x{#{cmd} 2>&1}
-
-            unless $? == 0
-                raise Puppet::PackageError.new(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]
-
-                unless version
-                    self.debug "No latest version"
-                    if Puppet[:debug]
-                        print output
-                    end
-                end
-
-                return version
-            else
-                self.err "Could not match string"
-            end
-        end
-
-        def update
-            self.install
-        end
-
-        def uninstall
-            cmd = "/usr/bin/apt-get -y -q remove %s" % self[:name]
-            output = %x{#{cmd} 2>&1}
-            if $? != 0
-                raise Puppet::PackageError.new(output)
-            end
-        end
-
-        def versionable?
-            true
-        end
-    end
-end

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

@@ -1,136 +0,0 @@
-module Puppet
-    Puppet.type(:package).newpkgtype(:blastwave, :sun) do
-        if pkgget = %x{which pkg-get 2>/dev/null}.chomp and pkgget != ""
-            @@pkgget = pkgget
-        else
-            @@pkgget = nil
-        end
-
-        # This is so stupid
-        ENV["PAGER"] = "/usr/bin/cat"
-
-        def self.extended(mod)
-            unless @@pkgget
-                raise Puppet::Error,
-                    "The pkg-get command is missing; blastwave packaging unavailable"
-            end
-
-            unless FileTest.exists?("/var/pkg-get/admin")
-                Puppet.notice "It is highly recommended you create '/var/pkg-get/admin'."
-                Puppet.notice "See /var/pkg-get/admin-fullauto"
-            end
-        end
-
-        # Turn our blastwave listing into a bunch of hashes.
-        def blastlist(hash)
-            command = "#{@@pkgget} -c"
-
-            if hash[:justme]
-                command += " " + self[:name]
-            end
-
-            begin
-                output = execute(command)
-            rescue ExecutionFailure => detail
-                raise Puppet::Error, "Could not get package listing: %s" %
-                    detail
-            end
-
-            list = output.split("\n").collect do |line|
-                next if line =~ /^#/
-                next if line =~ /^WARNING/
-                next if line =~ /localrev\s+remoterev/
-
-                blastsplit(line)
-            end.reject { |h| h.nil? }
-
-            if hash[:justme]
-                return list[0]
-            else
-                list.reject! { |h|
-                    h[:ensure] == :absent
-                }
-                return list
-            end
-
-        end
-
-        # Split the different lines into hashes.
-        def blastsplit(line)
-            if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
-                hash = {}
-                hash[:name] = $1
-                hash[:ensure] = if $2 == "[Not installed]"
-                    :absent
-                else
-                    $2
-                end
-                hash[:avail] = $5
-
-                if hash[:avail] == "SAME"
-                    hash[:avail] = hash[:ensure]
-                end
-                hash[:type] = :blastwave
-
-                return hash
-            else
-                Puppet.warning "Cannot match %s" % line
-                return nil
-            end
-        end
-
-        module_function :blastlist, :blastsplit
-
-        def install
-            begin
-                execute("#{@@pkgget} -f install #{self[:name]}")
-            rescue ExecutionFailure => detail
-                raise Puppet::Error,
-                    "Could not install %s: %s" %
-                    [self[:name], detail]
-            end
-        end
-
-        # Retrieve the version from the current package file.
-        def latest
-            hash = blastlist(:justme => true)
-            hash[:avail]
-        end
-
-        def list(hash = {})
-            blastlist(hash).each do |bhash|
-                bhash.delete(:avail)
-                Puppet::Type.type(:package).installedpkg(bhash)
-            end
-        end
-
-        def query
-            hash = blastlist(:justme => true)
-
-            {:ensure => hash[:ensure]}
-        end
-
-        # Remove the old package, and install the new one
-        def update
-            begin
-                execute("#{@@pkgget} -f upgrade #{self[:name]}")
-            rescue ExecutionFailure => detail
-                raise Puppet::Error,
-                    "Could not upgrade %s: %s" %
-                    [self[:name], detail]
-            end
-        end
-
-        def uninstall
-            begin
-                execute("#{@@pkgget} -f remove #{self[:name]}")
-            rescue ExecutionFailure => detail
-                raise Puppet::Error,
-                    "Could not remove %s: %s" %
-                    [self[:name], detail]
-            end
-        end
-    end
-end
-
-# $Id: blastwave.rb 1382 2006-07-11 16:27:42Z luke $