puppet 0.13.6 → 0.16.0

data/lib/puppet/type/pfile/checksum.rb

@@ -16,6 +16,43 @@ module Puppet
             @validtypes.include?(type)
         end
 
+        @validtypes.each do |ctype|
+            newvalue(ctype) do
+                handlesum()
+            end
+        end
+
+        str = @validtypes.join("|")
+
+        newvalue(/^\{#{str}\}/) do
+            handlesum()
+        end
+
+        newvalue(:nosum) do
+            # nothing
+            :nochange
+        end
+
+        # Convert from the sum type to the stored checksum.
+        munge do |value|
+            unless defined? @checktypes
+                @checktypes = []
+            end
+
+            if value =~ /^\{(\w+)\}(.+)$/
+                @checktypes << $1
+                #return $2
+                return value
+            else
+                if FileTest.directory?(@parent[:path])
+                    value = "time"
+                end
+                value = super(value)
+                @checktypes << value
+                return getcachedsum()
+            end
+        end
+
         def checktype
             @checktypes[0]
         end
@@ -80,15 +117,17 @@ module Puppet
         # Calculate the sum from disk.
         def getsum(checktype)
             sum = ""
+
+            checktype = checktype.intern if checktype.is_a? String
             case checktype
-            when "md5", "md5lite":
+            when :md5, :md5lite:
                 unless FileTest.file?(@parent[:path])
                     @parent.info "Cannot MD5 sum directory %s" %
                         @parent[:path]
 
-                    # because we cannot sum directories, just delete ourselves
-                    # from the file so we won't sync
-                    @parent.delete(self[:path])
+                    @should = [nil]
+                    @is = nil
+                    #@parent.delete(self[:path])
                     return
                 else
                     begin
@@ -100,7 +139,7 @@ module Puppet
                                 text = file.read(512)
                             end
                             if text.nil?
-                                self.info "Not checksumming empty file %s" %
+                                self.debug "Not checksumming empty file %s" %
                                     @parent[:path]
                                 sum = 0
                             else
@@ -117,35 +156,60 @@ module Puppet
                         @parent.delete(self.class.name)
                     end
                 end
-            when "timestamp","mtime":
+            when :timestamp, :mtime:
                 sum = @parent.stat.mtime.to_s
                 #sum = File.stat(@parent[:path]).mtime.to_s
-            when "time":
+            when :time:
                 sum = @parent.stat.ctime.to_s
                 #sum = File.stat(@parent[:path]).ctime.to_s
             else
                 raise Puppet::Error, "Invalid sum type %s" % checktype
             end
 
-            return sum
+            return "{#{checktype}}" + sum.to_s
+            #return sum.to_s
         end
 
-        # Convert from the sum type to the stored checksum.
-        munge do |value|
-            unless defined? @checktypes
-                @checktypes = []
-            end
-            unless self.class.validtype?(value)
-                self.fail "Invalid checksum type '%s'" % value
+        # At this point, we don't actually modify the system, we modify
+        # the stored state to reflect the current state, and then kick
+        # off an event to mark any changes.
+        def handlesum
+            if @is.nil?
+                raise Puppet::Error, "Checksum state for %s is somehow nil" %
+                    @parent.name
             end
 
-            if FileTest.directory?(@parent[:path])
-                value = "time"
-            end
+            if @is == :absent
+                self.retrieve
+
+                if self.insync?
+                    self.debug "Checksum is already in sync"
+                    return nil
+                end
+                #@parent.debug "%s(%s): after refresh, is '%s'" %
+                #    [self.class.name,@parent.name,@is]
 
-            @checktypes << value
+                # If we still can't retrieve a checksum, it means that
+                # the file still doesn't exist
+                if @is == :absent
+                    # if they're copying, then we won't worry about the file
+                    # not existing yet
+                    unless @parent.state(:source)
+                        self.warning(
+                            "File %s does not exist -- cannot checksum" %
+                            @parent[:path]
+                        )
+                    end
+                    return nil
+                end
+            end
 
-            return getcachedsum()
+            # If the sums are different, then return an event.
+            if self.updatesum
+                return :file_changed
+            else
+                return nil
+            end
         end
 
         # Even though they can specify multiple checksums, the insync?
@@ -156,12 +220,20 @@ module Puppet
                 @checktypes = ["md5"]
             end
 
-            unless FileTest.exists?(@parent[:path])
+            stat = nil
+            unless stat = @parent.stat
                 self.is = :absent
                 return
             end
 
-            if FileTest.directory?(@parent[:path]) and @checktypes[0] =~ /md5/
+            if stat.ftype == "link" and @parent[:links] != :follow
+                self.debug "Not checksumming symlink"
+                #@parent.delete(:checksum)
+                self.is = self.should
+                return
+            end
+
+            if stat.ftype == "directory" and @checktypes[0] =~ /md5/
                 @checktypes = ["time"]
             end
 
@@ -187,49 +259,6 @@ module Puppet
             #@parent.debug "checksum state is %s" % self.is
         end
 
-
-        # At this point, we don't actually modify the system, we modify
-        # the stored state to reflect the current state, and then kick
-        # off an event to mark any changes.
-        def sync
-            if @is.nil?
-                raise Puppet::Error, "Checksum state for %s is somehow nil" %
-                    @parent.name
-            end
-
-            if @is == :absent
-                self.retrieve
-
-                if self.insync?
-                    self.debug "Checksum is already in sync"
-                    return nil
-                end
-                #@parent.debug "%s(%s): after refresh, is '%s'" %
-                #    [self.class.name,@parent.name,@is]
-
-                # If we still can't retrieve a checksum, it means that
-                # the file still doesn't exist
-                if @is == :absent
-                    # if they're copying, then we won't worry about the file
-                    # not existing yet
-                    unless @parent.state(:source)
-                        self.warning(
-                            "File %s does not exist -- cannot checksum" %
-                            @parent[:path]
-                        )
-                    end
-                    return nil
-                end
-            end
-
-            # If the sums are different, then return an event.
-            if self.updatesum
-                return :file_changed
-            else
-                return nil
-            end
-        end
-
         # Store the new sum to the state db.
         def updatesum
             result = false
@@ -259,8 +288,7 @@ module Puppet
                 #@parent.debug "@is: %s; @should: %s" % [@is,@should]
                 result = true
             else
-                @parent.debug "Creating checksum %s of type %s" %
-                    [@is,@checktypes[0]]
+                @parent.debug "Creating checksum %s" % @is
                 result = false
             end
             state[@checktypes[0]] = @is
@@ -269,4 +297,4 @@ module Puppet
     end
 end
 
-# $Id: checksum.rb 947 2006-02-25 00:26:14Z luke $
+# $Id: checksum.rb 1126 2006-04-20 20:55:02Z luke $

data/lib/puppet/type/pfile/content.rb

@@ -27,10 +27,23 @@ module Puppet
         # We should probably take advantage of existing md5 sums if they're there,
         # but I really don't feel like dealing with the complexity right now.
         def retrieve
-            unless FileTest.exists?(@parent[:path])
+            stat = nil
+            unless stat = @parent.stat
                 @is = :absent
                 return
             end
+
+            if stat.ftype == "link" and @parent[:links] == :ignore
+                self.is = self.should
+                return
+            end
+
+            # Don't even try to manage the content on directories
+            if stat.ftype == "directory" and @parent[:links] == :ignore
+                @parent.delete(:content)
+                return
+            end
+
             begin
                 @is = File.read(@parent[:path])
             rescue => detail
@@ -43,17 +56,7 @@ module Puppet
 
         # Just write our content out to disk.
         def sync
-            begin
-                File.open(@parent[:path], "w") { |f|
-                    f.print self.should
-                    f.flush
-                }
-            rescue => detail
-                raise Puppet::Error, "Could not write content to %s: %s" %
-                    [@parent.name, detail]
-            end
-
-            @parent.setchecksum
+            @parent.write { |f| f.print self.should }
 
             if @is == :absent
                 return :file_created
@@ -64,4 +67,4 @@ module Puppet
     end
 end
 
-# $Id: content.rb 922 2006-02-16 19:10:34Z luke $
+# $Id: content.rb 1125 2006-04-20 19:38:48Z luke $

data/lib/puppet/type/pfile/ensure.rb

@@ -3,11 +3,32 @@ module Puppet
         require 'etc'
         desc "Whether to create files that don't currently exist.
             Possible values are *absent*, *present* (equivalent to *file*),
-            **file**/*directory*.  Specifying 'absent' will delete the file,
+            *file*, and *directory*.  Specifying 'absent' will delete the file,
             although currently this will not recursively delete directories.
+
+            Anything other than those values will be considered to be a symlink.
+            For instance, the following text creates a link::
+                
+                # Useful on solaris
+                file { \"/etc/inetd.conf\":
+                    ensure => \"/etc/inet/inetd.conf\"
+                }
             
-            This is the only element with an *ensure* state that does not have
-            a default value."
+            You can make relative links:
+                
+                # Useful on solaris
+                file { \"/etc/inetd.conf\":
+                    ensure => \"inet/inetd.conf\"
+                }
+
+            If you need to make a relative link to a file named the same
+            as one of the valid values, you must prefix it with ``./`` or
+            something similar.
+
+            You can also make recursive symlinks, which will create a
+            directory structure that maps to the target directory,
+            with directories corresponding to each directory
+            and links corresponding to each file."
 
         # Most 'ensure' states have a default, but with files we, um, don't.
         nodefault
@@ -23,21 +44,8 @@ module Puppet
             if state = @parent.state(:content) or state = @parent.state(:source)
                 state.sync
             else
+                @parent.write(false) { |f| f.flush }
                 mode = @parent.should(:mode)
-                Puppet::Util.asuser(asuser(), @parent.should(:group)) {
-                    f = nil
-                    if mode
-                        Puppet::Util.withumask(000) do
-                            f = File.open(@parent[:path],"w", mode)
-                        end
-                    else
-                        f = File.open(@parent[:path],"w")
-                    end
-
-                    f.flush
-                    f.close
-                    @parent.setchecksum
-                }
             end
             return :file_created
         end
@@ -52,7 +60,7 @@ module Puppet
                     "Cannot create %s; parent directory %s does not exist" %
                         [@parent[:path], parent]
             end
-            Puppet::Util.asuser(asuser()) {
+            Puppet::Util.asuser(@parent.asuser()) {
                 if mode
                     Puppet::Util.withumask(000) do
                         Dir.mkdir(@parent[:path],mode)
@@ -65,23 +73,39 @@ module Puppet
             return :directory_created
         end
 
-        def asuser
-            if @parent.should(:owner) and ! @parent.should(:owner).is_a?(Symbol)
-                writeable = Puppet::Util.asuser(@parent.should(:owner)) {
-                    FileTest.writable?(File.dirname(@parent[:path]))
-                }
 
-                # If the parent directory is writeable, then we execute
-                # as the user in question.  Otherwise we'll rely on
-                # the 'owner' state to do things.
-                if writeable
-                    asuser = @parent.should(:owner)
+        newvalue(:link) do
+            if state = @parent.state(:target)
+                state.retrieve
+
+                if state.linkmaker
+                    self.set_directory
+                    return :directory_created
+                else
+                    return state.sync
                 end
+            else
+                self.fail "Cannot create a symlink without a target"
             end
+        end
+
+        # Symlinks.
+        newvalue(/./) do
+            # This code never gets executed.  We need the regex to support
+            # specifying it, but the work is done in the 'symlink' code block.
+        end
 
-            return asuser
+        munge do |value|
+            value = super(value)
+
+            return value if value.is_a? Symbol
+
+            @parent[:target] = value
+
+            return :link
         end
 
+        # Check that we can actually create anything
         def check
             basedir = File.dirname(@parent[:path])
 
@@ -106,112 +130,26 @@ module Puppet
                     @is = :absent
                 end
             end
-
-            #self.debug "'exists' state is %s" % self.is
         end
 
+        def sync
+            event = super
 
-        # We can mostly rely on the superclass method, but we want other states
-        # to take precedence over 'ensure' if they are present.
-#        def sync
-#            # XXX This is a bad idea, because it almost guarantees bugs if we
-#            # introduce more states to manage content, but anything else is just
-#            # about as bad.
-#            event = nil
-#            #if state = @parent.state(:source) or state = @parent.state(:content)
-#            #    event = state.sync
-#            #else
-#                event = super
-#                @parent.setchecksum
-#            #end
-#            return event
-#        end
-
-        def disabled_sync
-            event = nil
-            basedir = File.dirname(@parent[:path])
-
-            if ! FileTest.exists?(basedir)
-                raise Puppet::Error,
-                    "Can not create %s; parent directory does not exist" %
-                    @parent.name
-            elsif ! FileTest.directory?(basedir)
-                raise Puppet::Error,
-                    "Can not create %s; %s is not a directory" %
-                    [@parent.name, dirname]
-            end
-
-            self.retrieve
-            if self.insync?
-                self.info "already in sync"
-                return nil
-            end
-
-            mode = @parent.should(:mode)
-
-            # First, determine if a user has been specified and if so if
-            # that user has write access to the parent dir
-            asuser = nil
-            if @parent.should(:owner) and ! @parent.should(:owner).is_a?(Symbol)
-                writeable = Puppet::Util.asuser(@parent.should(:owner)) {
-                    FileTest.writable?(File.dirname(@parent[:path]))
-                }
+            # There are some cases where all of the work does not get done on
+            # file creation, so we have to do some extra checking.
+            @parent.each do |thing|
+                next unless thing.is_a? Puppet::State
+                next if thing == self
 
-                # If the parent directory is writeable, then we execute
-                # as the user in question.  Otherwise we'll rely on
-                # the 'owner' state to do things.
-                if writeable
-                    asuser = @parent.should(:owner)
+                thing.retrieve
+                unless thing.insync?
+                    thing.sync
                 end
             end
-            begin
-                case self.should
-                when "file":
-                    # just create an empty file
-                    Puppet::Util.asuser(asuser, @parent.should(:group)) {
-                        if mode
-                            File.open(@parent[:path],"w", mode) {
-                            }
-                        else
-                            File.open(@parent[:path],"w") {
-                            }
-                        end
-                    }
-                    event = :file_created
-                when "directory":
-                    Puppet::Util.asuser(asuser) {
-                        if mode
-                            Dir.mkdir(@parent[:path],mode)
-                        else
-                            Dir.mkdir(@parent[:path])
-                        end
-                    }
-                    event = :directory_created
-                when :absent:
-                    # this is where the file should be deleted...
-
-                    # This value is only valid when we're rolling back a creation,
-                    # so we verify that the file has not been modified since then.
-                    unless FileTest.size(@parent[:path]) == 0
-                        raise Puppet::Error.new(
-                            "Created file %s has since been modified; cannot roll back."
-                        )
-                    end
 
-                    File.unlink(@parent[:path])
-                else
-                    error = Puppet::Error.new(
-                        "Somehow got told to create a %s file" % self.should)
-                    raise error
-                end
-            rescue => detail
-                raise Puppet::Error.new("Could not create %s: %s" %
-                    [self.should, detail]
-                )
-            end
             return event
         end
     end
 end
 
-# $Id: ensure.rb 966 2006-03-02 17:12:26Z luke $
+# $Id: ensure.rb 1123 2006-04-20 05:14:13Z luke $