puppet 0.22.4 → 0.23.0

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

@@ -49,7 +49,7 @@ module Puppet
                 cache(type, sum)
                 return type
             else
-                if FileTest.directory?(@parent[:path])
+                if FileTest.directory?(@resource[:path])
                     return :time
                 else
                     return symbolize(value)
@@ -64,10 +64,10 @@ module Puppet
                 raise ArgumentError, "A type must be specified to cache a checksum"
             end
             type = symbolize(type)
-            unless state = @parent.cached(:checksums) 
+            unless state = @resource.cached(:checksums) 
                 self.debug "Initializing checksum hash"
                 state = {}
-                @parent.cache(:checksums, state)
+                @resource.cache(:checksums, state)
             end
 
             if sum
@@ -83,9 +83,8 @@ module Puppet
         # Because source and content and whomever else need to set the checksum
         # and do the updating, we provide a simple mechanism for doing so.
         def checksum=(value)
-            @is = value
             munge(@should)
-            self.updatesum
+            self.updatesum(value)
         end
 
         def checktype
@@ -93,21 +92,21 @@ module Puppet
         end
 
         # Checksums need to invert how changes are printed.
-        def change_to_s
+        def change_to_s(currentvalue, newvalue)
             begin
-                if @is == :absent
+                if currentvalue == :absent
                     return "defined '%s' as '%s'" %
                         [self.name, self.currentsum]
-                elsif self.should == :absent
+                elsif newvalue == :absent
                     return "undefined %s from '%s'" %
-                        [self.name, self.is_to_s]
+                        [self.name, self.is_to_s(currentvalue)]
                 else
                     if defined? @cached and @cached
                         return "%s changed '%s' to '%s'" %
-                            [self.name, @cached, self.is_to_s]
+                            [self.name, @cached, self.is_to_s(currentvalue)]
                     else
                         return "%s changed '%s' to '%s'" %
-                            [self.name, self.currentsum, self.is_to_s]
+                            [self.name, self.currentsum, self.is_to_s(currentvalue)]
                     end
                 end
             rescue Puppet::Error, Puppet::DevError
@@ -126,16 +125,16 @@ module Puppet
         # Retrieve the cached sum
         def getcachedsum
             hash = nil
-            unless hash = @parent.cached(:checksums) 
+            unless hash = @resource.cached(:checksums) 
                 hash = {}
-                @parent.cache(:checksums, hash)
+                @resource.cache(:checksums, hash)
             end
 
             sumtype = self.should
 
             if hash.include?(sumtype)
                 #self.notice "Found checksum %s for %s" %
-                #    [hash[sumtype] ,@parent[:path]]
+                #    [hash[sumtype] ,@resource[:path]]
                 sum = hash[sumtype]
 
                 unless sum =~ /^\{\w+\}/
@@ -147,7 +146,7 @@ module Puppet
                 return :nosum
             else
                 #self.notice "Found checksum for %s but not of type %s" %
-                #    [@parent[:path],sumtype]
+                #    [@resource[:path],sumtype]
                 return :nosum
             end
         end
@@ -159,45 +158,39 @@ module Puppet
             checktype = checktype.intern if checktype.is_a? String
             case checktype
             when :md5, :md5lite:
-                if ! FileTest.file?(@parent[:path])
-                    @parent.debug "Cannot MD5 sum %s; using mtime" %
-                        [@parent.stat.ftype]
-                    sum = @parent.stat.mtime.to_s
+                if ! FileTest.file?(@resource[:path])
+                    @resource.debug "Cannot MD5 sum %s; using mtime" %
+                        [@resource.stat.ftype]
+                    sum = @resource.stat.mtime.to_s
                 else
                     begin
