puppet 0.24.9 → 0.25.0

data/lib/puppet/util/autoload/file_cache.rb

@@ -0,0 +1,115 @@
+module Puppet::Util::Autoload::FileCache
+    @found_files = {}
+    @missing_files = {}
+    class << self
+        attr_reader :found_files, :missing_files
+    end
+
+    # Only used for testing.
+    def self.clear
+        @found_files.clear
+        @missing_files.clear
+    end
+
+    def found_files
+        Puppet::Util::Autoload::FileCache.found_files
+    end
+
+    def missing_files
+        Puppet::Util::Autoload::FileCache.missing_files
+    end
+
+    def directory_exist?(path)
+        cache = cached_data?(path, :directory?)
+        return cache unless cache.nil?
+
+        protect(path) do
+            stat = File.lstat(path)
+            if stat.directory?
+                found_file(path, stat)
+                return true
+            else
+                missing_file(path)
+                return false
+            end
+        end
+    end
+
+    def file_exist?(path)
+        cache = cached_data?(path)
+        return cache unless cache.nil?
+
+        protect(path) do
+            stat = File.lstat(path)
+            found_file(path, stat)
+            return true
+        end
+    end
+
+    def found_file?(path, type = nil)
+        if data = found_files[path] and ! data_expired?(data[:time])
+            if type and ! data[:stat].send(type)
+                return false
+            end
+            return true
+        else
+            return false
+        end
+    end
+
+    def found_file(path, stat)
+        found_files[path] = {:stat => stat, :time => Time.now}
+    end
+
+    def missing_file?(path)
+        if time = missing_files[path] and ! data_expired?(time)
+            return true
+        else
+            return false
+        end
+    end
+
+    def missing_file(path)
+        missing_files[path] = Time.now
+    end
+
+    def named_file_missing?(name)
+        @named_files ||= {}
+        if time = @named_files[name] and ! data_expired?(time)
+            return true
+        end
+        false
+    end
+
+    def named_file_is_missing(name)
+        @named_files ||= {}
+        @named_files[name] = Time.now
+        false
+    end
+
+    private
+
+    def cached_data?(path, type = nil)
+        if found_file?(path, type)
+            return true
+        elsif missing_file?(path)
+            return false
+        else
+            return nil
+        end
+    end
+
+    def data_expired?(time)
+        Time.now - time > 15
+    end
+
+    def protect(path)
+        begin
+            yield
+        rescue => detail
+            raise unless detail.class.to_s.include?("Errno")
+            missing_file(path)
+            return false
+        end
+    end
+end

data/lib/puppet/util/backups.rb

@@ -0,0 +1,86 @@
+require 'find'
+module Puppet::Util::Backups
+
+    # Deal with backups.
+    def perform_backup(file = nil)
+        # if they specifically don't want a backup, then just say
+        # we're good
+        return true unless self[:backup]
+
+        # let the path be specified
+        file ||= self[:path]
+        return true unless FileTest.exists?(file)  
+
+        return perform_backup_with_bucket(file) if self.bucket
+        return perform_backup_with_backuplocal(file, self[:backup]) 
+    end
+
+    private
+
+    def perform_backup_with_bucket(fileobj)
+        file = (fileobj.class == String) ? fileobj : fileobj.name
+        case File.stat(file).ftype
+        when "directory"
+            # we don't need to backup directories when recurse is on
+            return true if self[:recurse]
+            info "Recursively backing up to filebucket"
+            Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
+        when "file"; backup_file_with_filebucket(file)
+        when "link"; return true
+        end
+    end
+
+    def perform_backup_with_backuplocal(fileobj, backup)
+        file = (fileobj.class == String) ? fileobj : fileobj.name
+        newfile = file + backup
+
+        remove_backup(newfile)
+
+        begin
+            bfile = file + backup
+
+            # Ruby 1.8.1 requires the 'preserve' addition, but
+            # later versions do not appear to require it.
+            # N.B. cp_r works on both files and directories
+            FileUtils.cp_r(file, bfile, :preserve => true)
+            return true
+        rescue => detail
+            # since they said they want a backup, let's error out
+            # if we couldn't make one
+            self.fail "Could not back %s up: %s" % [file, detail.message]
+        end
+    end
+
+    def remove_backup(newfile)
+        if self.class.name == :file and self[:links] != :follow
+            method = :lstat
+        else
+            method = :stat
+        end
+
+        begin
+            stat = File.send(method, newfile)
+        rescue Errno::ENOENT
+            return
+        end
+
+        if stat.ftype == "directory"
+            raise Puppet::Error, "Will not remove directory backup %s; use a filebucket" % newfile
+        end
+
+        info "Removing old backup of type %s" % stat.ftype
+
+        begin
+            File.unlink(newfile)
+        rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            self.fail "Could not remove old backup: %s" % detail
+        end
+    end
+
+    def backup_file_with_filebucket(f)
+        sum = self.bucket.backup(f)
+        self.info "Filebucketed %s to %s with sum %s" % [f, self.bucket.name, sum]
+        return sum
+	end
+end

