puppet 0.18.4 → 0.22.4

data/lib/puppet/type/group.rb

@@ -8,47 +8,37 @@
 
 require 'etc'
 require 'facter'
-require 'puppet/type/state'
-require 'puppet/type/nameservice'
+require 'puppet/type/property'
 
 module Puppet
-    newtype(:group, Puppet::Type::NSSType) do
+    newtype(:group) 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.
+            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
-        when "FreeBSD":
-            @parentstate = Puppet::NameService::PW::PWGroup
-            @parentmodule = Puppet::NameService::PW
-        else
-            @parentstate = Puppet::NameService::ObjectAdd::ObjectAddGroup
-            @parentmodule = Puppet::NameService::ObjectAdd
-        end
+        newproperty(:ensure) do
+            desc "The basic state that the object should be in."
 
-        newstate(:ensure, @parentstate) do
             newvalue(:present) do
-                self.syncname(:present)
+                provider.create
+
+                :group_created
             end
 
             newvalue(:absent) do
-                self.syncname(:absent)
-            end
+                provider.delete
 
-            desc "The basic state that the object should be in."
+                :group_removed
+            end
 
             # If they're talking about the thing at all, they generally want to
             # say it should exist.
-            #defaultto :present
             defaultto do
                 if @parent.managed?
                     :present
@@ -77,7 +67,7 @@ module Puppet
             end
 
             def retrieve
-                if @parent.exists?
+                if provider.exists?
                     @is = :present
                 else
                     @is = :absent
@@ -99,36 +89,28 @@ module Puppet
                 end
 
                 # Set ourselves to whatever our should value is.
-                self.set
+                self.set(self.should)
             end
 
         end
 
-        newstate(:gid, @parentstate) do
+        newproperty(:gid) 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."
 
-            def autogen
-                highest = 0
+            def retrieve
+                @is = provider.gid
+            end
 
-                # Make sure we don't use the same value multiple times
-                if defined? @@prevauto
-                    @@prevauto += 1
+            def sync
+                if self.should == :absent
+                    raise Puppet::DevError, "GID cannot be deleted"
                 else
-                    Etc.group { |group|
-                        if group.gid > highest
-                            unless group.gid > 65000
-                                highest = group.gid
-                            end
-                        end
-                    }
-
-                    @@prevauto = highest + 1
+                    provider.gid = self.should
+                    :group_modified
                 end
-
-                return @@prevauto
             end
 
             munge do |gid|
@@ -140,28 +122,15 @@ module Puppet
                         self.fail "Invalid GID %s" % gid
                     end
                 when Symbol
-                    unless gid == :auto or gid == :absent
+                    unless gid == :absent
                         self.devfail "Invalid GID %s" % gid
                     end
-                    if gid == :auto
-                        # FIXME this should be done at sync time, not
-                        # here.
-                        unless self.class.autogen?
-                            gid = autogen()
-                        end
-                    end
                 end
 
                 return gid
             end
         end
 
-        class << self
-            attr_accessor :netinfodir
-        end
-
-        @netinfodir = "groups"
-
         newparam(:name) do
             desc "The group name.  While naming limitations vary by
                 system, it is advisable to keep the name to the degenerate
@@ -172,56 +141,36 @@ module Puppet
         end
 
         newparam(:allowdupe) do
-            desc "Whether to allow duplicate GIDs."
+            desc "Whether to allow duplicate GIDs.  This option does not work on
+                FreeBSD (contract to the ``pw`` man page)."
                 
             newvalues(:true, :false)
 
             defaultto false
         end
 
-        # List all groups
-        def self.listbyname
-            groups = []
-            while ent = Etc.getgrent
-                groups << ent.name
+        def self.list_by_name
+            users = []
+            defaultprovider.listbyname do |user|
+                users << user
             end
-            Etc.endgrent
-
-            return groups
+            return users
         end
 
-        def exists?
-            self.class.parentmodule.exists?(self)
-        end
+        def self.list
+            defaultprovider.list
 
-        def getinfo(refresh = false)
-            if @groupinfo.nil? or refresh == true
-                begin
-                    @groupinfo = Etc.getgrnam(self[:name])
-                rescue ArgumentError => detail
-                    @groupinfo = nil
-                end
+            self.collect do |user|
+                user
             end
