puppet 0.25.5 → 2.6.0

data/lib/puppet/util/backups.rb

@@ -1,87 +1,87 @@
 require 'find'
+require 'fileutils'
 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]
+  # 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)  
+    # 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
+    return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
+  end
 
-    private
+  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";
-        end
-        true
+  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";
     end
+    true
+  end
 
-    def perform_backup_with_backuplocal(fileobj, backup)
-        file = (fileobj.class == String) ? fileobj : fileobj.name
-        newfile = file + backup
+  def perform_backup_with_backuplocal(fileobj, backup)
+    file = (fileobj.class == String) ? fileobj : fileobj.name
+    newfile = file + backup
 
-        remove_backup(newfile)
+    remove_backup(newfile)
 
-        begin
-            bfile = file + backup
+    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
+      # 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 #{file} up: #{detail.message}"
     end
+  end
 
-    def remove_backup(newfile)
-        if self.class.name == :file and self[:links] != :follow
-            method = :lstat
-        else
-            method = :stat
-        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
+    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
+    if stat.ftype == "directory"
+      raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
+    end
 
-        info "Removing old backup of type %s" % stat.ftype
+    info "Removing old backup of type #{stat.ftype}"
 
-        begin
-            File.unlink(newfile)
-        rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            self.fail "Could not remove old backup: %s" % detail
-        end
+    begin
+      File.unlink(newfile)
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      self.fail "Could not remove old backup: #{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
+  def backup_file_with_filebucket(f)
+    sum = self.bucket.backup(f)
+    self.info "Filebucketed #{f} to #{self.bucket.name} with sum #{sum}"
+    return sum
+    end
 end

data/lib/puppet/util/cacher.rb

@@ -1,135 +1,127 @@
 module Puppet::Util::Cacher
-    module Expirer
-        attr_reader :timestamp
+  module Expirer
+    attr_reader :timestamp
 
-        # Cause all cached values to be considered expired.
-        def expire
-            @timestamp = Time.now
-        end
+    # 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
+
+      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}"
+      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
 
-        # 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
+    def attr_ttl(name)
+      return nil unless @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
 
-            return timestamp > ts
-        end
+    def expirer
+      Puppet::Util::Cacher
     end
 
-    extend Expirer
+    private
 
-    # 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
+    def cache_timestamp
+      @cache_timestamp ||= Time.now
     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)
+    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
+      value_cache[name] = send("init_#{name}") unless value_cache.include?(name)
+      value_cache[name]
     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
+    def expired_by_expirer?(name)
+      if expirer.nil?
+        return true unless self.class.attr_ttl(name)
+      end
+      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
+
+      (Time.now - @ttl_timestamps[name]) > ttl
     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
+    def value_cache
+      @value_cache ||= {}
     end
+  end
 end

data/lib/puppet/util/checksums.rb

@@ -1,90 +1,125 @@
 # 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
+  # Is the provided string a checksum?
+  def checksum?(string)
+    string =~ /^\{(\w{3,5})\}\S+/
+  end
+
+  # Strip the checksum type from an existing checksum
+  def sumdata(checksum)
+    checksum =~ /^\{(\w+)\}(.+)/ ? $2 : nil
+  end
+
+  # Strip the checksum type from an existing checksum
+  def sumtype(checksum)
+    checksum =~ /^\{(\w+)\}/ ? $1 : nil
+  end
+
+  # Calculate a checksum using Digest::MD5.
+  def md5(content)
+    require 'digest/md5'
+    Digest::MD5.hexdigest(content)
+  end
+
+  # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
+  def md5lite(content)
+    md5(content[0..511])
+  end
+
+  # Calculate a checksum of a file's content using Digest::MD5.
+  def md5_file(filename, lite = false)
+    require 'digest/md5'
+
+    digest = Digest::MD5.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
+  def md5lite_file(filename)
+    md5_file(filename, true)
+  end
+
+  def md5_stream(&block)
+    require 'digest/md5'
+    digest = Digest::MD5.new
+    yield digest
+    digest.hexdigest
+  end
+
+  alias :md5lite_stream :md5_stream
+
+  # Return the :mtime timestamp of a file.
+  def mtime_file(filename)
+    File.stat(filename).send(:mtime)
+  end
+
+  # by definition this doesn't exist
+  def mtime_stream
+    nil
+  end
+
+  alias :ctime_stream :mtime_stream
+
+  # Calculate a checksum using Digest::SHA1.
+  def sha1(content)
+    require 'digest/sha1'
+    Digest::SHA1.hexdigest(content)
+  end
+
+  # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
+  def sha1lite(content)
+    sha1(content[0..511])
+  end
+
+  # Calculate a checksum of a file's content using Digest::SHA1.
+  def sha1_file(filename, lite = false)
+    require 'digest/sha1'
+
+    digest = Digest::SHA1.new
+    checksum_file(digest, filename, lite)
+  end
+
+  # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
+  def sha1lite_file(filename)
+    sha1_file(filename, true)
+  end
+
+  def sha1_stream
+    require 'digest/sha1'
+    digest = Digest::SHA1.new
+    yield digest
+    digest.hexdigest
+  end
+
+  alias :sha1lite_stream :sha1_stream
+
+  # Return the :ctime of a file.
+  def ctime_file(filename)
+    File.stat(filename).send(:ctime)
+  end
+
+  # Return a "no checksum"
+  def none_file(filename)
+    ""
+  end
+
+  def none_stream
+    ""
+  end
+
+  private
+
+  # 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(buffer)
+        digest << content
+        break if lite
+      end
     end
 
-    # Calculate a checksum using Digest::MD5.
-    def md5(content)
-        require 'digest/md5'
-        Digest::MD5.hexdigest(content)
-    end
-
-    # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
-    def md5lite(content)
-        md5(content[0..511])
-    end
-
-    # Calculate a checksum of a file's content using Digest::MD5.
-    def md5_file(filename, lite = false)
-        require 'digest/md5'
-
-        digest = Digest::MD5.new()
-        return checksum_file(digest, filename,  lite)
-    end
-
-    # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
-    def md5lite_file(filename)
-        md5_file(filename, true)
-    end
-
-    # Return the :mtime timestamp of a file.
-    def mtime_file(filename)
-        File.stat(filename).send(:mtime)
-    end
-
-    # Calculate a checksum using Digest::SHA1.
-    def sha1(content)
-        require 'digest/sha1'
-        Digest::SHA1.hexdigest(content)
-    end
-
-    # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
-    def sha1lite(content)
-        sha1(content[0..511])
-    end
-
-    # Calculate a checksum of a file's content using Digest::SHA1.
-    def sha1_file(filename, lite = false)
-        require 'digest/sha1'
-
-        digest = Digest::SHA1.new()
-        return checksum_file(digest, filename, lite)
-    end
-
-    # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
-    def sha1lite_file(filename)
-        sha1_file(filename, true)
-    end
-
-    # Return the :ctime of a file.
-    def ctime_file(filename)
-        File.stat(filename).send(:ctime)
-    end
-
-    # Return a "no checksum"
-    def none_file(filename)
-        ""
-    end
-
-    private
-
-    # 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(buffer)
-                digest << content
-                break if lite
-            end
-        end
-
-        return digest.hexdigest
-    end
+    digest.hexdigest
+  end
 end