ffi-libfuse 0.0.1.rctest12 → 0.1.0.rc20220550

data/lib/ffi/stat.rb

@@ -1,28 +1,19 @@
 # frozen_string_literal: true
 
 require_relative 'struct_wrapper'
-require_relative 'stat/native'
 require_relative 'stat/constants'
 
 module FFI
   # Ruby representation of stat.h struct
   class Stat
-    class << self
-      # @return [Stat] Newly allocated stat representing a regular file - see {Stat#file}
-      def file(**fields)
-        new.file(**fields)
-      end
-
-      # @return [Stat] Newly allocated stat representing a directory - see {Stat#dir}
-      def dir(**fields)
-        new.dir(**fields)
-      end
-      alias directory dir
-    end
-
-    # We need to be a StructWrapper because of clash with #size
+    # Use a StructWrapper because of clash with #size and the ability to attach functions
     include StructWrapper
 
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    # stat/native will attach functions to Stat
+    require_relative 'stat/native'
     native_struct(Native)
 
     # @!attribute [rw] mode
@@ -56,16 +47,12 @@ module FFI
     # @!attribute [rw] ctime
     #   @return [Time] time of last status change
 
-    time_members = Native
-                   .members
-                   .select { |m| m.to_s.start_with?('st_') && m.to_s.end_with?('timespec') }
-                   .map { |m| m[3..-5].to_sym }
+    time_members = Native.members.select { |m| m.to_s =~ /^st_.*timespec$/ }.map { |m| m[3..-5].to_sym }
 
     ffi_attr_reader(*time_members, format: 'st_%sspec', &:time)
 
     ffi_attr_writer(*time_members, format: 'st_%sspec', simple: false) do |sec, nsec = 0|
-      t = self[__method__[0..-2].to_sym]
-      t.set_time(sec, nsec)
+      self[__method__[0..-2].to_sym].set_time(sec, nsec)
     end
 
     # Fill content for a regular file
@@ -87,10 +74,112 @@ module FFI
     # @param [Integer] gid
     # @param [Hash] args additional system specific stat fields
     # @return [self]
-    def dir(mode:, nlink: 1, uid: Process.uid, gid: Process.gid, **args)
+    def dir(mode:, nlink: 3, uid: Process.uid, gid: Process.gid, **args)
       mode = ((S_IFDIR & S_IFMT) | (mode & 0o777))
       fill(mode: mode, uid: uid, gid: gid, nlink: nlink, **args)
     end
     alias directory dir
+
+    # Fill attributes from file (using native LIBC calls)
+    # @param [Integer|:to_s] file descriptor or a file path
+    # @param [Boolean] follow links
+    # @return [self]
+    def from(file, follow: true)
+      return fstat(file) if file.is_a?(Integer)
+
+      return stat(file.to_s) if follow
+
+      lstat(file.to_s)
+    end
+
+    # @!method stat(path)
+    # Fill attributes from file, following links
+    # @param [:to_s] path a file path
+    # @raise [SystemCallError] on error
+    # @return [self]
+
+    # @!method lstat(path)
+    # Fill attributes from file path, without following links
+    # @param [:to_s] path
+    # @raise [SystemCallError] on error
+    # @return [self]
+
+    # @!method fstat(fileno)
+    # Fill attributes from file descriptor
+    # @param [:to_i] fileno file descriptor
+    # @raise [SystemCallError] on error
+    # @return [self]
+
+    %i[stat lstat fstat].each do |m|
+      define_method(m) do |file|
+        res = self.class.send("native_#{m}", (m == :fstat ? file.to_i : file.to_s), native)
+        raise SystemCallError.new('', FFI::LastError.error) unless res.zero?
+
+        self
+      end
+    end
+
+    # Apply permissions mask to mode
+    # @param [Integer] mask (see umask)
+    # @param [Hash] overrides see {fill}
+    # @return self
+    def mask(mask = 0o4000, **overrides)
+      fill(mode: mode & (~mask), **overrides)
+    end
+
+    def file?
+      mode & S_IFREG != 0
+    end
+
+    def directory?
+      mode & S_IFDIR != 0
+    end
+
+    def setuid?
+      mode & S_ISUID != 0
+    end
+
+    def setgid?
+      mode & S_ISGID != 0
+    end
+
+    def sticky?
+      mode & S_ISVTX != 0
+    end
+
+    class << self
+      # @!method file(stat,**fields)
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#file
+
+      # @!method dir(stat,**fields)
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#dir
+      %i[file dir].each { |m| define_method(m) { |stat = new, **args| stat.send(m, **args) } }
+      alias directory dir
+
+      # @!method from(file, stat = new(), follow: false)
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#from
+
+      # @!method stat(file, stat = new())
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#stat
+
+      # @!method lstat(file, stat = new())
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#lstat
+
+      # @!method fstat(file, stat = new())
+      # @return [Stat]
+      # @raise [SystemCallError]
+      # @see Stat#fstat
+      %i[from stat lstat fstat].each { |m| define_method(m) { |file, stat = new, **args| stat.send(m, file, **args) } }
+    end
   end
 end

