ffi-libfuse 0.4.0 → 0.4.1

data/lib/ffi/libfuse/fuse_loop_config.rb

@@ -1,43 +1,91 @@
 # frozen_string_literal: true
 
 require_relative '../accessors'
+require_relative '../boolean_int'
 
 module FFI
   module Libfuse
-    # struct fuse_loop_config {
-    #   int clone_fd;
-    #   unsigned int max_idle_threads;
-    # };
+    # For native fuse_loop_mt only
     class FuseLoopConfig < FFI::Struct
       include(FFI::Accessors)
 
-      layout(
-        clone_fd: :int,
-        max_idle: :int
-      )
-
-      # @!attribute [rw] clone_fd
+      # @!attribute [w] clone_fd?
       #   whether to use separate device fds for each thread (may increase performance)
       #   Unused by ffi-libfuse as we do not call fuse_loop_mt
       #   @return [Boolean]
-      ffi_attr_reader(:clone_fd) do |v|
-        v != 0
-      end
-
-      ffi_attr_writer(:clone_fd) do |v|
-        v ? 1 : 0
-      end
 
-      # @!attribute [rw] max_idle_threads
+      # @!attribute [w] max_idle_threads
       #   The maximum number of available worker threads before they start to get deleted when they become idle. If not
       #    specified, the default is 10.
       #
       #   Adjusting this has performance implications; a very small number of threads in the pool will cause a lot of
       #    thread creation and deletion overhead and performance may suffer. When set to 0, a new thread will be created
       #    to service every operation.
-      #
+      #   @deprecated at Fuse 3.12. Use max_threads instead
       #   @return [Integer] the maximum number of threads to leave idle
-      ffi_attr_accessor(:max_idle)
+
+      # @!attribute [w] max_threads
+      #   @return [Integer]
+      #   @since Fuse 3.12
+
+      if FUSE_VERSION >= 312
+        layout(
+          version_id: :int,
+          clone_fd: :bool_int,
+          max_idle_threads: :uint,
+          max_threads: :uint
+        )
+
+        Libfuse.attach_function :fuse_loop_cfg_create, [], by_ref
+        Libfuse.attach_function :fuse_loop_cfg_destroy, [:pointer], :void
+
+        ffi_attr_reader(:clone_fd?)
+        Libfuse.attach_function :fuse_loop_cfg_set_clone_fd, %i[pointer uint], :void
+        def clone_fd=(bool_val)
+          Libfuse.fuse_loop_cfg_set_clone_fd(to_ptr, bool_val ? 1 : 0)
+        end
+
+        ffi_attr_reader(:max_idle_threads)
+        Libfuse.attach_function :fuse_loop_cfg_set_idle_threads, %i[pointer uint], :uint
+        def max_idle_threads=(val)
+          Libfuse.fuse_loop_cfg_set_idle_threads(to_ptr, val) if val
+        end
+
+        Libfuse.attach_function :fuse_loop_cfg_set_max_threads, %i[pointer uint], :uint
+        ffi_attr_reader(:max_threads)
+        def max_threads=(val)
+          Libfuse.fuse_loop_cfg_set_max_threads(to_ptr, val) if val
+        end
+
+        class << self
+          def create(max_idle_threads: nil, max_threads: 10, clone_fd: false, **_)
+            cfg = Libfuse.fuse_loop_cfg_create
+            ObjectSpace.define_finalizer(cfg, finalizer(cfg.to_ptr))
+            cfg.clone_fd = clone_fd
+            cfg.max_idle_threads = max_idle_threads if max_idle_threads
+            cfg.max_threads = max_threads if max_threads
+            cfg
+          end
+
+          def finalizer(ptr)
+            proc { |_| Libfuse.fuse_loop_cfg_destroy(ptr) }
+          end
+        end
+      else
+        layout(
+          clone_fd: :bool_int,
+          max_idle_threads: :uint
+        )
+
+        ffi_attr_accessor(:clone_fd?)
+        ffi_attr_accessor(:max_idle_threads)
+
+        class << self
+          def create(clone_fd: false, max_idle_threads: 10, **_)
+            new.fill(max_idle_threads: max_idle_threads, clone_fd: clone_fd)
+          end
+        end
+      end
     end
   end
 end

data/lib/ffi/libfuse/main.rb

@@ -189,12 +189,16 @@ module FFI
       # @!method fuse_traps
       #  @abstract
       #  Passed to {FuseCommon#run} to allow filesystem to handle custom signal traps. These traps
-      #  are merged over those from {FuseCommon#default_traps}
-      #  @return [Hash<String|Symbol|Integer,String|Proc>]
+      #  are merged over those from {FuseCommon#default_traps}. A nil value can be used to avoid a default trap
+      #  being set.
+      #  @return [Hash<String|Symbol|Integer,String|Proc|nil>]
       #    map of signal name or number to signal handler as per Signal.trap
       #  @example
       #    def fuse_traps
-      #      { HUP: ->() { reload() }}
+      #      {
+      #         HUP: ->() { reload() },
+      #         INT: nil
+      #      }
       #    end
 
       # @!method fuse_version

data/lib/ffi/libfuse/test_helper.rb

@@ -73,7 +73,7 @@ module FFI
         return [o, e, s.exitstatus] unless err
 
         warn "Errors\n#{e}" unless e.empty?
