puppet 0.9.2 → 0.13.0

data/lib/puppet/type/tidy.rb

@@ -1,16 +1,92 @@
-#!/usr/local/bin/ruby -w
-
-# $Id: tidy.rb 731 2005-10-26 04:44:25Z luke $
 
 require 'etc'
 require 'puppet/type/state'
 require 'puppet/type/pfile'
 
 module Puppet
-    # okay, how do we deal with parameters that don't have operations
-    # associated with them?
-    class State
-        class TidyUp < Puppet::State
+    newtype(:tidy, Puppet.type(:file)) do
+        @doc = "Remove unwanted files based on specific criteria."
+
+        newparam(:path) do
+            desc "The path to the file or directory to manage.  Must be fully
+                qualified."
+            isnamevar
+        end
+
+        copyparam(Puppet.type(:file), :backup)
+
+        newparam(:age) do
+            desc "Tidy files whose age is equal to or greater than
+                the specified number of days."
+
+            munge do |age|
+                case age
+                when /^[0-9]+$/, /^[0-9]+[dD]/:
+                    Integer(age.gsub(/[^0-9]+/,'')) *
+                        60 * 60 * 24
+                when /^[0-9]+$/, /^[0-9]+[hH]/:
+                    Integer(age.gsub(/[^0-9]+/,'')) * 60 * 60
+                when /^[0-9]+[mM]/:
+                    Integer(age.gsub(/[^0-9]+/,'')) * 60
+                when /^[0-9]+[sS]/:
+                    Integer(age.gsub(/[^0-9]+/,''))
+                else
+                    self.fail "Invalid tidy age %s" % age
+                end
+            end
+        end
+
+        newparam(:size) do
+            desc "Tidy files whose size is equal to or greater than
+                the specified size.  Unqualified values are in kilobytes, but
+                *b*, *k*, and *m* can be appended to specify *bytes*, *kilobytes*,
+                and *megabytes*, respectively.  Only the first character is
+                significant, so the full word can also be used."
+            
+            munge do |size|
+                if FileTest.directory?(@parent[:path])
+                    # don't do size comparisons for directories
+                    return
+                end
+                case size
+                when /^[0-9]+$/, /^[0-9]+[kK]/:
+                    Integer(size.gsub(/[^0-9]+/,'')) * 1024
+                when /^[0-9]+[bB]/:
+                    Integer(size.gsub(/[^0-9]+/,''))
+                when /^[0-9]+[mM]/:
+                    Integer(size.gsub(/[^0-9]+/,'')) *
+                        1024 * 1024
+                else
+                    self.fail "Invalid tidy size %s" % size
+                end
+            end
+        end
+
+        newparam(:type) do
+            desc "Set the mechanism for determining age.
+            **atime**/*mtime*/*ctime*."
+            
+            munge do |type|
+                case type
+                when "atime", "mtime", "ctime":
+                    type.intern
+                else
+                    self.fail "Invalid tidy type %s" % type
+                end
+            end
+        end
+
+        newparam(:recurse) do
+            desc "If target is a directory, recursively descend
+                into the directory looking for files to tidy."
+        end
+
+        newparam(:rmdirs) do
+            desc "Tidy directories in addition to files; that is, remove
+                directories whose age is older than the specified criteria."
+        end
+
+        newstate(:tidyup) do
             require 'etc'
 
             @nodoc = true
@@ -69,115 +145,42 @@ module Puppet
                     File.unlink(file)
                 when "symlink":     File.unlink(file)
                 else
-                    raise Puppet::Error, "Cannot tidy files of type %s" %
+                    self.fail "Cannot tidy files of type %s" %
                         File.lstat(file).ftype
                 end
 
                 return :file_tidied
             end
         end
-    end
-
-    class Type
-        class Tidy < PFile
-
-            # class instance variable
-            @states = [
-                Puppet::State::TidyUp
-            ]
-
-            @parameters = [
-                :path,
-                :age,
-                :size,
-                :type,
-                :backup,
-                :rmdirs,
-                :recurse
-            ]
-
-            @paramdoc[:age] = "Tidy files whose age is equal to or greater than
-                the specified number of days."
-            @paramdoc[:size] = "Tidy files whose size is equal to or greater than
-                the specified size.  Unqualified values are in kilobytes, but
-                *b*, *k*, and *m* can be appended to specify *bytes*, *kilobytes*,
-                and *megabytes*, respectively.  Only the first character is
-                significant, so the full word can also be used."
-            @paramdoc[:type] = "Set the mechanism for determining age.  Access
-                time is the default mechanism, but modification."
-            @paramdoc[:recurse] = "If target is a directory, recursively descend
-                into the directory looking for files to tidy."
-            @paramdoc[:rmdirs] = "Tidy directories in addition to files."
-            @doc = "Remove unwanted files based on specific criteria."
-            @name = :tidy
-            @namevar = :path
 