data/lib/ffi/stat_vfs.rb

@@ -75,7 +75,65 @@ module FFI
     # @!attribute [rw] namemax
     #  @return [Integer] Maximum filename length
 
-    int_members = members.select { |m| m =~ /^f_/ }.map { |m| m[2..].to_sym }
+    int_members = members.grep(/^f_/).map { |m| m[2..].to_sym }
     ffi_attr_accessor(*int_members, format: 'f_%s')
+
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :native_statvfs, :statvfs, [:string, by_ref], :int
+    attach_function :native_fstatvfs, :fstatvfs, [:int, by_ref], :int
+
+    # Fill from native statvfs for path
+    # @param [:to_s] path
+    # @return [self]
+    def statvfs(path)
+      res = self.class.native_statvfs(path.to_s, self)
+      raise SystemCallError.new('', FFI::LastError.errno) unless res.zero?
+
+      self
+    end
+
+    # Fill from native fstatvfs for fileno
+    # @param [Integer] fileno
+    # @return [self]
+    def fstatvfs(fileno)
+      res = self.class.native_fstatvfs(fileno, self)
+      raise SystemCallError.new('', FFI::LastError.errno) unless res.zero?
+
+      self
+    end
+
+    # File from native LIBC calls for file
+    # @param [Integer|:to_s] file a file descriptor or a file path
+    # @return [self]
+    def from(file)
+      return fstatvfs(file) if file.is_a?(Integer)
+
+      statvfs(file)
+    end
+
+    class << self
+      # @!method from(file)
+      # @return [StatVfs]
+      # @raise [SystemCallError]
+      # @see StatVfs#from
+
+      # @!method statvfs(file)
+      # @return [StatVfs]
+      # @raise [SystemCallError]
+      # @see StatVfs#statvfs
+
+      # @!method fstatvfs(file)
+      # @return [StatVfs]
+      # @raise [SystemCallError]
+      # @see StatVfs#fstatvfs
+      %i[from statvfs fstatvfs].each { |m| define_method(m) { |file, stat = new, **args| stat.send(m, file, **args) } }
+
+      # @!visibility private
+
+      # @!method native_statvfs(path, statvfs_buf)
+      # @!method native_fstatvfs(fd, statvfs_buf)
+    end
   end
 end

data/lib/ffi/struct_wrapper.rb

@@ -5,6 +5,16 @@ require_relative 'accessors'
 
 module FFI
   # Helper to wrap structs with ugly names and attribute clashes with FFI::Struct (eg size)
+  #
+  # @example
+  #  class MyStruct
+  #    include FFI::StructWrapper
+  #    native_struct(MyNativeStruct)
+  #
+  #    #!@attribute [rw] field
+  #    ffi_attr_accessor :field
+  #  end
+  #
   module StructWrapper
     # @!visibility private
     class ByReference < StructByReference
@@ -78,8 +88,9 @@ module FFI
 
     # @!parse extend ClassMethods
     # @!parse include Accessors
+    # @!parse extend Accessors::ClassMethods
 
-    # @!visibility private
+    # @return [FFI::Struct] the underlying native struct
     attr_reader :native
 
     # @!visibility private
