ffi-libfuse 0.3.4 → 0.4.0

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

@@ -6,88 +6,94 @@ require 'stringio'
 module FFI
   module Libfuse
     module Filesystem
+      module Ruby
+        # Filesystem methods representing a single synthetic file at the root and satisfying
+        # Satisfies the contract of {Adapter::Ruby}
+        module VirtualFile
+          include VirtualNode
+
+          # @return [String] the (binary) content of the synthetic file
+          attr_reader :content
+
+          # @return [Integer] the number of links to this file
+          attr_reader :nlink
+
+          # Create an empty synthetic file
+          def initialize(accounting: nil)
+            super(accounting: accounting)
+          end
+
+          # @!group FUSE Callbacks
+
+          def getattr(path, stat = nil, ffi = nil)
+            # We don't exist until create or otherwise or virtual stat exists
+            raise Errno::ENOENT unless root?(path) && virtual_stat
+
+            stat&.file(size: (ffi&.fh || content).size, nlink: nlink, **virtual_stat)
+            self
+          end
+
+          # @param [String] _path ignored, expected to be '/'
+          # @param [Integer] mode
+          # @param [FuseFileInfo] ffi
+          # @return [Object] a file handled (captured by {Adapter::Ruby::Prepend})
+          def create(_path, mode, ffi = nil)
+            init_node(mode)
+            @content = String.new(encoding: 'binary')
+            @nlink = 1
+            sio(ffi) if ffi
+          end
+
+          def open(_path, ffi)
+            virtual_stat[:atime] = Time.now.utc
+            sio(ffi)
+          end
+
+          # write(const char* path, char *buf, size_t size, off_t offset, struct fuse_file_info* fi)
+          def write(path, data, offset = 0, _ffi = nil)
+            raise Errno::ENOENT unless root?(path)
+
+            accounting&.write(content.size, data.size, offset)
+            virtual_stat[:mtime] = Time.now.utc
+            nil # just let the sio in ffi handle it
+          end
+
+          def truncate(path, size, ffi = nil)
+            raise Errno::ENOENT unless root?(path)
+
+            accounting&.truncate(content.size, size)
+            sio(ffi).truncate(size)
+            virtual_stat[:mtime] = Time.now.utc
+          end
+
+          def link(_target, path)
+            raise Errno::ENOENT unless root?(path)
+
+            accounting&.adjust(content.size, 1) if @nlink.zero?
+            @nlink += 1
+            self
+          end
+
+          def unlink(path)
+            raise Errno::ENOENT unless root?(path)
+
+            @nlink -= 1
+            accounting&.adjust(-content.size, -1) if @nlink.zero?
+          end
+
+          private
+
+          def sio(ffi)
+            ffi&.fh || StringIO.new(content, ffi&.flags)
+          end
+        end
+      end
+
       # A Filesystem representing a single synthetic file at the root
-      class VirtualFile < VirtualNode
+      class VirtualFile
         prepend Adapter::Ruby::Prepend
         include Fuse2Compat
-
-        # @return [String] the (binary) content of the synthetic file
-        attr_reader :content
-
-        # Create an empty synthetic file
-        def initialize(accounting: nil)
-          super(accounting: accounting)
-        end
-
-        # @!visibility private
-        def path_method(_method, *_args)
-          raise Errno::ENOENT
-        end
-
-        # @!group FUSE Callbacks
-
-        def getattr(path, stat, ffi = nil)
-          # We don't exist until create or otherwise or virtual stat exists
-          raise Errno::ENOENT unless root?(path) && virtual_stat
-
-          stat.file(size: (ffi&.fh || content).size, **virtual_stat)
-          self
-        end
-
-        # @param [String] _path ignored, expected to be '/'
-        # @param [Integer] mode
-        # @param [FuseFileInfo] ffi
-        # @return [Object] a file handled (captured by {Adapter::Ruby::Prepend})
-        def create(_path, mode, ffi = nil)
-          init_node(mode)
-          @content = String.new(encoding: 'binary')
-          sio(ffi) if ffi
-        end
-
-        def open(_path, ffi)
-          virtual_stat[:atime] = Time.now.utc
-          sio(ffi)
-        end
-
-        # op[:read] = [:pointer, :size_t, :off_t, FuseFileInfo.by_ref]
-        def read(path, size, off, ffi)
-          raise Errno::ENOENT unless root?(path)
-
-          io = sio(ffi)
-          io.seek(off)
-          io.read(size)
-        end
-
-        # write(const char* path, char *buf, size_t size, off_t offset, struct fuse_file_info* fi)
-        def write(path, data, offset = 0, ffi = nil)
-          raise Errno::ENOENT unless root?(path)
-
-          accounting&.write(content.size, data.size, offset)
-          io = sio(ffi)
-          io.seek(offset)
-          io.write(data)
-          virtual_stat[:mtime] = Time.now.utc
-        end
-
-        def truncate(path, size, ffi = nil)
-          raise Errno::ENOENT unless root?(path)
-
-          accounting&.truncate(content.size, size)
-          sio(ffi).truncate(size)
-          virtual_stat[:mtime] = Time.now.utc
-        end
-
-        def unlink(path)
-          raise Errno::ENOENT unless root?(path)
-
-          accounting&.adjust(-content.size, -1)
-        end
-
-        private
-
-        def sio(ffi)
-          ffi&.fh || StringIO.new(content, ffi&.flags)
-        end
+        include Ruby::VirtualFile
       end
     end
   end

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