-            @depthfirst = true
+        # Erase PFile's validate method
+        validate do
+        end
 
-            def initialize(hash)
-                super
+        @depthfirst = true
 
-                unless  @parameters.include?(:age) or
-                        @parameters.include?(:size)
-                    unless FileTest.directory?(self[:path])
-                        # don't do size comparisons for directories
-                        raise Puppet::Error, "Tidy must specify size, age, or both"
-                    end
-                end
+        def initialize(hash)
+            super
+            #self.setdefaults
 
-                # only allow backing up into filebuckets
-                unless self[:backup].is_a? Puppet::Client::Dipper
-                    self[:backup] = false
-                end
-                self[:tidyup] = [:age, :size].collect { |param|
-                    @parameters[param]
-                }.reject { |p| p == false }
-            end
-
-            def paramage=(age)
-                @parameters[:age] = age
-                case age
-                when /^[0-9]+$/, /^[0-9]+[dD]/:
-                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,'')) *
-                        60 * 60 * 24
-                when /^[0-9]+$/, /^[0-9]+[hH]/:
-                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,'')) * 60 * 60
-                when /^[0-9]+[mM]/:
-                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,'')) * 60
-                when /^[0-9]+[sS]/:
-                    @parameters[:age] = Integer(age.gsub(/[^0-9]+/,''))
-                else
-                    raise Puppet::Error.new("Invalid tidy age %s" % age)
-                end
-            end
-
-            def paramsize=(size)
-                if FileTest.directory?(self[:path])
+            unless  @parameters.include?(:age) or
+                    @parameters.include?(:size)
+                unless FileTest.directory?(self[:path])
                     # don't do size comparisons for directories
-                    return
-                end
-                case size
-                when /^[0-9]+$/, /^[0-9]+[kK]/:
-                    @parameters[:size] = Integer(size.gsub(/[^0-9]+/,'')) * 1024
-                when /^[0-9]+[bB]/:
-                    @parameters[:size] = Integer(size.gsub(/[^0-9]+/,''))
-                when /^[0-9]+[mM]/:
-                    @parameters[:size] = Integer(size.gsub(/[^0-9]+/,'')) *
-                        1024 * 1024
-                else
-                    raise Puppet::Error.new("Invalid tidy size %s" % size)
+                    self.fail "Tidy must specify size, age, or both"
                 end
             end
 
-            def paramtype=(type)
-                case type
-                when "atime", "mtime", "ctime":
-                    @parameters[:type] = type.intern
-                else
-                    raise Puppet::Error.new("Invalid tidy type %s" % type)
-                end
+            # only allow backing up into filebuckets
+            unless self[:backup].is_a? Puppet::Client::Dipper
+                self[:backup] = false
             end
+            self[:tidyup] = [:age, :size].collect { |param|
+                self[param]
+            }.reject { |p| p == false }
+        end
 
-        end # Puppet::Type::Symlink
-    end # Puppet::Type
+    end
 end
+
+# $Id: tidy.rb 841 2006-01-18 17:24:15Z luke $

data/lib/puppet/type/user.rb

@@ -4,19 +4,27 @@ require 'puppet/type/state'
 require 'puppet/type/nameservice'
 
 module Puppet
-    class State
-        module UserUID
-            def self.doc
-                "The user ID.  Must be specified numerically.  For new users
+    newtype(:user, Puppet::Type::NSSType) do
+        case Facter["operatingsystem"].value
+        when "Darwin":
+            @parentstate = Puppet::NameService::NetInfo::NetInfoState
+            @parentmodule = Puppet::NameService::NetInfo
+        else
+            @parentstate = Puppet::NameService::ObjectAdd::ObjectAddUser
+            @parentmodule = Puppet::NameService::ObjectAdd
+        end
+
+        # The 'create' and 'destroy' methods are defined in type/nameservice.rb
+        self.ensurable()
+
+        newstate(:uid, @parentstate) do
+            desc "The user ID.  Must be specified numerically.  For new users
                 being created, if no user ID is specified then one will be
                 chosen automatically, which will likely result in the same user
                 having different IDs on different systems, which is not
                 recommended."
