puppet 0.9.2

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

@@ -0,0 +1,219 @@
+# Keep a copy of the file checksums, and notify when they change.
+
+# This state never actually modifies the system, it only notices when the system
+# changes on its own.
+module Puppet
+    class State
+        class PFileChecksum < Puppet::State
+            @doc = "How to check whether a file has changed.  **md5**/*lite-md5*/
+                *time*/*mtime*"
+            @name = :checksum
+            @event = :file_modified
+
+            @unmanaged = true
+
+            @validtypes = %w{md5 md5lite timestamp mtime time}
+
+            def self.validtype?(type)
+                @validtypes.include?(type)
+            end
+
+            def checktype
+                @checktypes[0]
+            end
+
+            def getsum(checktype)
+                sum = ""
+                case checktype
+                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.name)
+                        return
+                    else
+                        begin
+                            File.open(@parent[:path]) { |file|
+                                text = nil
+                                if checktype == "md5"
+                                    text = file.read
+                                else
+                                    text = file.read(512)
+                                end
+                                if text.nil?
+                                    self.info "Not checksumming empty file %s" %
+                                        @parent.name
+                                    sum = 0
+                                else
+                                    sum = Digest::MD5.hexdigest(text)
+                                end
+                            }
+                        rescue Errno::EACCES => detail
+                            self.notice "Cannot checksum %s: permission denied" %
+                                @parent.name
+                            @parent.delete(self.class.name)
+                        rescue => detail
+                            self.notice "Cannot checksum %s: %s" %
+                                detail
+                            @parent.delete(self.class.name)
+                        end
+                    end
+                when "timestamp","mtime":
+                    sum = File.stat(@parent[:path]).mtime.to_s
+                when "time":
+                    sum = File.stat(@parent[:path]).ctime.to_s
+                else
+                    raise Puppet::Error, "Invalid sum type %s" % checktype
+                end
+
+                return sum
+            end
+
+            # Convert from the sum type to the stored checksum.
+            def shouldprocess(value)
+                unless defined? @checktypes
+                    @checktypes = []
+                end
+                unless self.class.validtype?(value)
+                    raise Puppet::Error, "Invalid checksum type '%s'" % value
+                end
+
+                @checktypes << value
+                state = Puppet::Storage.state(self)
+                if hash = state[@parent[:path]]
+                    if hash.include?(value)
+                        return hash[value]
+                        #@parent.debug "Found checksum %s for %s" %
+                        #    [self.should,@parent[:path]]
+                    else
+                        #@parent.debug "Found checksum for %s but not of type %s" %
+                        #    [@parent[:path],@checktype]
+                        return :nosum
+                    end
+                else
+                    # We can't use :notfound here, because then it'll match on
+                    # non-existent files
+                    return :nosum
+                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
+                unless defined? @checktypes
+                    @checktypes = ["md5"]
+                end
+
+                unless FileTest.exists?(@parent.name)
+                    self.is = :notfound
+                    return
+                end
+
+                # Just use the first allowed check type
+                @is = getsum(@checktypes[0])
+
+                # If there is no should defined, then store the current value
+                # into the 'should' value, so that we're not marked as being
+                # out of sync.  We don't want to generate an event the first
+                # time we get a sum.
+                if ! defined? @should or @should == [:nosum]
+                    @should = [@is]
+                    # FIXME we should support an updatechecksums-like mechanism
+                    self.updatesum
+                end
+
+                #@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 == :notfound
+                    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 == :notfound
+                        # 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.name
+                            )
+                        end
+                        return nil
+                    end
+                end
+
+                # If the sums are different, then return an event.
+                if self.updatesum
+                    return :file_modified
+                else
+                    return nil
+                end
+            end
+
+            # Store the new sum to the state db.
+            def updatesum
+                result = false
+                state = Puppet::Storage.state(self)
+                unless state.include?(@parent.name)
+                    self.debug "Initializing state hash"
+
+                    state[@parent.name] = Hash.new
+                end
+
+                if @is.is_a?(Symbol)
+                    error = Puppet::Error.new("%s has invalid checksum" %
+                        @parent.name)
+                    raise error
+                #elsif @should == :notfound
+                #    error = Puppet::Error.new("%s has invalid 'should' checksum" %
+                #        @parent.name)
+                #    raise error
+                end
+
+                # if we're replacing, vs. updating
+                if state[@parent.name].include?(@checktypes[0])
+                    unless defined? @should
+                        raise Puppet::Error.new(
+                            ("@should is not initialized for %s, even though we " +
+                            "found a checksum") % @parent[:path]
+                        )
+                    end
+                    self.debug "Replacing %s checksum %s with %s" %
+                        [@parent.name, state[@parent.name][@checktypes[0]],@is]
+                    #@parent.debug "@is: %s; @should: %s" % [@is,@should]
+                    result = true
+                else
+                    @parent.debug "Creating checksum %s of type %s" %
+                        [@is,@checktypes[0]]
+                    result = false
+                end
+                state[@parent.name][@checktypes[0]] = @is
+                return result
+            end
+        end
+    end
+end
+
+# $Id: checksum.rb 731 2005-10-26 04:44:25Z luke $

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

@@ -0,0 +1,108 @@
+module Puppet
+    class State
+        class PFileCreate < Puppet::State
+            require 'etc'
+            @doc = "Whether to create files that don't currently exist.
+                **false**/*true*/*file*/*directory*"
+            @name = :create
+            @event = :file_created
+
+            def shouldprocess(value)
+                # default to just about anything meaning 'true'
+                case value
+                when "false", false, nil:
+                    return false
+                when "true", true, "file", "plain", /^f/:
+                    return "file"
+                when "directory", /^d/:
+                    return "directory"
+                when :notfound:
+                    # this is where a creation is being rolled back
+                    return :notfound
+                else
+                    raise Puppet::Error, "Cannot create files of type %s" % value
+                end
+            end
+
+            def retrieve
+                if stat = @parent.stat(true)
+                    @is = stat.ftype
+                else
+                    @is = :notfound
+                end
+
+                #self.debug "'exists' state is %s" % self.is
+            end
+
+
+            def sync
+                event = nil
+                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]))
+                    }
+
+                    # 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)
+                    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.name,mode)
+                            else
+                                Dir.mkdir(@parent.name)
+                            end
+                        }
+                        event = :directory_created
+                    when :notfound:
+                        # 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.name) == 0
+                            raise Puppet::Error.new(
+                                "Created file %s has since been modified; cannot roll back."
+                            )
+                        end
+
+                        File.unlink(@parent.name)
+                    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
+end
+
+# $Id: create.rb 731 2005-10-26 04:44:25Z luke $

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