@@ -15,6 +15,8 @@ module FFI
       # Delegate filesystems like {VirtualDir} may raise ENOTSUP to indicate a callback is not handled at runtime
       #   although the behaviour of C libfuse varies in this regard.
       #
+      # It is writable to the user that mounted it may create and edit files within it
+      #
       # Filesystem options
       # ===
       #
@@ -33,15 +35,14 @@ module FFI
       #       Note that {VirtualFile} and {MappedFiles} both prepend {Adapter::Ruby::Prepend} which implements
       #       the logic to fallback from :read/:write_buf to plain :read/:write as necessary to support this option.
       #
-      # It is writable to the user that mounted it may create and edit files within it
-      #
       # @example
       #   class MyFS < FFI::Libfuse::Filesystem::VirtualFS
       #     def fuse_configure
       #       build({ 'hello' => { 'world.txt' => 'Hello World'}})
       #       mkdir("/hello")
-      #       create("/hello/world").write("Hello World!\n")
+      #       create("/hello/world.txt").write("Hello World!\n")
       #       create("/hello/everybody").write("Hello Everyone!\n")
+      #       symlink("/hello/link","everybody")`
       #     end
       #   end
       #
@@ -51,7 +52,7 @@ module FFI
         include Utils
         include Adapter::Context
         include Adapter::Debug
-        include Adapter::Safe
+        include Adapter::Fuse2Compat
 
         # @return [Object] the root filesystem that quacks like a {FuseOperations}
         attr_reader :root
@@ -73,12 +74,13 @@ module FFI
 
         # @overload build(files)
         #  Adds files directly to the filesystem
-        #  @param [Hash] files map of paths to content responding to
+        #  @param [Hash<String,:each_pair, :readdir,:getattr .:to_str] files map of paths to content generated
+        #  according to the content implementing one of the methods below
         #
         #    * :each_pair is treated as a subdir of files
         #    * :readdir (eg {PassThroughDir}) is treated as a directory- sent via mkdir
         #    * :getattr (eg {PassThroughFile}) is treated as a file - sent via create
-        #    * :to_str (eg {::String} ) is created as a {VirtualFile}
+        #    * :to_str (eg {::String} ) is created a default file, with the string sent via write
         def build(files, base_path = Pathname.new('/'))
           files.each_pair do |path, content|
             path = (base_path + path).cleanpath
@@ -103,10 +105,6 @@ module FFI
         #   * :copy_file_range can raise ENOTSUP to trigger glibc to fallback to inefficient copy
         def fuse_respond_to?(method)
           case method
-          when :getdir, :fgetattr
-            # TODO: Find out if fgetattr works on linux, something wrong with stat values on OSX.
-            #     https://github.com/osxfuse/osxfuse/issues/887
-            false
           when :read_buf, :write_buf
             !no_buf
           else
@@ -117,16 +115,21 @@ module FFI
         # Default fuse options
         # Subclasses can override this method and call super with the additional options:
         # @param [Hash] opts additional options to parse into the {#options} attribute
-        def fuse_options(args, opts = {})
+        # @yield(key, value, **args)
+        #   Called for each matching key in opts
+        # @see FuseArgs#parse!
+        def fuse_options(args, opts = {}, &block)
           @options = {}
           opts = opts.merge({ 'no_buf' => :no_buf }).merge(Accounting::OPTIONS)
