puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/file_collection.rb

@@ -0,0 +1,19 @@
+# This was a simple way to turn file names into singletons,
+#
+# The theory was, like:
+# 1. Turn filenames into singletons.
+# 2. ????
+# 3. Huge memory savings!
+#
+# In practice it used several MB more memory overall, and it cost more CPU
+# time, and it added complexity to the code.  Which was awesome.
+#
+# So, I gutted it.  It doesn't do anything any more, but we retain the
+# external form that people included so that they don't explode so much.
+#
+# This should be removed from the system after a graceful deprecation period,
+# probably about the time that a version of Puppet containing this change is
+# the last supported version. --daniel 2012-07-17
+class Puppet::FileCollection
+  require 'puppet/file_collection/lookup'
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_collection/lookup.rb

@@ -0,0 +1,10 @@
+require 'puppet/file_collection'
+
+module Puppet::FileCollection::Lookup
+  # Yeah, this is all the external interface that was added to the folks who
+  # included this really was.  Thankfully.
+  #
+  # See the comments in `puppet/file_collection.rb` for the annotated version,
+  # or just port your code away from this by adding the accessors on your own.
+  attr_accessor :line, :file
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_serving.rb

@@ -0,0 +1,3 @@
+# Just a stub class.
+class Puppet::FileServing # :nodoc:
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_serving/base.rb

