puppet 0.13.6 → 0.16.0

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

@@ -96,7 +96,7 @@ module Puppet
                     end
                     self.debug "Executing %s" % cmd.join(" ").inspect
 
-                    output = %x{#{cmd.join(" ")} 2>&1}.split("\n").each { |line|
+                    %x{#{cmd.join(" ")} 2>&1}.split("\n").each { |line|
                         if line =~ /^(\w+)\s+(.+)$/
                             name = $1
                             value = $2.sub(/\s+$/, '')
@@ -118,6 +118,73 @@ module Puppet
                     end
                 end
 
+                # The list of all groups the user is a member of.  Different
+                # user mgmt systems will need to override this method.
+                def grouplist
+                    groups = []
+
+                    user = @parent[:name]
+                    # Retrieve them all from netinfo
+                    open("| nireport / /groups name users") do |file|
+                        file.each do |line|
+                            name, members = line.split(/\s+/)
+                            next unless members
+                            next if members =~ /NoValue/
+                            members = members.split(",")
+
+                            if members.include? user
+                                groups << name
+                            end
+                        end
+                    end
+
+                    groups
+                end
+
+                # This is really lame.  We have to iterate over each
+                # of the groups and add us to them.
+                def setgrouplist(groups)
+                    # Get just the groups we need to modify
+                    diff = groups - @is
+
+                    data = {}
+                    open("| nireport / /groups name users") do |file|
+                        file.each do |line|
+                            name, members = line.split(/\s+/)
+
+                            if members.nil? or members =~ /NoValue/
+                                data[name] = []
+                            else
+                                # Add each diff group's current members
+                                data[name] = members.split(/,/)
+                            end
+                        end
+                    end
+
+                    user = @parent[:name]
+                    data.each do |name, members|
+                        if members.include? user and groups.include? name
+                            # I'm in the group and should be
+                            next
+                        elsif members.include? user
+                            # I'm in the group and shouldn't be
+                            setuserlist(name, members - [user])
+                        elsif groups.include? name
+                            # I'm not in the group and should be
+                            setuserlist(name, members + [user])
+                        else
+                            # I'm not in the group and shouldn't be
+                            next
+                        end
+                    end
+                end
+
+                def setuserlist(group, list)
+                    cmd = "niutil -createprop / /groups/%s users %s" %
+                        [group, list.join(",")]
+                    output = %x{#{cmd}}
+                end
+
                 # How to add an object.
                 def addcmd
                     creatorcmd("-create")

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

@@ -92,6 +92,7 @@ module Puppet
                         @allatonce = true
                         case self.name
                         when :home: setflag "-d"
+                        when :groups: setflag "-G"
                         end
                     end
                 end

data/lib/puppet/type/package.rb

@@ -11,7 +11,7 @@ module Puppet
         @doc = "Manage packages.  There is a basic dichotomy in package
             support right now:  Some package types (e.g., yum and apt) can
             retrieve their own package files, while others (e.g., rpm and
-            sunpkg) cannot.  For those package formats that cannot retrieve
+            sun) cannot.  For those package formats that cannot retrieve
             their own files, you can use the ``source`` parameter to point to
             the correct file.
 
@@ -33,12 +33,12 @@ module Puppet
 
             # Add our parent, if it exists
             if parent
-                unless @pkgtypes.include?(parent)
+                unless parenttype = pkgtype(parent)
                     raise Puppet::DevError,
                         "No parent type %s for package type %s" %
                         [parent, name]
                 end
-                mod.send(:include, @pkgtypes[parent])
+                mod.send(:include, parenttype)
             end
 
             # And now define the support methods
@@ -60,10 +60,46 @@ module Puppet
 
             mod.module_eval(&block)
 
+            # It's at least conceivable that a module would not define this method
+            # "module_function" makes the :list method private, so if the parent
+            # method also called module_function, then it's already private
+            if mod.public_method_defined? :list or mod.private_method_defined? :list
+                mod.send(:module_function, :list)
+            end
+
+            # Add it to our list
             @pkgtypes[name] = mod
+
+            # And mark it as a valid type
+            unless defined? @typeparam
+                @typeparam = @parameters.find { |p| p.name == :type }
+
+                unless @typeparam
+                    Puppet.warning @parameters.inspect
+                    raise Puppet::DevError, "Could not package type parameter"
+                end
+            end
+            @typeparam.newvalues(name)
         end
 
+        # Autoload the package types, if they're not already defined.
         def self.pkgtype(name)
+            #name = name[0] if name.is_a? Array
+            name = name.intern if name.is_a? String
+            @pkgtypes ||= {}
+            unless @pkgtypes.include? name
+                begin
+                    require "puppet/type/package/#{name}"
+
+                    unless @pkgtypes.include? name
+                        Puppet.warning @pkgtypes.keys
+                        raise Puppet::DevError,
+                            "Loaded %s but pkgtype was not created" % name.inspect
+                    end
+                rescue LoadError
+                    raise Puppet::Error, "Could not load package type %s" % name
+                end
+            end
             @pkgtypes[name]
         end
 
@@ -78,28 +114,7 @@ module Puppet
                 those packaging formats that can retrieve new packages on
                 their own."
 
-            #munge do |value|
-            #    # possible values are: true, false, and a version number
-            #    case value
-            #    when "latest":
-            #        unless @parent.respond_to?(:latest)
-            #            self.err @parent.inspect
-            #            raise Puppet::Error,
-            #                "Package type %s cannot install later versions" %
-            #                @parent[:type].name
-            #        end
-            #        return :latest
-            #    when true, :present:
-            #        return :present
-            #    when false, :absent:
-            #        return :absent
-            #    else
-            #        # We allow them to set a should value however they want,
-            #        # but only specific package types will be able to use this
-            #        # value
-            #        return value
-            #    end
-            #end
+            attr_accessor :latest
 
             newvalue(:present) do
                 @parent.install
@@ -111,9 +126,6 @@ module Puppet
 
             # Alias the 'present' value.
             aliasvalue(:installed, :present)
-            #newvalue(:installed) do
-            #    self.set(:present)
-            #end
 
             newvalue(:latest) do
                 unless @parent.respond_to?(:latest)
@@ -139,6 +151,9 @@ module Puppet
             # funky definitions of 'in sync'.
             def insync?
                 @should ||= []
+
+                @latest = nil unless defined? @latest
+                @lateststamp ||= (Time.now.to_i - 1000)
                 # Iterate across all of the should values, and see how they
                 # turn out.
                 @should.each { |should|
@@ -148,6 +163,11 @@ module Puppet
                             return true
                         end
                     when :latest
+                        # Short-circuit packages that are not present
+                        if @is == :absent
+                            return false
+                        end
+
                         unless @parent.respond_to?(:latest)
                             self.fail(
                                 "Package type %s does not support specifying 'latest'" %
@@ -155,21 +175,30 @@ module Puppet
                             )
                         end
 
-                        begin
-                            latest = @parent.latest
-                        rescue => detail
-                            self.fail "Could not get latest version: %s" % detail
+                        # Don't run 'latest' more than about every 5 minutes
+                        if @latest and ((Time.now.to_i - @lateststamp) / 60) < 5
+                            #self.debug "Skipping latest check"
+                        else
+                            begin
+                                @latest = @parent.latest
+                                @lateststamp = Time.now.to_i
+                            rescue => detail
+                                self.fail "Could not get latest version: %s" % detail
+                            end
                         end
                         case @is
-                        when latest:
+                        when @latest:
                             return true
                         when :present:
-                            if @parent[:version] == latest
+                            if @parent[:version] == @latest
                                 return true
+                            else
+                                self.debug "our version is %s and latest is %s" %
+                                    [@parent[:version], @latest]
                             end
                         else
-                            #self.debug "@is is %s, latest %s is %s" %
-                            #    [@is, @parent.name, latest]
+                            self.debug "@is is %s, latest %s is %s" %
+                                [@is, @parent.name, @latest]
                         end
                     when :absent
                         if @is == :absent
@@ -255,14 +284,24 @@ module Puppet
 
             defaultto { @parent.class.default }
 
-            # We cannot log in this routine, because this gets called before
-            # there's a name for the package.
+
+            validate do |value|
+                value = value[0] if value.is_a? Array
+                unless @parent.class.pkgtype(value)
+                    raise ArgumentError, "Invalid package type '%s'" % value
+                end
+            end
+
+
             munge do |type|
+                type = type[0] if type.is_a? Array
                 if type.is_a? String
                     type = type.intern
                 end
                 @parent.type2module(type)
+                type
             end
+
         end
 
         newparam(:source) do
@@ -383,7 +422,7 @@ module Puppet
                 )
             end
             case @platform
-            when "solaris": @default = :sunpkg
+            when "solaris": @default = :sun
             when "gentoo":
                 Puppet.notice "No support for gentoo yet"
                 @default = nil
@@ -391,7 +430,9 @@ module Puppet
             when "centos": @default = :rpm
             when "fedora": @default = :yum
             when "redhat": @default = :rpm
-            when "openbsd": @default = :bsd
+            when "freebsd": @default = :ports
+            when "openbsd": @default = :openbsd
+            when "darwin": @default = :apple
             else
                 if Facter["kernel"] == "Linux"
                     Puppet.warning "Defaulting to RPM for %s" %
@@ -405,74 +446,68 @@ module Puppet
             end
         end
 
-        def self.getpkglist
-            if @types.nil?
-                if @default.nil?
-                    self.init
-                end
-                @types = [@default]
-            end
-
-            list = @types.collect { |type|
-                if typeobj = Puppet::PackagingType[type]
-                    # pull all of the objects
-                    typeobj.list
-                else
-                    raise Puppet::Error, "Could not find package type '%s'" % type
-                end
-            }.flatten
-            @listed = true
-            return list
-        end
+        # Return a list of valid package types
+#        def self.getpkglist
+#            if @types.nil?
+#                if @default.nil?
+#                    self.init
+#                end
+#                @types = [@default]
+#            end
+#
+#            list = @types.collect { |type|
+#                if typeobj = Puppet::PackagingType[type]
+#                    # pull all of the objects
+#                    typeobj.list
+#                else
+#                    raise Puppet::Error, "Could not find package type '%s'" % type
+#                end
+#            }.flatten
+#            @listed = true
+#            return list
+#        end
 
+        # Create a new package object from listed information
         def self.installedpkg(hash)
+            unless hash.include? :type
+                raise Puppet::DevError, "Got installed package with no type"
+            end
             # this is from code, so we don't have to do as much checking
             name = hash[:name]
             hash.delete(:name)
 
-            # if it already exists, modify the existing one
-            if object = Package[name]
-                states = {}
-                object.eachstate { |state|
-                    Puppet.debug "Adding %s" % state.name.inspect
-                    states[state.name] = state
-                }
-                hash.each { |var,value|
-                    if states.include?(var)
-                        Puppet.debug "%s is a set state" % var.inspect
-                        states[var].is = value
-                    else
-                        Puppet.debug "%s is not a set state" % var.inspect
-                        if object[var] and object[var] != value
-                            Puppet.warning "Overriding %s => %s on %s with %s" %
-                                [var,object[var],name,value]
-                        end
+            object = self[name] || self.create(:name => name)
+            object.setparams(hash)
+
+            return object
+        end
 
-                        #object.state(var).is = value
+        # List all package instances
+        def self.list
+            pkgtype(default).list()
 
-                        # swap the values if we're a state
-                        if states.include?(var)
-                            Puppet.debug "Swapping %s because it's a state" % var
-                            states[var].is = value
-                            states[var].should = nil
-                        else
-                            Puppet.debug "%s is not a state" % var.inspect
-                            Puppet.debug "States are %s" % states.keys.collect { |st|
-                                st.inspect
-                            }.join(" ")
-                        end
-                    end
-                }
-                return object
-            else # just create it
-                obj = self.create(:name => name)
-                hash.each { |var,value|
-                    obj.addis(var,value)
-                }
-                return obj
+            self.collect do |pkg|
+                pkg
             end
         end
 
+        # Iterate across all packages of a given type and mark them absent
+        # if they are not in the list
+        def self.markabsent(pkgtype, packages)
+            # Mark any packages we didn't find as absent
+            self.each do |pkg|
+                next unless packages[:type] == pkgtype
+                unless packages.include? pkg
+                    pkg.is = [:ensure, :absent] 
+                end
+            end
+        end
+
+        # This only exists for testing.
+        def clear
+            @states[:ensure].latest = nil
+        end
+
         # The 'query' method returns a hash of info if the package
         # exists and returns nil if it does not.
         def exists?
@@ -515,15 +550,16 @@ module Puppet
             # about it and set it appropriately.
             #@states[:ensure].retrieve
             if hash = self.query
+                if hash == :listed # Mmmm, hackalicious
+                    return
+                end
                 hash.each { |param, value|
                     unless self.class.validattr?(param)
                         hash.delete(param)
                     end
                 }
 
-                hash.each { |param, value|
-                    self.is = [param, value]
-                }
+                setparams(hash)
             else
                 # Else just mark all of the states absent.
                 self.class.validstates.each { |name|
@@ -532,6 +568,19 @@ module Puppet
             end
         end
 
+        # Set all of the params' "is" value.  Most are parameters, but some
+        # are states.
+        def setparams(hash)
+            # Everything on packages is a parameter except :ensure
+            hash.each { |param, value|
+                if self.class.attrtype(param) == :state
+                    self.is = [param, value]
+                else
+                    self[param] = value
+                end
+            }
+        end
+
         # Extend the package with the appropriate package type.
         def type2module(typename)
             if type = self.class.pkgtype(typename)
@@ -589,12 +638,4 @@ module Puppet
     }
 end
 
-# The order these are loaded is important.
-require 'puppet/type/package/dpkg.rb'
-require 'puppet/type/package/apt.rb'
-require 'puppet/type/package/rpm.rb'
-require 'puppet/type/package/yum.rb'
-require 'puppet/type/package/sun.rb'
-require 'puppet/type/package/bsd.rb'
-
-# $Id: package.rb 937 2006-02-24 20:00:30Z luke $
+# $Id: package.rb 1129 2006-04-21 19:14:59Z luke $