data/lib/puppet/util/cacher.rb

@@ -0,0 +1,135 @@
+module Puppet::Util::Cacher
+    module Expirer
+        attr_reader :timestamp
+
+        # Cause all cached values to be considered expired.
+        def expire
+            @timestamp = Time.now
+        end
+
+        # Is the provided timestamp earlier than our expiration timestamp?
+        # If it is, then the associated value is expired.
+        def dependent_data_expired?(ts)
+            return false unless timestamp
+
+            return timestamp > ts
+        end
+    end
+
+    extend Expirer
+
+    # Our module has been extended in a class; we can only add the Instance methods,
+    # which become *class* methods in the class.
+    def self.extended(other)
+        class << other
+            extend ClassMethods
+            include InstanceMethods
+        end
+    end
+
+    # Our module has been included in a class, which means the class gets the class methods
+    # and all of its instances get the instance methods.
+    def self.included(other)
+        other.extend(ClassMethods)
+        other.send(:include, InstanceMethods)
+    end
+
+    # Methods that can get added to a class.
+    module ClassMethods
+        # Provide a means of defining an attribute whose value will be cached.
+        # Must provide a block capable of defining the value if it's flushed..
+        def cached_attr(name, options = {}, &block)
+            init_method = "init_" + name.to_s
+            define_method(init_method, &block)
+
+            define_method(name) do
+                cached_value(name)
+            end
+
+            define_method(name.to_s + "=") do |value|
+                # Make sure the cache timestamp is set
+                cache_timestamp
+                value_cache[name] = value
+            end
+
+            if ttl = options[:ttl]
+                set_attr_ttl(name, ttl)
+            end
+        end
+
+        def attr_ttl(name)
+            return nil unless defined?(@attr_ttls) and @attr_ttls
+            @attr_ttls[name]
+        end
+
+        def set_attr_ttl(name, value)
+            @attr_ttls ||= {}
+            @attr_ttls[name] = Integer(value)
+        end
+    end
+
+    # Methods that get added to instances.
+    module InstanceMethods
+        def expire
+            # Only expire if we have an expirer.  This is
+            # mostly so that we can comfortably handle cases
+            # like Puppet::Type instances, which use their
+            # catalog as their expirer, and they often don't
+            # have a catalog.
+            if e = expirer
+                e.expire
+            end
+        end
+
+        def expirer
+            Puppet::Util::Cacher
+        end
+
+        private
+
+        def cache_timestamp
+            unless defined?(@cache_timestamp)
+                @cache_timestamp = Time.now
+            end
+            @cache_timestamp
+        end
+
+        def cached_value(name)
+            # Allow a nil expirer, in which case we regenerate the value every time.
+            if expired_by_expirer?(name)
+                value_cache.clear
+                @cache_timestamp = Time.now
+            elsif expired_by_ttl?(name)
+                value_cache.delete(name)
+            end
+            unless value_cache.include?(name)
+                value_cache[name] = send("init_%s" % name)
+            end
+            value_cache[name]
+        end
+
+        def expired_by_expirer?(name)
+            if expirer.nil?
+                return true unless self.class.attr_ttl(name)
+            end
+            return expirer.dependent_data_expired?(cache_timestamp)
+        end
+
+        def expired_by_ttl?(name)
+            return false unless self.class.respond_to?(:attr_ttl)
+            return false unless ttl = self.class.attr_ttl(name)
+
+            @ttl_timestamps ||= {}
+            @ttl_timestamps[name] ||= Time.now
+
+            return (Time.now - @ttl_timestamps[name]) > ttl
+        end
+
+        def value_cache
+            unless defined?(@value_cache) and @value_cache
+                @value_cache = {}
+            end
+            @value_cache
+        end
+    end
+end

data/lib/puppet/util/checksums.rb

@@ -1,6 +1,15 @@
 # A stand-alone module for calculating checksums
 # in a generic way.
 module Puppet::Util::Checksums
+    # Strip the checksum type from an existing checksum
+    def sumtype(checksum)
+        if checksum =~ /^\{(\w+)\}/
+            return $1
+        else
+            return nil
+        end
+    end
+
     # Calculate a checksum using Digest::MD5.
     def md5(content)
         require 'digest/md5'