-                        File.open(@parent[:path]) { |file|
-                            text = nil
-                            case checktype
-                            when :md5
-                                text = file.read
-                            when :md5lite
-                                text = file.read(512)
-                            end
-
-                            if text.nil?
-                                self.debug "Not checksumming empty file %s" %
-                                    @parent[:path]
-                                sum = 0
-                            else
-                                sum = Digest::MD5.hexdigest(text)
-                            end
+                        File.open(@resource[:path]) { |file|
+                            hashfunc = Digest::MD5.new
+                            while (!file.eof)
+                                readBuf = file.read(512)
+                                hashfunc.update(readBuf)
+                                if checktype == :md5lite then
+                                   break
+                                end
+                             end
+                            sum = hashfunc.hexdigest
                         }
                     rescue Errno::EACCES => detail
                         self.notice "Cannot checksum %s: permission denied" %
-                            @parent[:path]
-                        @parent.delete(self.class.name)
+                            @resource[:path]
+                        @resource.delete(self.class.name)
                     rescue => detail
                         self.notice "Cannot checksum: %s" %
                             detail
-                        @parent.delete(self.class.name)
+                        @resource.delete(self.class.name)
                     end
                 end
             when :timestamp, :mtime:
-                sum = @parent.stat.mtime.to_s
-                #sum = File.stat(@parent[:path]).mtime.to_s
+                sum = @resource.stat.mtime.to_s
+                #sum = File.stat(@resource[:path]).mtime.to_s
             when :time:
-                sum = @parent.stat.ctime.to_s
-                #sum = File.stat(@parent[:path]).ctime.to_s
+                sum = @resource.stat.ctime.to_s
+                #sum = File.stat(@resource[:path]).ctime.to_s
             else
                 raise Puppet::Error, "Invalid sum type %s" % checktype
             end
@@ -209,80 +202,75 @@ module Puppet
         # the stored state to reflect the current state, and then kick
         # off an event to mark any changes.
         def handlesum
-            if @is.nil?
+            currentvalue = self.retrieve
+            if currentvalue.nil?
                 raise Puppet::Error, "Checksum state for %s is somehow nil" %
-                    @parent.title
+                    @resource.title
             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 self.insync?(currentvalue)
+                self.debug "Checksum is already in sync"
+                return nil
+            end
+            # @resource.debug "%s(%s): after refresh, is '%s'" %
+                #    [self.class.name,@resource.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.property(:source)
-                        self.warning(
-                            "File %s does not exist -- cannot checksum" %
-                            @parent[:path]
-                        )
-                    end
-                    return nil
+            if currentvalue == :absent
+                # if they're copying, then we won't worry about the file
+                # not existing yet
+                unless @resource.property(:source)
+                    self.warning("File %s does not exist -- cannot checksum" %
+                                     @resource[:path]
+                                 )
                 end
+                return nil
             end
-
+            
             # If the sums are different, then return an event.
-            if self.updatesum
+            if self.updatesum(currentvalue)
                 return :file_changed
             else
                 return nil
             end
         end
 
-        def insync?
-            @should = [checktype]
+        def insync?(currentvalue)
+            @should = [checktype()]
             if cache(checktype())
-                return @is == currentsum()
+                return currentvalue == currentsum()
             else
                 # If there's no cached sum, then we don't want to generate
                 # an event.
                 return true
             end
         end
-
+        
         # Even though they can specify multiple checksums, the insync?
         # mechanism can really only test against one, so we'll just retrieve
         # the first specified sum type.
         def retrieve(usecache = false)
             # When the 'source' is retrieving, it passes "true" here so
             # that we aren't reading the file twice in quick succession, yo.
-            if usecache and @is
-                return @is
+            currentvalue = currentsum()
+            if usecache and currentvalue
+               return currentvalue
             end
 
             stat = nil
-            unless stat = @parent.stat
-                self.is = :absent
-                return
+            unless stat = @resource.stat
+                return :absent
             end
 
-            if stat.ftype == "link" and @parent[:links] != :follow
+            if stat.ftype == "link" and @resource[:links] != :follow
                 self.debug "Not checksumming symlink"
-                #@parent.delete(:checksum)
-                self.is = self.currentsum
-                return
+                # @resource.delete(:checksum)
+                return currentvalue
             end
 
             # Just use the first allowed check type
-            @is = getsum(checktype())
+            currentvalue = getsum(checktype())
 
             # If there is no sum defined, then store the current value
             # into the cache, so that we're not marked as being
@@ -290,18 +278,19 @@ module Puppet
             # time we get a sum.
             unless cache(checktype())
                 # FIXME we should support an updatechecksums-like mechanism
-                self.updatesum
+                self.updatesum(currentvalue)
             end
-
-            #@parent.debug "checksum state is %s" % self.is
+            
+            # @resource.debug "checksum state is %s" % self.is
+            return currentvalue
         end
 
         # Store the new sum to the state db.
-        def updatesum
+        def updatesum(newvalue)
             result = false
 
-            if @is.is_a?(Symbol)
-                raise Puppet::Error, "%s has invalid checksum" % @parent.title
+            if newvalue.is_a?(Symbol)
+                raise Puppet::Error, "%s has invalid checksum" % @resource.title
             end
 
             # if we're replacing, vs. updating
@@ -309,32 +298,30 @@ module Puppet
                 # unless defined? @should
                 #     raise Puppet::Error.new(
                 #         ("@should is not initialized for %s, even though we " +
-                #         "found a checksum") % @parent[:path]
+                #         "found a checksum") % @resource[:path]
                 #     )
                 # end
                 
-                if @is == sum
+                if newvalue == sum
                     return false
                 end
 
-                #if cache(self.should) == @is
-                #    raise Puppet::Error, "Got told to update same sum twice"
-                #end
                 self.debug "Replacing %s checksum %s with %s" %
-                    [@parent.title, sum, @is]
-                #@parent.debug "@is: %s; @should: %s" % [@is,@should]
+                    [@resource.title, sum, newvalue]
+                # @resource.debug "currentvalue: %s; @should: %s" % 
+                #    [newvalue,@should]
                 result = true
             else
-                @parent.debug "Creating checksum %s" % @is
+                @resource.debug "Creating checksum %s" % newvalue
                 result = false
             end
 
             # Cache the sum so the log message can be right if possible.
             @cached = sum
-            cache(checktype(), @is)
+            cache(checktype(), newvalue)
             return result
         end
     end
 end
 
-# $Id: checksum.rb 2169 2007-02-07 06:47:10Z luke $
+# $Id: checksum.rb 2629 2007-06-19 22:18:55Z luke $

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

@@ -20,13 +20,13 @@ module Puppet
             This attribute is especially useful when used with
             `PuppetTemplating templating`:trac:."
 
-        def change_to_s
-            should = "{md5}" + Digest::MD5.hexdigest(self.should)
-            if @is == :absent
-                return "created file with contents %s" % should
+        def change_to_s(currentvalue, newvalue)
+            newvalue = "{md5}" + Digest::MD5.hexdigest(newvalue)
+            if currentvalue == :absent
+                return "created file with contents %s" % newvalue
             else
-                is = "{md5}" + Digest::MD5.hexdigest(@is)
-                return "changed file contents from %s to %s" % [is, should]
+                currentvalue = "{md5}" + Digest::MD5.hexdigest(currentvalue)
+                return "changed file contents from %s to %s" % [currentvalue, newvalue]
             end
         end
 
@@ -34,43 +34,39 @@ module Puppet
         # but I really don't feel like dealing with the complexity right now.
         def retrieve
             stat = nil
-            unless stat = @parent.stat
-                @is = :absent
-                return
+            unless stat = @resource.stat
+                return :absent
             end
 
-            if stat.ftype == "link" and @parent[:links] == :ignore
-                self.is = self.should
-                return
+            if stat.ftype == "link" and @resource[:links] == :ignore
+                return self.should
             end
 
             # Don't even try to manage the content on directories
-            if stat.ftype == "directory" and @parent[:links] == :ignore
-                @parent.delete(:content)
-                return
+            if stat.ftype == "directory" and @resource[:links] == :ignore
+                @resource.delete(:content)
+                return nil
             end
 
             begin
-                @is = File.read(@parent[:path])
+                currentvalue = File.read(@resource[:path])
+                return currentvalue
             rescue => detail
-                @is = nil
                 raise Puppet::Error, "Could not read %s: %s" %
-                    [@parent.title, detail]
+                    [@resource.title, detail]
             end
         end
 
 
         # Just write our content out to disk.
         def sync
-            @parent.write { |f| f.print self.should }
+            return_event = @resource.stat ? :file_changed : :file_created
+            
+            @resource.write { |f| f.print self.should }
 
-            if @is == :absent
-                return :file_created
-            else
-                return :file_changed
-            end
+            return return_event
         end
     end
 end
 
-# $Id: content.rb 2408 2007-04-24 02:41:16Z luke $
+# $Id: content.rb 2500 2007-05-09 22:05:32Z luke $

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

@@ -36,18 +36,18 @@ module Puppet
         nodefault
 
         newvalue(:absent) do
-            File.unlink(@parent[:path])
+            File.unlink(@resource[:path])
         end
 
         aliasvalue(:false, :absent)
 
         newvalue(:file) do
             # Make sure we're not managing the content some other way
-            if property = (@parent.property(:content) || @parent.property(:source))
+            if property = (@resource.property(:content) || @resource.property(:source))
                 property.sync
             else
-                @parent.write(false) { |f| f.flush }
-                mode = @parent.should(:mode)
+                @resource.write(false) { |f| f.flush }
+                mode = @resource.should(:mode)
             end
             return :file_created
         end
@@ -60,30 +60,30 @@ module Puppet
         end
 
         newvalue(:directory) do
-            mode = @parent.should(:mode)
-            parent = File.dirname(@parent[:path])
+            mode = @resource.should(:mode)
+            parent = File.dirname(@resource[:path])
             unless FileTest.exists? parent
                 raise Puppet::Error,
                     "Cannot create %s; parent directory %s does not exist" %
-                        [@parent[:path], parent]
+                        [@resource[:path], parent]
             end
-            @parent.write_if_writable(parent) do
+            @resource.write_if_writable(parent) do
                 if mode
                     Puppet::Util.withumask(000) do
-                        Dir.mkdir(@parent[:path],mode)
+                        Dir.mkdir(@resource[:path],mode)
                     end
                 else
-                    Dir.mkdir(@parent[:path])
+                    Dir.mkdir(@resource[:path])
                 end
             end
-            @parent.send(:property_fix)
-            @parent.setchecksum
+            @resource.send(:property_fix)
+            @resource.setchecksum
             return :directory_created
         end
 
 
         newvalue(:link) do
-            if property = @parent.property(:target)
+            if property = @resource.property(:target)
                 property.retrieve
 
                 return property.mklink
@@ -103,62 +103,64 @@ module Puppet
 
             return value if value.is_a? Symbol
 
-            @parent[:target] = value
+            @resource[:target] = value
 
             return :link
         end
 
-        def change_to_s
-            if property = (@parent.property(:content) || @parent.property(:source)) and ! property.insync?
-                return property.change_to_s
+        def change_to_s(currentvalue, newvalue)
+            if property = (@resource.property(:content) || @resource.property(:source)) and ! property.insync?(currentvalue)
+                currentvalue = property.retrieve
+                
+                return property.change_to_s(property.retrieve, property.should)
             else
-                super
+                super(currentvalue, newvalue)
             end
         end
 
         # Check that we can actually create anything
         def check
-            basedir = File.dirname(@parent[:path])
+            basedir = File.dirname(@resource[:path])
 
             if ! FileTest.exists?(basedir)
                 raise Puppet::Error,
                     "Can not create %s; parent directory does not exist" %
-                    @parent.title
+                    @resource.title
             elsif ! FileTest.directory?(basedir)
                 raise Puppet::Error,
                     "Can not create %s; %s is not a directory" %
-                    [@parent.title, dirname]
+                    [@resource.title, dirname]
             end
         end
 
         # We have to treat :present specially, because it works with any
         # type of file.
-        def insync?
+        def insync?(currentvalue)
             if self.should == :present
-                if @is.nil? or @is == :absent
+                if currentvalue.nil? or currentvalue == :absent
                     return false
                 else
                     return true
                 end
             else
-                return super
+                return super(currentvalue)
             end
         end
 
         def retrieve
-            if stat = @parent.stat(false)
-                @is = stat.ftype.intern
+            if stat = @resource.stat(false)
+                return stat.ftype.intern
             else
                 if self.should == :false
-                    @is = :false
+                    return :false
                 else
-                    @is = :absent
+                    return :absent
                 end
             end
         end
 
         def sync
-            @parent.remove_existing(self.should)
+            @resource.remove_existing(self.should)
             if self.should == :absent
                 return :file_removed
             end
@@ -170,4 +172,4 @@ module Puppet
     end
 end
 
-# $Id: ensure.rb 2408 2007-04-24 02:41:16Z luke $
+# $Id: ensure.rb 2500 2007-05-09 22:05:32Z luke $