openvox 7.37.1

data/lib/puppet/file_system/file_impl.rb

@@ -0,0 +1,188 @@
+# Abstract implementation of the Puppet::FileSystem
+#
+class Puppet::FileSystem::FileImpl
+
+  def pathname(path)
+    path.is_a?(Pathname) ? path : Pathname.new(path)
+  end
+
+  def assert_path(path)
+    return path if path.is_a?(Pathname)
+
+    # Some paths are string, or in the case of WatchedFile, it pretends to be
+    # one by implementing to_str.
+    if path.respond_to?(:to_str)
+      Pathname.new(path)
+    else
+      raise ArgumentError, _("FileSystem implementation expected Pathname, got: '%{klass}'") % { klass: path.class }
+    end
+  end
+
+  def path_string(path)
+    path.to_s
+  end
+
+  def expand_path(path, dir_string = nil)
+    # ensure `nil` values behave like underlying File.expand_path
+    ::File.expand_path(path.nil? ? nil : path_string(path), dir_string)
+  end
+
+  def open(path, mode, options, &block)
+    ::File.open(path, options, mode, &block)
+  end
+
+  def dir(path)
+    path.dirname
+  end
+
+  def basename(path)
+    path.basename.to_s
+  end
+
+  def size(path)
+    path.size
+  end
+
+  def exclusive_create(path, mode, &block)
+    opt = File::CREAT | File::EXCL | File::WRONLY
+    self.open(path, mode, opt, &block)
+  end
+
+  def exclusive_open(path, 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)
+          Puppet.debug{ _("Locked '%{path}'") % { path: path } }
+          yield rf
+          written = true
+          Puppet.debug{ _("Unlocked '%{path}'") % { path: path } }
+        else
+          Puppet.debug{ "Failed to lock '%s' retrying in %.2f milliseconds" % [path, wait * 1000] }
+          sleep wait
+          timeout -= wait
+          wait *= 2
+          if timeout < 0
+            raise Timeout::Error, _("Timeout waiting for exclusive lock on %{path}") % { path: path }
+          end
+        end
+      end
+    end
+  end
+
+  def each_line(path, &block)
+    ::File.open(path) do |f|
+      f.each_line do |line|
+        yield line
+      end
+    end
+  end
+
+  def read(path, opts = {})
+    path.read(**opts)
+  end
+
+  def read_preserve_line_endings(path)
+    default_encoding = Encoding.default_external.name
+    encoding = default_encoding.downcase.start_with?('utf-') ? "bom|#{default_encoding}" : default_encoding
+    read(path, encoding: encoding)
+  end
+
+  def binread(path)
+    raise NotImplementedError
+  end
+
+  def exist?(path)
+    ::File.exist?(path)
+  end
+
+  def directory?(path)
+    ::File.directory?(path)
+  end
+
+  def file?(path)
+    ::File.file?(path)
+  end
+
+  def executable?(path)
+    ::File.executable?(path)
+  end
+
+  def writable?(path)
+    path.writable?
+  end
+
+  def touch(path, mtime: nil)
+    ::FileUtils.touch(path, mtime: mtime)
+  end
+
+  def mkpath(path)
+    path.mkpath
+  end
+
+  def children(path)
+    path.children
+  end
+
+  def symlink(path, dest, options = {})
+    FileUtils.symlink(path, dest, **options)
+  end
+
+  def symlink?(path)
+    ::File.symlink?(path)
+  end
+
+  def readlink(path)
+    ::File.readlink(path)
+  end
+
+  def unlink(*paths)
+    ::File.unlink(*paths)
+  end
+
+  def stat(path)
+    ::File.stat(path)
+  end
+
+  def lstat(path)
+    ::File.lstat(path)
+  end
+
+  def compare_stream(path, stream)
+    ::File.open(path, 0, 'rb') { |this| FileUtils.compare_stream(this, stream) }
+  end
+
+  def chmod(mode, path)
+    FileUtils.chmod(mode, path)
+  end
+
+  def replace_file(path, mode = nil)
+    begin
+      stat = lstat(path)
+      gid = stat.gid
+      uid = stat.uid
+      mode ||= stat.mode & 07777
+    rescue Errno::ENOENT
+      mode ||= 0640
+    end
+
+    tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(path), Puppet::FileSystem.dir_string(path))
+    begin
+      begin
+        yield tempfile
+        tempfile.flush
+        tempfile.fsync
+      ensure
+        tempfile.close
+      end
+
+      tempfile_path = tempfile.path
+      FileUtils.chown(uid, gid, tempfile_path) if uid && gid
+      chmod(mode, tempfile_path)
+      ::File.rename(tempfile_path, path_string(path))
+    ensure
+      tempfile.close!
+    end
+  end
+end

data/lib/puppet/file_system/jruby.rb