-          args.parse!(opts) do |key:, value:, **|
+          args.parse!(opts) do |key:, value:, **kwargs|
             case key
             when *Accounting::OPTIONS.values.uniq
               next accounting.fuse_opt_proc(key: key, value: value)
             when :no_buf
               @no_buf = true
             else
+              next block.call(key, value, **kwargs) if block
+
               options[key] = value
             end
             :handled
@@ -147,6 +150,21 @@ module FFI
           self.class.name
         end
 
+        # @!visibility private
+        def init_fuse_config(fuse_config, _fuse_version)
+          fuse_config.use_ino = use_ino
+        end
+
+        # Configure whether entries in this filesystem provide useful inode values in #gettattr and #readdir
+        #
+        # Defaults to true since default Dir, File, Link all use {VirtualNode} which uses
+        # Ruby object id as the inode value.
+        #
+        # Subclasses should override to false if some sub-filesystems will not provide inode values.
+        # @return [Boolean]
+        def use_ino
+          true
+        end
         # @!endgroup
 
         private
@@ -156,15 +174,16 @@ module FFI
         end
 
         def build_readdir(content, path)
-          @root.mkdir(path.to_s) { content }
+          @root.mkdir(path.to_s) { |_| content }
         end
 
         def build_getattr(content, path)
-          @root.create(path.to_s) { content }
+          @root.create(path.to_s) { |_| content }
         end
 
         def build_to_str(content, path)
-          @root.create(path.to_s) { content }
+          vf = @root.create(path.to_s)
+          vf.write(content.to_str)
         end
 
         # Passes FUSE Callbacks on to the {#root} filesystem

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module FFI
+  module Libfuse
+    module Filesystem
+      module Ruby
+        # Filesystem methods representing a symbolic link
+        # Satisfies the contract of {Adapter::Ruby}
+        module VirtualLink
+          attr_accessor :target
+
+          include VirtualNode
+          def initialize(accounting: nil)
+            @target = target
+            super(accounting: accounting)
+          end
+
+          def readlink(_path, size)
+            @target[0, size - 1] # buffer size needs null terminator
+          end
+
+          def symlink(from_path, path)
+            raise Errno::ENOENT unless root?(path)
+
+            @target = from_path
+            init_node(0o777)
+          end
+
+          def link(_from_path, path)
+            raise Errno::ENOENT unless root?(path)
+
+            # Cannot hard link a symbolic link
+            raise Errno::EPERM
+          end
+
+          def unlink(path)
+            raise Errno::ENOENT unless root?(path)
+
+            accounting&.adjust(0, -1)
+          end
+
+          def getattr(path, stat = nil, _ffi = nil)
+            # We don't exist until create or otherwise or virtual stat exists
+            raise Errno::ENOENT unless root?(path) && virtual_stat
+
+            stat&.symlink(size: @target.length + 1, **virtual_stat)
+            self
+          end
+        end
+      end
+
+      # A Filesystem that represents a single symbolic link at the root
+      class VirtualLink
+        prepend Adapter::Ruby::Prepend
+        include Fuse2Compat
+        include Ruby::VirtualLink
+      end
+    end
+  end
+end

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

@@ -6,95 +6,112 @@ require_relative '../adapter/ruby'
 module FFI
   module Libfuse
     module Filesystem