@@ -96,5 +107,15 @@ module FFI
     def []=(member_or_attr, val)
       @native[self.class.ffi_attr_writers.fetch(member_or_attr, member_or_attr)] = val
     end
+
+    # Pass unimplemented methods on to {#native} underlying struct
+    def method_missing(method, *args)
+      @native.send(method, *args)
+    end
+
+    # @!visibility private
+    def respond_to_missing?(method, private = false)
+      @native.respond_to?(method, private)
+    end
   end
 end

data/sample/hello_fs.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'ffi/libfuse'
+
+# Hello World!
+class HelloFS
+  include FFI::Libfuse::Adapter::Ruby
+  include FFI::Libfuse::Adapter::Fuse2Compat
+
+  # FUSE Configuration methods
+
+  def fuse_options(args)
+    args.parse!({ 'subject=' => :subject }) do |key:, value:, **|
+      raise FFI::Libfuse::Error, 'subject option must be at least 2 characters' unless value.size >= 2
+
+      @subject = value if key == :subject
+      :handled
+    end
+  end
+
+  def fuse_help
+    '-o subject=<subject>   a target to say hello to'
+  end
+
+  def fuse_configure
+    @subject ||= 'World!'
+    @content = "Hello #{@subject}\n"
+  end
+
+  # FUSE callbacks
+
+  def getattr(path, stat, *_args)
+    case path
+    when '/'
+      stat.directory(mode: 0o550)
+    when '/hello.txt'
+      stat.file(mode: 0o440, size: @content.size)
+    else
+      raise Errno::ENOENT
+    end
+  end
+
+  def readdir(_path, *_args)
+    yield 'hello.txt'
+  end
+
+  def read(_path, *_args)
+    @content
+  end
+end
+
+# Start the file system
+FFI::Libfuse.fuse_main(operations: HelloFS.new) if __FILE__ == $0

data/sample/memory_fs.rb

@@ -2,188 +2,12 @@
 # frozen_string_literal: true
 
 require 'ffi/libfuse'
+require 'ffi/libfuse/filesystem/virtual_fs'
 
 # A simple in-memory filesystem defined with hashes.
-#
-# It is writable to the user that mounted it may create and edit files within it
-#
-# === Usage
-#   root = Memory.new(files: { 'hello' => { 'world.txt' => 'Hello World'}})
-#   root.mkdir("/hello")
-#   root.("/hello/world","Hello World!\n")
-#   root.write("/hello/everybody","Hello Everyone!\n")
-#
-#   Libfuse::fuse_main($0,ARGV,operations: root)
-#
-#
-class MemoryFS
-  # @return [Hash<String,Object>] list of file objects by path
-  attr_reader :root
+class MemoryFS < FFI::Libfuse::Filesystem::VirtualFS; end
 
-  include FFI::Libfuse::Adapter::Fuse3Support
-  include FFI::Libfuse::Adapter::Ruby
-  include FFI::Libfuse::Adapter::Pathname
+# Set this to test multi-threading etc...
+main_class = ENV.fetch('MEMORY_FS_SKIP_DEFAULT_ARGS', 'N') == 'Y' ? FFI::Libfuse::Main : FFI::Libfuse
 
