puppet 3.3.2 → 3.4.0.rc1

data/lib/puppet/file_system.rb

@@ -1,3 +1,6 @@
 module Puppet::FileSystem
   require 'puppet/file_system/path_pattern'
+  require 'puppet/file_system/file'
+  require 'puppet/file_system/memory_file'
+  require 'puppet/file_system/tempfile'
 end

data/lib/puppet/file_system/file.rb

@@ -0,0 +1,261 @@
+# An abstraction over the ruby file system operations for a single file.
+#
+# For the time being this is being kept private so that we can evolve it for a
+# while.
+#
+# @api private
+class Puppet::FileSystem::File
+  attr_reader :path
+
+  IMPL = if RUBY_VERSION =~ /^1\.8/
+           require 'puppet/file_system/file18'
+           Puppet::FileSystem::File18
+         elsif Puppet::Util::Platform.windows?
+           require 'puppet/file_system/file19windows'
+           Puppet::FileSystem::File19Windows
+         else
+           require 'puppet/file_system/file19'
+           Puppet::FileSystem::File19
+         end
+
+  @remembered = {}
+
+  def self.new(path)
+    if @remembered.include?(path.to_s)
+      @remembered[path.to_s]
+    else
+      file = IMPL.allocate
+      file.send(:initialize, path)
+      file
+    end
+  end
+
+  # Run a block of code with a file accessible in the filesystem.
+  # @note This API should only be used for testing
+  #
+  # @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
+  # @api private
+  def self.overlay(file, &block)
+    remember(file)
+    yield
+  ensure
+    forget(file)
+  end
+
+  # Create a binding between a filename and a particular instance of a file object.
+  # @note This API should only be used for testing
+  #
+  # @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
+  # @api private
+  def self.remember(file)
+    @remembered[file.path.to_s] = file
+  end
+
+  # Forget a remembered file
+  # @note This API should only be used for testing
+  #
+  # @param file [Object] an object that conforms to the Puppet::FileSystem::File interface
+  # @api private
+  def self.forget(file)
+    @remembered.delete(file.path.to_s)
+  end
+
+  def initialize(path)
+    if path.is_a?(Pathname)
+      @path = path
+    else
+      @path = Pathname.new(path)
+    end
+  end
+
+  def open(mode, options, &block)
+    ::File.open(@path, options, mode, &block)
+  end
+
+  # @return [Puppet::FileSystem::File] The directory of this file
+  # @api public
+  def dir
+    Puppet::FileSystem::File.new(@path.dirname)
+  end
+
+  # @return [Num] The size of this file
+  # @api public
+  def size
+    @path.size
+  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 aquire the lock the process will wait ever increasing
+  # amounts of time in order to prevent multiple processes from wasting
+  # resources.
+  #
+  # @param mode [Integer] The mode to apply to the file if it is created
+  # @param options [Integer] Extra file operation mode information to use
+  # (defaults to read-only mode)
+  # @param timeout [Integer] Number of seconds to wait for the lock (defaults to 300)
+  # @yield The file handle, in read-write mode
+  # @return [Void]
+  # @raise [Timeout::Error] If the timeout is exceeded while waiting to aquire the lock
+  # @api public
+  def exclusive_open(mode, options = 'r', timeout = 300, &block)
+    wait = 0.001 + (Kernel.rand / 1000)
+    written = false
+    while !written
+      ::File.open(@path, options, mode) do |rf|
+        if rf.flock(::File::LOCK_EX|::File::LOCK_NB)
+          yield rf
+          written = true
+        else
+          sleep wait
+          timeout -= wait
+          wait *= 2
+          if timeout < 0
+            raise Timeout::Error, "Timeout waiting for exclusive lock on #{@path}"
+          end
+        end
+      end
+    end
+  end
+
+  def each_line(&block)
+    ::File.open(@path) do |f|
+      f.each_line do |line|
+        yield line
+      end
+    end
+  end
+
+  # @return [String] The contents of the file
+  def read
+    @path.read
+  end
+
+  # @return [String] The binary contents of the file
+  def binread
+    raise NotImplementedError
+  end
+
+  # Determine 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.
+  def self.exist?(path)
+    return IMPL.exist?(path) if IMPL.method(:exist?) != self.method(:exist?)
+    File.exist?(path)
+  end
+
+  # Determine 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 path of this file is present
+  def exist?
+    self.class.exist?(@path)
+  end
+
+  # Determine 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
+  def executable?
+    ::File.executable?(@path)
+  end
+
+  # @return [Boolean] Whether the file is writable by the current
+  # process
+  def writable?
+    @path.writable?
+  end
+
+  # Touches the file. On most systems this updates the mtime of the file.
+  def touch
+    ::FileUtils.touch(@path)
+  end
+
+  # Create the entire path as directories
+  def mkpath
+    @path.mkpath
+  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
+  def symlink(dest, options = {})
+    FileUtils.symlink(@path, dest, options)
+  end
+
+  # @return [Boolean] true if the file is a symbolic link.
+  def symlink?
+    File.symlink?(@path)
+  end
+
+  # @return [String] the name of the file referenced by the given link.
+  def readlink
+    File.readlink(@path)
+  end
+
+  # Deletes the named files, returning the number of names passed as arguments.
+  # See also Dir::rmdir.
+  #
+  # @raise an exception on any error.
+  #
+  # @return [Integer] the number of names passed as arguments
+  def self.unlink(*file_names)
+    return IMPL.unlink(*file_names) if IMPL.method(:unlink) != self.method(:unlink)
+    File.unlink(*file_names)
+  end
+
+  # Deletes the file.
+  # See also Dir::rmdir.
+  #
+  # @raise an exception on any error.
+  #
+  # @return [Integer] the number of names passed as arguments, in this case 1
+  def unlink
+    self.class.unlink(@path)
+  end
+
+  # @return [File::Stat] object for the named file.
+  def stat
+    File.stat(@path)
+  end
+
+  # @return [File::Stat] Same as stat, but does not follow the last symbolic
+  # link. Instead, reports on the link itself.
+  def lstat
+    File.lstat(@path)
+  end
+
+  # Compare 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
+  def compare_stream(stream)
+    open(0, 'rb') do |this|
+      FileUtils.compare_stream(this, stream)
+    end
+  end
+end