-      # @abstract
-      # Common FUSE Callbacks for a virtual inode
-      #
-      # **Note** this class is used by both {VirtualFile} which is under {Adapter::Ruby::Prepend}
-      #  and {VirtualDir} which passes on native {FuseOperations} calls
-      class VirtualNode
-        # @return [Hash<Symbol,Integer>] base file or directory stat information used for :getattr of this node
-        attr_reader :virtual_stat
-
-        # @return [Hash<String,String>] virtual extended attributes
-        attr_reader :virtual_xattr
-
-        # @return [Accounting|nil] file system statistcs accumulator
-        attr_reader :accounting
-
-        # @param [Accounting] accounting accumulator of filesystem statistics
-        def initialize(accounting: Accounting.new)
-          @accounting = accounting
-
-          @virtual_xattr = {}
-        end
-
-        # @!method path_method(callback, *args)
-        #   @abstract
-        #   called if this node cannot handle the callback (ie path is not root or an entry in this directory)
-
-        # @!group FUSE Callbacks
-
-        def utimens(path, *args)
-          return path_method(__method__, path, *args) unless root?(path)
-
-          atime, mtime, *_fuse3 = args
-          # if native fuse call atime will be Array<Stat::TimeSpec>
-          atime, mtime = Stat::TimeSpec.fill_times(atime[0, 2], 2).map(&:time) if atime.is_a?(Array)
-          virtual_stat[:atime] = atime if atime
-          virtual_stat[:mtime] = mtime if mtime
-          virtual_stat[:ctime] = mtime if mtime
-        end
-
-        def chmod(path, mode, *args)
-          return path_method(__method__, path, mode, *args) unless root?(path)
-
-          virtual_stat[:mode] = mode
-          virtual_stat[:ctime] = Time.now
-        end
-
-        def chown(path, uid, gid, *args)
-          return path_method(__method__, path, uid, gid, *args) unless root?(path)
-
-          virtual_stat[:uid] = uid
-          virtual_stat[:gid] = gid
-          virtual_stat[:ctime] = Time.now
+      module Ruby
+        # Common FUSE Callbacks for a virtual inode representing a single filesystem object at '/'
+        #
+        # **Note** this module is used by both {VirtualFile} which is under {Adapter::Ruby::Prepend}
+        #  and {VirtualDir} which passes on native {FuseOperations} calls
+        module VirtualNode
+          # @return [Hash<Symbol,Integer>] base file or directory stat information used for :getattr of this node
+          attr_reader :virtual_stat
+
+          # @return [Hash<String,String>] virtual extended attributes
+          attr_reader :virtual_xattr
+
+          # @return [Accounting|nil] file system statistcs accumulator
+          attr_reader :accounting
+
+          # @param [Accounting] accounting accumulator of filesystem statistics
+          def initialize(accounting: Accounting.new)
+            @accounting = accounting
+
+            @virtual_xattr = {}
+          end
+
+          # @!method path_method(callback, *args)
+          #   @abstract
+          #   called if this node cannot handle the callback (ie path is not root or an entry in this directory)
+
+          # @!group FUSE Callbacks
+
+          def utimens(path, *args)
+            return path_method(__method__, path, *args) unless root?(path)
+
+            atime, mtime, *_fuse3 = args
+            # if native fuse call atime will be Array<Stat::TimeSpec>
+            atime, mtime = Stat::TimeSpec.fill_times(atime[0, 2], 2).map(&:time) if atime.is_a?(Array)
+            virtual_stat[:atime] = atime if atime
+            virtual_stat[:mtime] = mtime if mtime
+            virtual_stat[:ctime] = mtime if mtime
+          end
+
+          def chmod(path, mode, *args)
+            return path_method(__method__, path, mode, *args) unless root?(path)
+
+            virtual_stat[:mode] = mode
+            virtual_stat[:ctime] = Time.now
+          end
+
+          def chown(path, uid, gid, *args)
+            return path_method(__method__, path, uid, gid, *args) unless root?(path)
+
+            virtual_stat[:uid] = uid
+            virtual_stat[:gid] = gid
+            virtual_stat[:ctime] = Time.now
+          end
+
+          def statfs(path, statfs_buf)
+            return path_method(__method__, path, statfs_buf) unless root?(path)
+            raise Errno::ENOTSUP unless accounting
+
+            accounting.to_statvfs(statfs_buf)
+          end
+
+          def getxattr(path, name, buf = nil, size = nil)
+            return path_method(__method__, path, name, buf, size) unless root?(path)
+            return virtual_xattr[name] unless buf
+
+            Adapter::Ruby.getxattr(buf, size) { virtual_xattr[name] }
+          end
+
+          def listxattr(path, buf = nil, size = nil)
+            return path_method(__method__, path) unless root?(path)
+            return virtual_xattr.keys unless buf
+
+            Adapter::Ruby.listxattr(buf, size) { virtual_xattr.keys }
+          end
+
+          # @!endgroup
+
+          # Initialise the stat information for the node - should only be called once (eg from create or mkdir)
+          def init_node(mode, ctx: FuseContext.get, now: Time.now)
+            @virtual_stat =
+              {
+                mode: mode & ~ctx.umask, uid: ctx.uid, gid: ctx.gid,
+                ctime: now, mtime: now, atime: now,
+                ino: object_id
+              }
+            accounting&.adjust(0, +1)
+            self
+          end
+
+          private
+
+          # @!visibility private
+          def path_method(_method, *_args)
+            raise Errno::ENOENT
+          end
+
+          def root?(path)
+            path.to_s == '/'
+          end
         end
+      end
 