@@ -0,0 +1,23 @@
+require_relative '../../puppet/file_system/posix'
+
+class Puppet::FileSystem::JRuby < Puppet::FileSystem::Posix
+  def unlink(*paths)
+    File.unlink(*paths)
+  rescue Errno::ENOENT
+    # JRuby raises ENOENT if the path doesn't exist or the parent directory
+    # doesn't allow execute/traverse. If it's the former, `stat` will raise
+    # ENOENT, if it's the later, it'll raise EACCES
+    # See https://github.com/jruby/jruby/issues/5617
+    stat(*paths)
+  end
+
+  def replace_file(path, mode = nil, &block)
+    # MRI Ruby rename checks if destination is a directory and raises, while
+    # JRuby removes the directory and replaces the file.
+    if directory?(path)
+      raise Errno::EISDIR, _("Is a directory: %{directory}") % { directory: path }
+    end
+
+    super
+  end
+end

data/lib/puppet/file_system/memory_file.rb

@@ -0,0 +1,79 @@
+# An in-memory file abstraction. Commonly used with Puppet::FileSystem::File#overlay
+# @api private
+class Puppet::FileSystem::MemoryFile
+  attr_reader :path, :children
+
+  def self.a_missing_file(path)
+    new(path, :exist? => false, :executable? => false)
+  end
+
+  def self.a_missing_directory(path)
+    new(path,
+        :exist? => false,
+        :executable? => false,
+        :directory? => true)
+  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 self.a_directory(path, children = [])
+    new(path,
+        :exist? => true,
+        :executable? => true,
+        :directory? => true,
+        :children => children)
+  end
+
+  def self.a_symlink(target_path, source_path)
+    new(target_path, :exist? => true, :symlink? => true, :source_path => source_path)
+  end
+
+  def initialize(path, properties)
+    @path = path
+    @properties = properties
+    @children = (properties[:children] || []).collect do |child|
+      child.duplicate_as(File.join(@path, child.path))
+    end
+  end
+
+  def directory?; @properties[:directory?]; end
+  def exist?; @properties[:exist?]; end
+  def executable?; @properties[:executable?]; end
+  def symlink?; @properties[:symlink?]; end
+  def source_path; @properties[:source_path]; end
+
+  def each_line(&block)
+    handle.each_line(&block)
+  end
+
+  def handle
+    raise Errno::ENOENT unless exist?
+    StringIO.new(@properties[:content] || '')
+  end
+
+  def duplicate_as(other_path)
+    self.class.new(other_path, @properties)
+  end
+
+  def absolute?
+    Pathname.new(path).absolute?
+  end
+
+  def to_path
+    path
+  end
+
+  def to_s
+    to_path
+  end
+
+  def inspect
+    "<Puppet::FileSystem::MemoryFile:#{self}>"
+  end
+end

data/lib/puppet/file_system/memory_impl.rb

@@ -0,0 +1,99 @@
+class Puppet::FileSystem::MemoryImpl
+  def initialize(*files)
+    @files = files + all_children_of(files)
+  end
+
+  def expand_path(path, dir_string = nil)
+    File.expand_path(path, dir_string)
+  end
+
+  def exist?(path)
+    path.exist?
+  end
+
+  def directory?(path)
+    path.directory?
+  end
+
+  def file?(path)
+    path.file?
+  end
+
+  def executable?(path)
+    path.executable?
+  end
+
+  def symlink?(path)
+    path.symlink?
+  end
+
+  def readlink(path)
+    path = path.path
+    link = find(path)
+    return Puppet::FileSystem::MemoryFile.a_missing_file(path) unless link
+    source = link.source_path
+    return Puppet::FileSystem::MemoryFile.a_missing_file(link) unless source
+    find(source) || Puppet::FileSystem::MemoryFile.a_missing_file(source)
+  end
+
+  def children(path)
+    path.children
+  end
+
+  def each_line(path, &block)
+    path.each_line(&block)
+  end
+
+  def pathname(path)
+    find(path) || Puppet::FileSystem::MemoryFile.a_missing_file(path)
+  end
+
+  def basename(path)
+    path.duplicate_as(File.basename(path_string(path)))
+  end
+
+  def path_string(object)
+    object.path
+  end
+
+  def read(path, opts = {})
+    handle = assert_path(path).handle
+    handle.read
+  end
+
+  def read_preserve_line_endings(path)
+    read(path)
+  end
+
+  def open(path, *args, &block)
+    handle = assert_path(path).handle
+    if block_given?
+      yield handle
+    else
+      return handle
+    end
+  end
+
+  def assert_path(path)
+    if path.is_a?(Puppet::FileSystem::MemoryFile)
+      path
+    else
+      find(path) or raise ArgumentError, _("Unable to find registered object for %{path}") % { path: path.inspect }
+    end
+  end
+
+  private
+
+  def find(path)
+    @files.find { |file| file.path == path }
+  end
+
+  def all_children_of(files)
+    children = files.collect(&:children).flatten
+    if children.empty?
+      []
+    else
+      children + all_children_of(children)
+    end
+  end
+end

