puppet 0.18.4 → 0.22.4

data/lib/puppet/type/sshkey.rb

@@ -0,0 +1,76 @@
+module Puppet
+    newtype(:sshkey) do
+        @doc = "Installs and manages ssh host keys.  At this point, this type
+            only knows how to install keys into /etc/ssh/ssh_known_hosts, and
+            it cannot manage user authorized keys yet."
+        
+        ensurable
+
+        newproperty(:type) do
+            desc "The encryption type used.  Probably ssh-dss or ssh-rsa."
+            
+            newvalue("ssh-dss")
+            newvalue("ssh-rsa")
+            aliasvalue(:dsa, "ssh-dss")
+            aliasvalue(:rsa, "ssh-rsa")
+        end
+
+        newproperty(:key) do
+            desc "The key itself; generally a long string of hex digits."
+        end
+
+        # FIXME This should automagically check for aliases to the hosts, just
+        # to see if we can automatically glean any aliases.
+        newproperty(:alias) do
+            desc "Any alias the host might have.  Multiple values must be
+                specified as an array.  Note that this parameter has the same name
+                as one of the metaparams; using this parameter to set aliases will
+                make those aliases available in your Puppet scripts."
+
+            attr_accessor :meta
+            
+            def insync?
+                @is == @should
+            end
+
+            # We actually want to return the whole array here, not just the first
+            # value.
+            def should
+                if defined? @should
+                    return @should
+                else
+                    return nil
+                end
+            end
+
+            validate do |value|
+                if value =~ /\s/
+                    raise Puppet::Error, "Aliases cannot include whitespace"
+                end
+                if value =~ /,/
+                    raise Puppet::Error, "Aliases cannot include whitespace"
+                end
+            end
+        end
+
+        newparam(:name) do
+            desc "The host name."
+
+            isnamevar
+        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
+    end
+end
+
+# $Id: sshkey.rb 2169 2007-02-07 06:47:10Z luke $

data/lib/puppet/type/tidy.rb

@@ -1,11 +1,13 @@
 
 require 'etc'
-require 'puppet/type/state'
+require 'puppet/type/property'
 require 'puppet/type/pfile'
 
 module Puppet
     newtype(:tidy, Puppet.type(:file)) do
-        @doc = "Remove unwanted files based on specific criteria."
+        @doc = "Remove unwanted files based on specific criteria.  Multiple
+            criteria are OR'd together, so a file that is too large but is not
+            old enough will still get tidied."
 
         newparam(:path) do
             desc "The path to the file or directory to manage.  Must be fully
@@ -14,111 +16,70 @@ module Puppet
         end
 
         copyparam(Puppet.type(:file), :backup)
+        
+        newproperty(:ensure) do
+            desc "An internal attribute used to determine which files should be removed."
+            require 'etc'
 
-        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."
+            @nodoc = true
             
-            munge do |size|
-                if FileTest.directory?(@parent[:path])
-                    # don't do size comparisons for directories
-                    return
+            TATTRS = [:age, :size]
+            
+            defaultto :anything # just so we always get this property
+
+            def change_to_s
+                start = "Tidying"
+                if @out.include?(:age)
+                    start += ", older than %s seconds" % @parent.should(:age)
                 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
+                if @out.include?(:size)
+                    start += ", larger than %s bytes" % @parent.should(: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
+                start
             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
-            @name = :tidyup
-
-            def age(stat)
-                type = nil
-                if stat.ftype == "directory"
-                    type = :mtime
+            def insync?
+                if @is.is_a?(Symbol)
+                    if [:absent, :notidy].include?(@is)
+                        return true
+                    else
+                        return false
+                    end
                 else
-                    type = @parent[:type] || :atime
+                    @out = []
+                    TATTRS.each do |param|
+                        if property = @parent.property(param)
+                            unless property.insync?
+                                @out << param
+                            end
+                        end
+                    end
+                    if @out.length > 0
+                        return false
+                    else
+                        return true
+                    end
                 end
-                
-                return Integer(Time.now - stat.send(type))
             end
 
             def retrieve
                 stat = nil
                 unless stat = @parent.stat
-                    @is = :unknown
+                    @is = :absent
+                    return
+                end
+                
+                if stat.ftype == "directory" and ! @parent[:rmdirs]
+                    @is = :notidy
                     return
                 end
 
-                @is = [:age, :size].collect { |param|
-                    if @parent[param]
-                        self.send(param, stat)
+                TATTRS.each { |param|
+                    if property = @parent.property(param)
+                        property.is = property.assess(stat)
                     end
-                }.reject { |p| p == false or p.nil? }
-            end
-
-            def size(stat)
-                return stat.size
+                }
             end
 
             def sync
@@ -143,7 +104,8 @@ module Puppet
                 when "file":
                     @parent.handlebackup(file)
                     File.unlink(file)
-                when "symlink":     File.unlink(file)
+                when "link":
+                    File.unlink(file)
                 else
                     self.fail "Cannot tidy files of type %s" %
                         File.lstat(file).ftype
@@ -153,6 +115,139 @@ module Puppet
             end
         end
 
+        newproperty(:age) do
+            desc "Tidy files whose age is equal to or greater than
+                the specified time.  You can choose seconds, minutes,
+                hours, days, or weeks by specifying the first letter of any
+                of those words (e.g., '1w')."
+
+            @@ageconvertors = {
+                :s => 1,
+                :m => 60
+            }
+
+            @@ageconvertors[:h] = @@ageconvertors[:m] * 60
+            @@ageconvertors[:d] = @@ageconvertors[:h] * 24
+            @@ageconvertors[:w] = @@ageconvertors[:d] * 7
+
+            def assess(stat)
+                type = nil
+                if stat.ftype == "directory"
+                    type = :mtime
+                else
+                    type = @parent[:type] || :atime
+                end
+                
+                #return Integer(Time.now - stat.send(type))
+                return stat.send(type).to_i
+            end
+
+            def convert(unit, multi)
+                if num = @@ageconvertors[unit]
+                    return num * multi
+                else
+                    self.fail "Invalid age unit '%s'" % unit
+                end
+            end
+
+            def insync?
+                if (Time.now.to_i - @is) > self.should
+                    return false
+                end
+
+                true
+            end
+
+            munge do |age|
+                unit = multi = nil
+                case age
+                when /^([0-9]+)(\w)\w*$/:
+                    multi = Integer($1)
+                    unit = $2.downcase.intern
+                when /^([0-9]+)$/:
+                    multi = Integer($1)
+                    unit = :d
+                else
+                    self.fail "Invalid tidy age %s" % age
+                end
+
+                convert(unit, multi)
+            end
+        end
+
+        newproperty(: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."
+
+            @@sizeconvertors = {
+                :b => 0,
+                :k => 1,
+                :m => 2,
+                :g => 3
+            }
+
+            # Retrieve the size from a File::Stat object
+            def assess(stat)
+                return stat.size
+            end
+
+            def convert(unit, multi)
+                if num = @@sizeconvertors[unit]
+                    result = multi
+                    num.times do result *= 1024 end
+                    return result
+                else
+                    self.fail "Invalid size unit '%s'" % unit
+                end
+            end
+            
+            def insync?
+                if @is > self.should
+                    return false
+                end
+
+                true
+            end
+            
+            munge do |size|
+                case size
+                when /^([0-9]+)(\w)\w*$/:
+                    multi = Integer($1)
+                    unit = $2.downcase.intern
+                when /^([0-9]+)$/:
+                    multi = Integer($1)
+                    unit = :k
+                else
+                    self.fail "Invalid tidy size %s" % age
+                end
+
+                convert(unit, multi)
+            end
+        end
+
+        newparam(:type) do
+            desc "Set the mechanism for determining age."
+            
+            newvalues(:atime, :mtime, :ctime)
+
+            defaultto :atime
+        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.
+                This will only remove empty directories, so all contained
+                files must also be tidied before a directory gets removed."
+        end
+        
         # Erase PFile's validate method
         validate do
         end
@@ -165,7 +260,6 @@ module Puppet
 
         def initialize(hash)
             super
-            #self.setdefaults
 
             unless  @parameters.include?(:age) or
                     @parameters.include?(:size)
@@ -176,15 +270,21 @@ module Puppet
             end
 
             # only allow backing up into filebuckets
-            unless self[:backup].is_a? Puppet::Client::Dipper
+            unless self[:backup].is_a? Puppet::Network::Client::Dipper
                 self[:backup] = false
             end
-            self[:tidyup] = [:age, :size].collect { |param|
-                self[param]
-            }.reject { |p| p == false }
         end
-
+        
+        def retrieve
+            # Our ensure property knows how to retrieve everything for us.
+            obj = @parameters[:ensure] and obj.retrieve
+        end
+        
+        # Hack things a bit so we only ever check the ensure property.
+        def properties
+            []
+        end
     end
 end
 
-# $Id: tidy.rb 1125 2006-04-20 19:38:48Z luke $
+# $Id: tidy.rb 2179 2007-02-08 01:39:39Z luke $

data/lib/puppet/type/user.rb

@@ -1,57 +1,40 @@
 require 'etc'
 require 'facter'
-require 'puppet/type/state'
-require 'puppet/type/nameservice'
+require 'puppet/type/property'
 
 module Puppet
-    newtype(:user, Puppet::Type::NSSType) do
-        case Facter["operatingsystem"].value
-        when "Darwin":
-            @parentstate = Puppet::NameService::NetInfo::NetInfoState
-            @parentmodule = Puppet::NameService::NetInfo
-        when "FreeBSD":
-            @parentstate = Puppet::NameService::PW::PWUser
-            @parentmodule = Puppet::NameService::PW
-        else
-            @parentstate = Puppet::NameService::ObjectAdd::ObjectAddUser
-            @parentmodule = Puppet::NameService::ObjectAdd
-        end
+    newtype(:user) do
+        @doc = "Manage users.  This type is mostly built to manage system
+            users, so it is lacking some features useful for managing normal
+            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/passwd or anything."
 
-        newstate(:ensure, @parentstate) do
-            newvalue(:present) do
-                # Verify that they have provided everything necessary, if we
-                # are trying to manage the user
-                if @parent.managed?
-                    @parent.class.states.each { |state|
-                        next if stateobj = @parent.state(state.name)
-                        next if state.name == :ensure
-
-                        unless state.autogen? or state.isoptional?
-                            if state.method_defined?(:autogen)
-                                @parent[state.name] = :auto
-                            else
-                                @parent.fail "Users require a value for %s" %
-                                    state.name
-                            end
-                        end
-                    }
+        feature :allows_duplicates,
+            "The provider supports duplicate users with the same UID."
 
-                    #if @states.empty?
-                    #    @parent[:comment] = @parent[:name]
-                    #end
-                end
-                self.syncname(:present)
+        feature :manages_homedir,
+            "The provider can create and remove home directories."
+
+        feature :manages_passwords,
+            "The provider can modify user passwords, by accepting a password
+            hash."
+
+        newproperty(:ensure) do
+            newvalue(:present, :event => :user_created) do
+                provider.create
             end
 
-            newvalue(:absent) do
-                self.syncname(:absent)
+            newvalue(:absent, :event => :user_removed) do
+                provider.delete
             end
 
             desc "The basic state that the object should be in."
 
             # 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
@@ -80,12 +63,13 @@ module Puppet
             end
 
             def retrieve
-                if @parent.exists?
+                if provider.exists?
                     @is = :present
                 else
                     @is = :absent
                 end
             end
+
             # The default 'sync' method only selects among a list of registered
             # values.
             def sync
@@ -101,32 +85,20 @@ module Puppet
                 end
 
                 # Set ourselves to whatever our should value is.
-                self.set
+                self.set(self.should)
             end
 
         end
 
-        newstate(:uid, @parentstate) do
+        newproperty(:uid) 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."
-
-            isautogen
-
-            def autogen
-                highest = 0
-                Etc.passwd { |user|
-                    if user.uid > highest
-                        unless user.uid > 65000
-                            highest = user.uid
-                        end
-                    end
-                }
-
-                return highest + 1
-            end
+                recommended.  This is especially noteworthy if you use Puppet
+                to manage the same user on both Darwin and other platforms,
+                since Puppet does the ID generation for you on Darwin, but the
+                tools do so on other platforms."
 
             munge do |value|
                 case value
@@ -134,25 +106,19 @@ module Puppet
                     if value =~ /^[-0-9]+$/
                         value = Integer(value)
                     end
-                when Symbol
-                    unless value == :absent or value == :auto
-                        self.devfail "Invalid UID %s" % value
-                    end
-
-                    if value == :auto
-                        value = autogen()
-                    end
                 end
 
                 return value
             end
         end
 
-        newstate(:gid, @parentstate) do
+        newproperty(:gid) do
             desc "The user's primary group.  Can be specified numerically or
                 by name."
-
-            isautogen
+            
+            def found?
+                defined? @found and @found
+            end
 
             munge do |gid|
                 method = :getgrgid
@@ -186,7 +152,7 @@ module Puppet
                 unless defined? @should
                     return super
                 end
-                unless defined? @found and @found
+                unless found?
                     @should = @should.each { |val|
                         next unless val
                         Puppet::Util.gid(val)
@@ -194,38 +160,31 @@ module Puppet
                 end
                 super
             end
-
         end
 
-        newstate(:comment, @parentstate) do
+        newproperty(:comment) do
             desc "A description of the user.  Generally is a user's full name."
-
-            isoptional
-
-            @posixmethod = :gecos
         end
 
-        newstate(:home, @parentstate) do
+        newproperty(:home) do
             desc "The home directory of the user.  The directory must be created
                 separately and is not currently checked for existence."
-
-            isautogen
-            @posixmethod = :dir
         end
 
-        newstate(:shell, @parentstate) do
+        newproperty(:shell) do
             desc "The user's login shell.  The shell must exist and be
                 executable."
-            isautogen
         end
 
-        newstate(:groups, @parentstate) do
+        newproperty(:password, :required_features => :manages_passwords) do
+            desc "The user's password, in whatever encrypted format the local machine requires."
+        end
+
+        newproperty(:groups) do
             desc "The groups of which the user is a member.  The primary
                 group should not be listed.  Multiple groups should be
                 specified as an array."
 
-            isoptional
-
             def should_to_s
                 self.should
             end
@@ -241,34 +200,42 @@ module Puppet
                     retrieve
                 end
 
-                @should ||= []
+                unless defined? @should and @should
+                    return nil
+                end
 
                 if @parent[:membership] == :inclusive
-                    @should.sort.join(",")
+                    return @should.sort.join(",")
                 else
                     members = @should
                     if @is.is_a?(Array)
                         members += @is
                     end
-                    members.uniq.sort.join(",")
+                    return members.uniq.sort.join(",")
                 end
             end
 
             def retrieve
-                @is = grouplist()
+                if tmp = provider.groups
+                    @is = tmp.split(",")
+                else
+                    @is = :absent
+                end
             end
 
             def insync?
                 unless defined? @should and @should
-                    return false
+                    return true
                 end
                 unless defined? @is and @is
-                    return false
+                    return true
                 end
-                unless @is.class == @should.class
-                    return false
+                tmp = @is
+                if @is.is_a? Array
+                    tmp = @is.sort.join(",")
                 end
-                return @is.sort == @should.sort
+
+                return tmp == self.should
             end
 
             validate do |value|
@@ -276,42 +243,29 @@ module Puppet
                     raise ArgumentError, "Group names must be provided, not numbers"
                 end
             end
-
-            def sync
-                if respond_to? :setgrouplist
-                    # Pass them the group list, so that the :membership logic
-                    # is all in this class, not in parent classes.
-                    setgrouplist(self.should)
-                    return :user_modified
-                else
-                    super
-                end
-            end
         end
 
-        # these three states are all implemented differently on each platform,
+        # these three properties are all implemented differently on each platform,
         # so i'm disabling them for now
 
-        # FIXME Puppet::State::UserLocked is currently non-functional
-        #newstate(:locked, @parentstate) do
+        # FIXME Puppet::Property::UserLocked is currently non-functional
+        #newproperty(:locked) 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
-        #newstate(:expire, @parentstate) do
+        # FIXME Puppet::Property::UserExpire is currently non-functional
+        #newproperty(:expire) 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
-        #newstate(:inactive, @parentstate) do
+        # FIXME Puppet::Property::UserInactive is currently non-functional
+        #newproperty(:inactive) 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
@@ -331,7 +285,7 @@ module Puppet
             defaultto :minimum
         end
 
-        newparam(:allowdupe) do
+        newparam(:allowdupe, :boolean => true) do
             desc "Whether to allow duplicate UIDs."
                 
             newvalues(:true, :false)
@@ -339,29 +293,27 @@ module Puppet
             defaultto false
         end
 
-        @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."
+        newparam(:managehome, :boolean => true) do
+            desc "Whether to manage the home directory when managing the user."
+
+            newvalues(:true, :false)
+
+            defaultto false
 
-        @netinfodir = "users"
+            validate do |val|
+                if val.to_s == "true"
+                    unless provider.class.manages_homedir?
+                        raise ArgumentError, "User provider %s can not manage home directories" % provider.class.name
+                    end
+                end
+            end
+        end
 
         # Autorequire the group, if it's around
         autorequire(:group) do
-            #return nil unless @states.include?(:gid)
-            #return nil unless groups = @states[:gid].shouldorig
             autos = []
 
-            if @states.include?(:gid) and groups = @states[:gid].shouldorig
+            if obj = @parameters[:gid] and groups = obj.shouldorig
                 groups = groups.collect { |group|
                     if group =~ /^\d+$/
                         Integer(group)
@@ -384,73 +336,45 @@ module Puppet
                 }
             end
 
-            if @states.include?(:groups) and groups = @states[:groups].should.split(",")
-                autos += groups
+            if obj = @parameters[:groups] and groups = obj.should
+                autos += groups.split(",")
             end
 
             autos
         end
 
-        autorequire(:file) do
-            dir = self.should(:home) or self.is(:home)
-            if dir =~ /^#{File::SEPARATOR}/
-                dir
-            else
-                nil
-            end
-        end
-
-        # List all found users
-        def self.listbyname
+        def self.list_by_name
             users = []
-            Etc.setpwent
-            while ent = Etc.getpwent
-                users << ent.name
+            defaultprovider.listbyname do |user|
+                users << user
             end
-            Etc.endpwent
-
             return users
         end
 
-        def exists?
-            self.class.parentmodule.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
-            end
-
-            @userinfo
-        end
-
-        def initialize(hash)
-            @userinfo = nil
-            super
+        def self.list
+            defaultprovider.list
 
-            unless defined? @states
-                raise "wtf?"
+            self.collect do |user|
+                user
             end
         end
 
         def retrieve
-            info = self.getinfo(true)
+            absent = false
+            properties().each { |property|
+                if absent
+                    property.is = :absent
+                else
+                    property.retrieve
+                end
 
-            if info.nil?
-                # the user does not exist
-                @states.each { |name, state|
-                    state.is = :absent
-                }
-                return
-            else
-                super
-            end
+                if property.name == :ensure and property.is == :absent
+                    absent = true
+                    next
+                end
+            }
         end
     end
 end
 
-# $Id: user.rb 1416 2006-07-21 19:05:30Z luke $
+# $Id: user.rb 2414 2007-04-25 20:59:00Z luke $