-        def statfs(path, statfs_buf)
-          return path_method(__method__, path, statfs_buf) unless root?(path)
-          raise Errno::ENOTSUP unless accounting
-
-          accounting.to_statvfs(statfs_buf)
-        end
-
-        def getxattr(path, name, buf = nil, size = nil)
-          return path_method(__method__, path, name, buf, size) unless root?(path)
-          return virtual_xattr[name] unless buf
-
-          Adapter::Ruby.getxattr(buf, size) { virtual_xattr[name] }
-        end
-
-        def listxattr(path, buf = nil, size = nil)
-          return path_method(__method__, path) unless root?(path)
-          return virtual_xattr.keys unless buf
-
-          Adapter::Ruby.listxattr(buf, size) { virtual_xattr.keys }
-        end
-
-        # @!endgroup
-
-        # Initialise the stat information for the node - should only be called once (eg from create or mkdir)
-        def init_node(mode, ctx: FuseContext.get, now: Time.now)
-          @virtual_stat = { mode: mode & ~ctx.umask, uid: ctx.uid, gid: ctx.gid, ctime: now, mtime: now, atime: now }
-          accounting&.adjust(0, +1)
-          self
-        end
-
-        private
-
-        def root?(path)
-          path.to_s == '/'
-        end
+      # @abstract
+      # Base class Represents a virtual inode
+      class VirtualNode
+        include Ruby::VirtualNode
       end
     end
   end

data/lib/ffi/libfuse/filesystem.rb

@@ -7,7 +7,7 @@ module FFI
     # This module namespace contains classes and modules to assist with building and composing filesystems
     #
     # ### Virtual Filesystems
-    # Classes to help compose in-memory filesystems {VirtualFS}, {VirtualDir}, {VirtualFile}
+    # Classes to help compose in-memory filesystems {VirtualFS}, {VirtualDir}, {VirtualFile}, {VirtualLink}
     #
     # ### Mapped Filesystem
     # Modules to map paths in the fuse filesystem to either real files or other filesystem objects

data/lib/ffi/libfuse/fuse2.rb

@@ -44,14 +44,15 @@ module FFI
         def parse_cmdline(args, handler: nil)
           # This also handles -h to print help information on stderr
           # Parse mountpoint, -f , -s from args
-          # @return [Array<(String,Boolean,Boolean)>|nil]
+          # @return [Array<(String,Boolean,Boolean)>]
           #     mountpoint, multi_thread, foreground options from args if available
           #     nil if no mountpoint, or options is requesting help or version information
           mountpoint_ptr = FFI::MemoryPointer.new(:pointer, 1)
           multi_thread_ptr = FFI::MemoryPointer.new(:int, 1)
           foreground_ptr = FFI::MemoryPointer.new(:int, 1)
 
-          return nil unless Libfuse.fuse_parse_cmdline2(args, mountpoint_ptr, multi_thread_ptr, foreground_ptr).zero?
+          res = Libfuse.fuse_parse_cmdline2(args, mountpoint_ptr, multi_thread_ptr, foreground_ptr)
+          raise Error unless res.zero?
 
           # noinspection RubyResolve
           mp_data_ptr = mountpoint_ptr.get_pointer(0)

data/lib/ffi/libfuse/fuse3.rb

@@ -56,7 +56,7 @@ module FFI
       class << self
         def parse_cmdline(args, handler: nil)
           cmdline_opts = FuseCmdlineOpts.new
-          return nil unless Libfuse.fuse_parse_cmdline3(args, cmdline_opts).zero?
+          raise Error unless Libfuse.fuse_parse_cmdline3(args, cmdline_opts).zero?
 
           handler&.fuse_debug(cmdline_opts.debug) if handler.respond_to?(:fuse_debug)
 

data/lib/ffi/libfuse/fuse_args.rb

@@ -121,7 +121,8 @@ module FFI
       #  - :error            an error, alternatively raise {Error}
       #  - :keep             retain the current argument for further processing
       #  - :handled,:discard remove the current argument from further processing
-      # @return [nil|self] nil on error otherwise self
+      # @raise Error if an error is raised during parsing
+      # @return [self]
       def parse!(opts, data = nil, ignore: %i[non_option unmatched], &block)
         ignore ||= []
 
@@ -140,7 +141,9 @@ module FFI
         end
 
         fop = fuse_opt_proc(symbols, bool_opts, param_opts, ignore, &block)
-        Libfuse.fuse_opt_parse(self, data, int_opts, fop).zero? ? self : nil
+        raise Error unless Libfuse.fuse_opt_parse(self, data, int_opts, fop).zero?
+
+        self
       end
 
       private