data/lib/puppet/file_system/path_pattern.rb

@@ -0,0 +1,93 @@
+require 'pathname'
+require_relative '../../puppet/error'
+
+module Puppet::FileSystem
+  class PathPattern
+    class InvalidPattern < Puppet::Error; end
+
+    DOTDOT = '..'.freeze
+    ABSOLUTE_UNIX = /^\//
+    ABSOLUTE_WINDOWS = /^[a-z]:/i
+    CURRENT_DRIVE_RELATIVE_WINDOWS = /^\\/
+
+    def self.relative(pattern)
+      RelativePathPattern.new(pattern)
+    end
+
+    def self.absolute(pattern)
+      AbsolutePathPattern.new(pattern)
+    end
+
+    class << self
+      protected :new
+    end
+
+    # @param prefix [AbsolutePathPattern] An absolute path pattern instance
+    # @return [AbsolutePathPattern] A new AbsolutePathPattern prepended with
+    #   the passed prefix's pattern.
+    def prefix_with(prefix)
+      new_pathname = prefix.pathname + pathname
+      self.class.absolute(new_pathname.to_s)
+    end
+
+    def glob
+      Dir.glob(@pathstr)
+    end
+
+    def to_s
+      @pathstr
+    end
+
+    protected
+
+    attr_reader :pathname
+
+    private
+
+    def validate
+      if @pathstr.split(Pathname::SEPARATOR_PAT).any? { |f| f == DOTDOT }
+        raise(InvalidPattern, _("PathPatterns cannot be created with directory traversals."))
+      elsif @pathstr.match?(CURRENT_DRIVE_RELATIVE_WINDOWS)
+        raise(InvalidPattern, _("A PathPattern cannot be a Windows current drive relative path."))
+      end
+    end
+
+    def initialize(pattern)
+      begin
+        @pathname = Pathname.new(pattern.strip)
+        @pathstr = @pathname.to_s
+      rescue ArgumentError => error
+        raise InvalidPattern.new(_("PathPatterns cannot be created with a zero byte."), error)
+      end
+      validate
+    end
+  end
+
+  class RelativePathPattern < PathPattern
+    def absolute?
+      false
+    end
+
+    def validate
+      super
+      if @pathstr.match?(ABSOLUTE_WINDOWS)
+        raise(InvalidPattern, _("A relative PathPattern cannot be prefixed with a drive."))
+      elsif @pathstr.match?(ABSOLUTE_UNIX)
+        raise(InvalidPattern, _("A relative PathPattern cannot be an absolute path."))
+      end
+    end
+  end
+
+  class AbsolutePathPattern < PathPattern
+    def absolute?
+      true
+    end
+
+    def validate
+      super
+      if !@pathstr.match?(ABSOLUTE_UNIX) && !@pathstr.match?(ABSOLUTE_WINDOWS)
+        raise(InvalidPattern, _("An absolute PathPattern cannot be a relative path."))
+      end
+    end
+  end
+end

data/lib/puppet/file_system/posix.rb

@@ -0,0 +1,47 @@
+class Puppet::FileSystem::Posix < Puppet::FileSystem::FileImpl
+  def binread(path)
+    path.binread
+  end
+
+  # Provide an encoding agnostic version of compare_stream
+  #
+  # The FileUtils implementation in Ruby 2.0+ was modified in a manner where
+  # it cannot properly compare File and StringIO instances. To sidestep that
+  # issue this method reimplements the faster 2.0 version that will correctly
+  # compare binary File and StringIO streams.
+  def compare_stream(path, stream)
+    ::File.open(path, 'rb') do |this|
+      bsize = stream_blksize(this, stream)
+      sa = "".force_encoding('ASCII-8BIT')
+      sb = "".force_encoding('ASCII-8BIT')
+      loop do
+        this.read(bsize, sa)
+        stream.read(bsize, sb)
+        return true if sa.empty? && sb.empty?
+        break if sa != sb
+      end
+      false
+    end
+  end
+
+  private
+  def stream_blksize(*streams)
+    streams.each do |s|
+      next unless s.respond_to?(:stat)
+      size = blksize(s.stat)
+      return size if size
+    end
+    default_blksize()
+  end
+
+  def blksize(st)
+    s = st.blksize
+    return nil unless s
+    return nil if s == 0
+    s
+  end
+
+  def default_blksize
+    1024
+  end
+end

data/lib/puppet/file_system/uniquefile.rb

