virtfs 0.0.1

data/lib/virtfs/find_class_methods.rb

@@ -0,0 +1,106 @@
+module VirtFS
+  # VirtFS Find Class representation - implements the core Ruby Find methods,
+  # dispatching to underlying mounted VirtFS filesystems
+  module FindClassMethods
+    #
+    # Modified version of Find.find:
+    # - Accepts only a single path.
+    # - Can be restricted by depth - optimization for glob searches.
+    # - Will work with VirtFS, even when it's not active.
+    #
+    # @param path [String] starting directory of the find
+    # @param max_depth [Integer] max number of levels to decend befroelookup
+    # @yield files found
+    #
+    def find(path, max_depth = nil)
+      raise SystemCallError.new(path, Errno::ENOENT::Errno) unless VirtFS::VFile.exist?(path)
+      block_given? || (return enum_for(__method__, path, max_depth))
+
+      depths = [0]
+      paths  = [path.dup]
+
+      while (file = paths.shift)
+        depth = depths.shift
+        catch(:prune) do
+          yield file.dup.taint
+          begin
+            s = VirtFS::VFile.lstat(file)
+          rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+            next
+          end
+          if s.directory?
+            next if depth + 1 > max_depth if max_depth
+            begin
+              fs = VirtFS::VDir.entries(file)
+            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+              next
+            end
+            fs.sort!
+            fs.reverse_each do |f|
+              next if f == "." || f == ".."
+              f = VfsRealFile.join(file, f)
+              paths.unshift f.untaint
+              depths.unshift depth + 1
+            end
+          end
+        end
+      end
+    end
+
+    # Implementation of Find.prune
+    #
+    # @raise [RuntimeError] always
+    def prune
+      throw :prune
+    end
+
+    GLOB_CHARS = '*?[{'
+    def glob_str?(str)
+      str.gsub(/\\./, "X").count(GLOB_CHARS) != 0
+    end
+
+    # Returns files matching glob pattern
+    #
+    # @api private
+    # @param glob_pattern [String,Regex] pattern to search for
+    # @return [String] paths to files found
+    #
+    def dir_and_glob(glob_pattern)
+      glob_path = Pathname.new(glob_pattern)
+
+      if glob_path.absolute?
+        search_path    = VfsRealFile::SEPARATOR
+        specified_path = VfsRealFile::SEPARATOR
+      else
+        search_path    = dir_getwd
+        specified_path = nil
+      end
+
+      components = glob_path.each_filename.to_a
+      while (comp = components.shift)
+        if glob_str?(comp)
+          components.unshift(comp)
+          break
+        end
+        search_path = VfsRealFile.join(search_path, comp)
+        if specified_path
+          specified_path = VfsRealFile.join(specified_path, comp)
+        else
+          specified_path = comp
+        end
+      end
+      return normalize_path(search_path), specified_path, VfsRealFile.join(components)
+    end
+
+    # Return max levels which glob pattern may resolve to
+    #
+    # @api private
+    # @param glob_pattern [String,Regex] pattern to search for
+    # @return [Integer] max levels which pattern may match
+    def glob_depth(glob_pattern)
+      path_components = Pathname(glob_pattern).each_filename.to_a
+      return nil if path_components.include?('**')
+      path_components.length
+    end
+  end
+end

data/lib/virtfs/io_buffer.rb