data/lib/puppet/file_system/file18.rb

@@ -0,0 +1,5 @@
+class Puppet::FileSystem::File18 < Puppet::FileSystem::File
+  def binread
+    ::File.open(@path, 'rb') { |f| f.read }
+  end
+end

data/lib/puppet/file_system/file19.rb

@@ -0,0 +1,5 @@
+class Puppet::FileSystem::File19 < Puppet::FileSystem::File
+  def binread
+    @path.binread
+  end
+end

data/lib/puppet/file_system/file19windows.rb

@@ -0,0 +1,113 @@
+require 'puppet/file_system/file19'
+require 'puppet/util/windows'
+
+class Puppet::FileSystem::File19Windows < Puppet::FileSystem::File19
+
+  def self.exist?(path)
+    if ! Puppet.features.manages_symlinks?
+      return ::File.exist?(path)
+    end
+
+    path = path.to_str if path.respond_to?(:to_str) # support WatchedFile
+    path = path.to_s # support String and Pathname
+
+    begin
+      if Puppet::Util::Windows::File.symlink?(path)
+        path = Puppet::Util::Windows::File.readlink(path)
+      end
+      ! Puppet::Util::Windows::File.stat(path).nil?
+    rescue # generally INVALID_HANDLE_VALUE which means 'file not found'
+      false
+    end
+  end
+
+  def exist?
+    self.class.exist?(@path)
+  end
+
+  def symlink(dest, options = {})
+    raise_if_symlinks_unsupported
+
+    dest_exists = self.class.exist?(dest) # returns false on dangling symlink
+    dest_stat = Puppet::Util::Windows::File.stat(dest) if dest_exists
+    dest_symlink = Puppet::Util::Windows::File.symlink?(dest)
+
+    # silent fail to preserve semantics of original FileUtils
+    return 0 if dest_exists && dest_stat.ftype == 'directory'
+
+    if dest_exists && dest_stat.ftype == 'file' && options[:force] != true
+      raise(Errno::EEXIST, "#{dest} already exists and the :force option was not specified")
+    end
+
+    if options[:noop] != true
+      ::File.delete(dest) if dest_exists # can only be file
+      Puppet::Util::Windows::File.symlink(@path, dest)
+    end
+
+    0
+  end
+
+  def symlink?
+    return false if ! Puppet.features.manages_symlinks?
+    Puppet::Util::Windows::File.symlink?(@path)
+  end
+
+  def readlink
+    raise_if_symlinks_unsupported
+    Puppet::Util::Windows::File.readlink(@path)
+  end
+
+  def self.unlink(*file_names)
+    if ! Puppet.features.manages_symlinks?
+      return ::File.unlink(*file_names)
+    end
+
+    file_names.each do |file_name|
+      file_name = file_name.to_s # handle PathName
+      stat = Puppet::Util::Windows::File.stat(file_name) rescue nil
+
+      # sigh, Ruby + Windows :(
+      if stat && stat.ftype == 'directory'
+        if Puppet::Util::Windows::File.symlink?(file_name)
+          Dir.rmdir(file_name)
+        else
+          raise Errno::EPERM.new(file_name)
+        end
+      else
+        ::File.unlink(file_name)
+      end
+    end
+
+    file_names.length
+  end
+
+  def unlink
+    self.class.unlink(@path)
+  end
+
+  def stat
+    if ! Puppet.features.manages_symlinks?
+      return super
+    end
+    Puppet::Util::Windows::File.stat(@path)
+  end
+
+  def lstat
+    if ! Puppet.features.manages_symlinks?
+      return Puppet::Util::Windows::File.stat(@path)
+    end
+    Puppet::Util::Windows::File.lstat(@path)
+  end
+
+  private
+  def raise_if_symlinks_unsupported
+    if ! Puppet.features.manages_symlinks?
+      msg = "This version of Windows does not support symlinks.  Windows Vista / 2008 or higher is required."
+      raise Puppet::Util::Windows::Error.new(msg)
+    end
+
+    if ! Puppet::Util::Windows::Process.process_privilege_symlink?
+      Puppet.warning "The current user does not have the necessary permission to manage symlinks."
+    end
+  end
+end