-  File = Struct.new(:mode, :content, :ctime, :atime, :mtime) do
-    def dig(*_args)
-      raise Errno::ENOTDIR
-    end
-
-    def fill_stat(stat = FFI::Stat.new)
-      stat.file(mode: mode, ctime: ctime, atime: atime, mtime: mtime, size: content.size)
-    end
-  end
-
-  # rubocop:disable Lint/StructNewOverride
-  Dir = Struct.new(:mode, :entries, :ctime, :atime, :mtime) do
-    def dig(*args)
-      entries.dig(*args)
-    end
-
-    def fill_stat(stat = FFI::Stat.new)
-      stat.directory(mode: mode, ctime: ctime, atime: atime, mtime: mtime)
-    end
-  end
-  # rubocop:enable Lint/StructNewOverride
-
-  def initialize(files: {}, max_size: 100_000, max_files: 1_000)
-    now = Time.now
-    @root = Dir.new(0x755, {}, now, now, now)
-    @total_size = 0
-    @total_files = 1
-    @max_size = max_size
-    @max_files = max_files
-
-    build(files)
-  end
-
-  def build(files, path = ::Pathname.new('/'))
-    files.each_pair do |basename, content|
-      raise 'Initial file keys must be String' unless basename.is_a?(String)
-      raise 'Initial file keys must not contain path separators' if basename =~ %r{[/\\]}
-
-      entry_path = path + basename
-      case content
-      when String
-        create(entry_path, 0x644)
-        write(entry_path, content, 0)
-      when Hash
-        mkdir(entry_path, 0x755)
-        build(content, entry_path)
-      else
-        raise 'Initial files must be String or Hash'
-      end
-    end
-  end
-
-  def fuse_version
-    'MemoryFS: Version x.y.z'
-  end
-
-  def fuse_traps
-    {
-      HUP: -> { reload }
-    }
-  end
-
-  def statfs(_path, statfs_buf)
-    blocks = @total_size / 1_000
-    statfs_buf.bsize    = 1 # block size (in Kb)
-    statfs_buf.frsize   = 1 # fragment size pretty much always bsize
-    statfs_buf.blocks   = @max_size
-    statfs_buf.bfree    = @max_size - blocks
-    statfs_buf.bavail   = @max_size - blocks
-    statfs_buf.files    = @max_files
-    statfs_buf.ffree    = @max_files - @total_files
-    statfs_buf.favail   = @max_files - @total_files
-    0
-  end
-
-  def getattr(path, stat_buf)
-    entry = find(path)
-    return -Errno::ENOENT::Errno unless entry
-
-    entry.fill_stat(stat_buf)
-    0
-  end
-
-  def readdir(path, _offset, _ffi)
-    %w[. ..].each { |d| yield(d, nil) }
-    dir = find(path)
-    dir.entries.each_pair { |k, e| yield(k, e.fill_stat) }
-  end
-
-  def create(path, mode, _ffi)
-    dir_entries = find(path.dirname).entries
-    now = Time.now
-    dir_entries[path.basename.to_s] = File.new(mode, String.new, now, now, now)
-    @total_files += 1
-    0
-  end
-
-  # op[:read] = [:pointer, :size_t, :off_t, FuseFileInfo.by_ref]
-  def read(path, len, off, _ffi)
-    file = find(path)
-    file.atime = Time.now.utc
-    FFI::Libfuse::ThreadPool.busy
-    sleep 0.5
-    file.content[off, len]
-  end
-
-  # write(const char* path, char *buf, size_t size, off_t offset, struct fuse_file_info* fi)
-  def write(path, data, offset, _ffi)
-    file = find(path)
-    content = file.content
-    @total_size -= content.size
-    content[offset, data.length] = data
-    @total_size += content.size
-    file.mtime = Time.now.utc
-  end
-
-  def truncate(path, size)
-    file = find(path)
-    @total_size -= file.content.size
-    file.content[size..-1] = ''
-    file.mtime = Time.now.utc
-    @total_size += file.content.size
-    0
-  end
-
-  def unlink(path)
-    dir = find(path.dirname)
-    deleted = dir.entries.delete(path.basename.to_s)
-    @total_files -= 1
-    @total_size -= deleted.content.size if deleted.is_a?(File)
-    0
-  end
-
-  def mkdir(path, mode)
-    entries = find(path.dirname).entries
-    now = Time.now
-    entries[path.basename.to_s] = Dir.new(mode, {}, now, now, now)
-  end
-
-  def rmdir(path)
-    dir = find(path)
-    raise Errno::ENOTDIR unless dir.is_a?(Dir)
-    raise Errno::ENOTEMPTY unless dir.entries.empty?
-
-    find(path.dirname).entries.delete(path.basename.to_s)
-    0
-  end
-
-  def utimens(path, atime, mtime)
-    entry = find(path)
-    entry.atime = atime if atime
-    entry.mtime = mtime if mtime
-    0
-  end
-
-  private
-
-  def find(path)
-    path.root? ? root : root.dig(*path.to_s.split('/')[1..])
-  end
-end
-
-exit(FFI::Libfuse.fuse_main($0, *ARGV, operations: MemoryFS.new)) if __FILE__ == $0
+exit(main_class.fuse_main(operations: MemoryFS.new)) if __FILE__ == $0

