puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/util/autoload.rb

@@ -0,0 +1,231 @@
+require 'pathname'
+require 'puppet/util/rubygems'
+require 'puppet/util/warnings'
+require 'puppet/util/methodhelper'
+
+# Autoload paths, either based on names or all at once.
+class Puppet::Util::Autoload
+  include Puppet::Util::MethodHelper
+
+  @autoloaders = {}
+  @loaded = {}
+
+  class << self
+    attr_reader :autoloaders
+    attr_accessor :loaded
+    private :autoloaders, :loaded
+
+    def gem_source
+      @gem_source ||= Puppet::Util::RubyGems::Source.new
+    end
+
+    # Has a given path been loaded?  This is used for testing whether a
+    # changed file should be loaded or just ignored.  This is only
+    # used in network/client/master, when downloading plugins, to
+    # see if a given plugin is currently loaded and thus should be
+    # reloaded.
+    def loaded?(path)
+      path = cleanpath(path).chomp('.rb')
+      loaded.include?(path)
+    end
+
+    # Save the fact that a given path has been loaded.  This is so
+    # we can load downloaded plugins if they've already been loaded
+    # into memory.
+    def mark_loaded(name, file)
+      name = cleanpath(name).chomp('.rb')
+      ruby_file = name + ".rb"
+      $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
+      loaded[name] = [file, File.mtime(file)]
+    end
+
+    def changed?(name)
+      name = cleanpath(name).chomp('.rb')
+      return true unless loaded.include?(name)
+      file, old_mtime = loaded[name]
+      environment = Puppet.lookup(:current_environment)
+      return true unless file == get_file(name, environment)
+      begin
+        old_mtime.to_i != File.mtime(file).to_i
+      rescue Errno::ENOENT
+        true
+      end
+    end
+
+    # Load a single plugin by name.  We use 'load' here so we can reload a
+    # given plugin.
+    def load_file(name, env)
+      file = get_file(name.to_s, env)
+      return false unless file
+      begin
+        mark_loaded(name, file)
+        Kernel.load file, @wrap
+        return true
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue Exception => detail
+        message = "Could not autoload #{name}: #{detail}"
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message, detail.backtrace
+      end
+    end
+
+    def loadall(path)
+      # Load every instance of everything we can find.
+      files_to_load(path).each do |file|
+        name = file.chomp(".rb")
+        load_file(name, nil) unless loaded?(name)
+      end
+    end
+
+    def reload_changed
+      loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
+    end
+
+    # Get the correct file to load for a given path
+    # returns nil if no file is found
+    def get_file(name, env)
+      name = name + '.rb' unless name =~ /\.rb$/
+      path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
+      path and File.join(path, name)
+    end
+
+    def files_to_load(path)
+      search_directories(nil).map {|dir| files_in_dir(dir, path) }.flatten.uniq
+    end
+
+    def files_in_dir(dir, path)
+      dir = Pathname.new(File.expand_path(dir))
+      Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
+        Pathname.new(file).relative_path_from(dir).to_s
+      end
+    end
+
+    def module_directories(env)
+      # We're using a per-thread cache of module directories so that we don't
+      # scan the filesystem each time we try to load something. This is reset
+      # at the beginning of compilation and at the end of an agent run.
+      $env_module_directories ||= {}
+
+
+      # This is a little bit of a hack.  Basically, the autoloader is being
+      # called indirectly during application bootstrapping when we do things
+      # such as check "features".  However, during bootstrapping, we haven't
+      # yet parsed all of the command line parameters nor the config files,
+      # and thus we don't yet know with certainty what the module path is.
+      # This should be irrelevant during bootstrapping, because anything that
+      # we are attempting to load during bootstrapping should be something
+      # that we ship with puppet, and thus the module path is irrelevant.
+      #
+      # In the long term, I think the way that we want to handle this is to
+      # have the autoloader ignore the module path in all cases where it is
+      # not specifically requested (e.g., by a constructor param or
+      # something)... because there are very few cases where we should
+      # actually be loading code from the module path.  However, until that
+      # happens, we at least need a way to prevent the autoloader from
+      # attempting to access the module path before it is initialized.  For
+      # now we are accomplishing that by calling the
+      # "app_defaults_initialized?" method on the main puppet Settings object.
+      # --cprice 2012-03-16
+      if Puppet.settings.app_defaults_initialized?
+        env ||= Puppet.lookup(:environments).get(Puppet[:environment])
+
+        if env
+          # if the app defaults have been initialized then it should be safe to access the module path setting.
+          $env_module_directories[env] ||= env.modulepath.collect do |dir|
+            Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
+          end.flatten.find_all do |d|
+            FileTest.directory?(d)
+          end
+        else
+          []
+        end
+      else
+        # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
+        []
+      end
+    end
+
+    def libdirs()
+      # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
+      # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
+      if (Puppet.settings.app_defaults_initialized?)
+        Puppet[:libdir].split(File::PATH_SEPARATOR)
+      else
+        []
+      end
+    end
+
+    def gem_directories
+      gem_source.directories
+    end
+
+    def search_directories(env)
+      [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
+    end
+
+    # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
+    # and eliminates unnecessary parts of a path.
+    def cleanpath(path)
+      # There are two cases here because cleanpath does not handle absolute
+      # paths correctly on windows (c:\ and c:/ are treated as distinct) but
+      # we don't want to convert relative paths to absolute
+      if Puppet::Util.absolute_path?(path)
+        File.expand_path(path)
+      else
+        Pathname.new(path).cleanpath.to_s
+      end
+    end
+  end
+
+  # Send [] and []= to the @autoloaders hash
+  Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
+
+  attr_accessor :object, :path, :objwarn, :wrap
+
+  def initialize(obj, path, options = {})
+    @path = path.to_s
+    raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
+    @object = obj
+
+    self.class[obj] = self
+
+    set_options(options)
+
+    @wrap = true unless defined?(@wrap)
+  end
+
+  def load(name, env = nil)
+    self.class.load_file(expand(name), env)
+  end
+
+  # Load all instances from a path of Autoload.search_directories matching the
+  # relative path this Autoloader was initialized with.  For example, if we
+  # have created a Puppet::Util::Autoload for Puppet::Type::User with a path of
+  # 'puppet/provider/user', the search_directories path will be searched for
+  # all ruby files matching puppet/provider/user/*.rb and they will then be
+  # loaded from the first directory in the search path providing them.  So
+  # earlier entries in the search path may shadow later entries.
+  #
+  # This uses require, rather than load, so that already-loaded files don't get
+  # reloaded unnecessarily.
+  def loadall
+    self.class.loadall(@path)
+  end
+
+  def loaded?(name)
+    self.class.loaded?(expand(name))
+  end
+
+  def changed?(name)
+    self.class.changed?(expand(name))
+  end
+
+  def files_to_load
+    self.class.files_to_load(@path)
+  end
+
+  def expand(name)
+    ::File.join(@path, name.to_s)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/backups.rb

@@ -0,0 +1,86 @@
+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]
+
+    # let the path be specified
+    file ||= self[:path]
+    return true unless Puppet::FileSystem.exist?(file)
+
+    return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
+  end
+
+  private
+
+  def perform_backup_with_bucket(fileobj)
+    file = (fileobj.class == String) ? fileobj : fileobj.name
+    case Puppet::FileSystem.lstat(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
+
+    remove_backup(newfile)
+
+    begin
+      bfile = file + backup
+
+      # 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 Puppet::Error, "Could not back #{file} up: #{detail.message}", detail
+    end
+  end
+
+  def remove_backup(newfile)
+    if self.class.name == :file and self[:links] != :follow
+      method = :lstat
+    else
+      method = :stat
+    end
+
+    begin
+      stat = Puppet::FileSystem.send(method, newfile)
+    rescue Errno::ENOENT
+      return
+    end
+
+    if stat.ftype == "directory"
+      raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
+    end
+
+    info "Removing old backup of type #{stat.ftype}"
+
+    begin
+      Puppet::FileSystem.unlink(newfile)
+    rescue => detail
+      message = "Could not remove old backup: #{detail}"
+      self.log_exception(detail, message)
+      self.fail Puppet::Error, message, detail
+    end
+  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/vendor/gems/puppet-3.7.3/lib/puppet/util/cacher.rb

@@ -0,0 +1,74 @@
+module Puppet::Util::Cacher
+  # 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, ttl, &block)
+      init_method = "init_#{name}"
+      define_method(init_method, &block)
+
+      set_attr_ttl(name, ttl)
+
+      define_method(name) do
+        cached_value(name)
+      end
+
+      define_method(name.to_s + "=") do |value|
+        # Make sure the cache timestamp is set
+        value_cache[name] = value
+        set_expiration(name)
+      end
+    end
+
+    def attr_ttl(name)
+      @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
+    private
+
+    def cached_value(name)
+      if value_cache[name].nil? or expired_by_ttl?(name)
+        value_cache[name] = send("init_#{name}")
+        set_expiration(name)
+      end
+      value_cache[name]
+    end
+
+    def expired_by_ttl?(name)
+      @attr_expirations[name] < Time.now
+    end
+
+    def set_expiration(name)
+      @attr_expirations ||= {}
+      @attr_expirations[name] = Time.now + self.class.attr_ttl(name)
+    end
+
+    def value_cache
+      @value_cache ||= {}
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/checksums.rb

@@ -0,0 +1,202 @@
+require 'digest/md5'
+require 'digest/sha1'
+
+# A stand-alone module for calculating checksums
+# in a generic way.
+module Puppet::Util::Checksums
+  # @deprecated
+  # In Puppet 4 we should switch this to `module_function` to make these methods
+  # private when this class is included.
+  extend self
+
+  # It's not a good idea to use some of these in some contexts: for example, I
+  # wouldn't try bucketing a file using the :none checksum type.
+  def known_checksum_types
+    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite,
+      :mtime, :ctime, :none]
+  end
+
+  class FakeChecksum
+    def <<(*args)
+      self
+    end
+  end
+
+  # Is the provided string a checksum?
+  def checksum?(string)
+    # 'sha256lite'.length == 10
+    string =~ /^\{(\w{3,10})\}\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::SHA256.
+  def sha256(content)
+    require 'digest/sha2'
+    Digest::SHA256.hexdigest(content)
+  end
+
+  def sha256lite(content)
+    sha256(content[0..511])
+  end
+
+  def sha256_file(filename, lite = false)
+    require 'digest/sha2'
+
+    digest = Digest::SHA256.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha256lite_file(filename)
+    sha256_file(filename, true)
+  end
+
+  def sha256_stream(&block)
+    require 'digest/sha2'
+    digest = Digest::SHA256.new
+    yield digest
+    digest.hexdigest
+  end
+
+  def sha256_hex_length
+    64
+  end
+
+  alias :sha256lite_stream :sha256_stream
+  alias :sha256lite_hex_length :sha256_hex_length
+
+  # Calculate a checksum using Digest::MD5.
+  def md5(content)
+    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)
+    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)
+    digest = Digest::MD5.new
+    yield digest
+    digest.hexdigest
+  end
+
+  def md5_hex_length
+    32
+  end
+
+  alias :md5lite_stream :md5_stream
+  alias :md5lite_hex_length :md5_hex_length
+
+  # Return the :mtime timestamp of a file.
+  def mtime_file(filename)
+    Puppet::FileSystem.stat(filename).send(:mtime)
+  end
+
+  # by definition this doesn't exist
+  # but we still need to execute the block given
+  def mtime_stream
+    noop_digest = FakeChecksum.new
+    yield noop_digest
+    nil
+  end
+
+  def mtime(content)
+    ""
+  end
+
+  # Calculate a checksum using Digest::SHA1.
+  def sha1(content)
+    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)
+    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
+    digest = Digest::SHA1.new
+    yield digest
+    digest.hexdigest
+  end
+
+  def sha1_hex_length
+    40
+  end
+
+  alias :sha1lite_stream :sha1_stream
+  alias :sha1lite_hex_length :sha1_hex_length
+
+  # Return the :ctime of a file.
+  def ctime_file(filename)
+    Puppet::FileSystem.stat(filename).send(:ctime)
+  end
+
+  alias :ctime_stream :mtime_stream
+
+  def ctime(content)
+    ""
+  end
+
+  # Return a "no checksum"
+  def none_file(filename)
+    ""
+  end
+
+  def none_stream
+    noop_digest = FakeChecksum.new
+    yield noop_digest
+    ""
+  end
+
+  def none(content)
+    ""
+  end
+
+  private
+
+  # Perform an incremental checksum on a file.
+  def checksum_file(digest, filename, lite = false)
+    buffer = lite ? 512 : 4096
+    File.open(filename, 'rb') do |file|
+      while content = file.read(buffer)
+        digest << content
+        break if lite
+      end
+    end
+
+    digest.hexdigest
+  end
+
+end