data/lib/puppet/file_system/memory_file.rb

@@ -0,0 +1,31 @@
+# An in-memory file abstraction. Commonly used with Puppet::FileSystem::File#overlay
+# @api private
+class Puppet::FileSystem::MemoryFile
+  attr_reader :path
+
+  def self.a_missing_file(path)
+    new(path, :exist? => false, :executable? => false)
+  end
+
+  def self.a_regular_file_containing(path, content)
+    new(path, :exist? => true, :executable? => false, :content => content)
+  end
+
+  def self.an_executable(path)
+    new(path, :exist? => true, :executable? => true)
+  end
+
+  def initialize(path, options)
+    @path = Pathname.new(path)
+    @exist = options[:exist?]
+    @executable = options[:executable?]
+    @content = options[:content]
+  end
+
+  def exist?; @exist; end
+  def executable?; @executable; end
+
+  def each_line(&block)
+    StringIO.new(@content).each_line(&block)
+  end
+end

data/lib/puppet/file_system/tempfile.rb

@@ -0,0 +1,20 @@
+require 'tempfile'
+
+class Puppet::FileSystem::Tempfile
+
+  # Variation of Tempfile.open which ensures that the tempfile is closed and
+  # unlinked before returning
+  #
+  # @param identifier [String] additional part of generated pathname
+  # @yieldparam file [File] the temporary file object
+  # @return result of the passed block
+  # @api private
+  def self.open(identifier)
+    file = ::Tempfile.new(identifier)
+
+    yield file
+
+  ensure
+    file.close!
+  end
+end