data/sample/no_fs.rb

@@ -6,13 +6,21 @@ require 'ffi/libfuse'
 # An empty file system
 class NoFS
   include FFI::Libfuse::Adapter::Context
-  include FFI::Libfuse::Adapter::Fuse3Support
   include FFI::Libfuse::Adapter::Ruby
+  include FFI::Libfuse::Adapter::Fuse3Support # must run outside of Adapter::Ruby
 
   OPTIONS = { 'log=' => :log }.freeze
 
-  def fuse_options
-    OPTIONS
+  def fuse_options(args)
+    args.parse!(OPTIONS) do |key:, value:, **|
+      case key
+      when :log
+        @logfile = value
+      else
+        next :keep
+      end
+      :handled
+    end
   end
 
   def fuse_help
@@ -24,46 +32,37 @@ class NoFS
   end
 
   def fuse_version
-    'NoFS: Version x.y.z'
-  end
-
-  def fuse_opt_proc(_data, arg, key, _outargs)
-    case key
-    when :log
-      @logfile = arg[4..]
-      return :handled
-    end
-    :keep
+    "NoFS: Version x.y.z. Fuse3Compat=#{fuse3_compat?}"
   end
 
-  def getattr(_ctx, path, stat)
+  def getattr(path, stat)
     raise Errno::ENOENT unless path == '/'
 
     stat.directory(mode: 0o555)
   end
 
-  def readdir(_ctx, _path, _offset, _ffi)
-    %w[. ..].each { |d| yield(d, nil) }
+  def readdir(_path, _offset, _ffi, &block)
+    puts "NOFS Readdir: #{block}"
+    %w[. ..].each(&block)
   end
 
   def log
     @log ||= File.open(@logfile || '/tmp/no_fs.out', 'a')
   end
 
-  def init(ctx, conn, cfg = nil)
+  def init(_conn)
+    ctx = FFI::Libfuse::Adapter::Context.fuse_context
     log.puts("NoFS init ctx- #{ctx.inspect}") if ctx
-    log.puts("NoFS init conn - #{conn.inspect}") if conn && !conn.null?
-    log.puts "NoFS init cfg #{cfg.inspect}" if cfg && !cfg.null?
     warn 'NoFS: DEBUG enabled' if debug?
     log.flush
     'INIT_DATA'
   end
 
-  def destroy(obj, *_rest)
+  def destroy(obj)
     # If the fs is not cleanly unmounted the init data will have been GC'd by the time this is called
     log.puts("NoFS destroy- #{obj.inspect}") if !obj.is_a?(WeakRef) || obj.weakref_alive?
     log.puts "NoFS destroy- pid=#{Process.pid}"
   end
 end
 
-exit(FFI::Libfuse.fuse_main($0, *ARGV, operations: NoFS.new, private_data: 'MAIN_DATA')) if __FILE__ == $0
+exit(FFI::Libfuse::Main.fuse_main($0, *ARGV, operations: NoFS.new, private_data: 'MAIN_DATA')) if __FILE__ == $0

data/sample/pass_through_fs.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'ffi/libfuse'
+require 'ffi/libfuse/filesystem/pass_through_dir'
+
+# Pass Through Filesystem - over a base directory
+class PassThroughFS < FFI::Libfuse::Filesystem::PassThroughDir
+  def fuse_options(args)
+    args.parse!({ 'base_dir=' => :base_dir }) do |key:, value:, **|
+      next :keep unless key == :base_dir
+
+      raise FFI::Libfuse::Error, "#{value} is not a directory" unless Dir.exist?(value)
+
+      self.base_dir = value
+      :handled
+    end
+  end
+
+  def fuse_help
+    '-o base_dir=<dir>'
+  end
+
+  def fuse_configure
+    self.base_dir ||= Dir.pwd
+    warn "Using #{self.base_dir} as base directory for file operations" if debug?
+  end
+end
+
+exit(FFI::Libfuse.fuse_main(operations: PassThroughFS.new)) if __FILE__ == $0