@@ -0,0 +1,133 @@
+module VirtFS
+  # I/O Buffer utility class, provides a fixed length byte buffer
+  # for I/O operations
+  class IOBuffer
+    attr_accessor :min_buf_sz, :external_encoding, :sync
+    attr_reader   :buffer, :range
+
+    MAX_CHAR_LEN = 8
+
+    def initialize(io_obj, min_buf_sz)
+      @io_obj            = io_obj
+      @min_buf_sz        = min_buf_sz
+      @binary_encoding   = Encoding.find("ASCII-8BIT")
+      @buffer            = ""
+      @range             = ByteRange.new
+      @write_range       = ByteRange.new
+      @sync              = false
+    end
+
+    def cover_range(pos, len)
+      len = adjust_len_to_eof(len, pos)
+      end_pos = pos + len - 1
+
+      return if @range.include?(pos) && @range.include?(end_pos)
+
+      if @range.include?(pos)
+        truncate_left(pos)
+        extend_right(len)
+        return
+      end
+
+      flush # If write data, flush.
+      raw_read_len = adjust_len_to_eof([@min_buf_sz, len].max, pos)
+      @buffer = @io_obj.fs_io_obj.raw_read(pos, raw_read_len)
+      @range.set(pos, pos + raw_read_len - 1)
+    end
+
+    def extend_right(len)
+      raw_read_len = adjust_len_to_eof([@min_buf_sz, len].max, @range.last)
+      rv = @io_obj.fs_io_obj.raw_read(@range.last + 1, raw_read_len)
+      @buffer << rv
+      @range.last += raw_read_len
+    end
+
+    def truncate_left(pos)
+      flush if @write_range.include?(pos) # If pos is within write_range, flush.
+      offset = buf_offset(pos)
+      return if offset == 0
+      @buffer = @buffer[offset..-1]
+      @range.first += offset
+    end
+
+    def prepend_bytes(str)
+      str = str.dup
+      str.force_encoding(@binary_encoding)
+      prepend(str)
+    end
+
+    def prepend_str(str)
+      str = str.dup
+      str.encode!(@io_obj.external_encoding) if @io_obj.external_encoding
+      str.force_encoding(@binary_encoding)
+      prepend(str)
+    end
+
+    # for unget, data does not get written - never in write_range.
+    def prepend(str)
+      @buffer.insert(0, str)
+      @range.first -= str.bytesize
+      str.bytesize
+    end
+
+    def write_to_buffer(pos, str)
+      len = str.bytesize
+      end_pos = pos + len - 1
+      flush unless @write_range.contiguous?(pos, end_pos)
+      @write_range.expand(pos, end_pos)
+      @range.expand(@write_range)
+      @buffer[buf_offset(pos), len] = str
+      flush if @sync
+      len
+    end
+
+    def adjust_len_to_eof(len, pos)
+      return @io_obj.end_byte_addr - pos + 1 if (pos + len - 1) > @io_obj.end_byte_addr
+      len
+    end
+
+    def get_byte(pos)
+      cover_range(pos, 1)
+      @buffer.getbyte(buf_offset(pos))
+    end
+
+    def get_char(pos)
+      max_char_len = adjust_len_to_eof(MAX_CHAR_LEN, pos)
+      cover_range(pos, max_char_len)
+      offset = buf_offset(pos)
+      (1..max_char_len).each do |len|
+        char = @buffer[offset, len]
+        char.force_encoding(@io_obj.external_encoding)
+        return char if char.valid_encoding?
+      end
+      raise "Invalid byte sequence"
+    end
+
+    def get_str(pos, len)
+      len = adjust_len_to_eof(len, pos)
+      cover_range(pos, len)
+      @buffer[buf_offset(pos), len]
+    end
+
+    def flush
+      return if @write_range.empty?
+      offset = buf_offset(@write_range.first)
+      length = @write_range.length
+      rv = @io_obj.fs_io_obj.raw_write(@write_range.first, @buffer[offset, length])
+      @write_range.clear
+      rv
+    end
+
+    def available_bytes(pos)
+      @range.last - pos + 1
+    end
+
+    def at_eof?
+      @range.last >= @io_obj.end_byte_addr
+    end
+
+    def buf_offset(pos)
+      pos - @range.first
+    end
+  end
+end

data/lib/virtfs/io_instance_delegate.rb

@@ -0,0 +1,3 @@
+module VirtFS
+  IOInstanceDelegate = delegate_module(VfsRealIO)
+end

data/lib/virtfs/kernel.rb

