puppet 0.9.2 → 0.13.0

data/lib/puppet/type/group.rb

@@ -12,18 +12,31 @@ require 'puppet/type/state'
 require 'puppet/type/nameservice'
 
 module Puppet
-    class State
-        module GroupGID
-            def self.doc
-                "The group ID.  Must be specified numerically.  If not
+    newtype(:group, Puppet::Type::NSSType) do
+        @doc = "Manage groups.  This type can only create groups.  Group
+            membership must be managed on individual users.  This element type
+            uses the prescribed native tools for creating groups and generally
+            uses POSIX APIs for retrieving information about them.  It does
+            not directly modify /etc/group or anything.
+            
+            For most platforms, the tools used are ``groupadd`` and its ilk;
+            for Mac OS X, NetInfo is used.  This is currently unconfigurable,
+            but if you desperately need it to be so, please contact us."
+
+        case Facter["operatingsystem"].value
+        when "Darwin":
+            @parentstate = Puppet::NameService::NetInfo::NetInfoState
+            @parentmodule = Puppet::NameService::NetInfo
+        else
+            @parentstate = Puppet::NameService::ObjectAdd::ObjectAddGroup
+            @parentmodule = Puppet::NameService::ObjectAdd
+        end
+
+        newstate(:gid, @parentstate) do
+            desc "The group ID.  Must be specified numerically.  If not
                 specified, a number will be picked, which can result in ID
                 differences across systems and thus is not recommended.  The
                 GID is picked according to local system standards."
-            end
-
-            def self.name
-                :gid
-            end
 
             def autogen
                 highest = 0
@@ -38,21 +51,22 @@ module Puppet
                 return highest + 1
             end
 
-            def shouldprocess(gid)
+            munge do |gid|
                 case gid
                 when String
                     if gid =~ /^[-0-9]+$/
                         gid = Integer(gid)
                     else
-                        raise Puppet::Error, "Invalid GID %s" % gid
+                        self.fail "Invalid GID %s" % gid
                     end
                 when Symbol
-                    unless gid == :auto or gid == :notfound
-                        raise Puppet::DevError, "Invalid GID %s" % gid
+                    unless gid == :auto or gid == :absent
+                        self.devfail "Invalid GID %s" % gid
                     end
                     if gid == :auto
                         unless self.class.autogen?
-                            gid = autogen
+                            gid = autogen()
+                            @parent.log "autogenerated value as %s" % gid
                         end
                     end
                 end
@@ -62,91 +76,60 @@ module Puppet
                 return gid
             end
         end
-    end
-
-    class Type
-        class Group < Type
-            statenames = [
-                "GroupGID"
-            ]
-            case Facter["operatingsystem"].value
-            when "Darwin":
-                @statemodule = Puppet::NameService::NetInfo
-            else
-                @statemodule = Puppet::NameService::ObjectAdd
-            end
 
-            @states = statenames.collect { |name|
-                fullname = @statemodule.to_s + "::" + name
-                begin
-                    eval(fullname)
-                rescue NameError
-                    raise Puppet::DevError, "Could not retrieve state class %s" %
-                        fullname
-                end
-            }.each { |klass|
-                klass.complete
-            }
-
-            @name = :group
-            @namevar = :name
-
-            @parameters = [:name]
-
-            class << self
-                attr_accessor :netinfodir
-                attr_accessor :statemodule
-            end
+        class << self
+            attr_accessor :netinfodir
+        end
 
-            @netinfodir = "groups"
+        @netinfodir = "groups"
 
-            @paramdoc[:name] = "The group name.  While naming limitations vary by
+        newparam(:name) do
+            desc "The group name.  While naming limitations vary by
                 system, it is advisable to keep the name to the degenerate
                 limitations, which is a maximum of 8 characters beginning with
                 a letter."
 
-            @doc = "Manage groups.  This type can only create groups.  Group
-                membership must be managed on individual users."
+            isnamevar
+        end
 
-            def exists?
-                self.class.statemodule.exists?(self)
-            end
+        def exists?
+            self.class.parentmodule.exists?(self)
+        end
 
-            def getinfo(refresh = false)
-                if @groupinfo.nil? or refresh == true
-                    begin
-                        @groupinfo = Etc.getgrnam(self.name)
-                    rescue ArgumentError => detail
-                        @groupinfo = nil
-                    end
+        def getinfo(refresh = false)
+            if @groupinfo.nil? or refresh == true
+                begin
+                    @groupinfo = Etc.getgrnam(self.name)
+                rescue ArgumentError => detail
+                    @groupinfo = nil
                 end
-
-                @groupinfo
-            end
-
-            def initialize(hash)
-                @groupinfo = nil
-                super
             end
 
-            def retrieve
-                if self.exists?
-                    super
-                else
-                    # the group does not exist
-                    unless @states.include?(:gid)
-                        self[:gid] = :auto
-                    end
+            @groupinfo
+        end
 
-                    @states.each { |name, state|
-                        state.is = :notfound
-                    }
+        def initialize(hash)
+            @groupinfo = nil
+            super
+        end
 