-
-            @groupinfo
-        end
-
-        def initialize(hash)
-            @groupinfo = nil
-            super
         end
 
         def retrieve
-            if self.exists?
+            if self.provider and @provider.exists?
                 super
             else
-                # the group does not exist
-                unless @states.include?(:gid)
-                    self[:gid] = :auto
-                end
-
-                @states.each { |name, state|
-                    state.is = :absent
+                properties().each { |property|
+                    property.is = :absent
                 }
 
                 return
@@ -230,4 +179,4 @@ module Puppet
     end
 end
 
-# $Id: group.rb 1416 2006-07-21 19:05:30Z luke $
+# $Id: group.rb 2408 2007-04-24 02:41:16Z luke $

data/lib/puppet/type/host.rb

@@ -0,0 +1,110 @@
+require 'puppet/type/parsedtype'
+
+module Puppet
+    newtype(:host) do
+        ensurable
+
+        newproperty(:ip) do
+            desc "The host's IP address, IPv4 or IPv6."
+        end
+
+        newproperty(:alias) do
+            desc "Any alias the host might have.  Multiple values must be
+                specified as an array.  Note that this state has the same name
+                as one of the metaparams; using this state to set aliases will
+                make those aliases available in your Puppet scripts and also on
+                disk."
+
+            def insync?
+                @is == @should
+            end
+            
+            # Make sure our "is" value is always an array.
+            def is
+                current = super
+                current = [current] unless current.is_a? Array
+                current
+            end
+
+            def is_to_s
+                self.is.join(" ")
+            end
+
+            # We have to override the feeding mechanism; it might be nil or 
+            # white-space separated
+            def is=(value)
+                # If it's just whitespace, ignore it
+                case value
+                when /^\s+$/
+                    @is = nil
+                when String
+                    @is = value.split(/\s+/)
+                else
+                    @is = value
+                end
+            end
+            
+            def retrieve
+                super
+                case @is
+                when String
+                    @is = @is.split(/\s*,\s*/)
+                when Symbol:
+                    @is = [@is]
+                when Array
+                    # nothing
+                else
+                    raise Puppet::DevError, "Invalid @is type %s" % @is.class
+                end
+            end
+
+            # We actually want to return the whole array here, not just the first
+            # value.
+            def should
+                if defined? @should
+                    if @should == [:absent]
+                        return :absent
+                    else
+                        return @should
+                    end
+                else
+                    return nil
+                end
+            end
+
+            def should_to_s
+                @should.join(" ")
+            end
+
+            validate do |value|
+                if value =~ /\s/
+                    raise Puppet::Error, "Aliases cannot include whitespace"
+                end
+            end
+        end
+
+        newproperty(:target) do
+            desc "The file in which to store service information.  Only used by
+                those providers that write to disk (i.e., not NetInfo)."
+
+            defaultto { if @parent.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+                    @parent.class.defaultprovider.default_target
+                else
+                    nil
+                end
+            }
+        end
+
+        newparam(:name) do
+            desc "The host name."
+
+            isnamevar
+        end
+
+        @doc = "Installs and manages host entries.  For most systems, these
+            entries will just be in ``/etc/hosts``, but some systems (notably OS X)
+            will have different solutions."
+    end
+end
+
+# $Id: host.rb 2408 2007-04-24 02:41:16Z luke $

data/lib/puppet/type/mount.rb

@@ -0,0 +1,189 @@
+require 'puppet/type/parsedtype'
+
+module Puppet
+    # We want the mount to refresh when it changes.
+    newtype(:mount, :self_refresh => true) do
+        @doc = "Manages mounted filesystems, including putting mount
+            information into the mount table. The actual behavior depends 
+            on the value of the 'ensure' parameter.
+	    
+            Note that if a ``mount`` receives an event from another resource,
+            it will try to remount the filesystems if ``ensure => mounted`` is
+            set."
+        
+        # Use the normal parent class, because we actually want to
+        # call code when sync() is called.
+        newproperty(:ensure) do
+            desc "Control what to do with this mount. If the value is 
+                  ``present``, the mount is entered into the mount table, 
+                  but not mounted, if it is ``absent``, the entry is removed 
+                  from the mount table and the filesystem is unmounted if 
+                  currently mounted, if it is ``mounted``, the filesystem 
+                  is entered into the mount table and mounted."
+
+            newvalue(:present) do
+                if provider.mounted?
+                    syncothers()
+                    provider.unmount
+                    return :mount_unmounted
+                else
+                    provider.create
+                    return :mount_created
+                end
+            end
+            aliasvalue :unmounted, :present
+
+            newvalue(:absent, :event => :mount_deleted) do
+                if provider.mounted?
+                    provider.unmount
+                end
+
+                provider.destroy
+            end
+
+            newvalue(:mounted, :event => :mount_mounted) do
+                # Create the mount point if it does not already exist.
+                if self.is == :absent or self.is.nil?
+                    provider.create
+                end
+
+                syncothers()
+                provider.mount
+            end
+
+            def retrieve
+                if provider.mounted?
+                    @is = :mounted
+                else
+                    @is = super()
+                end
+            end
+
+            def syncothers
+                # We have to flush any changes to disk.
+                oos = @parent.send(:properties).find_all do |prop|
+                    if prop.name == :ensure
+                        false
+                    else
+                        ! prop.insync?
+                    end
+                end.each { |prop| prop.sync }.length
+                if oos > 0
+                    @parent.flush
+                end
+            end
+        end
+
+        newproperty(:device) do
+            desc "The device providing the mount.  This can be whatever
+                device is supporting by the mount, including network
+                devices or devices specified by UUID rather than device
+                path, depending on the operating system."
+        end
+
+        # Solaris specifies two devices, not just one.
+        newproperty(:blockdevice) do
+            desc "The the device to fsck.  This is property is only valid
+                on Solaris, and in most cases will default to the correct
+                value."
+
+            # Default to the device but with "dsk" replaced with "rdsk".
+            defaultto do
+                if Facter["operatingsystem"].value == "Solaris"
+                    device = @parent.value(:device)
+                    if device =~ %r{/dsk/}
+                        device.sub(%r{/dsk/}, "/rdsk/")
+                    else
+                        nil
+                    end
+                else
+                    nil
+                end
+            end
+        end
+
+        newproperty(:fstype) do
+            desc "The mount type.  Valid values depend on the
+                operating system."
+        end
+
+        newproperty(:options) do
+            desc "Mount options for the mounts, as they would
+                appear in the fstab."
+        end
+
+        newproperty(:pass) do
+            desc "The pass in which the mount is checked."
+        end
+
+        newproperty(:atboot) do
+            desc "Whether to mount the mount at boot.  Not all platforms
+                support this."
+        end
+
+        newproperty(:dump) do
+            desc "Whether to dump the mount.  Not all platforms
+                support this."
+        end
+
+        newproperty(:target) do
+            desc "The file in which to store the mount table.  Only used by
+                those providers that write to disk (i.e., not NetInfo)."
+
+            defaultto { if @parent.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+                    @parent.class.defaultprovider.default_target
+                else
+                    nil
+                end
+            }
+        end
+
+        newparam(:name) do
+            desc "The mount path for the mount."
+
+            isnamevar
+        end
+
+        newparam(:path) do
+            desc "The deprecated name for the mount point.  Please use ``name`` now."
+
+            def value=(value)
+                warning "'path' is deprecated for mounts.  Please use 'name'."
+                @parent[:name] = value
+                super
+            end
+        end
+        
+        newparam(:remounts) do
+            desc "Whether the mount can be remounted  ``mount -o remount``.  If
+                this is false, then the filesystem will be unmounted and remounted
+                manually, which is prone to failure."
+            
+            newvalues(:true, :false)
+            defaultto do
+                case Facter.value(:operatingsystem)
+                when "Darwin", "FreeBSD": false
+                else
+                    true
+                end
+            end
+        end
+
+        def refresh
+            # Only remount if we're supposed to be mounted.
+            if ens = @parameters[:ensure] and ens.should == :mounted
+                provider.remount
+            end
+        end
+
+        def value(name)
+            name = symbolize(name)
+            ret = nil
+            if property = @parameters[name]
+                return property.value
+            end
+        end
+    end
+end
+
+# $Id: mount.rb 2183 2007-02-11 23:50:15Z luke $