puppet 0.9.2 → 0.13.0

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

@@ -0,0 +1,67 @@
+module Puppet
+    Puppet.type(:file).newstate(:content) do
+        desc "Specify the contents of a file as a string.  Newlines, tabs, and spaces
+            can be specified using the escaped syntax (e.g., \\n for a newline).  The
+            primary purpose of this parameter is to provide a kind of limited
+            templating::
+
+                define resolve(nameserver1, nameserver2, domain, search) {
+                    $str = \"search $search
+                domain $domain
+                nameserver $nameserver1
+                nameserver $nameserver2
+                \"
+
+                    file { \"/etc/resolv.conf\":
+                        content => $str
+                    }
+                }
+            
+            Yes, it's very primitive, and it's useless for larger files, but it
+            is mostly meant as a stopgap measure for simple cases."
+
+        def change_to_s
+            "synced"
+        end
+
+        # 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.name)
+                @is = :absent
+                return
+            end
+            begin
+                @is = File.read(@parent.name)
+            rescue => detail
+                @is = nil
+                raise Puppet::Error, "Could not read %s: %s" %
+                    [@parent.name, detail]
+            end
+        end
+
+
+        # Just write our content out to disk.
+        def sync
+            begin
+                File.open(@parent.name, "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
+
+            if @is == :absent
+                return :file_created
+            else
+                return :file_changed
+            end
+        end
+    end
+end
+
+# $Id: content.rb 883 2006-02-08 16:53:34Z luke $

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

@@ -0,0 +1,212 @@
+module Puppet
+    Puppet.type(:file).ensurable do
+        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,
+            although currently this will not recursively delete directories.
+            
+            This is the only element with an *ensure* state that does not have
+            a default value."
+
+        # Most 'ensure' states have a default, but with files we, um, don't.
+        nodefault
+
+        #newvalue(:false) do
+        #    # If they say "false" here, we just don't do anything at all; either
+        #    # the file is there or it's not.
+        #end
+
+        newvalue(:absent) do
+            File.unlink(@parent.name)
+        end
+
+        aliasvalue(:false, :absent)
+
+        newvalue(:file) do
+            # Make sure we're not managing the content some other way
+            if state = @parent.state(:content) or state = @parent.state(:source)
+                state.sync
+            else
+                mode = @parent.should(:mode)
+                Puppet::Util.asuser(asuser(), @parent.should(:group)) {
+                    f = nil
+                    if mode
+                        f = File.open(@parent[:path],"w", mode)
+                    else
+                        f = File.open(@parent[:path],"w")
+                    end
+
+                    f.flush
+                    f.close
+                    @parent.setchecksum
+                }
+            end
+            return :file_created
+        end
+
+        aliasvalue(:present, :file)
+
+        newvalue(:directory) do
+            mode = @parent.should(:mode)
+            Puppet::Util.asuser(asuser()) {
+                if mode
+                    Dir.mkdir(@parent.name,mode)
+                else
+                    Dir.mkdir(@parent.name)
+                end
+            }
+            @parent.setchecksum
+            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)
+                end
+            end
+
+            return asuser
+        end
+
+        def check
+            basedir = File.dirname(@parent.name)
+
+            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
+        end
+
+        def retrieve
+            if stat = @parent.stat(false)
+                @is = stat.ftype.intern
+            else
+                if self.should == :false
+                    @is = :false
+                else
+                    @is = :absent
+                end
+            end
+
+            #self.debug "'exists' state is %s" % self.is
+        end
+
+
+        # 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.name)
+
+            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]))
+                }
+
+                # 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 :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.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
+
+# $Id: ensure.rb 885 2006-02-08 17:44:44Z luke $

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

@@ -1,129 +1,130 @@
 # 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
+    Puppet.type(:file).newstate(:group) do
+        require 'etc'
+        desc "Which group should own the file.  Argument can be either group
+            name or group ID."
+        @event = :file_changed
+
+        def id2name(id)
+            begin
+                group = Etc.getgrgid(id)
+            rescue ArgumentError
+                return nil
             end
-
-            # We want to print names, not numbers
-            def is_to_s
-                id2name(@is) || @is
+            if group.gid == ""
+                return nil
+            else
+                return group.name
             end
+        end
 
-            def should_to_s
-                id2name(self.should) || self.should
-            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)
+        def retrieve
+            stat = @parent.stat(false)
 
+            if stat
                 self.is = stat.gid
+            else
+                self.is = :absent
             end
+        end
 
-            def shouldprocess(value)
-                method = nil
-                gid = nil
-                gname = nil
-
-                if value.is_a?(Integer)
-                    method = :getgrgid
-                else
-                    method = :getgrnam
-                end
+        munge do |value|
+            method = nil
+            gid = nil
+            gname = nil
 
-                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
+            if value.is_a?(Integer)
+                method = :getgrgid
+            else
+                method = :getgrnam
+            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
+            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
 
-                if gid.nil?
-                    raise Puppet::Error.new(
-                        "Nil gid for %s" % @parent.name)
-                else
-                    return gid
-                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
 
-            # 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
+            #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 == :absent
+                @parent.stat(true)
+                self.retrieve
+
+                if @is == :absent
+                    self.info "File '%s' does not exist; cannot chgrp" %
+                        @parent[:path]
+                    return nil
                 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
+                if self.insync?
+                    return nil
                 end
-                return :inode_changed
             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 :file_changed
         end
     end
 end
 
-# $Id: group.rb 731 2005-10-26 04:44:25Z luke $
+# $Id: group.rb 862 2006-01-31 02:07:56Z luke $