puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,199 @@
+require 'puppet'
+require 'puppet/indirector'
+require 'puppet/file_serving'
+require 'puppet/file_serving/base'
+require 'puppet/util/checksums'
+
+# A class that handles retrieving file metadata.
+class Puppet::FileServing::Metadata < Puppet::FileServing::Base
+
+  include Puppet::Util::Checksums
+
+  extend Puppet::Indirector
+  indirects :file_metadata, :terminus_class => :selector
+
+  attr_reader :path, :owner, :group, :mode, :checksum_type, :checksum, :ftype, :destination
+
+  PARAM_ORDER = [:mode, :ftype, :owner, :group]
+
+  def checksum_type=(type)
+    raise(ArgumentError, "Unsupported checksum type #{type}") unless respond_to?("#{type}_file")
+
+    @checksum_type = type
+  end
+
+  class MetaStat
+    extend Forwardable
+
+    def initialize(stat, source_permissions = nil)
+      @stat = stat
+      @source_permissions_ignore = source_permissions == :ignore
+    end
+
+    def owner
+      @source_permissions_ignore ? Process.euid : @stat.uid
+    end
+
+    def group
+      @source_permissions_ignore ? Process.egid : @stat.gid
+    end
+
+    def mode
+      @source_permissions_ignore ? 0644 : @stat.mode
+    end
+
+    def_delegators :@stat, :ftype
+  end
+
+  class WindowsStat < MetaStat
+    if Puppet.features.microsoft_windows?
+      require 'puppet/util/windows/security'
+    end
+
+    def initialize(stat, path, source_permissions = nil)
+      super(stat, source_permissions)
+      @path = path
+    end
+
+    { :owner => 'S-1-5-32-544',
+      :group => 'S-1-0-0',
+      :mode => 0644
+    }.each do |method, default_value|
+      define_method method do
+        return default_value if @source_permissions_ignore
+
+        # this code remains for when source_permissions is not set to :ignore
+        begin
+          Puppet::Util::Windows::Security.send("get_#{method}", @path) || default_value
+        rescue Puppet::Util::Windows::Error => detail
+          # Very carefully catch only this specific error that result from
+          # trying to read permissions on a symlinked file that is on a volume
+          # that does not support ACLs.
+          #
+          # Unfortunately readlink method will not return the target path when
+          # the given path is not the symlink.
+          #
+          # For instance, consider:
+          #   symlink c:\link points to c:\target
+          #   FileSystem.readlink('c:/link') returns 'c:/target'
+          #   FileSystem.readlink('c:/link/file') will NOT return 'c:/target/file'
+          #
+          # Since detecting this up front is costly, since the path in question
+          # needs to be recursively split and tested at each depth in the path,
+          # we catch the standard error that will result from trying to read a
+          # file that doesn't have a DACL - 1336 is ERROR_INVALID_DACL
+          #
+          # Note that this affects any manually created symlinks as well as
+          # paths like puppet:///modules
+          return default_value if detail.code == 1336
+
+          # Also handle a VirtualBox bug where ERROR_INVALID_FUNCTION is
+          # returned when following a symlink to a volume that is not NTFS.
+          # It appears that the VirtualBox file system is not propagating
+          # the standard Win32 error code above like it should.
+          #
+          # Apologies to all who enter this code path at a later date
+          if detail.code == 1 && Facter.value(:virtual) == 'virtualbox'
+            return default_value
+          end
+
+          raise
+        end
+      end
+    end
+  end
+
+  def collect_stat(path, source_permissions)
+    stat = stat()
+
+    if Puppet.features.microsoft_windows?
+      WindowsStat.new(stat, path, source_permissions)
+    else
+      MetaStat.new(stat, source_permissions)
+    end
+  end
+
+  # Retrieve the attributes for this file, relative to a base directory.
+  # Note that Puppet::FileSystem.stat(path) raises Errno::ENOENT
+  # if the file is absent and this method does not catch that exception.
+  def collect(source_permissions = nil)
+    real_path = full_path
+
+    stat = collect_stat(real_path, source_permissions)
+    @owner = stat.owner
+    @group = stat.group
+    @ftype = stat.ftype
+
+    # We have to mask the mode, yay.
+    @mode = stat.mode & 007777
+
+    case stat.ftype
+    when "file"
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s
+    when "directory" # Always just timestamp the directory.
+      @checksum_type = "ctime"
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", path).to_s
+    when "link"
+      @destination = Puppet::FileSystem.readlink(real_path)
+      @checksum = ("{#{@checksum_type}}") + send("#{@checksum_type}_file", real_path).to_s rescue nil
+    else
+      raise ArgumentError, "Cannot manage files of type #{stat.ftype}"
+    end
+  end
+
+  def initialize(path,data={})
+    @owner       = data.delete('owner')
+    @group       = data.delete('group')
+    @mode        = data.delete('mode')
+    if checksum = data.delete('checksum')
+      @checksum_type = checksum['type']
+      @checksum      = checksum['value']
+    end
+    @checksum_type ||= Puppet[:digest_algorithm]
+    @ftype       = data.delete('type')
+    @destination = data.delete('destination')
+    super(path,data)
+  end
+
+  def to_data_hash
+    super.update(
+      {
+        'owner'        => owner,
+        'group'        => group,
+        'mode'         => mode,
+        'checksum'     => {
+          'type'   => checksum_type,
+          'value'  => checksum
+        },
+        'type'         => ftype,
+        'destination'  => destination,
+
+      }
+    )
+  end
+
+  def self.from_data_hash(data)
+    new(data.delete('path'), data)
+  end
+
+  PSON.register_document_type('FileMetadata',self)
+  def to_pson_data_hash
+    {
+      'document_type' => 'FileMetadata',
+      'data'          => to_data_hash,
+      'metadata'      => {
+        'api_version' => 1
+        }
+    }
+  end
+
+  def to_pson(*args)
+    to_pson_data_hash.to_pson(*args)
+  end
+
+  def self.from_pson(data)
+    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
+    self.from_data_hash(data)
+  end
+
+end

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

