ffi-libfuse 0.0.1.rctest12 → 0.3.3

data/lib/ffi/libfuse/adapter/safe.rb

@@ -10,7 +10,7 @@ module FFI
         # @!visibility private
         def fuse_wrappers(*wrappers)
           wrappers << {
-            wrapper: proc { |fm, *args, **_, &b| Safe.safe_callback(fm, *args, &b) },
+            wrapper: proc { |fm, *args, **_, &b| Safe.safe_callback(fm, *args, default_errno: default_errno, &b) },
             excludes: %i[init destroy]
           }
           return wrappers unless defined?(super)
@@ -18,8 +18,10 @@ module FFI
           super(*wrappers)
         end
 
-        # Callbacks that are expected to return meaningful positive integers
-        MEANINGFUL_RETURN = %i[read write write_buf lseek copy_file_range getxattr listxattr].freeze
+        # @return [Integer] the default errno.  ENOTRECOVERABLE unless overridden
+        def default_errno
+          defined?(super) ? super : Errno::ENOTRECOVERABLE::Errno
+        end
 
         module_function
 
@@ -27,30 +29,29 @@ module FFI
         #
         # @yieldreturn [SystemCallError] expected callback errors rescued to return equivalent -ve errno value
         # @yieldreturn [StandardError,ScriptError] unexpected callback errors are rescued
-        #   to return -Errno::ENOTRECOVERABLE after emitting backtrace to #warn
+        #   to return -ve {default_errno} after emitting backtrace to #warn
         #
         # @yieldreturn [Integer]
         #
         #   * -ve values returned directly
-        #   * +ve values returned directly for fuse_methods in {MEANINGFUL_RETURN} list
+        #   * +ve values returned directly for fuse_methods in {FuseOperations.MEANINGFUL_RETURN} list
         #   * otherwise returns 0
         #
         # @yieldreturn [Object] always returns 0 if no exception is raised
         #
-        def safe_callback(fuse_method, *args)
+        def safe_callback(fuse_method, *args, default_errno: Errno::ENOTRECOVERABLE::Errno)
           result = yield(*args)
 
-          return 0 unless result.is_a?(Integer)
-          return 0 unless result.negative? || MEANINGFUL_RETURN.include?(fuse_method)
+          return result.to_i if FuseOperations.meaningful_return?(fuse_method)
 
-          result
+          0
         rescue SystemCallError => e
           -e.errno
         rescue StandardError, ScriptError => e
           # rubocop:disable Layout/LineLength
-          warn "FFI::libfuse error in callback #{fuse_method}: #{e.class.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+          warn ["FFI::Libfuse error in #{fuse_method}", *e.backtrace.reverse, "#{e.class.name}:#{e.message}"].join("\n\t")
           # rubocop:enable Layout/LineLength
-          -Errno::ENOTRECOVERABLE::Errno
+          -default_errno.abs
         end
       end
     end

data/lib/ffi/libfuse/adapter.rb

@@ -11,7 +11,7 @@ module FFI
     #
     #    These will implement {FuseOperations#fuse_wrappers} to add the proc which can then...
     #
-    #    * prepend additional arguments - eg. ({Context})
+    #    * populate thread local information - eg. ({Context})
     #    * wrap common arguments - eg. ({Pathname})
     #    * handle return values/exceptions - eg. ({Safe})
     #    * or just wrap the underlying block - eg. ({Debug})
@@ -70,7 +70,6 @@ module FFI
 end
 
 require_relative 'adapter/context'
-require_relative 'adapter/thread_local_context'
 require_relative 'adapter/debug'
 require_relative 'adapter/ruby'
 require_relative 'adapter/interrupt'

data/lib/ffi/libfuse/callbacks.rb

@@ -37,7 +37,7 @@ module FFI
 
       def initialize_callbacks(callbacks, delegate:, wrappers: [])
         callbacks.select { |m| respond_to_callback?(m, delegate) }.each do |m|
-          register(m, wrappers) { |*f_args| delegate.send(m, *f_args) }
+          register(m, wrappers) { |*f_args| delegate.public_send(m, *f_args) }
         end
       end
 

