puppet 0.13.6 → 0.16.0

data/lib/puppet/type/parsedtype/port.rb

@@ -131,13 +131,14 @@ module Puppet
 
         # Parse a services file
         #
-        # This method also stores existing comments, and it stores all host
-        # jobs in order, mostly so that comments are retained in the order
-        # they were written and in proximity to the same jobs.
+        # This method also stores existing comments, and it stores all port
+        # info in order, mostly so that comments are retained in the order
+        # they were written and in proximity to the same ports.
         def self.parse(text)
             count = 0
             hash = {}
             text.chomp.split("\n").each { |line|
+                hash.clear
                 case line
                 when /^#/, /^\s*$/:
                     # add comments and blank lines to the list as they are
@@ -185,7 +186,6 @@ module Puppet
 
                     hash2obj(hash)
 
-                    hash.clear
                     count += 1
                 end
             }
@@ -206,6 +206,9 @@ module Puppet
                 return false
             end
 
+            # If this is happening, our object exists
+            self.is = [:ensure, :present]
+
             if hash[:protocols]
                 # The protocol can be a symbol, so...
                 if proto.is_a?(Symbol)
@@ -220,7 +223,6 @@ module Puppet
             end
 
             if hash.include?(:description) and ! @states.include?(:description)
-                Puppet.info "Adding description to %s" % hash[:name]
                 self.is = [:description, hash[:description]]
             end
 
@@ -250,4 +252,4 @@ module Puppet
     end
 end
 
-# $Id: port.rb 915 2006-02-15 21:56:54Z luke $
+# $Id: port.rb 1129 2006-04-21 19:14:59Z luke $

data/lib/puppet/type/pfile.rb

@@ -34,34 +34,60 @@ module Puppet
             desc "Whether files should be backed up before
                 being replaced.  If a filebucket_ is specified, files will be
                 backed up there; else, they will be backed up in the same directory
-                with a ``.puppet-bak`` extension."
+                with a ``.puppet-bak`` extension.
+                
+                To use filebuckets, you must first create a filebucket in your
+                configuration::
+                    
+                    filebucket { main:
+                        server => puppet
+                    }
+
+                ``puppetmasterd`` creates a filebucket by default, so you can
+                usually back up to your main server with this configuration.  Once
+                you've described the bucket in your configuration, you can use
+                it in any file::
+
+                    file { \"/my/file\":
+                        source => \"/path/in/nfs/or/something\",
+                        backup => main
+                    }
+
+                This will back the file up to the central server.
+
+                At this point, the only benefits to doing so are that you do not
+                have backup files lying around on each of your machines, a given
+                version of a file is only backed up once, and you can restore
+                any given file manually, no matter how old.  Eventually,
+                transactional support will be able to automatically restore
+                filebucketed files.
+                "
 
+            attr_reader :bucket
             defaultto true
 
             munge do |value|
                 case value
                 when false, "false":
                     false
-                when true, "true":
+                when true, "true", ".puppet-bak":
                     ".puppet-bak"
-                when Array:
-                    case value[0]
-                    when "filebucket":
-                        if bucket = Puppet.type(:filebucket).bucket(value[1])
-                            bucket
-                        else
-                            self.fail "Could not retrieve filebucket %s" %
-                                value[1]
-                        end
-                    else
-                        self.fail "Invalid backup object type %s" %
-                            value[0].inspect
-                    end
+                when String:
+                    # We can't depend on looking this up right now,
+                    # we have to do it after all of the objects
+                    # have been instantiated.
+                    @bucket = value
                 else
                     self.fail "Invalid backup type %s" %
                         value.inspect
                 end
             end
+
+            # Provide a straight-through hook for setting the bucket.
+            def bucket=(bucket)
+                @value = bucket
+                @bucket = bucket
+            end
         end
 
         newparam(:linkmaker) do
@@ -94,6 +120,22 @@ module Puppet
             end
         end
 
+        newparam(:links) do
+            desc "How to handle links during file actions.  During file copying,
+                ``follow`` will copy the target file instead of the link, ``manage``
+                will copy the link itself, and ``ignore`` will just pass it by.
+                When not copying, ``manage`` and ``ignore`` behave equivalently
+                (because you cannot really ignore links entirely during local
+                recursion), and ``follow`` will manage the file to which the
+                link points."
+
+            newvalues(:follow, :manage, :ignore)
+
+            # :ignore and :manage behave equivalently on local files,
+            # but don't copy remote links
+            defaultto :ignore
+        end
+
         autorequire(:file) do
             cur = []
             pary = self[:path].split(File::SEPARATOR)
@@ -115,6 +157,29 @@ module Puppet
             end
         end
 
