bolt 0.20.0 → 0.20.2

data/vendored/puppet/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}") % { file: 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") % { path: path } unless FileTest.directory?(path)
+      raise ArgumentError, _("%{path} is not readable") % { path: path } 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") % { path: path }
+      # 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/vendored/puppet/lib/puppet/file_serving/mount/locales.rb

@@ -0,0 +1,35 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' locales directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Locales < Puppet::FileServing::Mount
+  # Return an instance of the appropriate class.
+  def find(relative_path, request)
+    return nil unless mod = request.environment.modules.find { |m|  m.locale(relative_path) }
+
+    path = mod.locale(relative_path)
+
+    path
+  end
+
+  def search(relative_path, request)
+    # We currently only support one kind of search on locales - return
+    # them all.
+    Puppet.debug("Warning: calling Locales.search with empty module path.") if request.environment.modules.empty?
+    paths = request.environment.modules.find_all { |mod| mod.locales? }.collect { |mod| mod.locale_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/vendored/puppet/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/vendored/puppet/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 { |m|  m.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/vendored/puppet/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 { |m|  m.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

data/vendored/puppet/lib/puppet/file_serving/mount/tasks.rb

@@ -0,0 +1,21 @@
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::Tasks < Puppet::FileServing::Mount
+  def find(path, request)
+    raise _("No task specified") if path.to_s.empty?
+    module_name, task_path = path.split("/", 2)
+    return nil unless mod = request.environment.module(module_name)
+
+    mod.task_file(task_path)
+  end
+
+  def search(path, request)
+    if result = find(path, request)
+      [result]
+    end
+  end
+
+  def valid?
+    true
+  end
+end

data/vendored/puppet/lib/puppet/file_serving/terminus_helper.rb

@@ -0,0 +1,31 @@
+require 'puppet/file_serving'
+require 'puppet/file_serving/fileset'
+
+# Define some common methods for FileServing termini.
+
+module Puppet::FileServing::TerminusHelper
+  # Create model instance for a file in a file server.
+  def path2instance(request, path, options = {})
+    result = model.new(path, :relative_path => options[:relative_path])
+    result.links = request.options[:links] if request.options[:links]
+
+    result.checksum_type = request.options[:checksum_type] if request.options[:checksum_type]
+    result.source_permissions = request.options[:source_permissions] if request.options[:source_permissions]
+
+    result.collect
+
+    result
+  end
+
+  # Create model instances for all files in a fileset.
+  def path2instances(request, *paths)
+    filesets = paths.collect do |path|
+      # Filesets support indirector requests as an options collection
+      Puppet::FileServing::Fileset.new(path, request)
+    end
+
+    Puppet::FileServing::Fileset.merge(*filesets).collect do |file, base_path|
+      path2instance(request, base_path, :relative_path => file)
+    end
+  end
+end

data/vendored/puppet/lib/puppet/file_serving/terminus_selector.rb

@@ -0,0 +1,32 @@
+require 'puppet/file_serving'
+
+# This module is used to pick the appropriate terminus
+# in file-serving indirections.  This is necessary because
+# the terminus varies based on the URI asked for.
+module Puppet::FileServing::TerminusSelector
+  def select(request)
+    # We rely on the request's parsing of the URI.
+
+    # Short-circuit to :file if it's a fully-qualified path or specifies a 'file' protocol.
+    if Puppet::Util.absolute_path?(request.key)
+      return :file
+    end
+
+    case request.protocol
+    when "file"
+      :file
+    when "puppet"
+      if request.server
+        :rest
+      else
+        Puppet[:default_file_terminus]
+      end
+   when "http","https"
+     :http
+    when nil
+      :file_server
+    else
+      raise ArgumentError, _("URI protocol '%{protocol}' is not currently supported for file serving") % { protocol: request.protocol }
+    end
+  end
+end

data/vendored/puppet/lib/puppet/file_system.rb

@@ -0,0 +1,404 @@
+module Puppet::FileSystem
+  require 'puppet/util'
+  require 'puppet/file_system/path_pattern'
+  require 'puppet/file_system/file_impl'
+  require 'puppet/file_system/memory_file'
+  require 'puppet/file_system/memory_impl'
+  require 'puppet/file_system/uniquefile'
+
+  # create instance of the file system implementation to use for the current platform
+  @impl = if Puppet::Util::Platform.windows?
+           require 'puppet/file_system/windows'
+           Puppet::FileSystem::Windows
+         else
+           require 'puppet/file_system/posix'
+           Puppet::FileSystem::Posix
+         end.new()
+
+  # Allows overriding the filesystem for the duration of the given block.
+  # The filesystem will only contain the given file(s).
+  #
+  # @param files [Puppet::FileSystem::MemoryFile] the files to have available
+  #
+  # @api private
+  #
+  def self.overlay(*files, &block)
+    old_impl = @impl
+    @impl = Puppet::FileSystem::MemoryImpl.new(*files)
+    yield
+  ensure
+    @impl = old_impl
+  end
+
+  # Opens the given path with given mode, and options and optionally yields it to the given block.
+  #
+  # @param path [String, Pathname] the path to the file to operate on
+  # @param mode [Integer] The mode to apply to the file if it is created
+  # @param options [String] Extra file operation mode information to use
+  #   This is the standard mechanism Ruby uses in the IO class, and therefore
+  #   encoding may be specified explicitly as fmode : encoding or fmode : "BOM|UTF-*"
+  #   for example, a:ASCII or w+:UTF-8
+  # @yield The file handle, in the mode given by options, else read-write mode
+  # @return [Void]
+  #
+  # @api public
+  #
+  def self.open(path, mode, options, &block)
+    @impl.open(assert_path(path), mode, options, &block)
+  end
+
+  # @return [Object] The directory of this file as an opaque handle
+  #
+  # @api public
+  #
+  def self.dir(path)
+    @impl.dir(assert_path(path))
+  end
+
+  # @return [String] The directory of this file as a String
+  #
+  # @api public
+  #
+  def self.dir_string(path)
+    @impl.path_string(@impl.dir(assert_path(path)))
+  end
+
+  # @return [Boolean] Does the directory of the given path exist?
+  def self.dir_exist?(path)
+    @impl.exist?(@impl.dir(assert_path(path)))
+  end
+
+  # Creates all directories down to (inclusive) the dir of the given path
+  def self.dir_mkpath(path)
+    @impl.mkpath(@impl.dir(assert_path(path)))
+  end
+
+  # @return [Object] the name of the file as a opaque handle
+  #
+  # @api public
+  #
+  def self.basename(path)
+    @impl.basename(assert_path(path))
+  end
+
+  # @return [String] the name of the file
+  #
+  # @api public
+  #
+  def self.basename_string(path)
+    @impl.path_string(@impl.basename(assert_path(path)))
+  end
+
+  # @return [Integer] the size of the file
+  #
+  # @api public
+  #
+  def self.size(path)
+    @impl.size(assert_path(path))
+  end
+
+  # Allows exclusive updates to a file to be made by excluding concurrent
+  # access using flock. This means that if the file is on a filesystem that
+  # does not support flock, this method will provide no protection.
+  #
+  # While polling to acquire the lock the process will wait ever increasing
+  # amounts of time in order to prevent multiple processes from wasting
+  # resources.
+  #
+  # @param path [Pathname] the path to the file to operate on
+  # @param mode [Integer] The mode to apply to the file if it is created
+  # @param options [String] Extra file operation mode information to use
+  #   (defaults to read-only mode 'r')
+  #   This is the standard mechanism Ruby uses in the IO class, and therefore
+  #   encoding may be specified explicitly as fmode : encoding or fmode : "BOM|UTF-*"
+  #   for example, a:ASCII or w+:UTF-8
+  # @param timeout [Integer] Number of seconds to wait for the lock (defaults to 300)
+  # @yield The file handle, in the mode given by options, else read-write mode
+  # @return [Void]
+  # @raise [Timeout::Error] If the timeout is exceeded while waiting to acquire the lock
+  #
+  # @api public
+  #
+  def self.exclusive_open(path, mode, options = 'r', timeout = 300, &block)
+    @impl.exclusive_open(assert_path(path), mode, options, timeout, &block)
+  end
+
+  # Processes each line of the file by yielding it to the given block
+  #
+  # @api public
+  #
+  def self.each_line(path, &block)
+    @impl.each_line(assert_path(path), &block)
+  end
+
+  # @return [String] The contents of the file
+  #
+  # @api public
+  #
+  def self.read(path, opts = {})
+    @impl.read(assert_path(path), opts)
+  end
+
+  # Read a file keeping the original line endings intact. This
+  # attempts to open files using binary mode using some encoding
+  # overrides and falling back to IO.read when none of the
+  # encodings are valid.
+  #
+  # @return [String] The contents of the file
+  #
+  # @api public
+  #
+  def self.read_preserve_line_endings(path)
+    @impl.read_preserve_line_endings(assert_path(path))
+  end
+
+  # @return [String] The binary contents of the file
+  #
+  # @api public
+  #
+  def self.binread(path)
+    @impl.binread(assert_path(path))
+  end
+
+  # Determines if a file exists by verifying that the file can be stat'd.
+  # Will follow symlinks and verify that the actual target path exists.
+  #
+  # @return [Boolean] true if the named file exists.
+  #
+  # @api public
+  #
+  def self.exist?(path)
+    @impl.exist?(assert_path(path))
+  end
+
+  # Determines if a file is a directory.
+  #
+  # @return [Boolean] true if the given file is a directory.
+  #
+  # @api public
+  def self.directory?(path)
+    @impl.directory?(assert_path(path))
+  end
+
+  # Determines if a file is a file.
+  #
+  # @return [Boolean] true if the given file is a file.
+  #
+  # @api public
+  def self.file?(path)
+    @impl.file?(assert_path(path))
+  end
+
+  # Determines if a file is executable.
+  #
+  # @todo Should this take into account extensions on the windows platform?
+  #
+  # @return [Boolean] true if this file can be executed
+  #
+  # @api public
+  #
+  def self.executable?(path)
+    @impl.executable?(assert_path(path))
+  end
+
+  # @return [Boolean] Whether the file is writable by the current process
+  #
+  # @api public
+  #
+  def self.writable?(path)
+    @impl.writable?(assert_path(path))
+  end
+
+  # Touches the file. On most systems this updates the mtime of the file.
+  #
+  # @api public
+  #
+  def self.touch(path)
+    @impl.touch(assert_path(path))
+  end
+
+  # Creates directories for all parts of the given path.
+  #
+  # @api public
+  #
+  def self.mkpath(path)
+    @impl.mkpath(assert_path(path))
+  end
+
+  # @return [Array<Object>] references to all of the children of the given
+  #   directory path, excluding `.` and `..`.
+  # @api public
+  def self.children(path)
+    @impl.children(assert_path(path))
+  end
+
+  # Creates a symbolic link dest which points to the current file.
+  # If dest already exists:
+  #
+  # * and is a file, will raise Errno::EEXIST
+  # * and is a directory, will return 0 but perform no action
+  # * and is a symlink referencing a file, will raise Errno::EEXIST
+  # * and is a symlink referencing a directory, will return 0 but perform no action
+  #
+  # With the :force option set to true, when dest already exists:
+  #
+  # * and is a file, will replace the existing file with a symlink (DANGEROUS)
+  # * and is a directory, will return 0 but perform no action
+  # * and is a symlink referencing a file, will modify the existing symlink
+  # * and is a symlink referencing a directory, will return 0 but perform no action
+  #
+  # @param dest [String] The path to create the new symlink at
+  # @param [Hash] options the options to create the symlink with
+  # @option options [Boolean] :force overwrite dest
+  # @option options [Boolean] :noop do not perform the operation
+  # @option options [Boolean] :verbose verbose output
+  #
+  # @raise [Errno::EEXIST] dest already exists as a file and, :force is not set
+  #
+  # @return [Integer] 0
+  #
+  # @api public
+  #
+  def self.symlink(path, dest, options = {})
+    @impl.symlink(assert_path(path), dest, options)
+  end
+
+  # @return [Boolean] true if the file is a symbolic link.
+  #
+  # @api public
+  #
+  def self.symlink?(path)
+    @impl.symlink?(assert_path(path))
+  end
+
+  # @return [String] the name of the file referenced by the given link.
+  #
+  # @api public
+  #
+  def self.readlink(path)
+    @impl.readlink(assert_path(path))
+  end
+
+  # Deletes the given paths, returning the number of names passed as arguments.
+  # See also Dir::rmdir.
+  #
+  # @raise an exception on any error.
+  #
+  # @return [Integer] the number of paths passed as arguments
+  #
+  # @api public
+  #
+  def self.unlink(*paths)
+    @impl.unlink(*(paths.map {|p| assert_path(p) }))
+  end
+
+  # @return [File::Stat] object for the named file.
+  #
+  # @api public
+  #
+  def self.stat(path)
+    @impl.stat(assert_path(path))
+  end
+
+  # @return [Integer] the size of the file
+  #
+  # @api public
+  #
+  def self.size(path)
+    @impl.size(assert_path(path))
+  end
+
+  # @return [File::Stat] Same as stat, but does not follow the last symbolic
+  # link. Instead, reports on the link itself.
+  #
+  # @api public
+  #
+  def self.lstat(path)
+    @impl.lstat(assert_path(path))
+  end
+
+  # Compares the contents of this file against the contents of a stream.
+  #
+  # @param stream [IO] The stream to compare the contents against
+  # @return [Boolean] Whether the contents were the same
+  #
+  # @api public
+  #
+  def self.compare_stream(path, stream)
+    @impl.compare_stream(assert_path(path), stream)
+  end
+
+  # Produces an opaque pathname "handle" object representing the given path.
+  # Different implementations of the underlying file system may use different runtime
+  # objects. The produced "handle" should be used in all other operations
+  # that take a "path". No operation should be directly invoked on the returned opaque object
+  #
+  # @param path [String] The string representation of the path
+  # @return [Object] An opaque path handle on which no operations should be directly performed
+  #
+  # @api public
+  #
+  def self.pathname(path)
+    @impl.pathname(path)
+  end
+
+  # Produces a string representation of the opaque path handle, with expansions
+  # performed on ~.  For Windows, this means that C:\Users\Admini~1\AppData will
+  # be expanded to C:\Users\Administrator\AppData.  On POSIX filesystems, the
+  # value ~ will be expanded to something like /Users/Foo
+  #
+  # This method exists primarlily to resolve a Ruby deficiency where
+  # File.expand_path doesn't handle ~ in each segment on a Windows path
+  #
+  # @param path [Object] a path handle produced by {#pathname}
+  # @return [String] a string representation of the path
+  #
+  def self.expand_path(path, dir_string = nil)
+    @impl.expand_path(path, dir_string)
+  end
+
+  # Asserts that the given path is of the expected type produced by #pathname
+  #
+  # @raise [ArgumentError] when path is not of the expected type
+  #
+  # @api public
+  #
+  def self.assert_path(path)
+    @impl.assert_path(path)
+  end
+
+  # Produces a string representation of the opaque path handle.
+  #
+  # @param path [Object] a path handle produced by {#pathname}
+  # @return [String] a string representation of the path
+  #
+  def self.path_string(path)
+    @impl.path_string(path)
+  end
+
+  # Create and open a file for write only if it doesn't exist.
+  #
+  # @see Puppet::FileSystem::open
+  #
+  # @raise [Errno::EEXIST] path already exists.
+  #
+  # @api public
+  #
+  def self.exclusive_create(path, mode, &block)
+    @impl.exclusive_create(assert_path(path), mode, &block)
+  end
+
+  # Changes permission bits on the named path to the bit pattern represented
+  # by mode.
+  #
+  # @param mode [Integer] The mode to apply to the file if it is created
+  # @param path [String] The path to the file, can also accept [PathName]
+  #
+  # @raise [Errno::ENOENT]: path doesn't exist
+  #
+  # @api public
+  #
+  def self.chmod(mode, path)
+    @impl.chmod(mode, path)
+  end
+end