@@ -0,0 +1,146 @@
+require "pathname"
+
+module VirtFS
+  module Kernel # rubocop:disable ModuleLength
+    @kernel_mutex = Mutex.new
+
+    def self.inject # rubocop:disable AbcSize
+      @kernel_mutex.synchronize do
+        return false if @injected
+
+        #
+        # If the 'require' method is implemented in ruby (method(:require).source_location != nil)
+        # and 'gem_original_require' is defined, then rubygems is active. Replace gem_original_require
+        # with our VirtFS aware implementation of require - the rubygems require will call us.
+        #
+        # If the 'require' method is implemented in 'C' (method(:require).source_location == nil)
+        # then rubygems is not active (even if 'gem_original_require' is defined). Replace 'require'
+        # with our VirtFS aware implementation of require
+        #
+        @rubygems_active = method(:require).source_location && private_method_defined?(:gem_original_require)
+
+        ::Kernel.module_exec(@rubygems_active) do |gems_active|
+          if gems_active
+            alias_method :virtfs_original_require, :gem_original_require
+          else
+            alias_method :virtfs_original_require, :require
+          end
+          private :virtfs_original_require
+
+          alias_method :virtfs_original_load, :load
+          private :virtfs_original_load
+
+          define_method(:virtfs_require) do |file_name|
+            VirtFS::Kernel.virtfs_require(file_name)
+          end
+          private :virtfs_require
+
+          define_method(:virtfs_load) do |file_name, wrap = false|
+            VirtFS::Kernel.virtfs_load(file_name, wrap)
+          end
+          private :virtfs_load
+        end
+        @injected = true
+      end
+    end
+
+    def self.withdraw
+      @kernel_mutex.synchronize do
+        return false unless @injected
+        raise "Cannot withdraw while VirtFS::Kernel is enabled" if @enabled
+
+        ::Kernel.module_eval do
+          remove_method :virtfs_original_require
+          remove_method :virtfs_original_load
+          remove_method :virtfs_require
+          remove_method :virtfs_load
+        end
+        @injected = false
+      end
+      true
+    end
+
+    def self.enable
+      @kernel_mutex.synchronize do
+        return false if @enabled
+
+        inject unless @injected
+
+        ::Kernel.module_exec(@rubygems_active) do |gems_active|
+          if gems_active
+            alias_method :gem_original_require, :virtfs_require
+          else
+            alias_method :require, :virtfs_require
+          end
+
+          alias_method :load, :virtfs_load
+        end
+        @enabled = true
+      end
+      true
+    end
+
+    def self.disable
+      @kernel_mutex.synchronize do
+        return false unless @enabled
+
+        ::Kernel.module_exec(@rubygems_active) do |gems_active|
+          if gems_active
+            alias_method :gem_original_require, :virtfs_original_require
+          else
+            alias_method :require, :virtfs_original_require
+          end
+
+          alias_method :load, :virtfs_original_load
+        end
+        @enabled = false
+      end
+      true
+    end
+
+    def self.virtfs_load(file_name, wrap)
+      file_path = ::Pathname.new(file_name)
+      return virtfs_original_load(file_name, wrap) unless file_path.extname == ".rb"
+      file_path = canonical_path(file_path)
+      raise LoadError, "cannot load such file -- #{file_name}" unless file_path
+      eval_file(file_path, wrap)
+      true
+    end
+
+    def self.virtfs_require(lib_name)
+      lib_path = canonical_path(::Pathname.new(lib_name))
+      raise LoadError, "cannot load such file -- #{lib_name}" unless lib_path
+      return virtfs_original_require(lib_name) unless lib_path.extname == ".rb"
+      return false if already_loaded(lib_path)
+      eval_file(lib_path, false)
+      $LOADED_FEATURES << lib_path.to_path
+      true
+    end
+
+    def self.canonical_path(path)
+      has_ext = path.extname != ""
+      return path if path.absolute?
+      $LOAD_PATH.each do |dir|
+        full_path = path.expand_path(dir)
+        if has_ext
+          return full_path if full_path.file?
+        else
+          %w(.rb .so .o .dll).each do |ext|
+            ext_path = full_path.sub_ext(ext)
+            return ext_path if ext_path.file?
+          end
+        end
+      end
+      nil
+    end
+
+    def self.already_loaded(canonical_name)
+      $LOADED_FEATURES.include?(canonical_name.to_path)
+    end
+
+    def self.eval_file(file_path, wrap)
+      eval_binding = wrap ? Module.new.send(:binding) : TOPLEVEL_BINDING
+      eval(file_path.read, eval_binding, file_path.to_path) # rubocop:disable Lint/Eval
+    end
+  end
+end

data/lib/virtfs/nativefs/thick.rb

@@ -0,0 +1,30 @@
+require_relative 'thick/file_class_methods'
+require_relative 'thick/dir_class_methods'
+
+module VirtFS::NativeFS # rubocop:disable Style/ClassAndModuleChildren
+  class Thick
+    attr_accessor :mount_point, :name
+
+    include FileClassMethods
+    include DirClassMethods
+
+    def initialize(root = VfsRealFile::SEPARATOR)
+      @mount_point  = nil
+      @name         = self.class.name
+      @root         = root
+    end
+
+    def thin_interface?
+      false
+    end
+
+    def umount
+      @mount_point = nil
+    end
+
+    def apply_root(path)
+      VfsRealFile.join(@root, path)
+    end
+    private :apply_root
+  end
+end

data/lib/virtfs/nativefs/thick/dir_class_methods.rb

@@ -0,0 +1,38 @@
+#
+# Dir class methods - are instance methods of filesystem instance.
+#
+module VirtFS::NativeFS # rubocop:disable Style/ClassAndModuleChildren
+  class Thick
+    module DirClassMethods
+      def dir_delete(p)
+        VfsRealDir.delete(apply_root(p))
+      end
+
+      def dir_entries(p)
+        VfsRealDir.entries(apply_root(p))
+      end
+
+      def dir_exist?(p)
+        VfsRealDir.exist?(apply_root(p))
+      end
+
+      def dir_foreach(p, &block)
+        VfsRealDir.foreach(apply_root(p), &block)
+      end
+
+      def dir_mkdir(p, permissions)
+        VfsRealDir.mkdir(apply_root(p), permissions)
+      end
+
+      def dir_new(fs_rel_path, hash_args, _open_path, cwd)
+        owd = VfsRealDir.getwd
+        begin
+          VfsRealDir.chdir(cwd)
+          return VfsRealDir.new(apply_root(fs_rel_path), hash_args)
+        ensure
+          VfsRealDir.chdir(owd)
+        end
+      end
+    end
+  end
+end