@@ -0,0 +1,188 @@
+require_relative '../../puppet/file_system'
+require 'delegate'
+require 'tmpdir'
+
+# A class that provides `Tempfile`-like capabilities, but does not attempt to
+# manage the deletion of the file for you.  API is identical to the
+# normal `Tempfile` class.
+#
+# @api public
+class Puppet::FileSystem::Uniquefile < DelegateClass(File)
+  # Convenience method which ensures that the file 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_tmp(identifier)
+    f = new(identifier)
+    yield f
+  ensure
+    if f
+      f.close!
+    end
+  end
+
+  def initialize(basename, *rest)
+    create_tmpname(basename, *rest) do |tmpname, n, opts|
+      mode = File::RDWR|File::CREAT|File::EXCL
+      perm = 0600
+      if opts
+        mode |= opts.delete(:mode) || 0
+        opts[:perm] = perm
+        perm = nil
+      else
+        opts = perm
+      end
+      self.class.locking(tmpname) do
+        @tmpfile = File.open(tmpname, mode, opts)
+        @tmpname = tmpname
+      end
+      @mode = mode & ~(File::CREAT|File::EXCL)
+      perm or opts.freeze
+      @opts = opts
+    end
+
+    super(@tmpfile)
+  end
+
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, @mode, @opts)
+    __setobj__(@tmpfile)
+  end
+
+  def _close
+    begin
+      @tmpfile.close if @tmpfile
+    ensure
+      @tmpfile = nil
+    end
+  end
+  protected :_close
+
+  def close(unlink_now=false)
+    if unlink_now
+      close!
+    else
+      _close
+    end
+  end
+
+  def close!
+    _close
+    unlink
+  end
+
+  def unlink
+    return unless @tmpname
+    begin
+      File.unlink(@tmpname)
+    rescue Errno::ENOENT
+    rescue Errno::EACCES
+      # may not be able to unlink on Windows; just ignore
+      return
+    end
+    @tmpname = nil
+  end
+  alias delete unlink
+
+  # Returns the full path name of the temporary file.
+  # This will be nil if #unlink has been called.
+  def path
+    @tmpname
+  end
+
+  private
+
+  def make_tmpname(prefix_suffix, n)
+    case prefix_suffix
+      when String
+        prefix = prefix_suffix
+        suffix = ""
+      when Array
+        prefix = prefix_suffix[0]
+        suffix = prefix_suffix[1]
+      else
+        raise ArgumentError, _("unexpected prefix_suffix: %{value}") % { value: prefix_suffix.inspect }
+    end
+    t = Time.now.strftime("%Y%m%d")
+    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+    path << "-#{n}" if n
+    path << suffix
+  end
+
+  def create_tmpname(basename, *rest)
+    opts = try_convert_to_hash(rest[-1])
+    if opts
+      opts = opts.dup if rest.pop.equal?(opts)
+      max_try = opts.delete(:max_try)
+      opts = [opts]
+    else
+      opts = []
+    end
+    tmpdir, = *rest
+    tmpdir ||= tmpdir()
+    n = nil
+    begin
+      path = File.join(tmpdir, make_tmpname(basename, n))
+      yield(path, n, *opts)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry if !max_try or n < max_try
+      raise _("cannot generate temporary name using `%{basename}' under `%{tmpdir}'") % { basename: basename, tmpdir: tmpdir }
+    end
+    path
+  end
+
+  def try_convert_to_hash(h)
+    begin
+      h.to_hash
+    rescue NoMethodError
+      nil
+    end
+  end
+
+  @@systmpdir ||= defined?(Etc.systmpdir) ? Etc.systmpdir : '/tmp'
+
+  def tmpdir
+    tmp = '.'
+    for dir in [ Puppet::Util.get_env('TMPDIR'), Puppet::Util.get_env('TMP'), Puppet::Util.get_env('TEMP'), @@systmpdir, '/tmp']
+      stat = File.stat(dir) if dir
+      if stat && stat.directory? && stat.writable?
+        tmp = dir
+        break
+      end rescue nil
+    end
+    File.expand_path(tmp)
+  end
+
+
+  class << self
+    # yields with locking for +tmpname+ and returns the result of the
+    # block.
+    def locking(tmpname)
+      lock = tmpname + '.lock'
+      mkdir(lock)
+      yield
+    rescue Errno::ENOENT => e
+      ex = Errno::ENOENT.new("A directory component in #{lock} does not exist or is a dangling symbolic link")
+      ex.set_backtrace(e.backtrace)
+      raise ex
+    ensure
+      rmdir(lock) if Puppet::FileSystem.exist?(lock)
+    end
+
+    def mkdir(*args)
+      Dir.mkdir(*args)
+    end
+
+    def rmdir(*args)
+      Dir.rmdir(*args)
+    end
+  end
+
+end