ffi-libfuse 0.1.0.rc20220550 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d71e73d4261d20d3e8318fa01517342da232c0167f4febd73249fb99bb314e15
-  data.tar.gz: 5d478d73897b3d590b1c23ddc656f416574865a53db88bb078ddc949c310bc81
+  metadata.gz: d59c87631dfe38e9dc49b36f829acdd704165162deff3bad6479f3394f348657
+  data.tar.gz: 01ab562dd537f1f11f7e3c454e49c5df3ef1ce5cfd6cb8b1aa6b5e6a7f89a4c0
 SHA512:
-  metadata.gz: bfc6ff5b7a9e706be919eaf35fbdfe7b3c2575c68e03008f2381c723ab6896f9826047427e78e8915b90985c0ce26e04e83e639817dd5b7f40bbe1adc69e8aa8
-  data.tar.gz: ac2c8aa63ee627f73cd2d8a06071273bbbc8af64f9ae21862ff6f9bc235c7a0aa031c4fe601aea2b7e3ad4f93ef8ffd248fba35fbcf7cbabf422c37727995f72
+  metadata.gz: ae437c153a84155c86a9e2d71d4dd1c6234879fae7553676efacd311e26cae3cf653dd4439b2ec4ab584cd01698636915fc6c9cefd14a2f045c2b19e4077e60b
+  data.tar.gz: af5fab46502ff889710facc930ee59d7bb27e129da3c70f0d5089c1fa85e29bbfe3ec91b01f75db907da5f8be220755edec6b4b3976421ce0454cc43830387da

data/.yardopts

@@ -1,3 +1,3 @@
 --markup=markdown
 -
-CHANGES.md
+CHANGELOG.md