-        warn "Output\n#{o}" unless o.empty? Minitest::Assertion, StandardError => e
+        warn "Output\n#{o}" unless o.empty?
         raise err
       end
 
@@ -87,7 +87,7 @@ module FFI
         if mac_fuse?
           system("diskutil unmount force #{mnt} >/dev/null 2>&1")
         else
-          system("fusermount -zu #{mnt} >/dev/null 2>&1")
+          system("fusermount#{FUSE_MAJOR_VERSION == 3 ? '3' : ''} -zu #{mnt} >/dev/null 2>&1")
         end
       end
 
@@ -107,10 +107,8 @@ module FFI
       private
 
       def open3_filesystem(args, env, filesystem, fsname, mnt)
-        if defined?(Bundler)
-          Bundler.with_unbundled_env do
-            Open3.capture3(env, 'bundle', 'exec', filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
-          end
+        if ENV['BUNDLER_GEMFILE']
+          Open3.capture3(env, 'bundle', 'exec', filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
         else
           Open3.capture3(env, filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
         end

data/lib/ffi/libfuse/version.rb

@@ -3,6 +3,6 @@
 module FFI
   # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
   module Libfuse
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

data/lib/ffi/stat.rb

@@ -34,9 +34,9 @@ module FFI
     int_members = Native
                   .members
                   .select { |m| m.to_s.start_with?('st_') && !m.to_s.end_with?('timespec') }
-                  .map { |m| m[3..].to_sym }
+                  .to_h { |m| [:"#{m[3..]}", m] }
 
-    ffi_attr_accessor(*int_members, format: 'st_%s')
+    ffi_attr_accessor(**int_members)
 
     # @!attribute [rw] atime
     #   @return [Time] time of last access
@@ -47,12 +47,13 @@ module FFI
     # @!attribute [rw] ctime
     #   @return [Time] time of last status change
 
-    time_members = Native.members.select { |m| m.to_s =~ /^st_.*timespec$/ }.map { |m| m[3..-5].to_sym }
+    time_members = Native.members.select { |m| m.to_s =~ /^st_.*timespec$/ }.to_h { |m| [:"#{m[3..-5]}", m] }
 
-    ffi_attr_reader(*time_members, format: 'st_%sspec', &:time)
+    ffi_attr_reader(**time_members, &:time)
 
-    ffi_attr_writer(*time_members, format: 'st_%sspec', simple: false) do |sec, nsec = 0|
-      self[__method__[0..-2].to_sym].set_time(sec, nsec)
+    ffi_attr_writer_method(**time_members) do |sec, nsec = 0|
+      _attr, member = ffi_attr_writer_member(__method__)
+      self[member].set_time(sec, nsec)
     end
 
     # Fill content for a regular file
@@ -164,16 +165,22 @@ module FFI
     end
 
     class << self
-      # @!method file(stat,**fields)
+      # @!method file(**fields)
       # @return [Stat]
       # @raise [SystemCallError]
       # @see Stat#file
 
-      # @!method dir(stat,**fields)
+      # @!method dir(**fields)
       # @return [Stat]
       # @raise [SystemCallError]
       # @see Stat#dir
-      %i[file dir].each { |m| define_method(m) { |stat = new, **args| stat.send(m, **args) } }
+
+      # @!method symlink(**fields)
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#symlink
+
+      %i[file dir symlink].each { |m| define_method(m) { |stat = new, **args| stat.send(m, **args) } }
       alias directory dir
 
       # @!method from(file, stat = new(), follow: false)

data/lib/ffi/stat_vfs.rb

@@ -75,8 +75,7 @@ module FFI
     # @!attribute [rw] namemax
     #  @return [Integer] Maximum filename length
 
-    int_members = members.grep(/^f_/).map { |m| m[2..].to_sym }
-    ffi_attr_accessor(*int_members, format: 'f_%s')
+    ffi_attr_accessor(**members.grep(/^f_/).to_h { |m| [m[2..].to_sym, m] })
 
     extend FFI::Library
     ffi_lib FFI::Library::LIBC

data/lib/ffi/struct_wrapper.rb

@@ -27,13 +27,13 @@ module FFI
         return Pointer::NULL if value.nil?
 
         value = value.native if value.is_a?(StructWrapper)
-        super(value, ctx)
+        super
       end
 
       def from_native(value, ctx)
         return nil if value.null?
 
-        native = super(value, ctx)
+        native = super
         @wrapper_class.new(native)
       end
     end
@@ -100,12 +100,14 @@ module FFI
 
     # Get attribute
     def [](member_or_attr)
-      @native[self.class.ffi_attr_readers.fetch(member_or_attr, member_or_attr)]
+      _attr, member = ffi_attr_reader_member(member_or_attr, member_or_attr)
+      @native[member]
     end
 
     # Set attribute
     def []=(member_or_attr, val)
-      @native[self.class.ffi_attr_writers.fetch(member_or_attr, member_or_attr)] = val
+      _attr, member = ffi_attr_writer_member(member_or_attr, member_or_attr)
+      @native[member] = val
     end
 
     # Pass unimplemented methods on to {#native} underlying struct

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libfuse
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Grant Gardner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-21 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi