puppet 0.24.9 → 0.25.0

data/lib/puppet/type/selmodule.rb

@@ -48,7 +48,7 @@ Puppet::Type.newtype(:selmodule) do
             [self[:selmodulepath]]
         else
             ["#{self[:selmoduledir]}/#{self[:name]}.pp"]
-        end       
+        end
     end
 end
 

data/lib/puppet/type/service.rb

@@ -16,15 +16,15 @@ module Puppet
             command matching the service name), but the more information you
             can provide the better behaviour you will get.  Or, you can just
             use a platform that has very good service support.
-	    
+
             Note that if a ``service`` receives an event from another resource,
             the service will get restarted. The actual command to restart the
             service depends on the platform. You can provide a special command
             for restarting with the ``restart`` attribute."
-        
+
         feature :refreshable, "The provider can restart the service.",
             :methods => [:restart]
-        
+
         feature :enableable, "The provider can enable and disable the service",
             :methods => [:disable, :enable, :enabled?]
 
@@ -95,7 +95,7 @@ module Puppet
                 manually whether the service you are running has such a
                 command (or you can specify a specific command using the
                 ``status`` parameter).
-                
+
                 If you do not specify anything, then the service name will be
                 looked for in the process table."
 
@@ -113,7 +113,7 @@ module Puppet
 
             munge do |value|
                 value = [value] unless value.is_a?(Array)
-                # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
+                # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
                 # It affects stand-alone blocks, too.
                 paths = value.flatten.collect { |p| x = p.split(":") }.flatten.find_all do |path|
                     if FileTest.directory?(path)
@@ -139,10 +139,10 @@ module Puppet
                 support init scripts, and is also used for determining service
                 status on those service whose init scripts do not include a status
                 command.
-                
+
                 If this is left unspecified and is needed to check the status
                 of a service, then the service name will be used instead.
-                
+
                 The pattern can be a simple string or any legal Ruby pattern."
 
             defaultto { @resource[:binary] || @resource[:name] }
@@ -180,6 +180,10 @@ module Puppet
             newvalues(:true, :false)
         end
 
+        newparam(:manifest) do
+            desc "Specify a command to config a service, or a path to a manifest to do so."
+        end
+
         # Basically just a synonym for restarting.  Used to respond
         # to events.
         def refresh

data/lib/puppet/type/ssh_authorized_key.rb

@@ -6,7 +6,8 @@ module Puppet
         ensurable
 
         newparam(:name) do
-            desc "The SSH key comment."
+            desc "The SSH key comment. This attribute is currently used as a
+            system-wide primary key and therefore has to be unique."
 
             isnamevar
         end
@@ -26,11 +27,15 @@ module Puppet
         end
 
         newproperty(:user) do
-            desc "The user account in which the SSH key should be installed."
+            desc "The user account in which the SSH key should be installed.
+            The resource will automatically depend on this user."
         end
 
         newproperty(:target) do
-            desc "The file in which to store the SSH key."
+            desc "The absolute filename in which to store the SSH key. This
+            property is optional and should only be used in cases where keys
+            are stored in a non-standard location (ie not in
+            ~user/.ssh/authorized_keys)."
 
             defaultto :absent
 
@@ -39,16 +44,23 @@ module Puppet
                     return super
                 end
 
-                if user = resource[:user]
+                return nil unless user = resource[:user]
+
+                begin
                     return File.expand_path("~%s/.ssh/authorized_keys" % user)
+                rescue
+                    Puppet.debug "The required user is not yet present on the system"
+                    return nil
                 end
+            end
 
-                return nil
+            def insync?(is)
+                is == should
             end
         end
 
         newproperty(:options, :array_matching => :all) do
-            desc "Key options, see sshd(8) for possible values. Multiple values 
+            desc "Key options, see sshd(8) for possible values. Multiple values
                   should be specified as an array."
 
             defaultto do :absent end
@@ -77,9 +89,14 @@ module Puppet
         end
 
         validate do
-            unless should(:target) or should(:user)
-                raise Puppet::Error, "Attribute 'user' or 'target' is mandatory"
-            end
+            # Go ahead if target attribute is defined
+            return if @parameters[:target].shouldorig[0] != :absent
+
+            # Go ahead if user attribute is defined
+            return if @parameters.include?(:user)
+
+            # If neither target nor user is defined, this is an error
+            raise Puppet::Error, "Attribute 'user' or 'target' is mandatory"
         end
     end
 end

data/lib/puppet/type/sshkey.rb

@@ -3,12 +3,12 @@ module Puppet
         @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")

data/lib/puppet/type/tidy.rb

@@ -1,332 +1,328 @@
-module Puppet
-    newtype(:tidy, :parent => Puppet.type(:file)) do
-        @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.
-            
-            You must specify either the size or age of the file (or both) for
-            files to be tidied."
-
-        newparam(:path) do
-            desc "The path to the file or directory to manage.  Must be fully
-                qualified."
-            isnamevar
+Puppet::Type.newtype(:tidy) do
+    require 'puppet/file_serving/fileset'
+
+    @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.
+
+        If you don't specify either 'age' or 'size', then all files will
+        be removed.
+
+        This resource type works by generating a file resource for every file
+        that should be deleted and then letting that resource perform the
+        actual deletion.
+        "
+
+    newparam(:path) do
+        desc "The path to the file or directory to manage.  Must be fully
+            qualified."
+        isnamevar
+    end
+
+    newparam(:matches) do
+        desc "One or more (shell type) file glob patterns, which restrict
+            the list of files to be tidied to those whose basenames match
+            at least one of the patterns specified. Multiple patterns can
+            be specified using an array.
+
+            Example::
+
+                    tidy { \"/tmp\":
+                        age => \"1w\",
+                        recurse => false,
+                        matches => [ \"[0-9]pub*.tmp\", \"*.temp\", \"tmpfile?\" ]
+                    }
+
+            This removes files from \/tmp if they are one week old or older,
+            are not in a subdirectory and match one of the shell globs given.
+
+            Note that the patterns are matched against the
+            basename of each file -- that is, your glob patterns should not
+            have any '/' characters in them, since you are only specifying
+            against the last bit of the file."
+
+        # Make sure we convert to an array.
+        munge do |value|
+            value = [value] unless value.is_a?(Array)
+            value
         end
 
-        newparam(:matches) do
-            desc "One or more file glob patterns, which restrict the list of
-                files to be tidied to those whose basenames match at least one
-                of the patterns specified.  Multiple patterns can be specified
-                using an array."
+        # Does a given path match our glob patterns, if any?  Return true
+        # if no patterns have been provided.
+        def tidy?(path, stat)
+            basename = File.basename(path)
+            flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
+            return true if value.find {|pattern| File.fnmatch(pattern, basename, flags) }
+            return false
         end
+    end
 
-        copyparam(Puppet.type(:file), :backup)
-        
-        newproperty(:ensure) do
-            desc "An internal attribute used to determine which files should be removed."
-
-            @nodoc = true
-            
-            TATTRS = [:age, :size]
-            
-            defaultto :anything # just so we always get this property
-
-            def change_to_s(currentvalue, newvalue)
-                start = "Tidying"
-                if @out.include?(:age)
-                    start += ", older than %s seconds" % @resource.should(:age)
-                end
-                if @out.include?(:size)
-                    start += ", larger than %s bytes" % @resource.should(:size)
-                end
-
-                start
-            end
+    newparam(:backup) do
+        desc "Whether tidied files should be backed up.  Any values are passed
+            directly to the file resources used for actual file deletion, so use
+            its backup documentation to determine valid values."
+    end
 
-            def insync?(is)
-                begin
-                    stat = File.lstat(resource[:path])
-                rescue Errno::ENOENT
-                    info "Tidy target does not exist; ignoring"
-                    return true
-                end
-
-                if stat.ftype == "directory" and ! @resource[:rmdirs]
-                    self.debug "Not tidying directories"
-                    return true
-                end
-
-                if is.is_a?(Symbol)
-                    if [:absent, :notidy].include?(is)
-                        return true
-                    else
-                        return false
-                    end
-                else
-                    @out = []
-                    if @resource[:matches]
-                        basename = File.basename(@resource[:path])
-                        flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
-                        unless @resource[:matches].any? {|pattern| File.fnmatch(pattern, basename, flags) }
-                            self.debug "No patterns specified match basename, skipping"
-                            return true
-                        end
-                    end
-                    TATTRS.each do |param|
-                        if property = @resource.property(param)
-                            self.debug "No is value for %s", [param] if is[property].nil?
-                            unless property.insync?(is[property])
-                                @out << param
-                            end
-                        end
-                    end
-                    
-                    if @out.length > 0
-                        return false
-                    else
-                        return true
-                    end
-                end
-            end
-            
-            def retrieve
-                stat = nil
-                unless stat = @resource.stat
-                    return { self => :absent}
-                end
-                
-                if stat.ftype == "directory" and ! @resource[:rmdirs]
-                    return {self => :notidy}
-                end
-
-                allprops = TATTRS.inject({}) { |prophash, param|
-                    if property = @resource.property(param)
-                        prophash[property] = property.assess(stat)
-                    end
-                    prophash
-                }
-                return { self => allprops } 
-            end
+    newparam(: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').
+
+            Specifying 0 will remove all files."
+
+        @@ageconvertors = {
+            :s => 1,
+            :m => 60
+        }
+
+        @@ageconvertors[:h] = @@ageconvertors[:m] * 60
+        @@ageconvertors[:d] = @@ageconvertors[:h] * 24
+        @@ageconvertors[:w] = @@ageconvertors[:d] * 7
 
-            def sync
-                file = @resource[:path]
-                case File.lstat(file).ftype
-                when "directory":
-                    # If 'rmdirs' is disabled, then we would have never
-                    # gotten to this method.
-                    subs = Dir.entries(@resource[:path]).reject { |d|
-                        d == "." or d == ".."
-                    }.length
-                    if subs > 0
-                        self.info "%s has %s children; not tidying" %
-                            [@resource[:path], subs]
-                        self.info Dir.entries(@resource[:path]).inspect
-                    else
-                        Dir.rmdir(@resource[:path])
-                    end
-                when "file":
-                    @resource.handlebackup(file)
-                    File.unlink(file)
-                when "link":
-                    File.unlink(file)
-                else
-                    self.fail "Cannot tidy files of type %s" %
-                        File.lstat(file).ftype
-                end
-
-                return :file_tidied
+        def convert(unit, multi)
+            if num = @@ageconvertors[unit]
+                return num * multi
+            else
+                self.fail "Invalid age unit '%s'" % unit
             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 = @resource[:type] || :atime
-                end
-                
-                return stat.send(type).to_i
+        def tidy?(path, stat)
+            # If the file's older than we allow, we should get rid of it.
+            if (Time.now.to_i - stat.send(resource[:type]).to_i) > value
+                return true
+            else
+                return false
             end
+        end
 
-            def convert(unit, multi)
-                if num = @@ageconvertors[unit]
-                    return num * multi
-                else
-                    self.fail "Invalid age unit '%s'" % unit
-                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
 
-            def insync?(is)
-                if (Time.now.to_i - is) > self.should
-                    return false
-                end
-
-                true
-            end
+            convert(unit, multi)
+        end
+    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)
+    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."
+
+        @@sizeconvertors = {
+            :b => 0,
+            :k => 1,
+            :m => 2,
+            :g => 3
+        }
+
+        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
 
-        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
+        def tidy?(path, stat)
+            if stat.size > value
+                return true
+            else
+                return false
             end
+        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
+        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
-            
-            def insync?(is)
-                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
+            convert(unit, multi)
         end
+    end
 
-        newparam(:type) do
-            desc "Set the mechanism for determining age."
-            
-            newvalues(:atime, :mtime, :ctime)
+    newparam(:type) do
+        desc "Set the mechanism for determining age."
 
-            defaultto :atime
-        end
+        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."
-
-            newvalues(:true, :false, :inf, /^[0-9]+$/)
-
-            # Replace the validation so that we allow numbers in
-            # addition to string representations of them.
-            validate { |arg| }
-            munge do |value|
-                newval = super(value)
-                case newval
-                when :true, :inf: true
-                when :false: false
-                when Integer, Fixnum, Bignum: value
-                when /^\d+$/: Integer(value)
-                else
-                    raise ArgumentError, "Invalid recurse value %s" % value.inspect
-                end
+    newparam(:recurse) do
+        desc "If target is a directory, recursively descend
+            into the directory looking for files to tidy."
+
+        newvalues(:true, :false, :inf, /^[0-9]+$/)
+
+        # Replace the validation so that we allow numbers in
+        # addition to string representations of them.
+        validate { |arg| }
+        munge do |value|
+            newval = super(value)
+            case newval
+            when :true, :inf; true
+            when :false; false
+            when Integer, Fixnum, Bignum; value
+            when /^\d+$/; Integer(value)
+            else
+                raise ArgumentError, "Invalid recurse value %s" % value.inspect
             end
         end
+    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
+    newparam(:rmdirs, :boolean => true) 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."
+
+        newvalues :true, :false
+    end
+
+    # Erase PFile's validate method
+    validate do
+    end
+
+    def self.instances
+        []
+    end
+
+    @depthfirst = true
+
+    def initialize(hash)
+        super
+
+        # only allow backing up into filebuckets
+        unless self[:backup].is_a? Puppet::Network::Client.dipper
+            self[:backup] = false
         end
+    end
 
-        def self.instances
-            []
+    # Make a file resource to remove a given file.
+    def mkfile(path)
+        # Force deletion, so directories actually get deleted.
+        Puppet::Type.type(:file).new :path => path, :backup => self[:backup], :ensure => :absent, :force => true
+    end
+
+    def retrieve
+        # Our ensure property knows how to retrieve everything for us.
+        if obj = @parameters[:ensure]
+            return obj.retrieve
+        else
+            return {}
         end
+    end
 
-        @depthfirst = true
+    # Hack things a bit so we only ever check the ensure property.
+    def properties
+        []
+    end
 
-        def initialize(hash)
-            super
+    def eval_generate
+        []
+    end
 
-            unless  @parameters.include?(:age) or
-                    @parameters.include?(:size)
-                unless FileTest.directory?(self[:path])
-                    # don't do size comparisons for directories
-                    self.fail "Tidy must specify size, age, or both"
-                end
-            end
+    def generate
+        return [] unless stat(self[:path])
 
-            # only allow backing up into filebuckets
-            unless self[:backup].is_a? Puppet::Network::Client.dipper
-                self[:backup] = false
+        if self[:recurse]
+            files = Puppet::FileServing::Fileset.new(self[:path], :recurse => self[:recurse]).files.collect do |f|
+                f == "." ? self[:path] : File.join(self[:path], f)
             end
+        else
+            files = [self[:path]]
         end
-        
-        def retrieve
-            # Our ensure property knows how to retrieve everything for us.
-            if obj = @parameters[:ensure] 
-                return obj.retrieve
+        result = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }.each { |file| notice "Tidying %s" % file.ref }.sort { |a,b| b[:path] <=> a[:path] }
+
+        # No need to worry about relationships if we don't have rmdirs; there won't be
+        # any directories.
+        return result unless rmdirs?
+
+        # Now make sure that all directories require the files they contain, if all are available,
+        # so that a directory is emptied before we try to remove it.
+        files_by_name = result.inject({}) { |hash, file| hash[file[:path]] = file; hash }
+
+        files_by_name.keys.sort { |a,b| b <=> b }.each do |path|
+            dir = File.dirname(path)
+            next unless resource = files_by_name[dir]
+            if resource[:require]
+                resource[:require] << Puppet::Resource::Reference.new(:file, path)
             else
-                return {}
+                resource[:require] = [Puppet::Resource::Reference.new(:file, path)]
             end
         end
-        
-        # Hack things a bit so we only ever check the ensure property.
-        def properties
-            []
+
+        return result
+    end
+
+    # Does a given path match our glob patterns, if any?  Return true
+    # if no patterns have been provided.
+    def matches?(path)
+        return true unless self[:matches]
+
+        basename = File.basename(path)
+        flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
+        if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
+            return true
+        else
+            debug "No specified patterns match %s, not tidying" % path
+            return false
         end
     end
-end
 
+    # Should we remove the specified file?
+    def tidy?(path)
+        return false unless stat = self.stat(path)
+
+        return false if stat.ftype == "directory" and ! rmdirs?
+
+        # The 'matches' parameter isn't OR'ed with the other tests --
+        # it's just used to reduce the list of files we can match.
+        return false if param = parameter(:matches) and ! param.tidy?(path, stat)
+
+        tested = false
+        [:age, :size].each do |name|
+            next unless param = parameter(name)
+            tested = true
+            return true if param.tidy?(path, stat)
+        end
+
+        # If they don't specify either, then the file should always be removed.
+        return true unless tested
+        return false
+    end
+
+    def stat(path)
+        begin
+            File.lstat(path)
+        rescue Errno::ENOENT => error
+            info "File does not exist"
+            return nil
+        rescue Errno::EACCES => error
+            warning "Could not stat; permission denied"
+            return nil
+        end
+    end
+end