data/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## [0.3.4](https://github.com/lwoggardner/ffi-libfuse/compare/v0.3.3...v0.3.4) (2023-01-08)
+
+
+### Miscellaneous Chores
+
+* **github:** allow downstream gems to use gem_version etc ([73f3b92](https://github.com/lwoggardner/ffi-libfuse/commit/73f3b92f5e8a1f86a9f6053b71470d7c113e6d19))
+
+## [0.3.3](https://github.com/lwoggardner/ffi-libfuse/compare/v0.1.0...v0.3.3) (2023-01-07)
+
+### Miscellaneous Chores
+
+* **github:** release 0.3.3 ([b54a56f](https://github.com/lwoggardner/ffi-libfuse/commit/b54a56f3f93f15c7684aa2cb2c2dd38c9d033e7f))
+  
+  Using github actions
+
+## 0.1.0 (2023-01-07)
+
+### ⚠ BREAKING CHANGES
+
+* Support downstream RFuse/RFuseFS
+* Changed option parsing.
+
+  {FFI::Libfuse::Main#fuse_options} takes a FuseArgs parameter and fuse_opt_proc is not used
+
+### Features
+
+* FFI::Libfuse::Filesystem - base filesystems ([5b19005](https://github.com/lwoggardner/ffi-libfuse/commit/5b19005c4b1ff2237b85c4854f481ea6e3625c62))
+
+### Code Refactoring
+
+* Support downstream RFuse/RFuseFS ([e6b3fb5](https://github.com/lwoggardner/ffi-libfuse/commit/e6b3fb552b8881dbf28f014617b7412f2542aaa3))
+* Test on OSX with macFuse

data/lib/ffi/flock.rb

@@ -12,18 +12,20 @@ module FFI
       SeekWhenceShort = enum :short, seek_whence
       SeekWhence = enum :int, seek_whence
 
-      LockType = enum :short, %i[f_rdlck f_wrlck f_unlck]
-      LockCmd = enum :int, [:f_getlk, 5, :f_setlk, 6, :f_setlkw, 7]
+      LockType = enum :short, %i[rdlck wrlck unlck]
+      LockCmd = enum :int, [:getlk, 5, :setlk, 6, :setlkw, 7]
     end
 
     include(Accessors)
 
-    layout(type: Enums::LockType, whence: Enums::SeekWhenceShort, start: :off_t, len: :off_t, pid: :pid_t)
+    layout(l_type: Enums::LockType, l_whence: Enums::SeekWhenceShort, l_start: :off_t, l_len: :off_t, l_pid: :pid_t)
 
-    ffi_attr_reader :type, :whence, :start, :len, :pid
+    l_members = members.grep(/^l_/).map { |m| m[2..].to_sym }
+
+    ffi_attr_reader(*l_members, format: 'l_%s')
 
     # @!attribute [r] type
-    #   @return [Symbol] lock type, :f_rdlck, :f_wrlck, :f_unlck
+    #   @return [Symbol] lock type, :rdlck, :wrlck, :unlck
 
     # @!attribute [r] whence
     #   @return [Symbol] specifies what the offset is relative to, one of :seek_set, :seek_cur or :seek_end

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

@@ -22,14 +22,14 @@ module FFI
 
           def getattr(*args)
             fi = args.pop
-            return fgetattr(*args, fi) if fi && respond_to?(:fgetattr)
+            return fgetattr(*args, fi) if fi && fuse_super_respond_to?(:fgetattr)
 
             super(*args)
           end
 
           def truncate(*args)
             fi = args.pop
-            return ftruncate(*args, fi) if fi && respond_to?(:ftruncate)
+            return ftruncate(*args, fi) if fi && fuse_super_respond_to?(:ftruncate)
 
             super(*args)
           end
@@ -50,7 +50,7 @@ module FFI
           #  but there is no way to handle OMIT
           def utimens(*args)
             args.pop
-            super(*args)
+            super(*args) if defined?(super)
           end
 
           def init(*args)
@@ -73,6 +73,10 @@ module FFI
 
             super(*args, &block)
           end
+
+          def fuse_respond_to(fuse_callback)
+            super || (%i[truncate getattr].include?(fuse_callback) && fuse_super_respond_to?("f#{fuse_callback}"))
+          end
         end
 
         # @!visibility private

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

@@ -27,7 +27,7 @@ module FFI
 
         # @raise [Errno::EINTR] if the fuse request is marked as interrupted
         def interrupt_callback(*args)
-          return -Errno::EINTR::Errno if Libfuse.fuse_interrupted?
+          Libfuse.raise_interrupt
 
           yield(*args)
         end

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 #{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/filesystem/utils.rb

@@ -19,7 +19,7 @@ module FFI
         # @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 = (0o0777 & ~FuseContext.get.umask), &mount_fs)
+        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|
@@ -71,7 +71,7 @@ module FFI
         # @return [Boolean] File exists at path and has zero size
         def empty_file?(path)
           s = stat(path)
-          (s&.file? && s.size.zero?) || false
+          (s&.file? && s.size.zero?) || false # rubocop:disable Style/ZeroLengthPredicate
         end
 
         # Check if a directory is empty

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

@@ -182,6 +182,14 @@ module FFI
         end
 
         attr_reader :no_buf
+
+        # This class does not implement any fuse methods, ensure they are passed to method missing.
+        # eg Kernel.open
+        FFI::Libfuse::FuseOperations.fuse_callbacks.each do |c|
+          undef_method(c)
+        rescue StandardError
+          nil
+        end
       end
     end
   end

data/lib/ffi/libfuse/fuse2.rb

@@ -115,9 +115,7 @@ module FFI
           @fuse = nil if @fuse&.null?
         end
       ensure
-        # if we unmount/destroy in the finalizer then the private_data object cannot be used in destory
-        # as it's weakref will have been GC'd
-        ObjectSpace.define_finalizer(self, self.class.finalize_fuse(@fuse, @mountpoint, @ch))
+        define_finalizer
       end
 
       # [IO] /dev/fuse file descriptor for use with IO.select
@@ -150,6 +148,16 @@ module FFI
         c = @ch
         @ch = nil
         Libfuse.fuse_unmount2(mountpoint, c)
+      ensure
+        # Can't unmount twice
+        define_finalizer
+      end
+
+      def define_finalizer
+        # if we unmount/destroy in the finalizer then the private_data object cannot be used in destory
+        # as it's weakref will have been GC'd
+        ObjectSpace.undefine_finalizer(self)
+        ObjectSpace.define_finalizer(self, self.class.finalize_fuse(@fuse, @mountpoint, @ch))
       end
     end
 

data/lib/ffi/libfuse/fuse3.rb

@@ -87,10 +87,10 @@ module FFI
           $stdout.puts "\n#{handler.fuse_help}" if handler.respond_to?(:fuse_help)
         end
 
-        def finalize_fuse(fuse)
+        def finalize_fuse(fuse, mounted)
           proc do
             if fuse
-              Libfuse.fuse_unmount3(fuse)
+              Libfuse.fuse_unmount3(fuse) if mounted
               Libfuse.fuse_destroy(fuse)
             end
           end
@@ -101,7 +101,7 @@ module FFI
 
       # Have we requested an unmount (note not actually checking if OS sees the fs as mounted)
       def mounted?
-        session && !fuse_exited?
+        session && !fuse_exited? && @mounted
       end
 
       def initialize(mountpoint, args, operations, private_data)
@@ -119,9 +119,7 @@ module FFI
 
         @mounted = @fuse && Libfuse.fuse_mount3(@fuse, @mountpoint).zero?
       ensure
-        # if we unmount/destroy in the finalizer then the private_data object cannot be used in destroy
-        # as it's weakref will have been GC'd
-        ObjectSpace.define_finalizer(self, self.class.finalize_fuse(@fuse))
+        define_finalizer
       end
 
       def fuse_exited?
@@ -152,7 +150,19 @@ module FFI
       end
 
       def unmount
-        Libfuse.fuse_unmount3(@fuse) if @mounted && @fuse && !@fuse.null?
+        return unless @mounted && @fuse && !@fuse.null?
+
+        Libfuse.fuse_unmount3(@fuse)
+        @mounted = false
+      ensure
+        define_finalizer
+      end
+
+      def define_finalizer
+        # if we unmount/destroy in the finalizer then the private_data object cannot be used in destroy
+        # as it's weakref will have been GC'd
+        ObjectSpace.undefine_finalizer(self)
+        ObjectSpace.define_finalizer(self, self.class.finalize_fuse(@fuse, @mounted))
       end
     end
 

data/lib/ffi/libfuse/fuse_args.rb

@@ -14,11 +14,13 @@ module FFI
       # Create a fuse_args struct from command line options
       # @param [Array<String>] argv command line args
       #
-      #   first arg is expected to be program name
+      #   first arg is expected to be program name and is ignored by fuse_opt_parse
+      #   it is handled specially only in fuse_parse_cmdline (ie no subtype is given)
       # @return [FuseArgs]
       # @example
       #  FFI::Libfuse::FuseArgs.create($0,*ARGV)
       def self.create(*argv)
+        argv.unshift('ffi-libfuse') if argv.empty? || argv[0].start_with?('-')
         new.fill(*argv)
       end
 
@@ -162,7 +164,7 @@ module FFI
               [opt, arg[opt.rstrip.length..].lstrip]
             else
               warn "FuseOptProc error - Cannot match option for #{arg}"
-              next -1
+              next FUSE_OPT_PROC_RETURN.fetch(:error)
             end
 
           safe_opt_proc(key: key, value: value, match: match, data: data, out: out, &block)

data/lib/ffi/libfuse/fuse_common.rb

@@ -100,7 +100,7 @@ module FFI
       # @param [Boolean] foreground
       # @param [Boolean] single_thread
       def run_native(foreground: true, single_thread: true, **options)
-        raise 'Cannot run deamonized native multi-thread fuse_loop' if !single_thread && !foreground
+        raise 'Cannot run daemonized native multi-thread fuse_loop' if !single_thread && !foreground
 
         clear_default_traps
         (se = session) && Libfuse.fuse_set_signal_handlers(se)
@@ -165,7 +165,7 @@ module FFI
       # @api private
       # Ruby implementation of single threaded fuse loop
       def fuse_loop(**_options)
-        fuse_process until fuse_exited?
+        safe_fuse_process until fuse_exited?
       end
 
       # @api private
@@ -179,11 +179,17 @@ module FFI
         ThreadPool.new(name: 'FuseThread', max_idle: max_idle_threads.to_i, max_active: max_threads&.to_i) do
           raise StopIteration if fuse_exited?
 
-          fuse_process
+          safe_fuse_process
         end.join
       end
 
       # @!visibility private
+
+      def safe_fuse_process
+        # sometimes we get null on unmount, and exit needs a chance to finish to avoid hangs
+        fuse_process || (sleep(0.1) && false)
+      end
+
       def teardown
         return unless @fuse
 
@@ -209,7 +215,6 @@ module FFI
           sleep 0.2 if mac_fuse?
 
           Libfuse.fuse_exit(@fuse)
-
           true
         end
       end

data/lib/ffi/libfuse/fuse_operations.rb

@@ -33,7 +33,10 @@ module FFI
     bitmask :lock_op, [:lock_sh, 0, :lock_ex, 2, :lock_nb, 4, :lock_un, 8]
     bitmask :falloc_mode, %i[keep_size punch_hole no_hide_stale collapse_range zero_range insert_range unshare_range]
     bitmask :flags_mask, %i[nullpath_ok nopath utime_omit_ok] if FUSE_MAJOR_VERSION < 3
-    enum :xattr, [:xattr_create, 1, :xattr_replace]
+
+    # @!visibility private
+    XAttr = enum :xattr, [:xattr_create, 1, :xattr_replace]
+
     callback :fill_dir_t, fill_dir_t_args, :int
 
     # The file system operations as specified in libfuse.
@@ -47,6 +50,14 @@ module FFI
     class FuseOperations < FFI::Struct
       include FuseCallbacks
 
+      # Callbacks that are expected to return meaningful positive integers
+      MEANINGFUL_RETURN = %i[read write write_buf lseek copy_file_range getxattr listxattr].freeze
+
+      # @return [Boolean] true if fuse_callback expects a meaningful integer return
+      def self.meaningful_return?(fuse_callback)
+        MEANINGFUL_RETURN.include?(fuse_callback)
+      end
+
       # Container to dynamically build up the operations layout which is dependent on the loaded libfuse version
       op = {}
 
@@ -213,6 +224,7 @@ module FFI
       op[:truncate] = [:off_t]
       op[:truncate] << FuseFileInfo.by_ref if FUSE_MAJOR_VERSION >= 3
 
+      # Not directly implemented see utimens
       # int (*utime) (const char *, struct utimbuf *);
       op[:utime] = [:pointer] if FUSE_MAJOR_VERSION < 3
 
@@ -568,7 +580,7 @@ module FFI
         #  @param [String] path
         #  @param [FuseFileInfo] fuse_file_info
         #    For checking lock ownership, the 'fuse_file_info->owner' argument must be used.
-        #  @param [Symbol] cmd either :f_getlck, :f_setlck or :f_setlkw.
+        #  @param [Symbol] cmd either :getlck, :setlck or :setlkw.
         #  @param [Flock] flock
         #    For the meaning of fields in 'struct flock' see the man page for fcntl(2).  The whence field will always
         #    be set to :seek_set.

data/lib/ffi/libfuse/fuse_opt.rb

@@ -19,7 +19,7 @@ module FFI
       def fill(template, value)
         str_ptr = FFI::MemoryPointer.from_string(template)
         self[:template] = str_ptr
-        self[:offset] = (2**(8 * FFI::Type::INT.size)) - 1 # -(1U)  in a LONG!!
+        self[:offset] = (2**(FFI::Type::INT.size * 8)) - 1 # -(1U)  in a LONG!!
         self[:value] = value.to_i
         self
       end

data/lib/ffi/libfuse/gem_helper.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    # @!visibility private
+    class GemHelper
+      SEMVER_TAG_REGEX = /^v\d+\.\d+\.\d+/.freeze
+
+      # branches the format is refs/heads/<branch_name>,
+      # tags it is refs/tags/<tag_name>.
+      # for pull requests it is refs/pull/<pr_number>/merge,
+      GIT_REF_TYPES = { 'heads' => :branch, 'tags' => :tag, 'pull' => :pull }.freeze
+
+      class << self
+        # set when install'd.
+        attr_accessor :instance
+
+        def install_tasks(main_branch:, version:)
+          require 'bundler/gem_tasks'
+          include Rake::DSL if defined? Rake::DSL
+          new(main_branch: main_branch, version: version).install
+        end
+
+        def git_ref(env: ENV)
+          ref = env.fetch('GIT_REF') do
+            # get branch ref, or detached head ref to tag
+            `git symbolic-ref HEAD 2>/dev/null || git name-rev HEAD | awk '{ gsub(/[\\^~@].*$/,"",$2); printf("refs/%s\\n",$2)}'`.strip # rubocop:disable Layout/LineLength
+          rescue StandardError
+            nil
+          end
+
+          return [ref, nil] unless ref&.start_with?('refs/')
+
+          _refs, ref_type, ref_name = ref.split('/', 3)
+          [ref_name, GIT_REF_TYPES[ref_type]]
+        end
+
+        def gem_version(main_branch:, version:, env: ENV)
+          ref_name, ref_type = git_ref(env: env)
+
+          version =
+            case ref_type
+            when :branch
+              ref_name == main_branch ? [version] : [version, ref_name]
+            when :tag
+              SEMVER_TAG_REGEX.match?(ref_name) ? [ref_name[1..]] : [version, ref_name]
+            when :pull
+              pr_number, merge, _rest = ref_name.split('/')
+              # GITHUB_BASE_REF	The name of the base ref or target branch of the pull request in a workflow run
+              base_ref = env.fetch('GIT_BASE_REF', 'undefined')
+              [version, base_ref, "#{merge}#{pr_number}"]
+            else
+              [version, 'pre', ref_name]
+            end.select { |p| p && !p.empty? }.join('.').tr('//_-', '')
+
+          [version, ref_name, ref_type]
+        end
+      end
+
+      attr_reader :version, :main_branch, :git_ref_name, :git_ref_type, :gem_version, :gem_version_tag
+
+      def initialize(version:, main_branch:)
+        @version = version
+        @main_branch = main_branch
+        @gem_version, @git_ref_name, @git_ref_type =
+          self.class.gem_version(main_branch: main_branch, version: version)
+        @gem_version_tag = "v#{@gem_version}"
+      end
+
+      def install
+        task 'release:guard_clean' => %i[release_guard_tag]
+
+        desc 'Version info'
+        task :version do
+          v, gv = [version, gem_version].map { |ver| Gem::Version.new(ver) }
+          msg = "VERSION='#{v}' GEM_VERSION='#{gv}'"
+          raise "Mismatched versions - #{msg}" unless gv.release == v
+
+          puts msg
+        end
+
+        task release_guard_tag: [:version] do
+          # If we're on a tag then tag must be tag for this version
+          if git_ref_type == :tag && git_ref_name != gem_version_tag
+            raise "Checkout is tag '#{git_ref_name}' but does not match the gem version '#{gem_version}'"
+          end
+
+          # BASH expression - test tag does not exist OR exists and points at HEAD
+          cmd = '[ -z "$(git tag -l ${V_TAG})" ] || git tag --points-at HEAD | grep "^${V_TAG}$" > /dev/null'
+          unless system({ 'V_TAG' => gem_version_tag }, cmd)
+            raise "Tag #{gem_version_tag} exists but does not point at HEAD"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ffi/libfuse/gem_version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'gem_helper'
+
+module FFI
+  # Ruby FFI Binding for [libfuse](https://github.com/libfuse/libfuse)
+  module Libfuse
+    # @visibility private
+    MAIN_BRANCH = 'main'
+    # @!visibility private
+    GEM_VERSION, = GemHelper.gem_version(main_branch: MAIN_BRANCH, version: VERSION)
+  end
+end

data/lib/ffi/libfuse/main.rb

@@ -9,6 +9,19 @@ module FFI
     # Controls the main run loop for a FUSE filesystem
     module Main
       class << self
+        # Builds default argument list for #{fuse_main} regardless of being called directly or from mount.fuse3
+        #
+        # @param [Array<String>] extra_args additional arguments to add to $0 and *ARGV
+        # @return [Array<String>]
+        # @see https://github.com/libfuse/libfuse/issues/621
+        def default_args(*extra_args)
+          args = ARGV.dup
+
+          # If called from mount.fuse3 we already have a 'source' argument which should go at args[0]
+          args.unshift($0) unless args.size >= 2 && args[0..1].all? { |a| !a.start_with?('-') }
+          args.concat(extra_args)
+        end
+
         # Main function of FUSE
         #
         # This function:
@@ -31,7 +44,7 @@ module FFI
         #  any data to be made available to the {FuseOperations#init} callback
         #
         # @return [Integer] suitable for process exit code
-        def fuse_main(*argv, operations:, args: argv.any? ? argv : [$0, *ARGV], private_data: nil)
+        def fuse_main(*argv, operations:, args: argv.any? ? argv : default_args, private_data: nil)
           run_args = fuse_parse_cmdline(args: args, handler: operations)
           return 2 unless run_args
 
@@ -63,7 +76,7 @@ module FFI
         # - parses standard fuse mount options
         #
         # @param [Array<String>] argv mount.fuse arguments
-        #   expects progname, [fsname,] mountpoint, options.... from mount.fuse3
+        #   expects progname, mountpoint, options....
         # @param [FuseArgs] args
         #   alternatively constructed args
         # @param [Object] handler
@@ -75,7 +88,7 @@ module FFI
         #   * show_version [Boolean]: -v or --version
         #   * debug [Boolean]: -d
         #   * others are options to pass to {FuseCommon#run}
-        def fuse_parse_cmdline(*argv, args: argv, handler: nil)
+        def fuse_parse_cmdline(*argv, args: argv.any? ? argv : default_args, handler: nil)
           args = fuse_init_args(args)
 
           # Parse args and print cmdline help
@@ -94,16 +107,15 @@ module FFI
 
         # @return [FuseCommon|nil] the mounted filesystem or nil if not mounted
         def fuse_create(mountpoint, *argv, operations:, args: nil, private_data: nil)
-          args = fuse_init_args(args || argv.unshift(mountpoint))
+          args = fuse_init_args(args || argv)
 
           operations = FuseOperations.new(delegate: operations) unless operations.is_a?(FuseOperations)
 
-          fuse = Fuse.new(mountpoint, args, operations, private_data)
+          fuse = Fuse.new(mountpoint.to_s, args, operations, private_data)
           fuse if fuse.mounted?
         end
 
         # @!visibility private
-
         def fuse_configure(operations:, show_help: false, show_version: false, **_)
           return true unless operations.respond_to?(:fuse_configure) && !show_help && !show_version
 
@@ -120,20 +132,15 @@ module FFI
           end
         end
 
-        # Version text
+        # @!visibility private
         def version
           "#{name}: #{VERSION}"
         end
 
+        private
+
         def fuse_init_args(args)
           if args.is_a?(Array)
-            args = args.map(&:to_s) # handle mountpoint as Pathname etc..
-
-            # https://github.com/libfuse/libfuse/issues/621 handle "source" field sent from /etc/fstab via mount.fuse3
-            # if arg[1] and arg[2] are both non option fields then replace arg1 with -ofsname=<arg1>
-            unless args.size <= 2 || args[1]&.start_with?('-') || args[2]&.start_with?('-')
-              args[1] = "-ofsname=#{args[1]}"
-            end
             warn "FuseArgs: #{args.join(' ')}" if args.include?('-d')
             args = FuseArgs.create(*args)
           end
@@ -143,8 +150,6 @@ module FFI
           raise ArgumentError "fuse main args: must be Array<String> or #{FuseArgs.class.name}"
         end
 
-        private
-
         def parse_run_options(args, run_args)
           args.parse!(RUN_OPTIONS) do |key:, value:, **|
             run_args[key] = value

data/lib/ffi/libfuse/test_helper.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative '../libfuse'
+require 'open3'
+require 'sys-filesystem'
+
+# utilities for running tests with fuse filesystems
+module FFI
+  module Libfuse
+    # Can be included test classes to assist with running/debugging filesystems
+    module TestHelper
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+
+      # Runs the fuse loop on a pre configured fuse filesystem
+      # @param [FuseOperations] operations
+      # @param [Array<String>] args to pass to  {FFI::Libfuse::Main.fuse_create}
+      # @param [Hash] options to pass to {FFI::Libfuse::FuseCommon.run}
+      # @yield [mnt]
+      #   caller can execute and test file operations using mnt and ruby File/Dir etc
+      #   the block is run in a forked process and is successful unless an exception is raised
+      # @yieldparam [String] mnt the temporary direct used as the mount point
+      # @raise [Error] if unexpected state is found during operations
+      # @return [void]
+      def with_fuse(operations, *args, **options)
+        raise ArgumentError, 'Needs block' unless block_given?
+
+        # ignore MacOS special files
+        args << '-onoappledouble,noapplexattr' if mac_fuse?
+        safe_fuse do |mnt|
+          # Start the fork before loading fuse (for MacOS)
+          fpid = Process.fork do
+            sleep 2.5 # Give fuse a chance to start
+            yield mnt
+          end
+
+          fuse = FFI::Libfuse::Main.fuse_create(mnt, *args, operations: operations)
+          raise FFI::Libfuse::Error, 'No fuse object returned from fuse_create' unless fuse
+
+          # Rake owns INT
+          fuse.default_traps.delete(:TERM)
+          fuse.default_traps.delete(:INT)
+
+          raise FFI::Libfuse::Error, 'fuse object is not mounted?' unless fuse.mounted?
+
+          t = Thread.new { fuse.run(foreground: true, **options) }
+
+          # TODO: Work out why waitpid2 hangs on mac unless the process has already finished
+          sleep 10 if mac_fuse?
+
+          _pid, block_status = Process.waitpid2(fpid)
+          block_exit = block_status.exitstatus
+          fuse.exit('fuse_helper')&.join
+          run_result = t.value
+
+          raise FFI::Libfuse::Error, 'fuse is still mounted after fuse.exit' if fuse.mounted?
+          raise FFI::Libfuse::Error, "forked file operations failed with #{block_exit}" unless block_exit.zero?
+          raise FFI::Libfuse::Error, "fuse run failed #{run_result}" unless run_result.zero?
+
+          if !mac_fuse? && mounted?(mnt)
+            raise FFI::Libfuse::Error, "OS reports fuse is still mounted at #{mnt} after fuse.exit"
+          end
+
+          true
+        end
+      end
+
+      # Runs a filesystem in a separate process
+      # @param [String] filesystem path to filesystem executable
+      # @param [Array<String>] args to pass the filesystem
+      # @param [Hash<String,String>] env environment to run the filesystem under
+      # @yield [mnt]
+      #   caller can execute and test file operations using mnt and ruby File/Dir etc
+      # @yieldparam [String] mnt the temporary direct used as the mount point
+      # @raise [Error] if unexpected state is found during operations
+      # @return [Array] stdout, stderr, exit code as captured by Open3.capture3
+      # @note if the filesystem is configured to daemonize then no output will be captured
+      def run_filesystem(filesystem, *args, env: {})
+        fsname = File.basename(filesystem)
+        safe_fuse do |mnt|
+          t = Thread.new do
+            if defined?(Bundler)
+              Bundler.with_unbundled_env do
+                Open3.capture3(env, 'bundle', 'exec', filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
+              end
+            else
+              Open3.capture3(env, filesystem.to_s, mnt, "-ofsname=#{fsname}", *args, binmode: true)
+            end
+          end
+          sleep 1
+
+          begin
+            if block_given?
+              raise Error, "#{fsname} not mounted at #{mnt}" unless mounted?(mnt, fsname)
+
+              yield mnt
+            end
+            # rubocop:disable Lint/RescueException
+            # Minitest::Assertion and other test assertion classes are not derived from StandardError
+          rescue Exception => _err
+            # rubocop:enable Lint/RescueException
+            unmount(mnt) if mounted?(mnt)
+            o, e, _s = t.value
+            warn "Errors\n#{e}" unless e.empty?
+            warn "Output\n#{o}" unless o.empty?
+            raise
+          end
+
+          unmount(mnt) if mounted?(mnt)
+          o, e, s = t.value
+          [o, e, s.exitstatus]
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      def mounted?(mnt, _filesystem = '.*')
+        type, prefix = mac_fuse? ? %w[macfuse /private] : %w[fuse]
+        mounts = Sys::Filesystem.mounts.select { |m| m.mount_type == type }
+        mounts.detect { |m| m.mount_point == "#{prefix}#{mnt}" }
+      end
+
+      def unmount(mnt)
+        if mac_fuse?
+          system("diskutil unmount force #{mnt} >/dev/null 2>&1")
+        else
+          system("fusermount -zu #{mnt} >/dev/null 2>&1")
+        end
+      end
+
+      def safe_fuse
+        Dir.mktmpdir('ffi-libfuse-spec') do |mountpoint|
+          yield mountpoint
+        ensure
+          # Attempt to force unmount.
+          unmount(mountpoint) if mounted?(mountpoint)
+        end
+      end
+
+      def mac_fuse?
+        FFI::Platform::IS_MAC
+      end
+    end
+  end
+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.1.0'
+    VERSION = '0.3.4'
   end
 end

data/lib/ffi/libfuse.rb

@@ -19,12 +19,12 @@ module FFI
     # Filesystems that want full control (eg to take advantage of multi-threaded operations) should call
     #  {Main.fuse_main} instead
     # @note These may change between major versions
-    DEFAULT_ARGS = [$0, '-s', '-odefault_permissions', *ARGV].freeze
+    DEFAULT_ARGS = %w[-s -odefault_permissions].freeze
 
     class << self
       # Filesystem entry point
       # @see Main.fuse_main
-      def fuse_main(*argv, operations:, args: argv.any? ? argv : DEFAULT_ARGS, private_data: nil)
+      def fuse_main(*argv, operations:, args: argv.any? ? argv : Main.default_args(*DEFAULT_ARGS), private_data: nil)
         Main.fuse_main(args: args, operations: operations, private_data: private_data) || -1
       end
       alias main fuse_main

data/lib/ffi/ruby_object.rb

@@ -32,6 +32,7 @@ module FFI
         return nil if object_id.zero?
 
         _ptr, obj = RubyObject.cache[object_id]
+        obj = obj.__getobj__ if obj.is_a?(WeakRef)
         obj
       end
     end
@@ -66,6 +67,8 @@ module FFI
         raise TypeError, "No RubyObject stored at #{ptr.address}" unless cache.key?(ptr.address.object_id)
 
         _ptr, obj = cache[ptr.get(:long, 0)]
+        # unwrap as the object gets used
+        obj = obj.__getobj__ if obj.is_a?(WeakRef)
         obj
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libfuse
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc20220550
+  version: 0.3.4
 platform: ruby
 authors:
 - Grant Gardner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-29 00:00:00.000000000 Z
+date: 2023-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -130,7 +130,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".yardopts"
-- CHANGES.md
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/ffi/accessors.rb
@@ -178,10 +178,11 @@ files:
 - lib/ffi/libfuse/fuse_opt.rb
 - lib/ffi/libfuse/fuse_poll_handle.rb
 - lib/ffi/libfuse/fuse_version.rb
+- lib/ffi/libfuse/gem_helper.rb
+- lib/ffi/libfuse/gem_version.rb
 - lib/ffi/libfuse/job_pool.rb
 - lib/ffi/libfuse/main.rb
-- lib/ffi/libfuse/test.rb
-- lib/ffi/libfuse/test/operations.rb
+- lib/ffi/libfuse/test_helper.rb
 - lib/ffi/libfuse/thread_pool.rb
 - lib/ffi/libfuse/version.rb
 - lib/ffi/ruby_object.rb
@@ -200,7 +201,7 @@ homepage:
 licenses:
 - MIT
 metadata:
-  source_code_uri: http://github.com/lwoggardner/ffi-libfuse
+  source_code_uri: https://github.com/lwoggardner/ffi-libfuse
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
@@ -213,11 +214,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: FFI Bindings for Libfuse

data/CHANGES.md

@@ -1,14 +0,0 @@
-0.1.0  / 2022-04
-------------------
-
-#### BREAKING changes
-* Changed option parsing.
-
-  {FFI::Libfuse::Main#fuse_options} now takes a FuseArgs parameter and fuse_opt_proc is not used
-
-#### New Features
-* Implemented helper filesystems in {FFI::Libfuse::Filesystem}
-
-#### Fixes
-* Test on OSX with macFuse
-* Lots

data/lib/ffi/libfuse/test/operations.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../fuse_operations'
-
-module FFI
-  module Libfuse
-    module Test
-      # A FuseOperations that holds callback procs in a Hash rather than FFI objects and allows for direct invocation of
-      # callback methods
-      # @!parse FuseOperations
-      class Operations
-        include FuseCallbacks
-
-        def initialize(delegate:, fuse_wrappers: [])
-          @callbacks = {}
-          initialize_callbacks(delegate: delegate, wrappers: fuse_wrappers)
-        end
-
-        # @!visibility private
-        def [](member)
-          @callbacks[member]
-        end
-
-        # @!visibility private
-        def []=(member, value)
-          @callbacks[member] = value
-        end
-
-        # @!visibility private
-        def members
-          FuseOperations.members
-        end
-
-        private
-
-        # Allow the fuse operations to be called directly - useful for testing
-        # @todo some fancy wrapper to convert tests using Fuse2 signatures when Fuse3 is the loaded library
-        #   and vice-versa
-        def method_missing(method, *args)
-          callback = callback?(method) && self[method]
-          return super unless callback
-
-          callback.call(*args)
-        end
-
-        def respond_to_missing?(method, _private = false)
-          self[method] && callback?(method)
-        end
-
-        def callback?(method)
-          callback_members.include?(method)
-        end
-      end
-    end
-  end
-end

data/lib/ffi/libfuse/test.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test/operations'