+        # List files, but only one level deep.
+        def self.list(base = "/")
+            unless FileTest.directory?(base)
+                return []
+            end
+
+            files = []
+            Dir.entries(base).reject { |e|
+                e == "." or e == ".."
+            }.each do |name|
+                path = File.join(base, name)
+                if obj = self[path]
+                    obj[:check] = :all
+                    files << obj
+                else
+                    files << self.create(
+                        :name => path, :check => :all
+                    )
+                end
+            end
+            files
+        end
+
         @depthfirst = false
 
 
@@ -122,6 +187,52 @@ module Puppet
             @arghash.include?(arg)
         end
 
+        # Determine the user to write files as.
+        def asuser
+            if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
+                writeable = Puppet::Util.asuser(self.should(:owner)) {
+                    FileTest.writable?(File.dirname(self[: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 = self.should(:owner)
+                end
+            end
+
+            return asuser
+        end
+
+        # We have to do some extra finishing, to retrieve our bucket if
+        # there is one
+        def finish
+            # Let's cache these values, since there should really only be
+            # a couple of these buckets
+            @@filebuckets ||= {}
+
+            # Look up our bucket, if there is one
+            if @parameters.include?(:backup) and bucket = @parameters[:backup].bucket
+                case bucket
+                when String:
+                    if obj = @@filebuckets.include?(bucket)
+                        @parameters[:backup].bucket = obj
+                    elsif obj = Puppet.type(:filebucket).bucket(bucket)
+                        @@filebuckets[bucket] = obj
+                        @parameters[:backup].bucket = obj
+                    else
+                        self.fail "Could not find filebucket %s" % bucket
+                    end
+                when Puppet::Client::Dipper: # things are hunky-dorey
+                else
+                    self.fail "Invalid bucket type %s" % bucket.class
+                end
+            end
+            super
+        end
+
+        # Deal with backups.
         def handlebackup(file = nil)
             # let the path be specified
             file ||= self[:path]
@@ -137,6 +248,7 @@ module Puppet
 
             case File.stat(file).ftype
             when "directory":
+                self.info :bc
                 # we don't need to backup directories
                 return true
             when "file":
@@ -144,8 +256,8 @@ module Puppet
                 case backup
                 when Puppet::Client::Dipper:
                     sum = backup.backup(file)
-                    self.info "Filebucketed %s with sum %s" %
-                        [file, sum]
+                    self.info "Filebucketed to %s with sum %s" %
+                        [backup.name, sum]
                     return true
                 when String:
                     newfile = file + backup
@@ -183,8 +295,8 @@ module Puppet
             return children unless self[:ignore]
             self[:ignore].each { |ignore|
                 ignored = []
-                Dir.glob(File.join(self[:path],ignore), File::FNM_DOTMATCH) { |match|
-                    ignored.push(File.basename(match))
+                Dir.glob(File.join(self[:path],ignore), File::FNM_DOTMATCH) {
+                    |match| ignored.push(File.basename(match))
                 }
                 children = children - ignored
             }
@@ -194,7 +306,6 @@ module Puppet
         def initialize(hash)
             # clean out as many references to any file paths as possible
             # this was the source of many, many bugs
-            
             @arghash = self.argclean(hash)
             @arghash.delete(self.class.namevar)
 
@@ -245,11 +356,10 @@ module Puppet
             # We specifically look in @parameters here, because 'linkmaker' isn't
             # a valid attribute for subclasses, so using 'self[:linkmaker]' throws
             # an error.
-            if @parameters.include?(:linkmaker) and
+            if @parameters.include?(:linkmaker) and 
                 args.include?(:source) and ! FileTest.directory?(args[:source])
                 klass = Puppet.type(:symlink)
 
-                self.debug "%s is a link" % path
                 # clean up the args a lot for links
                 old = args.dup
                 args = {
@@ -364,8 +474,8 @@ module Puppet
             end
 
             # are we at the end of the recursion?
-            if recurse == 0
-                self.info "finished recursing"
+            #if recurse == 0
+            unless self.recurse?
                 return
             end
 
@@ -374,11 +484,88 @@ module Puppet
             end
 
             self.localrecurse(recurse)
+            if @states.include? :target
+                self.linkrecurse(recurse)
+            end
             if @states.include?(:source)
                 self.sourcerecurse(recurse)
             end
         end
 
+        def recurse?
+            return false unless @parameters.include?(:recurse)
+
+            val = @parameters[:recurse].value
+
+            if val and (val == true or val > 0)
+                return true
+            else
+                return false
+            end
+        end
+
+        # Build a recursive map of a link source
+        def linkrecurse(recurse)
+            target = @states[:target].should
+
+            method = :lstat
+            if self[:links] == :follow
+                method = :stat
+            end
+
+            targetstat = nil
+            unless FileTest.exist?(target)
+                #self.info "%s does not exist; not recursing" %
+                #    target
+                return
+            end
+            # Now stat our target
+            targetstat = File.send(method, target)
+            unless targetstat.ftype == "directory"
+                #self.info "%s is not a directory; not recursing" %
+                #    target
+                return
+            end
+
+            # Now that we know our corresponding target is a directory,
+            # change our type
+            self[:ensure] = :directory
+
+            unless FileTest.readable? target
+                self.notice "Cannot manage %s: permission denied" % self.name
+                return
+            end
+
+            children = Dir.entries(target).reject { |d| d =~ /^\.+$/ }
+         
+            #Get rid of ignored children
+            if @parameters.include?(:ignore)
+                children = handleignore(children)
+            end  
+
+            added = []
+            children.each do |file|
+                Dir.chdir(target) do
+                    longname = File.join(target, file)
+
+                    # Files know to create directories when recursion
+                    # is enabled and we're making links
+                    args = {
+                        :recurse => recurse,
+                        :ensure => longname
+                    }
+
+                    if child = self.newchild(file, true, args)
+                        unless @children.include?(child)
+                            self.push child
+                            added.push file
+                        end
+                    end
+                end
+            end
+        end
+
+        # Build up a recursive map of what's around right now
         def localrecurse(recurse)
             unless FileTest.exist?(self[:path]) and self.stat.directory?
                 #self.info "%s is not a directory; not recursing" %
@@ -450,7 +637,7 @@ module Puppet
 
             #self.warning "Listing path %s with ignore %s" %
             #    [path.inspect, ignore.inspect]
-            desc = server.list(path, r, ignore)
+            desc = server.list(path, self[:links], r, ignore)
            
             desc.split("\n").each { |line|
                 file, type = line.split("\t")
@@ -513,15 +700,23 @@ module Puppet
             end
         end
 
+        # Stat our file.  Depending on the value of the 'links' attribute, we use
+        # either 'stat' or 'lstat', and we expect the states to use the resulting
+        # stat object accordingly (mostly by testing the 'ftype' value).
         def stat(refresh = false)
+            method = :stat
+
+            # Files are the only types that support links
+            if self.class.name == :file and self[:links] != :follow
+                method = :lstat
+            end
             if @stat.nil? or refresh == true
                 begin
-                    @stat = File.lstat(self[:path])
+                    @stat = File.send(method, self[:path])
                 rescue Errno::ENOENT => error
                     @stat = nil
-                rescue => error
-                    self.debug "Failed to stat %s: %s" %
-                        [self.name,error]
+                rescue Errno::EACCES => error
+                    self.warning "Could not stat; permission denied"
                     @stat = nil
                 end
             end
@@ -583,6 +778,64 @@ module Puppet
 
             return [sourceobj, path.sub(/\/\//, '/')]
         end
+
+        # Write out the file.  We open the file correctly, with all of the
+        # uid and mode and such, and then yield the file handle for actual
+        # writing.
+        def write(usetmp = true)
+            mode = self.should(:mode)
+
+            if FileTest.exists?(self[:path])
+                # this makes sure we have a copy for posterity
+                @backed = self.handlebackup
+            end
+
+            # The temporary file
+            path = nil
+            if usetmp
+                path = self[:path] + ".puppettmp"
+            else
+                path = self[:path]
+            end
+
+            # As the correct user and group
+            Puppet::Util.asuser(asuser(), self.should(:group)) do
+                f = nil
+                # Open our file with the correct modes
+                if mode
+                    Puppet::Util.withumask(000) do
+                        f = File.open(path,
+                            File::CREAT|File::WRONLY|File::TRUNC, mode)
+                    end
+                else
+                    f = File.open(path, File::CREAT|File::WRONLY|File::TRUNC)
+                end
+
+                # Yield it
+                yield f
+
+                f.flush
+                f.close
+            end
+
+            # And put our new file in place
+            if usetmp
+                begin
+                    File.rename(path, self[:path])
+                rescue => detail
+                    self.err "Could not rename tmp %s for replacing: %s" %
+                        [self[:path], detail]
+                ensure
+                    # Make sure the created file gets removed
+                    if FileTest.exists?(path)
+                        File.unlink(path)
+                    end
+                end
+            end
+
+            # And then update our checksum, so the next run doesn't find it.
+            self.setchecksum
+        end
     end # Puppet.type(:pfile)
 
     # the filesource class can't include the path, because the path
@@ -597,10 +850,11 @@ module Puppet
     require 'puppet/type/pfile/checksum'
     require 'puppet/type/pfile/content'     # can create the file
     require 'puppet/type/pfile/source'      # can create the file
+    require 'puppet/type/pfile/target'
     require 'puppet/type/pfile/ensure'      # can create the file
     require 'puppet/type/pfile/uid'
     require 'puppet/type/pfile/group'
     require 'puppet/type/pfile/mode'
     require 'puppet/type/pfile/type'
 end
-# $Id: pfile.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: pfile.rb 1125 2006-04-20 19:38:48Z luke $