-            end
 
-            def self.name
-                :uid
-            end
+            isautogen
 
             def autogen
                 highest = 0
@@ -31,15 +39,15 @@ module Puppet
                 return highest + 1
             end
 
-            def shouldprocess(value)
+            munge do |value|
                 case value
                 when String
                     if value =~ /^[-0-9]+$/
                         value = Integer(value)
                     end
                 when Symbol
-                    unless value == :notfound or value == :auto
-                        raise Puppet::DevError, "Invalid UID %s" % value
+                    unless value == :absent or value == :auto
+                        self.devfail "Invalid UID %s" % value
                     end
 
                     if value == :auto
@@ -51,17 +59,13 @@ module Puppet
             end
         end
 
-        module UserGID
-            def self.doc
-                "The user's primary group.  Can be specified numerically or
+        newstate(:gid, @parentstate) do
+            desc "The user's primary group.  Can be specified numerically or
                 by name."
-            end
 
-            def self.name
-                :gid
-            end
+            isautogen
 
-            def shouldprocess(gid)
+            munge do |gid|
                 method = :getgrgid
                 case gid
                 when String
@@ -71,8 +75,8 @@ module Puppet
                         method = :getgrnam
                     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
                     # these are treated specially by sync()
                     return gid
@@ -84,7 +88,7 @@ module Puppet
                 begin
                     ginfo = Etc.send(method, gid)
                 rescue ArgumentError => detail
-                    raise Puppet::Error, "Could not find group %s: %s" %
+                    self.fail "Could not find group %s: %s" %
                         [gid, detail]
                 end
 
@@ -93,198 +97,132 @@ module Puppet
             end
         end
 
-        module UserComment
-            def self.doc
-                "A description of the user.  Generally is a user's full name."
-            end
-
-            def self.name
-                :comment
-            end
+        newstate(:comment, @parentstate) do
+            desc "A description of the user.  Generally is a user's full name."
 
-            def self.optional?
-                true
-            end
+            isoptional
 
-            def self.posixmethod
-                :gecos
-            end
+            @posixmethod = :gecos
         end
 
-        module UserHome
-            def self.doc
-                "The home directory of the user.  The directory must be created
+        newstate(:home, @parentstate) do
+            desc "The home directory of the user.  The directory must be created
                 separately and is not currently checked for existence."
-            end
 
-            def self.name
-                :home
-            end
-
-            def self.posixmethod
-                :dir
-            end
+            isautogen
+            @posixmethod = :dir
         end
 
-        module UserShell
-            def self.doc
-                "The user's login shell.  The shell must exist and be
+        newstate(:shell, @parentstate) do
+            desc "The user's login shell.  The shell must exist and be
                 executable."
-            end
-
-            def self.name
-                :shell
-            end
+            isautogen
         end
 
         # these three states are all implemented differently on each platform,
         # so i'm disabling them for now
 
         # FIXME Puppet::State::UserLocked is currently non-functional
-        module UserLocked 
-            def self.doc
-                "The expected return code.  An error will be returned if the
-                executed command returns something else."
-            end
-
-            def self.name
-                :locked
-            end
-        end
+        #newstate(:locked, @parentstate) do
+        #    desc "The expected return code.  An error will be returned if the
+        #        executed command returns something else."
+        #end
 
         # FIXME Puppet::State::UserExpire is currently non-functional
-        module UserExpire 
-            def self.doc
-                "The expected return code.  An error will be returned if the
-                executed command returns something else."
-            end
-
-            def self.name; :expire; end
-        end
+        #newstate(:expire, @parentstate) do
+        #    desc "The expected return code.  An error will be returned if the
+        #        executed command returns something else."
+        #    @objectaddflag = "-e"
+        #    isautogen
+        #end
 
         # FIXME Puppet::State::UserInactive is currently non-functional
-        module UserInactive 
-            def self.doc
-                "The expected return code.  An error will be returned if the
-                executed command returns something else."
-            end
-
-            def self.name; :inactive; end
+        #newstate(:inactive, @parentstate) do
+        #    desc "The expected return code.  An error will be returned if the
+        #        executed command returns something else."
+        #    @objectaddflag = "-f"
+        #    isautogen
+        #end
+
+        newparam(:name) do
+            desc "User name.  While limitations are determined for
+                each operating system, it is generally a good idea to keep to
+                the degenerate 8 characters, beginning with a letter."
+            isnamevar
         end
 