@@ -63,8 +72,9 @@ module Puppet::Util::Checksums
 
     # Perform an incremental checksum on a file.
     def checksum_file(digest, filename, lite = false)
+        buffer = lite ? 512 : 4096
         File.open(filename, 'r') do |file|
-            while content = file.read(512)
+            while content = file.read(buffer)
                 digest << content
                 break if lite
             end

data/lib/puppet/util/classgen.rb

@@ -95,7 +95,7 @@ module Puppet::Util::ClassGen
                 end
                 @name = name
             end
-        else 
+        else
             options[:parent] ||= self
             evalmethod = :class_eval
             # Create the class, with the correct name.

data/lib/puppet/util/config_store.rb

@@ -54,8 +54,8 @@ module Puppet::Util
 
         def collect_exported(client, conditions)
             raise Puppet::DevError, "%s has not overridden collect_exported" % self.class.name
-        end   
-          
+        end
+
     end
 end
 

data/lib/puppet/util/constant_inflector.rb

@@ -5,7 +5,7 @@
 # file names.
 module Puppet::Util::ConstantInflector
     def file2constant(file)
-        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
+        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
         x = file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
     end
 

data/lib/puppet/util/diff.rb

@@ -35,8 +35,8 @@ module Puppet::Util::Diff
 
         diffs.each do |piece|
             begin
-                hunk = ::Diff::LCS::Hunk.new(data_old, data_new, piece, 
-                                           context_lines, 
+                hunk = ::Diff::LCS::Hunk.new(data_old, data_new, piece,
+                                           context_lines,
                                            file_length_difference)
                 file_length_difference = hunk.file_length_difference
             next unless oldhunk

data/lib/puppet/util/docs.rb

@@ -90,9 +90,15 @@ module Puppet::Util::Docs
         indent = nil
 
         # If we can match an indentation, then just remove that same level of
-        # indent from every line.
-        if text =~ /^(\s+)/
-            indent = $1
+        # indent from every line.  However, ignore any indentation on the
+        # first line, since that can be inconsistent.
+        text = text.lstrip()
+        text.gsub!(/^([\t]+)/) { |s| " "*8*s.length(); } # Expand leading tabs
+        # Find first non-empty line after the first line:
+        line2start = (text =~ /(\n?\s*\n)/)
+        line2start += $1.length
+        if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
+            indent = Regexp.quote($1)
             begin
                 return text.gsub(/^#{indent}/,'')
             rescue => detail

data/lib/puppet/util/execution.rb

@@ -1,5 +1,5 @@
 module Puppet::Util::Execution
-    module_function 
+    module_function
 
     # Run some code with a specific environment.  Resets the environment back to
     # what it was at the end of the code.

data/lib/puppet/util/feature.rb

@@ -26,7 +26,7 @@ class Puppet::Util::Feature
             end
             @results[name] = result
         end
-        
+
         meta_def(method) do
             unless @results.include?(name)
                 @results[name] = test(name, options)
@@ -34,14 +34,14 @@ class Puppet::Util::Feature
             @results[name]
         end
     end
-    
+
     # Create a new feature collection.
     def initialize(path)
         @path = path
         @results = {}
         @loader = Puppet::Util::Autoload.new(self, @path)
     end
-    
+
     def load
         @loader.loadall
     end
@@ -63,23 +63,30 @@ class Puppet::Util::Feature
     # someone asks for the feature, so we don't unnecessarily load
     # files.
     def test(name, options)
-        result = true
-        if ary = options[:libs]
-            ary = [ary] unless ary.is_a?(Array)
-            
-            ary.each do |lib|
-                unless lib.is_a?(String)
-                    raise ArgumentError, "Libraries must be passed as strings not %s" % lib.class
-                end
-            
-                begin
-                    require lib
-                rescue Exception
-                    Puppet.debug "Failed to load library '%s' for feature '%s'" % [lib, name]
-                    result = false
-                end
-            end
+        return true unless ary = options[:libs]
+        ary = [ary] unless ary.is_a?(Array)
+
+        ary.each do |lib|
+            return false unless load_library(lib, name)
+        end
+
+        # We loaded all of the required libraries
+        return true
+    end
+
+    private
+
+    def load_library(lib, name)
+        unless lib.is_a?(String)
+            raise ArgumentError, "Libraries must be passed as strings not %s" % lib.class
+        end
+
+        begin
+            require lib
+        rescue Exception
+            Puppet.debug "Failed to load library '%s' for feature '%s'" % [lib, name]
+            return false
         end
-        result
+        return true
     end
 end