@@ -0,0 +1,39 @@
+require 'puppet/network/authstore'
+require 'puppet/util/logging'
+require 'puppet/file_serving'
+require 'puppet/file_serving/metadata'
+require 'puppet/file_serving/content'
+
+# Broker access to the filesystem, converting local URIs into metadata
+# or content objects.
+class Puppet::FileServing::Mount < Puppet::Network::AuthStore
+  include Puppet::Util::Logging
+
+  attr_reader :name
+
+  def find(path, options)
+    raise NotImplementedError
+  end
+
+  # Create our object.  It must have a name.
+  def initialize(name)
+    unless name =~ %r{^[-\w]+$}
+      raise ArgumentError, "Invalid mount name format '#{name}'"
+    end
+    @name = name
+
+    super()
+  end
+
+  def search(path, options)
+    raise NotImplementedError
+  end
+
+  def to_s
+    "mount[#{@name}]"
+  end
+
+  # A noop.
+  def validate
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::File < Puppet::FileServing::Mount
+  def self.localmap
+    @localmap ||= {
+      "h" => Facter.value("hostname"),
+      "H" => [
+               Facter.value("hostname"),
+               Facter.value("domain")
+             ].join("."),
+      "d" => Facter.value("domain")
+    }
+  end
+
+  def complete_path(relative_path, node)
+    full_path = path(node)
+
+    raise ArgumentError.new("Mounts without paths are not usable") unless full_path
+
+    # If there's no relative path name, then we're serving the mount itself.
+    return full_path unless relative_path
+
+    file = ::File.join(full_path, relative_path)
+
+    if !(Puppet::FileSystem.exist?(file) or Puppet::FileSystem.symlink?(file))
+      Puppet.info("File does not exist or is not accessible: #{file}")
+      return nil
+    end
+
+    file
+  end
+
+  # Return an instance of the appropriate class.
+  def find(short_file, request)
+    complete_path(short_file, request.node)
+  end
+
+  # Return the path as appropriate, expanding as necessary.
+  def path(node = nil)
+    if expandable?
+      return expand(@path, node)
+    else
+      return @path
+    end
+  end
+
+  # Set the path.
+  def path=(path)
+    # FIXME: For now, just don't validate paths with replacement
+    # patterns in them.
+    if path =~ /%./
+      # Mark that we're expandable.
+      @expandable = true
+    else
+      raise ArgumentError, "#{path} does not exist or is not a directory" unless FileTest.directory?(path)
+      raise ArgumentError, "#{path} is not readable" unless FileTest.readable?(path)
+      @expandable = false
+    end
+    @path = path
+  end
+
+  def search(path, request)
+    return nil unless path = complete_path(path, request.node)
+    [path]
+  end
+
+  # Verify our configuration is valid.  This should really check to
+  # make sure at least someone will be allowed, but, eh.
+  def validate
+    raise ArgumentError.new("Mounts without paths are not usable") if @path.nil?
+  end
+
+  private
+
+  # Create a map for a specific node.
+  def clientmap(node)
+    {
+      "h" => node.sub(/\..*$/, ""),
+      "H" => node,
+      "d" => node.sub(/[^.]+\./, "") # domain name
+    }
+  end
+
+  # Replace % patterns as appropriate.
+  def expand(path, node = nil)
+    # This map should probably be moved into a method.
+    map = nil
+
+    if node
+      map = clientmap(node)
+    else
+      Puppet.notice "No client; expanding '#{path}' with local host"
+      # Else, use the local information
+      map = localmap
+    end
+
+    path.gsub(/%(.)/) do |v|
+      key = $1
+      if key == "%"
+        "%"
+      else
+        map[key] || v
+      end
+    end
+  end
+
+  # Do we have any patterns in our path, yo?
+  def expandable?
+    if defined?(@expandable)
+      @expandable
+    else
+      false
+    end
+  end
+
+  # Cache this manufactured map, since if it's used it's likely
+  # to get used a lot.
+  def localmap
+    self.class.localmap
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'puppet/file_serving/mount'
+
+# This is the modules-specific mount: it knows how to search through
+# modules for files.  Yay.
+class Puppet::FileServing::Mount::Modules < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(path, request)
+    raise "No module specified" if path.to_s.empty?
+    module_name, relative_path = path.split("/", 2)
+    return nil unless mod = request.environment.module(module_name)
+
+    mod.file(relative_path)
+  end
+
+  def search(path, request)
+    if result = find(path, request)
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' pluginfacts directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::PluginFacts < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    return nil unless mod = request.environment.modules.find { |mod|  mod.pluginfact(relative_path) }
+
+    path = mod.pluginfact(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on plugins - return
+    # them all.
+    Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
+    paths = request.environment.modules.find_all { |mod| mod.pluginfacts? }.collect { |mod| mod.plugin_fact_directory }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' plugins directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Plugins < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    return nil unless mod = request.environment.modules.find { |mod|  mod.plugin(relative_path) }
+
+    path = mod.plugin(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on plugins - return
+    # them all.
+    Puppet.debug("Warning: calling Plugins.search with empty module path.") if request.environment.modules.empty?
+    paths = request.environment.modules.find_all { |mod| mod.plugins? }.collect { |mod| mod.plugin_directory }
+    if paths.empty?
+      # If the modulepath is valid then we still need to return a valid root
+      # directory for the search, but make sure nothing inside it is
+      # returned.
+      request.options[:recurse] = false
+      request.environment.modulepath.empty? ? nil : request.environment.modulepath
+    else
+      paths
+    end
+  end
+
+  def valid?
+    true
+  end
+end