@@ -0,0 +1,129 @@
+# Manage file group ownership.
+module Puppet
+    class State
+        class PFileGroup < Puppet::State
+            require 'etc'
+            @doc = "Which group should own the file.  Argument can be either group
+                name or group ID."
+            @name = :group
+            @event = :inode_changed
+
+            def id2name(id)
+                begin
+                    group = Etc.getgrgid(id)
+                rescue ArgumentError
+                    return nil
+                end
+                if group.gid == ""
+                    return nil
+                else
+                    return group.name
+                end
+            end
+
+            # We want to print names, not numbers
+            def is_to_s
+                id2name(@is) || @is
+            end
+
+            def should_to_s
+                id2name(self.should) || self.should
+            end
+
+            def retrieve
+                stat = @parent.stat(true)
+
+                self.is = stat.gid
+            end
+
+            def shouldprocess(value)
+                method = nil
+                gid = nil
+                gname = nil
+
+                if value.is_a?(Integer)
+                    method = :getgrgid
+                else
+                    method = :getgrnam
+                end
+
+                begin
+                    group = Etc.send(method,value)
+
+                    # at one time, os x was putting the gid into the passwd
+                    # field of the group struct, but that appears to not
+                    # be the case any more
+                    #os = Puppet::Fact["Operatingsystem"]
+                    #case os
+                    #when "Darwin":
+                    #    #gid = group.passwd
+                    #    gid = group.gid
+                    #else
+                    #end
+
+                    gid = group.gid
+                    gname = group.name
+
+                rescue ArgumentError => detail
+                    raise Puppet::Error.new(
+                        "Could not find group %s" % value)
+                rescue => detail
+                    raise Puppet::Error.new(
+                        "Could not find group %s: %s" % [self.should,detail])
+                end
+                if gid.nil?
+                    raise Puppet::Error.new(
+                        "Could not retrieve gid for %s" % @parent.name)
+                end
+
+                #unless Process.uid == 0
+                #    groups = %x{groups}.chomp.split(/\s/)
+                #    unless groups.include?(gname)
+                #        self.notice "Cannot chgrp: not in group %s" % gname
+                #        raise Puppet::Error.new(
+                #            "Cannot chgrp: not in group %s" % gname)
+                #    end
+                #end
+
+                if gid.nil?
+                    raise Puppet::Error.new(
+                        "Nil gid for %s" % @parent.name)
+                else
+                    return gid
+                end
+            end
+
+            # Normal users will only be able to manage certain groups.  Right now,
+            # we'll just let it fail, but we should probably set things up so
+            # that users get warned if they try to change to an unacceptable group.
+            def sync
+                if @is == :notfound
+                    @parent.stat(true)
+                    self.retrieve
+
+                    if @is == :notfound
+                        self.err "File '%s' does not exist; cannot chgrp" %
+                            @parent[:path]
+                        return nil
+                    end
+
+                    if self.insync?
+                        return nil
+                    end
+                end
+
+                begin
+                    # set owner to nil so it's ignored
+                    File.chown(nil,self.should,@parent[:path])
+                rescue => detail
+                    error = Puppet::Error.new( "failed to chgrp %s to %s: %s" %
+                        [@parent[:path], self.should, detail.message])
+                    raise error
+                end
+                return :inode_changed
+            end
+        end
+    end
+end
+
+# $Id: group.rb 731 2005-10-26 04:44:25Z luke $