-                    return
+        def retrieve
+            if self.exists?
+                super
+            else
+                # the group does not exist
+                unless @states.include?(:gid)
+                    self[:gid] = :auto
                 end
+
+                @states.each { |name, state|
+                    state.is = :absent
+                }
+
+                return
             end
         end
     end
 end
 
-# $Id: group.rb 731 2005-10-26 04:44:25Z luke $
+# $Id: group.rb 841 2006-01-18 17:24:15Z luke $

data/lib/puppet/type/nameservice.rb

@@ -1,3 +1,247 @@
-require 'puppet/type/nameservice/posix'
-require 'puppet/type/nameservice/netinfo'
-require 'puppet/type/nameservice/objectadd'
+require 'puppet/type'
+
+module Puppet
+class Type
+    class NSSType < Puppet::Type
+        class << self
+            attr_reader :parentstate, :parentmodule
+
+            # Seems a lot like this should be elsewhere,
+            # but we'd have to have a different parent class for
+            # netinfo types if that were the case.
+            attr_accessor :netinfodir
+
+            def newstate(*args, &block)
+                s = super(*args, &block)
+
+                if s.respond_to?(:finish)
+                    s.finish
+                end
+            end
+        end
+
+        # Create the object.  We have to call the 'syncname' method
+        # on one of the non-ensure states, because the ensure state is not
+        # a subclass of NSSState.  Just find the first one and call it.
+        def create
+            @states.find { |name, state|
+                state.is_a?(Puppet::State::NSSState)
+            }[1].syncname(:present)
+        end
+
+        # Remove it
+        def destroy
+            @states.find { |name, state|
+                state.is_a?(Puppet::State::NSSState)
+            }[1].syncname(:absent)
+        end
+    end
+end
+
+class State
+    # This is the state that all other Nameservice states descend from.  It sets
+    # the standard for how one interacts with these state objects, but it leaves
+    # out any implementation details.  See the 'posix' stuff for the basics
+    # on how to retrieve information on most systems, but any adding of information
+    # is done specially per-system (e.g., netinfo, useradd, adduser).
+    class NSSState < Puppet::State
+        class << self
+            # Are all changes to states done in one step or do all states need
+            # to be synced individually?  This differentiates between netinfo,
+            # in which creation cannot be used to fill out information, and
+            # things like useradd, in which creation can be done with all
+            # information in one swell foop.
+            def allatonce?
+                Puppet.info "Returning allatonce %s" % @allatonce
+                if defined? @allatonce
+                    return @allatonce
+                else
+                    return false
+                end
+            end
+
+            # Yes, this value will autogenerate.
+            def isautogen
+                @isautogen = true
+            end
+
+            def noautogen
+                @isautogen = false
+            end
+
+            # Can we autogenerate a value for this field?  If a required field
+            # can be autogenerated then we don't require a value.
+            def autogen?
+                if defined? @isautogen and @isautogen
+                    return true
+                else
+                    return false
+                end
+            end
+
+            # Yes, this field is optional
+            def isoptional
+                @isoptional = true
+            end
+
+            # Is this field optional?  Defaults to false.
+            def isoptional?
+                if defined? @isoptional
+                    return @isoptional
+                else
+                    return false
+                end
+            end
+
+            # What method is used to retrieve the value from the POSIX struct?
+            # Really, these method names should be stored in this class somewhere,
+            # in a map or something, but then I would have to differentiate
+            # between the different posix classes (e.g., user and group).  In the
+            # end, we're _only_ using classes that _do_ have posix structs,
+            # so we might as well store the method in the class definition,
+            # rather than forcing it to be abstracted out or whatever.
+            def posixmethod
+                if defined? @posixmethod
+                    return @posixmethod
+                else
+                    return self.name
+                end
+            end
+        end
+
+        # We use the POSIX interfaces to retrieve all information, so we don't
+        # have to worry about abstracting that across the system.  Any class
+        # can still override this, but it should work for the vast majority of
+        # cases.
+        def retrieve
+            if obj = @parent.getinfo(true)
+
+                if method = self.class.posixmethod || self.class.name
+                    @is = obj.send(method)
+                else
+                    self.devfail "%s has no posixmethod" % self.class
+                end
+            else
+                @is = :absent
+            end
+        end
+
+        # Sync the information.
+        def sync
+            event = nil
+            # they're in sync some other way
+            if self.insync?
+                return nil
+            end
+            if @is == :absent
+                self.retrieve
+                if self.insync?
+                    return nil
+                end
+            end
+#            # if the object needs to be created or deleted,
+#            # depend on another method to do it all at once
+#            if @is == :absent or self.should == :absent
+#                Puppet.info "creating"
+#                event = syncname()
+#
+#                Puppet.info "created with event %s" % event
+#
+#                return event
+#                # if the whole object is created at once, just return
+#                # an event saying so
+#                #if self.class.allatonce?
+#                #    return event
+#                #end
+#            end
+
+            unless @parent.exists?
+                self.devfail "%s %s does not exist; cannot set %s" %
+                    [@parent.class.name, @parent.name, self.class.name]
+            end
+
+            # this needs to be set either by the individual state
+            # or its parent class
+            cmd = self.modifycmd
+
+            self.debug "Executing %s" % cmd.inspect
+
+            output = %x{#{cmd} 2>&1}
+
+
+            unless $? == 0
+                self.fail "Could not modify %s on %s %s: %s" %
+                    [self.class.name, @parent.class.name,
+                        @parent.name, output]
+            end
+
+            if event
+                return event
+            else
+                return "#{@parent.class.name}_modified".intern
+            end
+        end
+
+        # This is only used when creating or destroying the object.
+        def syncname(value)
+            cmd = nil
+            event = nil
+            case value
+            when :absent
+                # we need to remove the object...
+                unless @parent.exists?
+                    @parent.info "already absent"
+                    # the object already doesn't exist
+                    return nil
+                end
+
+                # again, needs to be set by the ind. state or its
+                # parent
+                cmd = self.deletecmd
+                type = "delete"
+            when :present
+                if @parent.exists?
+                    @parent.info "already exists"
+                    # The object already exists
+                    return nil
+                end
+
+                # blah blah, define elsewhere, blah blah
+                cmd = self.addcmd
+                type = "create"
+            end
+            self.debug "Executing %s" % cmd.inspect
+
+            output = %x{#{cmd} 2>&1}
+
+            unless $? == 0
+                raise Puppet::Error, "Could not %s %s %s: %s" %
+                    [type, @parent.class.name, @parent.name, output]
+            end
+
+            # we want object creation to show up as one event, 
+            # not many
+            unless self.class.allatonce?
+                Puppet.debug "%s is not allatonce" % self.class.name
+                if type == "create"
+                    @parent.eachstate { |state|
+                        state.sync
+                        state.retrieve
+                    }
+                end
+            end
+        end
+    end
+end
+end
+
+# Here's where we decide what type of objects we'll be dealing with.
+case Facter["operatingsystem"].value
+when "Darwin":
+    require 'puppet/type/nameservice/netinfo'
+else
+    require 'puppet/type/nameservice/objectadd'
+end
+
+
+# $Id: nameservice.rb 841 2006-01-18 17:24:15Z luke $

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

@@ -5,13 +5,9 @@ require 'puppet'
 require 'puppet/type/nameservice/posix'
 
 module Puppet
-    class Type
-        # Return the NetInfo directory in which a given object type is stored.
-        # Defaults to the type's name if @netinfodir is unset.
-    end
-
     module NameService
         module NetInfo
+            # Verify that we've got all of the commands we need.
             def self.test
                 system("which niutil > /dev/null 2>&1")
 
@@ -32,6 +28,7 @@ module Puppet
                 end
             end
 
+            # Does the object already exist?
             def self.exists?(obj)
                 cmd = "nidump -r /%s/%s /" %
                     [obj.class.netinfodir, obj.name]
@@ -45,6 +42,7 @@ module Puppet
                 end
             end
 
+            # Attempt to flush the database, but this doesn't seem to work at all.
             def self.flush
                 output = %x{lookupd -flushcache 2>&1}
 
@@ -53,19 +51,37 @@ module Puppet
                 end
             end
 
-            class NetInfoState < POSIX::POSIXState
-                def self.allatonce?
-                    false
-                end
-
+            # The state responsible for handling netinfo objects.  Because they
+            # are all accessed using the exact same interface, we can just 
+            # abstract the differents using a simple map where necessary
+            # (the netinfokeymap).
+            class NetInfoState < Puppet::State::NSSState
+                # Similar to posixmethod, what key do we use to get data?  Defaults
+                # to being the object name.
                 def self.netinfokey
-                    if defined? @netinfokey and @netinfokey
+                    if defined? @netinfokey
                         return @netinfokey
                     else
                         return self.name
                     end
                 end
 
+                def self.setkey(key)
+                    @netinfokey = key
+                end
+
+                def self.finish
+                    @allatonce = false
+                    case self.name
+                    when :comment: setkey "realname"
+                    when :uid:
+                        noautogen
+                    when :gid:
+                        noautogen
+                    end
+                end
+
+                # Retrieve the data, yo.
                 def retrieve
                     NetInfo.flush
                     dir = @parent.class.netinfodir
@@ -98,10 +114,11 @@ module Puppet
                     }
 
                     unless defined? @is
-                        @is = :notfound
+                        @is = :absent
                     end
                 end
 
+                # How to add an object.
                 def addcmd
                     creatorcmd("-create")
                 end
@@ -140,34 +157,6 @@ module Puppet
                     cmd.join(" ")
                 end
             end
-
-            class GroupGID < NetInfoState
-            end
-
-            class UserUID       < NetInfoState
-            end
-
-            class UserGID       < NetInfoState
-            end
-
-            class UserComment   < NetInfoState
-                @netinfokey = "realname"
-            end
-
-            class UserHome      < NetInfoState
-            end
-
-            class UserShell     < NetInfoState
-            end
-
-            class UserLocked    < NetInfoState
-            end
-
-            class UserExpire    < NetInfoState
-            end
-
-            class UserInactive  < NetInfoState
-            end
         end
     end
 end