@@ -0,0 +1,95 @@
+require 'puppet/file_serving'
+require 'puppet/util'
+require 'puppet/util/methodhelper'
+
+# The base class for Content and Metadata; provides common
+# functionality like the behaviour around links.
+class Puppet::FileServing::Base
+  include Puppet::Util::MethodHelper
+
+  # This is for external consumers to store the source that was used
+  # to retrieve the metadata.
+  attr_accessor :source
+
+  # Does our file exist?
+  def exist?
+      stat
+      return true
+  rescue
+      return false
+  end
+
+  # Return the full path to our file.  Fails if there's no path set.
+  def full_path(dummy_argument=:work_arround_for_ruby_GC_bug)
+    if relative_path.nil? or relative_path == "" or relative_path == "."
+       full_path = path
+     else
+       full_path = File.join(path, relative_path)
+     end
+
+     if Puppet.features.microsoft_windows?
+       # Replace multiple slashes as long as they aren't at the beginning of a filename
+       full_path.gsub(%r{(./)/+}, '\1')
+     else
+       full_path.gsub(%r{//+}, '/')
+     end
+  end
+
+  def initialize(path, options = {})
+    self.path = path
+    @links = :manage
+    set_options(options)
+  end
+
+  # Determine how we deal with links.
+  attr_reader :links
+  def links=(value)
+    value = value.to_sym
+    value = :manage if value == :ignore
+    raise(ArgumentError, ":links can only be set to :manage or :follow") unless [:manage, :follow].include?(value)
+    @links = value
+  end
+
+  # Set our base path.
+  attr_reader :path
+  def path=(path)
+    raise ArgumentError.new("Paths must be fully qualified") unless Puppet::FileServing::Base.absolute?(path)
+    @path = path
+  end
+
+  # Set a relative path; this is used for recursion, and sets
+  # the file's path relative to the initial recursion point.
+  attr_reader :relative_path
+  def relative_path=(path)
+    raise ArgumentError.new("Relative paths must not be fully qualified") if Puppet::FileServing::Base.absolute?(path)
+    @relative_path = path
+  end
+
+  # Stat our file, using the appropriate link-sensitive method.
+  def stat
+    @stat_method ||= self.links == :manage ? :lstat : :stat
+    Puppet::FileSystem.send(@stat_method, full_path)
+  end
+
+  def to_data_hash
+    {
+      'path'          => @path,
+      'relative_path' => @relative_path,
+      'links'         => @links
+    }
+  end
+
+  def to_pson_data_hash
+    {
+      # No 'document_type' since we don't send these bare
+      'data'       => to_data_hash,
+      'metadata' => {
+        'api_version' => 1
+        }
+    }
+  end
+
+  def self.absolute?(path)
+    Puppet::Util.absolute_path?(path, :posix) or (Puppet.features.microsoft_windows? and Puppet::Util.absolute_path?(path, :windows))
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_serving/configuration.rb

@@ -0,0 +1,109 @@
+require 'puppet'
+require 'puppet/file_serving'
+require 'puppet/file_serving/mount'
+require 'puppet/file_serving/mount/file'
+require 'puppet/file_serving/mount/modules'
+require 'puppet/file_serving/mount/plugins'
+require 'puppet/file_serving/mount/pluginfacts'
+
+class Puppet::FileServing::Configuration
+  require 'puppet/file_serving/configuration/parser'
+
+  def self.configuration
+    @configuration ||= new
+  end
+
+  Mount = Puppet::FileServing::Mount
+
+  private_class_method  :new
+
+  attr_reader :mounts
+  #private :mounts
+
+  # Find the right mount.  Does some shenanigans to support old-style module
+  # mounts.
+  def find_mount(mount_name, environment)
+    # Reparse the configuration if necessary.
+    readconfig
+    # This can be nil.
+    mounts[mount_name]
+  end
+
+  def initialize
+    @mounts = {}
+    @config_file = nil
+
+    # We don't check to see if the file is modified the first time,
+    # because we always want to parse at first.
+    readconfig(false)
+  end
+
+  # Is a given mount available?
+  def mounted?(name)
+    @mounts.include?(name)
+  end
+
+  # Split the path into the separate mount point and path.
+  def split_path(request)
+    # Reparse the configuration if necessary.
+    readconfig
+
+    mount_name, path = request.key.split(File::Separator, 2)
+
+    raise(ArgumentError, "Cannot find file: Invalid mount '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
+    raise(ArgumentError, "Cannot find file: Invalid relative path '#{path}'") if path and path.split('/').include?('..')
+
+    return nil unless mount = find_mount(mount_name, request.environment)
+    if mount.name == "modules" and mount_name != "modules"
+      # yay backward-compatibility
+      path = "#{mount_name}/#{path}"
+    end
+
+    if path == ""
+      path = nil
+    elsif path
+      # Remove any double slashes that might have occurred
+      path = path.gsub(/\/+/, "/")
+    end
+
+    return mount, path
+  end
+
+  def umount(name)
+    @mounts.delete(name) if @mounts.include? name
+  end
+
+  private
+
+  def mk_default_mounts
+    @mounts["modules"] ||= Mount::Modules.new("modules")
+    @mounts["modules"].allow('*') if @mounts["modules"].empty?
+    @mounts["plugins"] ||= Mount::Plugins.new("plugins")
+    @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
+    @mounts["pluginfacts"] ||= Mount::PluginFacts.new("pluginfacts")
+    @mounts["pluginfacts"].allow('*') if @mounts["pluginfacts"].empty?
+  end
+
+  # Read the configuration file.
+  def readconfig(check = true)
+    config = Puppet[:fileserverconfig]
+
+    return unless Puppet::FileSystem.exist?(config)
+
+    @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
+
+    return if check and ! @parser.changed?
+
+    # Don't assign the mounts hash until we're sure the parsing succeeded.
+    begin
+      newmounts = @parser.parse
+      @mounts = newmounts
+    rescue => detail
+      Puppet.log_exception(detail, "Error parsing fileserver configuration: #{detail}; using old configuration")
+    end
+
+  ensure
+    # Make sure we've got our plugins and modules.
+    mk_default_mounts
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_serving/configuration/parser.rb

@@ -0,0 +1,121 @@
+require 'puppet/file_serving/configuration'
+require 'puppet/util/watched_file'
+
+class Puppet::FileServing::Configuration::Parser
+  Mount = Puppet::FileServing::Mount
+  MODULES = 'modules'
+
+  # Parse our configuration file.
+  def parse
+    raise("File server configuration #{@file} does not exist") unless Puppet::FileSystem.exist?(@file)
+    raise("Cannot read file server configuration #{@file}") unless FileTest.readable?(@file)
+
+    @mounts = {}
+    @count = 0
+
+    File.open(@file) { |f|
+      mount = nil
+      f.each_line { |line|
+        # Have the count increment at the top, in case we throw exceptions.
+        @count += 1
+
+        case line
+        when /^\s*#/; next # skip comments
+        when /^\s*$/; next # skip blank lines
+        when /\[([-\w]+)\]/
+          mount = newmount($1)
+        when /^\s*(\w+)\s+(.+?)(\s*#.*)?$/
+          var = $1
+          value = $2
+          value.strip!
+          raise(ArgumentError, "Fileserver configuration file does not use '=' as a separator") if value =~ /^=/
+          case var
+          when "path"
+            path(mount, value)
+          when "allow"
+            allow(mount, value)
+          when "deny"
+            deny(mount, value)
+          else
+            raise ArgumentError.new("Invalid argument '#{var}' in #{@file.filename}, line #{@count}")
+          end
+        else
+          raise ArgumentError.new("Invalid line '#{line.chomp}' at #{@file.filename}, line #{@count}")
+        end
+      }
+    }
+
+    validate
+
+    @mounts
+  end
+
+  def initialize(filename)
+    @file = Puppet::Util::WatchedFile.new(filename)
+  end
+
+  def changed?
+    @file.changed?
+  end
+
+  private
+
+  # Allow a given pattern access to a mount.
+  def allow(mount, value)
+    value.split(/\s*,\s*/).each { |val|
+      begin
+        mount.info "allowing #{val} access"
+        mount.allow(val)
+      rescue Puppet::AuthStoreError => detail
+        raise ArgumentError.new("#{detail.to_s} in #{@file}, line #{@count}")
+      end
+    }
+  end
+
+  # Deny a given pattern access to a mount.
+  def deny(mount, value)
+    value.split(/\s*,\s*/).each { |val|
+      begin
+        mount.info "denying #{val} access"
+        mount.deny(val)
+      rescue Puppet::AuthStoreError => detail
+        raise ArgumentError.new("#{detail.to_s} in #{@file}, line #{@count}")
+      end
+    }
+  end
+
+  # Create a new mount.
+  def newmount(name)
+    raise ArgumentError.new("#{@mounts[name]} is already mounted at #{name} in #{@file}, line #{@count}") if @mounts.include?(name)
+    case name
+    when "modules"
+      mount = Mount::Modules.new(name)
+    when "plugins"
+      mount = Mount::Plugins.new(name)
+    else
+      mount = Mount::File.new(name)
+    end
+    @mounts[name] = mount
+    mount
+  end
+
+  # Set the path for a mount.
+  def path(mount, value)
+    if mount.respond_to?(:path=)
+      begin
+        mount.path = value
+      rescue ArgumentError => detail
+        Puppet.log_exception(detail, "Removing mount \"#{mount.name}\": #{detail}")
+        @mounts.delete(mount.name)
+      end
+    else
+      Puppet.warning "The '#{mount.name}' module can not have a path. Ignoring attempt to set it"
+    end
+  end
+
+  # Make sure all of our mounts are valid.  We have to do this after the fact
+  # because details are added over time as the file is parsed.
+  def validate
+    @mounts.each { |name, mount| mount.validate }
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_serving/content.rb

@@ -0,0 +1,45 @@
+require 'puppet/indirector'
+require 'puppet/file_serving'
+require 'puppet/file_serving/base'
+
+# A class that handles retrieving file contents.
+# It only reads the file when its content is specifically
+# asked for.
+class Puppet::FileServing::Content < Puppet::FileServing::Base
+  extend Puppet::Indirector
+  indirects :file_content, :terminus_class => :selector
+
+  attr_writer :content
+
+  def self.supported_formats
+    [:raw]
+  end
+
+  def self.from_raw(content)
+    instance = new("/this/is/a/fake/path")
+    instance.content = content
+    instance
+  end
+
+  # BF: we used to fetch the file content here, but this is counter-productive
+  # for puppetmaster streaming of file content. So collect just returns itself
+  def collect(source_permissions = nil)
+    return if stat.ftype == "directory"
+    self
+  end
+
+  # Read the content of our file in.
+  def content
+    unless @content
+      # This stat can raise an exception, too.
+      raise(ArgumentError, "Cannot read the contents of links unless following links") if stat.ftype == "symlink"
+
+      @content = Puppet::FileSystem.binread(full_path)
+    end
+    @content
+  end
+
+  def to_raw
+    File.new(full_path, "rb")
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/file_serving/fileset.rb

@@ -0,0 +1,172 @@
+require 'find'
+require 'puppet/file_serving'
+require 'puppet/file_serving/metadata'
+
+# Operate recursively on a path, returning a set of file paths.
+class Puppet::FileServing::Fileset
+  attr_reader :path, :ignore, :links
+  attr_accessor :recurse, :recurselimit, :checksum_type
+
+  # Produce a hash of files, with merged so that earlier files
+  # with the same postfix win.  E.g., /dir1/subfile beats /dir2/subfile.
+  # It's a hash because we need to know the relative path of each file,
+  # and the base directory.
+  #   This will probably only ever be used for searching for plugins.
+  def self.merge(*filesets)
+    result = {}
+
+    filesets.each do |fileset|
+      fileset.files.each do |file|
+        result[file] ||= fileset.path
+      end
+    end
+
+    result
+  end
+
+  def initialize(path, options = {})
+    if Puppet.features.microsoft_windows?
+      # REMIND: UNC path
+      path = path.chomp(File::SEPARATOR) unless path =~ /^[A-Za-z]:\/$/
+    else
+      path = path.chomp(File::SEPARATOR) unless path == File::SEPARATOR
+    end
+    raise ArgumentError.new("Fileset paths must be fully qualified: #{path}") unless Puppet::Util.absolute_path?(path)
+
+    @path = path
+
+    # Set our defaults.
+    self.ignore = []
+    self.links = :manage
+    @recurse = false
+    @recurselimit = :infinite
+
+    if options.is_a?(Puppet::Indirector::Request)
+      initialize_from_request(options)
+    else
+      initialize_from_hash(options)
+    end
+
+    raise ArgumentError.new("Fileset paths must exist") unless valid?(path)
+    raise ArgumentError.new("Fileset recurse parameter must not be a number anymore, please use recurselimit") if @recurse.is_a?(Integer)
+  end
+
+  # Return a list of all files in our fileset.  This is different from the
+  # normal definition of find in that we support specific levels
+  # of recursion, which means we need to know when we're going another
+  # level deep, which Find doesn't do.
+  def files
+    files = perform_recursion
+
+    # Now strip off the leading path, so each file becomes relative, and remove
+    # any slashes that might end up at the beginning of the path.
+    result = files.collect { |file| file.sub(%r{^#{Regexp.escape(@path)}/*}, '') }
+
+    # And add the path itself.
+    result.unshift(".")
+
+    result
+  end
+
+  def ignore=(values)
+    values = [values] unless values.is_a?(Array)
+    @ignore = values.collect(&:to_s)
+  end
+
+  def links=(links)
+    links = links.to_sym
+    raise(ArgumentError, "Invalid :links value '#{links}'") unless [:manage, :follow].include?(links)
+    @links = links
+    @stat_method = @links == :manage ? :lstat : :stat
+  end
+
+  private
+
+  def initialize_from_hash(options)
+    options.each do |option, value|
+      method = option.to_s + "="
+      begin
+        send(method, value)
+      rescue NoMethodError
+        raise ArgumentError, "Invalid option '#{option}'", $!.backtrace
+      end
+    end
+  end
+
+  def initialize_from_request(request)
+    [:links, :ignore, :recurse, :recurselimit, :checksum_type].each do |param|
+      if request.options.include?(param) # use 'include?' so the values can be false
+        value = request.options[param]
+      elsif request.options.include?(param.to_s)
+        value = request.options[param.to_s]
+      end
+      next if value.nil?
+      value = true if value == "true"
+      value = false if value == "false"
+      value = Integer(value) if value.is_a?(String) and value =~ /^\d+$/
+      send(param.to_s + "=", value)
+    end
+  end
+
+  FileSetEntry = Struct.new(:depth, :path, :ignored, :stat_method) do
+    def down_level(to)
+      FileSetEntry.new(depth + 1, File.join(path, to), ignored, stat_method)
+    end
+
+    def basename
+      File.basename(path)
+    end
+
+    def children
+      return [] unless directory?
+
+      Dir.entries(path).
+        reject { |child| ignore?(child) }.
+        collect { |child| down_level(child) }
+    end
+
+    def ignore?(child)
+      return true if child == "." || child == ".."
+      return false if ignored == [nil]
+
+      ignored.any? { |pattern| File.fnmatch?(pattern, child) }
+    end
+
+    def directory?
+      Puppet::FileSystem.send(stat_method, path).directory?
+    rescue Errno::ENOENT, Errno::EACCES
+      false
+    end
+  end
+
+  # Pull the recursion logic into one place.  It's moderately hairy, and this
+  # allows us to keep the hairiness apart from what we do with the files.
+  def perform_recursion
+    current_dirs = [FileSetEntry.new(0, @path, @ignore, @stat_method)]
+
+    result = []
+
+    while entry = current_dirs.shift
+      if continue_recursion_at?(entry.depth + 1)
+        entry.children.each do |child|
+          result << child.path
+          current_dirs << child
+        end
+      end
+    end
+
+    result
+  end
+
+  def valid?(path)
+    Puppet::FileSystem.send(@stat_method, path)
+    true
+  rescue Errno::ENOENT, Errno::EACCES
+    false
+  end
+
+  def continue_recursion_at?(depth)
+    # recurse if told to, and infinite recursion or current depth not at the limit
+    self.recurse && (self.recurselimit == :infinite || depth <= self.recurselimit)
+  end
+end