data/lib/ffi/libfuse/filesystem/accounting.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../../stat_vfs'
+
+module FFI
+  module Libfuse
+    module Filesystem
+      # Helper for filesystem accounting
+      class Accounting
+        OPTIONS = { 'max_space=' => :max_space, 'max_nodes=' => :max_nodes }.freeze
+
+        HELP =
+          <<~END_HELP
+            #{name} options:
+                -o max_space=<int>     maximum space consumed by files, --ve will always show free space
+                -o max_nodes=<int>     maximum number of files and directories, -ve will always show free nodes
+
+          END_HELP
+
+        def fuse_opt_proc(key:, value:, **)
+          return :keep unless OPTIONS.values.include?(key)
+
+          public_send("#{key}=", value.to_i)
+          :handled
+        end
+
+        # @return [Integer] maximum allowed space in bytes
+        #
+        #   Positive values will limit values in {adjust} to stay below this value
+        #
+        #   Negative or zero will simply report this amount of space as 'free' in  {to_statvfs}
+        attr_accessor :max_space
+
+        # @return [Integer] maximum number of (virtual) inodes
+        #
+        #   Positive values will limit {adjust} to stay below this value
+        #
+        #   Negative or zero will simply report this number of inodes as 'free' in {to_statvfs}
+        attr_accessor :max_nodes
+
+        # @return [Integer] accumulated space in bytes
+        attr_reader :space
+
+        # @return [Integer] accumulated inodes (typically count of files and directories)
+        attr_reader :nodes
+
+        # @return [Integer] block size for statvfs
+        attr_accessor :block_size
+
+        def initialize(max_space: 0, max_nodes: 0, block_size: 1024)
+          @nodes = 0
+          @space = 0
+          @max_space = max_space
+          @max_nodes = max_nodes
+          @block_size = block_size
+        end
+
+        # Adjust accumlated statistics
+        # @param [Integer] delta_space change in {#space} usage
+        # @param [Integer] delta_nodes change in {#nodes} usage
+        # @return [self]
+        # @raise [Errno::ENOSPC] if adjustment {#space}/{#nodes} would exceed {#max_space} or {#max_nodes}
+        def adjust(delta_space, delta_nodes = 0, strict: true)
+          strict_space = strict && delta_space.positive? && max_space.positive?
+          raise Errno::ENOSPC if strict_space && space + delta_space > max_space
+
+          strict_nodes = strict && delta_nodes.positive? && max_nodes.positive?
+          raise Errno::ENOSPC if strict_nodes && nodes + delta_nodes > max_nodes
+
+          @nodes += delta_nodes
+          @space += delta_space
+          self
+        end
+
+        # Adjust for incremental write
+        # @param [Integer] current_size
+        # @param [Integer] data_size size of new data
+        # @param [Integer] offset offset of new data
+        # @return [self]
+        def write(current_size, data_size, offset, strict: true)
+          adjust(offset + data_size - current_size, strict: strict) if current_size < offset + data_size
+          self
+        end
+
+        # Adjust for truncate
+        # @param [Integer] current_size
+        # @param [Integer] new_size the size being truncated to
+        # @return [self]
+        def truncate(current_size, new_size)
+          adjust(new_size - current_size, strict: false) if new_size < current_size
+          self
+        end
+
+        # rubocop:disable Metrics/AbcSize
+
+        # @param [FFI::StatVfs] statvfs an existing statvfs buffer to fill
+        # @param [Integer] block_size
+        # @return [FFI::StatVfs] the filesystem statistics
+        def to_statvfs(statvfs = FFI::StatVfs.new, block_size: self.block_size || 1024)
+          used_blocks, max_blocks = [space, max_space].map { |s| s / block_size }
+          max_blocks = used_blocks - max_blocks unless max_blocks.positive?
+          max_files = max_nodes.positive? ? max_nodes : nodes - max_nodes
+          statvfs.bsize    = block_size # block size (in Kb)
+          statvfs.frsize   = block_size # fragment size pretty much always bsize
+          statvfs.blocks   = max_blocks
+          statvfs.bfree    = max_blocks - used_blocks
+          statvfs.bavail   = max_blocks - used_blocks
+          statvfs.files    = max_files
+          statvfs.ffree    = max_files - nodes
+          statvfs
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/filesystem/mapped_dir.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'mapped_files'
+
+module FFI
+  module Libfuse
+    module Filesystem
+      # A read-only directory of {MappedFiles}
+      #
+      # Subclasses must implement {#entries} and {#map_path}
+      class MappedDir
+        include MappedFiles
+        include Utils
+        attr_accessor :stat
+
+        # @!method entries
+        #  @abstract
+        #  @return [Enumerable] set of entries in this directory (excluding '.' and '..')
+
+        def initialize(accounting: nil)
+          @accounting = accounting
+          @root = VirtualNode.new(accounting: accounting)
+        end
+
+        # @!group Fuse Callbacks
+
+        # For the root path provides this directory's stat information, otherwise passes on to the next filesystem
+        def getattr(path, stat = nil, _ffi = nil)
+          return super unless root?(path)
+
+          stat&.directory(@root.virtual_stat.merge({ nlink: entries.size + 2 }))
+
+          self
+        end
+
+        # For root path enumerates {#entries}
+        # @raise [Errno::ENOTDIR] unless root path
+        def readdir(path, *_args, &block)
+          raise Errno::ENOTDIR unless root?(path)
+
+          %w[. ..].concat(entries).each(&block)
+        end
+
+        def mkdir(path, mode, *_args)
+          raise Errno::EROFS unless root?(path)
+
+          @root.init_node(mode)
+        end
+
+        # @!endgroup
+
+        # Passes FUSE Callbacks on to the {#root} filesystem
+        def method_missing(method, path = nil, *args, &block)
+          return @root.public_send(method, path, *args, &block) if @root.respond_to?(method) && root?(path)
+
+          raise Errno::ENOTSUP if FuseOperations.path_callbacks.include?(method)
+
+          super
+        end
+
+        def respond_to_missing?(method, private = false)
+          (FuseOperations.fuse_callbacks.include?(method) && @root.respond_to?(method, false)) || super
+        end
+
+        # subclass only call super for root path
+        def map_path(path)
+          raise ArgumentError, "map_path received non root path #{path}" unless root?(path)
+
+          [path, @root]
+        end
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/filesystem/mapped_files.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../adapter'
+require_relative 'accounting'
+
+module FFI
+  module Libfuse
+    module Filesystem
+      # An abstract filesystem mapping paths to either real files or an alternate filesystem based on outcome of
+      # {#map_path} as implemented by including class
+      #
+      # Real files permissions are made read-only by default. Including classes can override {#stat_mask} to
+      # change this behaviour
+      #
+      # Implements callbacks satisfying {Adapter::Ruby} which is automatically included.
+      module MappedFiles
+        # Do we have ffi-xattr to handle extended attributes in real files
+        HAS_XATTR =
+          begin
+            require 'ffi-xattr'
+            true
+          rescue LoadError
+            false
+          end
+
+        # @return [Accounting|nil]
+        #   if set the accounting object will be used to provide {#statfs} for the root path
+        # @note the real LIBC statvfs is always used for non-root paths
+        attr_accessor :accounting
+
+        # @!method map_path(path)
+        #  @abstract
+        #  @param [String] path the path in the fuse filesystem
+        #  @return [String] mapped_path in an underlying filesystem
+        #
+        #    Fuse callbacks are fulfilled using Ruby's native File methods called on this path
+        #  @return [String, Adapter::Ruby::Prepend] mapped_path, filesystem
+        #
+        #    If an optional filesystem value is returned fuse callbacks will be passed on to this filesystem with the
+        #    mapped_path and other callback args unchanged
+        #  @return [nil]
+        #
+        #    eg on create to indicate the path does not exist
+
+        # Manipulate file attributes
+        #
+        # Default implementation forces read-only permissions
+        # @overload stat_mask(path,stat)
+        #   @param [String] path the path received by {#getattr}
+        #   @param [FFI::Stat] stat loaded from the mapped file, can be filled, mapped as necessary
+        #   @return [FFI::Stat] stat
+        def stat_mask(_path, stat)
+          stat.mask(0o0222)
+        end
+
+        # @!group FUSE Callbacks
+
+        # Pass to real stat and then {#stat_mask}
+        def getattr(path, stat, ffi = nil)
+          if (fd = ffi&.fh&.fileno)
+            stat.fstat(fd)
+          else
+            path_method(__method__, path, stat, ffi) { |rp| stat.stat(rp) }
+          end
+
+          stat_mask(path, stat)
+        end
+
+        # Create real file - assuming the path can be mapped before it exists
+        def create(path, perms, ffi)
+          path_method(__method__, path, perms, ffi, error: Errno::EROFS) do |rp|
+            File.open(rp, ffi.flags, perms)
+          end
+        end
+
+        # @return [File] the newly opened file at {#map_path}(path)
+        def open(path, ffi)
+          path_method(__method__, path, ffi) { |rp| File.open(rp, ffi.flags) }
+        end
+
+        # Truncates the file handle (or the real file)
+        def truncate(path, size, ffi = nil)
+          return ffi.fh.truncate(size) if ffi&.fh
+
+          path_method(__method__, path, size, ffi) { |rp| File.truncate(rp, size) }
+        end
+
+        # Delete the real file
+        def unlink(path)
+          path_method(__method__, path) { |rp| File.unlink(rp) }
+        end
+
+        # Calls File.utime on an Integer file handle or the real file
+        def utimens(_path, atime, mtime, ffi = nil)
+          return File.utime(atime, mtime, ffi.fh) if ffi&.fh.is_a?(Integer)
+
+          path_method(__method__, atime, mtime, ffi) { |rp| File.utime(atime, mtime, rp) }
+        end
+
+        # @return [String] the value of the extended attribute name from the real file
+        def getxattr(path, name)
+          return nil unless HAS_XATTR
+
+          path_method(__method__, path, name) { |rp| Xattr.new(rp)[name] }
+        end
+
+        # @return [Array<String>] the list of extended attributes from the real file
+        def listxattr(path)
+          return [] unless HAS_XATTR
+
+          path_method(__method__, path) { |rp| Xattr.new(rp).list }
+        end
+
+        # TODO: Set xattr
+        # TODO: chmod, change the stat[:mode]
+        # TODO: chown, change the stat[:uid,:gid]
+
+        def statfs(path, statvfs)
+          return accounting&.to_statvfs(statvfs) if root?(path)
+
+          path_method(__method__, path, statvfs) { |rp| statvfs.from(rp) }
+        end
+        # @!endgroup
+
+        # @!visibility private
+        def self.included(mod)
+          mod.prepend(Adapter::Ruby::Prepend)
+        end
+
+        private
+
+        def path_method(callback, path, *args, error: Errno::ENOENT, block: nil)
+          rp, fs = map_path(path)
+          raise error if error && !rp
+
+          fs ? fs.send(callback, rp, *args, &block) : yield(rp)
+        end
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/filesystem/pass_through_dir.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'mapped_files'
+
+module FFI
+  module Libfuse
+    module Filesystem
+      # A Filesystem that maps paths to an underlying directory
+      class PassThroughDir
+        include MappedFiles
+        include Adapter::Debug
+        include Adapter::Safe
+        include Utils
+
+        # @return [String] The base directory
+        attr_accessor :base_dir
+
+        # @!group FUSE Callbacks
+
+        # @return [Dir] the directory at {#map_path}(path)
+        def opendir(path, _ffi)
+          Dir.new(map_path(path))
+        end
+
+        # Removes the directory at {#map_path}(path)
+        def rmdir(path)
+          return Dir.rmdir(map_path(path)) unless root?(path)
+
+          accounting&.adjust(0, -1) if root?(path)
+          self
+        end
+
+        # Creates the directory at {#map_path}(path)
+        def mkdir(path, mode)
+          return Dir.mkdir(map_path(path), mode) unless root?(path)
+
+          accounting&.adjust(0, +1)
+          self
+        end
+
+        # Creates the File at {#map_path}(path)
+        def create(path, perms = 0o644, ffi = nil)
+          File.open(map_path(path), ffi&.flags, perms)
+        end
+
+        # @!endgroup
+
+        # @return [String] {#base_dir} + path
+        def map_path(path)
+          root?(path) ? @base_dir : "#{@base_dir}#{path}"
+        end
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/filesystem/pass_through_file.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'accounting'
+require_relative 'mapped_files'
+
+module FFI
+  module Libfuse
+    module Filesystem
+      # Represents a single regular file at a given underlying path
+      class PassThroughFile
+        include MappedFiles
+
+        # @param [String] real_path
+        def initialize(real_path)
+          @real_path = real_path
+        end
+
+        # @!visibility private
+        def map_path(path)
+          raise Errno::ENOENT unless root?(path)
+
+          @real_path
+        end
+
+        # @!group FUSE Callbacks
+
+        # Adjust accounting to add a node
+        def create(path, perms, ffi)
+          raise Errno::ENOENT unless root?(path)
+
+          accounting&.adjust(0, +1)
+          super
+        end
+
+        # Adjust accounting to remove a node
+        def unlink(path)
+          raise Errno::ENOENT unless root?(path)
+
+          accounting&.adjust(0, -1)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/filesystem/utils.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../fuse_context'
+
+module FFI
+  module Libfuse
+    module Filesystem
+      # RubySpace File Utilities
+      #
+      # This module provides utility methods for file operations in RubySpace which are useful for creating custom
+      # entries prior to mounting, or otherwise manipulating the filesystem from within the Ruby process that is
+      # running FUSE.
+      #
+      # **Note** You cannot generally call Ruby's {::File} and {::Dir} operations from within the same Ruby process
+      #   as the mounted filesystem because MRI will not release the GVL to allow the Fuse callbacks to run.
+      module Utils
+        # Recursive mkdir
+        # @param [:to_s] path
+        # @param [Integer] mode permissions for any dirs that need to be created
+        # @yieldparam [String] the path component being created
+        # @yieldreturn [FuseOperations] optionally a filesystem to mount at path, if the path did not previously exist
+        def mkdir_p(path, mode = (~FuseContext.get.umask & 0o0777), &mount_fs)
+          return if root?(path) # nothing to make
+
+          path.to_s.split('/')[1..].inject('') do |base_path, sub_dir|
+            full_path = "#{base_path}/#{sub_dir}"
+            err = Adapter::Safe.safe_callback(:mkdir) { mkdir(full_path, mode, &mount_fs) }
+            unless [0, -Errno::EEXIST::Errno].include?(err)
+              raise SystemCallError.new("Unexpected err #{err.abs} from mkdir #{full_path}", err.abs)
+            end
+
+            full_path
+          end
+          0
+        end
+        alias mkpath mkdir_p
+
+        # @param [:to_s] path
+        # @return [FFI::Stat]
+        def stat(path)
+          path = path.to_s
+          stat_buf = FFI::Stat.new
+
+          err = Adapter::Safe.safe_callback(:getattr) { getattr(path, stat_buf) }
+
+          return nil if err == -Errno::ENOENT::Errno
+          raise SystemCallError, "Unexpected error from #{fs}.getattr #{path}", err unless err.zero?
+
+          stat_buf
+        end
+
+        # @param [:to_s] path
+        # @return [Boolean] true if file or directory exists at path
+        def exists?(path)
+          stat(path) && true
+        end
+
+        # @param [:to_s] path
+        # @return [Boolean] true if regular file exists at path
+        def file?(path)
+          stat(path)&.file? || false
+        end
+
+        # @param [:to_s] path
+        # @return [Boolean] true if directory exists at path
+        def directory?(path)
+          stat(path)&.directory? || false
+        end
+
+        # @param [:to_s] path
+        # @return [Boolean] File exists at path and has zero size
+        def empty_file?(path)
+          s = stat(path)
+          (s&.file? && s.size.zero?) || false # rubocop:disable Style/ZeroLengthPredicate
+        end
+
+        # Check if a directory is empty
+        # @param [String] path
+        # @return [Boolean] true if an empty directory exists at path
+        # @raise [Errno::ENOTDIR] if path does not point to a directory
+        def empty_dir?(path)
+          return false unless directory?(path)
+
+          empty = true
+          fake_filler = proc do |_buf, name, _stat = nil, _offset = 0, _fuse_flag = 0|
+            next 0 if %w[. ..].include?(name)
+
+            empty = false
+            -1 # buf full don't send more entries!
+          end
+          readdir(path.to_s, nil, fake_filler, 0, nil, *(fuse3_compat? ? [] : [0]))
+          empty
+        end
+
+        # @!visibility private
+        def fuse3_compat?
+          FUSE_MAJOR_VERSION >= 3
+        end
+      end
+    end
+  end
+end