-    end
-
-    class Type
-        class User < Type
-            statenames = [
-                "UserUID",
-                "UserGID",
-                "UserComment",
-                "UserHome",
-                "UserShell"
-            ]
-            @statemodule = nil
-            case Facter["operatingsystem"].value
-            when "Darwin":
-                @statemodule = Puppet::NameService::NetInfo
-            else
-                @statemodule = Puppet::NameService::ObjectAdd
-            end
-
-            class << self
-                attr_accessor :netinfodir
-                attr_accessor :statemodule
-            end
-
-            @states = []
+        @doc = "Manage users.  Currently can create and modify users, but
+            cannot delete them.  Theoretically all of the parameters are
+            optional, but if no parameters are specified the comment will
+            be set to the user name in order to make the internals work out
+            correctly.
+            
+            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/passwd or anything.
+            
+            For most platforms, the tools used are ``useradd`` 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."
+
+        @netinfodir = "users"
+
+        def exists?
+            self.class.parentmodule.exists?(self)
+        end
 
-            @states = statenames.collect { |name|
-                fullname = @statemodule.to_s + "::" + name
+        def getinfo(refresh = false)
+            if @userinfo.nil? or refresh == true
                 begin
-                    eval(fullname)
-                rescue NameError
-                    raise Puppet::DevError, "Could not retrieve state class %s" %
-                        fullname
-                end
-            }.each { |klass|
-                klass.complete
-            }
-
-            @parameters = [
-                :name
-            ]
-
-            @paramdoc[:name] = "User name.  While limitations are determined for
-                each operating system, it is generally a good idea to keep to the
-                degenerate 8 characters, beginning with a letter."
-
-            @doc = "Manage users.  Currently can create and modify users, but
-                cannot delete them.  Theoretically all of the parameters are
-                optional, but if no parameters are specified the comment will
-                be set to the user name in order to make the internals work out
-                correctly."
-            @name = :user
-            @namevar = :name
-
-            @netinfodir = "users"
-
-            def exists?
-                self.class.statemodule.exists?(self)
-            end
-
-            def getinfo(refresh = false)
-                if @userinfo.nil? or refresh == true
-                    begin
-                        @userinfo = Etc.getpwnam(self[:name])
-                    rescue ArgumentError => detail
-                        @userinfo = nil
-                    end
+                    @userinfo = Etc.getpwnam(self[:name])
+                rescue ArgumentError => detail
+                    @userinfo = nil
                 end
-
-                @userinfo
             end
 
-            def initialize(hash)
-                @userinfo = nil
-                super
+            @userinfo
+        end
 
-                # Verify that they have provided everything necessary, if we
-                # are trying to manage the user
-                if self.managed?
-                    self.class.states.each { |state|
-                        next if @states.include?(state.name)
-
-                        unless state.autogen? or state.optional?
-                            if state.method_defined?(:autogen)
-                                self[state.name] = :auto
-                            else
-                                raise Puppet::Error,
-                                    "Users require a value for %s" % state.name
-                            end
+        def initialize(hash)
+            @userinfo = nil
+            super
+
+            # Verify that they have provided everything necessary, if we
+            # are trying to manage the user
+            if self.managed?
+                self.class.states.each { |state|
+                    next if @states.include?(state.name)
+                    next if state.name == :ensure
+
+                    unless state.autogen? or state.isoptional?
+                        if state.method_defined?(:autogen)
+                            self[state.name] = :auto
+                        else
+                            self.fail "Users require a value for %s" % state.name
                         end
-                    }
-
-                    if @states.empty?
-                        self[:comment] = self[:name]
                     end
+                }
+
+                if @states.empty?
+                    self[:comment] = self[:name]
                 end
             end
+        end
 
-            def retrieve
-                info = self.getinfo(true)
-
-                if info.nil?
-                    # the user does not exist
-                    @states.each { |name, state|
-                        state.is = :notfound
-                    }
-                    return
-                else
-                    super
-                end
+        def retrieve
+            info = self.getinfo(true)
+
+            if info.nil?
+                # the user does not exist
+                @states.each { |name, state|
+                    state.is = :absent
+                }
+                return
+            else
+                super
             end
         end
     end
 end
 
-# $Id: user.rb 731 2005-10-26 04:44:25Z luke $
+# $Id: user.rb 841 2006-01-18 17:24:15Z luke $