ffi-libfuse 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d59c87631dfe38e9dc49b36f829acdd704165162deff3bad6479f3394f348657
-  data.tar.gz: 01ab562dd537f1f11f7e3c454e49c5df3ef1ce5cfd6cb8b1aa6b5e6a7f89a4c0
+  metadata.gz: e105d84b1d0f73af20845ed1d39e51ae61f9ca4998fa9caf505b4e87ae08eaa9
+  data.tar.gz: 7f9013b530bc62e9fb4071899e13f191fdc720f662221da1cac0cd554a76bc5f
 SHA512:
-  metadata.gz: ae437c153a84155c86a9e2d71d4dd1c6234879fae7553676efacd311e26cae3cf653dd4439b2ec4ab584cd01698636915fc6c9cefd14a2f045c2b19e4077e60b
-  data.tar.gz: af5fab46502ff889710facc930ee59d7bb27e129da3c70f0d5089c1fa85e29bbfe3ec91b01f75db907da5f8be220755edec6b4b3976421ce0454cc43830387da
+  metadata.gz: 72b0a464ab67be704cb14f3ce4b07f1f9a29d260ee50864dcf8c75cc24ba2eaf43aab6ae9f79fda9edb707cded39fde10e8504be7b8ca011b1a7d625969d62f6
+  data.tar.gz: b85626a26f149dc1852ae5928cef67eb5dd7fc4353acb6bafa4fb0061aec38dce6d6e6c8137b216bc540263ba28f5b5f627f3af8feecb9bab417bbfc64df45ab

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.4.0](https://github.com/lwoggardner/ffi-libfuse/compare/v0.3.4...v0.4.0) (2024-01-21)
+
+
+### ⚠ BREAKING CHANGES
+
+* **filesystem:** Fuse callbacks :init and :destroy are no longer passed on to sub-filesystems.
+* **adapters:** Adapter::Debug now includes Adapter::Safe.
+* Option parsing errors via raise exception rather than return false/nil
+
+### Features
+
+* **adapters:** Adapter::Debug now includes Adapter::Safe. ([a595304](https://github.com/lwoggardner/ffi-libfuse/commit/a59530427d7eb85961a724969eaa6ec099c5e4f6))
+* **filesystem:** Support :rename operation in virtual filesystems ([a595304](https://github.com/lwoggardner/ffi-libfuse/commit/a59530427d7eb85961a724969eaa6ec099c5e4f6))
+* **filesystem:** Support symlinks and hardlinks in virtual filesystems (VirtualDir/MemoryFS) ([a595304](https://github.com/lwoggardner/ffi-libfuse/commit/a59530427d7eb85961a724969eaa6ec099c5e4f6))
+* Option parsing errors via raise exception rather than return false/nil ([a595304](https://github.com/lwoggardner/ffi-libfuse/commit/a59530427d7eb85961a724969eaa6ec099c5e4f6))
+
+
+### Bug Fixes
+
+* **fuse2compat:** Enhanced Fuse2 compatibility in Fuse2Compat module ([a595304](https://github.com/lwoggardner/ffi-libfuse/commit/a59530427d7eb85961a724969eaa6ec099c5e4f6))
+* symlinks and hard links ([a595304](https://github.com/lwoggardner/ffi-libfuse/commit/a59530427d7eb85961a724969eaa6ec099c5e4f6))
+
 ## [0.3.4](https://github.com/lwoggardner/ffi-libfuse/compare/v0.3.3...v0.3.4) (2023-01-08)
 
 

data/README.md

@@ -84,7 +84,7 @@ class HelloFS
 end
 
 # Start the file system
-FFI::Libfuse.fuse_main(operations: HelloFS.new) if __FILE__ == $0
+exit(FFI::Libfuse.fuse_main(operations: HelloFS.new)) if __FILE__ == $0
 
 ```
 <!-- SAMPLE END: sample/hello_fs.rb -->

data/lib/ffi/accessors.rb

@@ -19,22 +19,29 @@ module FFI
 
       #
       # Define a struct attribute reader for members
-      # @param [Array<Symbol>] attrs the attribute names
+      # @param [Array<Symbol>]
+      #   attrs the attribute names used as the reader method name
+      #
+      #   a trailing '?' will be stripped from attribute names for primary reader method name, and cause an
+      #   boolean alias method to be created.
       # @param [Proc|String] format
-      #   A Proc, or format string containing a single %s, to convert attr to struct member name
+      #   A Proc, or format string containing a single %s, to convert each attribute name to the corresponding
+      #   struct member name
       # @param [Boolean] simple
       #   Controls how writer methods are defined using block
       # @param [Proc] block
-      #   An optional block to the struct field(s) into something more useful
+      #   An optional block to convert the struct field value into something more useful
       #
       #   If simple is true then block takes the struct field value, otherwise method is defined directly from the block
-      #   and should use __method__ to get the attr name, and self.class.ffi_attr_readers[__method__] to get the member
-      #   name
+      #   and should use __method__ to get the attribute name. and self.class.ffi_attr_readers[__method__] to get the
+      #   member name if these are not available from enclosed variables.
       # @return [void]
       def ffi_attr_reader(*attrs, format: '%s', simple: true, &block)
         attrs.each do |attr|
+          bool, attr = attr[-1] == '?' ? [true, attr[..-2]] : [false, attr]
+
           member = (format.respond_to?(:call) ? format.call(attr) : format % attr).to_sym
-          ffi_attr_readers[attr] = member
+          ffi_attr_readers[attr.to_sym] = member
           if !block
             define_method(attr) { self[member] }
           elsif simple
@@ -42,11 +49,14 @@ module FFI
           else
             define_method(attr, &block)
           end
+
+          alias_method "#{attr}?", attr if bool
         end
       end
 
       # Define a struct attribute writer
       # @param [Array<Symbol>] attrs the attribute names
+      #   trailing '?' will be stripped from attribute names
       # @param [String|Proc] format
       #   A format string containing a single %s to convert attr symbol to struct member
       # @param [Boolean] simple
@@ -60,6 +70,8 @@ module FFI
       # @return [void]
       def ffi_attr_writer(*attrs, format: '%s', simple: true, &block)
         attrs.each do |attr|
+          attr = attr[..-2] if attr[-1] == '?'
+
           member = (format % attr).to_sym
           ffi_attr_writers[attr.to_sym] = member
           if !block
@@ -95,7 +107,9 @@ module FFI
       # @param [Array<Symbol>] flags list of flags
       # @return [void]
       def ffi_bitflag_reader(attr, *flags)
-        flags.each { |f| ffi_attr_reader(f, simple: false) { self[attr].include?(f) } }
+        flags.each do |f|
+          ffi_attr_reader(:"#{f}?", simple: false) { self[attr].include?(f) }
+        end
       end
 
       # Define individual flag writers over a bitmask field

data/lib/ffi/boolean_int.rb

@@ -21,7 +21,7 @@ module FFI
     end
 
     %i[char short int long int8 int16 int32 int64].each do |t|
-      FFI.typedef(BooleanInt.new(t), "bool_#{t}".to_sym)
+      FFI.typedef(BooleanInt.new(t), :"bool_#{t}")
     end
   end
 end

data/lib/ffi/devt.rb

@@ -15,17 +15,17 @@ module FFI
     #  @param [Integer] major
     #  @param [Integer] minor
     #  @return [Integer] combined major/minor to a single value to pass to mknod etc
-    attach_function :makedev, "#{prefix}makedev".to_sym, %i[int int], :int
+    attach_function :makedev, :"#{prefix}makedev", %i[int int], :int
 
     # @!method major(dev)
     #  @param [Integer] dev
     #  @return [Integer] the major component of dev
-    attach_function :major, "#{prefix}major".to_sym, [:int], :int
+    attach_function :major, :"#{prefix}major", [:int], :int
 
     # @!method minor(dev)
     #  @param [Integer] dev
     #  @return [Integer] the minor component of dev
-    attach_function :minor, "#{prefix}minor".to_sym, [:int], :int
+    attach_function :minor, :"#{prefix}minor", [:int], :int
   rescue FFI::NotFoundError
     case Platform::NAME
     when 'x86_64-darwin'

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

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
+require_relative 'safe'
+
 module FFI
   module Libfuse
     module Adapter
       # Debug callbacks
       #
       # When included in a filesystem class, and if debugging is enabled via {Main#fuse_debug}, then installs a wrapper
-      #  via #{FuseCallbacks#fuse_wrappers} to log callbacks via #warn
+      #  via #{FuseCallbacks#fuse_wrappers} to log callbacks.
+      #
+      # Simple format options can be handled by #{debug_config}, or override the **Module Functions** on an including
+      # class for more programmatic control of output.
+      #
+      # @note {Debug} includes {Safe} as it expects to handle (and re-raise) exceptions.
       module Debug
+        include Safe
+
+        # Default format
+        # @see debug_callback
         DEFAULT_FORMAT = "%<p>s %<n>s %<t>s %<m>s(%<a>s)\n\t=> %<r>s"
 
         # @return [Boolean] true if debug is enabled
@@ -26,8 +37,8 @@ module FFI
         def fuse_wrappers(*wrappers)
           conf = { prefix: self.class.name }.merge!(debug_config)
           # validate config for bad formats, strftime etc
-          Debug.debug_format(:test_debug, [], :result, **conf)
-          wrappers << proc { |fm, *args, &b| Debug.debug_callback(fm, *args, **conf, &b) } if debug?
+          debug_format(:test_debug, [], :result, **conf)
+          wrappers << proc { |fm, *args, &b| debug_callback(fm, *args, **conf, &b) } if debug?
           return wrappers unless defined?(super)
 
           super(*wrappers)
@@ -41,10 +52,11 @@ module FFI
 
         module_function
 
-        # Debug fuse method, args and result
+        # Debug fuse method, args and result of yielding args to the block
+        #
         # @param [Symbol] fuse_method the callback name
         # @param [Array] args callback arguments
-        # @param [Hash<Symbol,String>] options see {debug} for defaults
+        # @param [Hash<Symbol,String>] options see {debug_format} for defaults
         # @option options [String] prefix
         # @option options [String] strftime a date time format
         # @option options [String] format  format string with fields
@@ -55,25 +67,49 @@ module FFI
         #   * %<a>: Comma separate list of arguments
         #   * %<r>: Result of the method call (or any error raised)
         #   * %<p>: The value of prefix option
+        # @raise [SystemCallError]
+        #   expected Errors raised from callbacks are logged with their cause (if any)
+        # @raise [StandardError,ScriptError]
+        #   unexpected Errors raised from callbacks are logged with their backtrace
         def debug_callback(fuse_method, *args, **options)
-          debug(fuse_method, args, yield(*args), **options)
-        rescue SystemCallError => e
-          # expected behaviour
-          debug(fuse_method, args, "#{e.class.name}(errno=#{e.errno}): #{e.message}", **options)
-          raise
+          result = yield(*args)
+          debug(fuse_method, args, result, **options)
+          result
         rescue StandardError, ScriptError => e
-          # unexpected, debug with backtrace
-          debug(fuse_method, args, (["#{e.class.name}: #{e.message}"] + e.backtrace).join("\n\t"), **options)
+          debug(fuse_method, args, error_message(e), **options)
+          debug_error(e)
           raise
         end
 
-        # @!visibility private
+        # @!group Module Functions
+
+        # Logs the callback
         def debug(fuse_method, args, result, **options)
           warn debug_format(fuse_method, args, result, **options)
-          result
         end
 
-        # @!visibility private
+        # @param [Exception] err
+        # @return [String] the detailed error message for err
+        def error_message(err)
+          if err.is_a?(SystemCallError)
+            "#{err.class.name}(errno=#{err.errno}): #{err.message}"
+          else
+            "#{err.class.name}: #{err.message}"
+          end
+        end
+
+        # Log additional information for errors (cause/backtrace etc)
+        # @see debug_callback
+        def debug_error(err)
+          if err.is_a?(SystemCallError)
+            warn "Caused by #{error_message(err.cause)}" if err.cause
+          else
+            warn err.backtrace.join("\n\t")
+          end
+        end
+
+        # @return [String] the formatted debug message
+        # @see debug_callback
         def debug_format(fuse_method, args, result, prefix: 'DEBUG', strftime: '%FT%T%:z', format: DEFAULT_FORMAT)
           format(format,
                  p: prefix,
@@ -83,6 +119,8 @@ module FFI
                  a: args.map(&:to_s).join(','),
                  r: result)
         end
+
+        # @!endgroup
       end
     end
   end

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

@@ -31,8 +31,8 @@ module FFI
               super(path, mode, fuse_file_info)
             end
 
-            def utimens(path, atime, mtime, fuse_file_info = nil)
-              super(path, atime, mtime, fuse_file_info)
+            def utimens(path, times, fuse_file_info = nil)
+              super(path, times, fuse_file_info)
             end
 
             def readdir(path, buffer, filler, offset, fuse_file_info, fuse_readdir_flag = 0)
@@ -40,49 +40,66 @@ module FFI
               super(path, buffer, f3_fill, offset, fuse_file_info, fuse_readdir_flag)
             end
 
-            def fgetattr(path, stat, ffi)
-              stat.clear # For some reason (at least on OSX) the stat is not clear when this is called.
-              getattr(path, stat, ffi)
-              0
-            end
+            def fuse_respond_to?(fuse_method)
+              # getdir is never supported here anyway
+              # fgetattr and ftruncate already fallback to the respective basic method
+              return false if %i[getdir fgetattr ftruncate].include?(fuse_method)
 
-            def ftruncate(*args)
-              truncate(*args)
+              super(fuse_method)
             end
 
-            def fuse_respond_to?(fuse_method)
-              fuse_method = fuse_method[1..].to_sym if %i[fgetattr ftruncate].include?(fuse_method)
-              super(fuse_method)
+            def fuse_options(args)
+              super if defined?(super)
+              return unless respond_to?(:init_fuse_config)
+
+              FUSE_CONFIG_ONLY_ATTRIBUTES.each do |opt|
+                args.add("-o#{opt}") if fuse_config.send(opt)
+              end
             end
 
             def fuse_flags
               res = defined?(super) ? super : []
-              if respond_to?(:init_fuse_config)
-                fuse_config = FuseConfig.new
-                init_fuse_config(fuse_config, :fuse2)
-                res << :nullpath_ok if fuse_config.nullpath_ok?
-              end
+              return res unless respond_to?(:init_fuse_config)
 
+              FUSE_CONFIG_FLAGS.each { |opt| res << opt if fuse_config.send(opt) }
               res
             end
 
+            private
+
+            def fuse_config
+              @fuse_config ||= begin
+                fuse_config = FuseConfig.new
+                init_fuse_config(fuse_config, :fuse2) if respond_to?(:init_fuse_config)
+                fuse_config
+              end
+            end
+
           else
             def init(*args)
-              init_fuse_config(args.detect { |a| a.is_a?(FuseConfig) }) if respond_to?(:init_fuse_config)
+              init_fuse_config(args.detect { |a| a.is_a?(FuseConfig) }, :fuse3) if respond_to?(:init_fuse_config)
               super if defined?(super)
             end
           end
         end
 
+        # Attributes in Fuse3 config that cannot be set by Fuse3 options. If set via {init_fuse_config} the
+        # equivalent options will be force set under Fuse 2
+        FUSE_CONFIG_ONLY_ATTRIBUTES = %i[hard_remove use_ino readdir_ino direct_io].freeze
+
+        # Attributes in Fuse3 config that were {FuseOperations#fuse_flags} in Fuse2. If set via {init_fuse_config} the
+        # equivalent flags will be added
+        FUSE_CONFIG_FLAGS = %i[nullpath_ok].freeze
+
         # @!visibility private
         def self.included(mod)
-          mod.prepend(Prepend)
+          mod.prepend(Prepend) if FUSE_MAJOR_VERSION < 3
         end
 
         # @!method init_fuse_config(fuse_config,compat)
         # @abstract
-        # Define this method to configure the fuse config object so that under Fuse2 the config options
-        # can be converted to appropriate flags.
+        # Define this method to configure the {FuseConfig} object so that under Fuse2 the config options
+        # can be converted to appropriate flags or options
         #
         # @param [FuseConfig] fuse_config the fuse config object
         # @param [Symbol] compat either :fuse2 or :fuse3

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

@@ -81,7 +81,6 @@ module FFI
 
         # @!visibility private
         def self.included(mod)
-          # We prepend our shim module so caller doesn't have to call super
           mod.prepend(Prepend) if FUSE_MAJOR_VERSION > 2
         end
       end