ffi-libfuse 0.0.1.pre

data/lib/ffi/stat.rb

@@ -0,0 +1,96 @@
+# 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
+    include StructWrapper
+
+    native_struct(Native)
+
+    # @!attribute [rw] mode
+    #  @return [Integer] file mode (type | perms)
+
+    # @!attribute [rw] size
+    #  @return [Integer] size of file in bytes
+
+    # @!attribute [rw] nlink
+    #  @return [Integer] number of links
+
+    # @!attribute [rw] uid
+    #  @return [Integer] owner user id
+
+    # @!attribute [rw] gid
+    #  @return [Integer] owner group id
+
+    int_members = Native
+                  .members
+                  .select { |m| m.to_s.start_with?('st_') && !m.to_s.end_with?('timespec') }
+                  .map { |m| m[3..].to_sym }
+
+    ffi_attr_accessor(*int_members, format: 'st_%s')
+
+    # @!attribute [rw] atime
+    #   @return [Time] time of last access
+
+    # @!attribute [rw] mtime
+    #   @return [Time] time of last modification
+
+    # @!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 }
+
+    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)
+    end
+
+    # Fill content for a regular file
+    # @param [Integer] mode
+    # @param [Integer] size
+    # @param [Integer] uid
+    # @param [Integer] gid
+    # @param [Hash] args additional system specific stat fields
+    # @return [self]
+    def file(mode:, size:, uid: Process.uid, gid: Process.gid, **args)
+      mode = ((S_IFREG & S_IFMT) | (mode & 0o777))
+      fill(mode: mode, size: size, uid: uid, gid: gid, **args)
+    end
+
+    # Fill content for a directory
+    # @param [Integer] mode
+    # @param [Integer] nlink
+    # @param [Integer] uid
+    # @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)
+      mode = ((S_IFDIR & S_IFMT) | (mode & 0o777))
+      fill(mode: mode, uid: uid, gid: gid, nlink: nlink, **args)
+    end
+    alias directory dir
+  end
+end

data/lib/ffi/stat_vfs.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require_relative('accessors')
+
+module FFI
+  # Represents Statvfs for use with {Libfuse::FuseOperations#statfs} callback
+  class StatVfs < Struct
+    include Accessors
+
+    case Platform::NAME
+    when /darwin/
+      layout(
+        f_bsize: :ulong,
+        f_frsize: :ulong,
+        f_blocks: :uint,
+        f_bfree: :uint,
+        f_bavail: :uint,
+        f_files: :uint,
+        f_ffree: :uint,
+        f_favail: :uint,
+        f_fsid: :ulong,
+        f_flag: :ulong,
+        f_namemax: :ulong
+      )
+    when /linux/
+      layout(
+        :f_bsize, :ulong,
+        :f_frsize, :ulong,
+        :f_blocks, :uint64,
+        :f_bfree, :uint64,
+        :f_bavail, :uint64,
+        :f_files, :uint64,
+        :f_ffree, :uint64,
+        :f_favail, :uint64,
+        :f_fsid, :ulong,
+        :f_flag, :ulong,
+        :f_namemax, :ulong,
+        :f_spare, [:int, 6]
+      )
+    else
+      raise NotImplementedError, "FFI::StatVfs not implemented for FFI::Platform #{Platform::NAME}"
+    end
+
+    # @!attribute [rw] bsize
+    #  @return [Integer] Filesystem block size
+
+    # @!attribute [rw] frsize
+    #  @return [Integer] Fragment size
+
+    # @!attribute [rw] blocks
+    #  @return [Integer] Size of fs in frsize units
+
+    # @!attribute [rw] bfree
+    #  @return [Integer] Number of free blocks
+
+    # @!attribute [rw] bavail
+    #  @return [Integer] Number of free blocks for unprivileged users
+
+    # @!attribute [rw] files
+    #  @return [Integer] Number of inodes
+
+    # @!attribute [rw] ffree
+    #  @return [Integer] Number of free inodes
+
+    # @!attribute [rw] favail
+    #  @return [Integer] Number of free inodes for unprivileged users
+
+    # @!attribute [rw] fsid
+    #  @return [Integer] Filesystem ID
+
+    # @!attribute [rw] flag
+    #  @return [Integer] Mount flags
+
+    # @!attribute [rw] namemax
+    #  @return [Integer] Maximum filename length
+
+    int_members = members.select { |m| m =~ /^f_/ }.map { |m| m[2..].to_sym }
+    ffi_attr_accessor(*int_members, format: 'f_%s')
+  end
+end

data/lib/ffi/struct_array.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module FFI
+  # Module to extend struct classes that are present in callbacks as fixed length arrays
+  module StructArray
+    # Generate a one way converter for a fixed size array of struct
+    # @return [DataConverter]
+    def array(size)
+      ArrayConverter.new(self, size)
+    end
+
+    # @!visibility private
+    # Helper to handle callbacks containing fixed length array of struct
+    class ArrayConverter
+      include DataConverter
+
+      def initialize(type, size)
+        @type = type
+        @size = size
+      end
+
+      def native_type(_type = nil)
+        FFI::Type::POINTER
+      end
+
+      def from_native(ptr, _ctx)
+        return [] if ptr.null?
+
+        Array.new(@size) { |i| @type.new(ptr + (i * @type.size)) }
+      end
+
+      def to_native(ary, _ctx)
+        raise NotImplementedError, "#{self.class.name} Cannot convert #{ary} to pointer"
+      end
+    end
+  end
+end

data/lib/ffi/struct_wrapper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require_relative 'accessors'
+
+module FFI
+  # Helper to wrap structs with ugly names and attribute clashes with FFI::Struct (eg size)
+  module StructWrapper
+    # @!visibility private
+    class ByReference < StructByReference
+      def initialize(wrapper_class)
+        super(wrapper_class.native_struct)
+        @wrapper_class = wrapper_class
+      end
+
+      def to_native(value, ctx)
+        return Pointer::NULL if value.nil?
+
+        value = value.native if value.is_a?(StructWrapper)
+        super(value, ctx)
+      end
+
+      def from_native(value, ctx)
+        return nil if value.null?
+
+        native = super(value, ctx)
+        @wrapper_class.new(native)
+      end
+    end
+
+    # Additional class methods for StructWrapper
+    module ClassMethods
+      # @!visibility private
+      def from_native(value, _)
+        new(value)
+      end
+
+      # @!visibility private
+      def to_native(value, _)
+        case value
+        when native_type
+          value
+        when self
+          value.native
+        else
+          new.fill(value).native
+        end
+      end
+
+      # @!visibility private
+      def native_struct(struct_class = nil)
+        if struct_class
+          native_type(struct_class.by_value)
+          @struct_class = struct_class
+        end
+        @struct_class
+      end
+
+      # @return [Type] represents a pointer to the wrapped struct
+      def by_ref
+        @by_ref ||= ByReference.new(self)
+      end
+
+      # @return [Type] represents passing wrapped struct by value
+      def by_value
+        self
+      end
+    end
+
+    class << self
+      # @!visibility private
+      def included(mod)
+        mod.extend(DataConverter)
+        mod.extend(ClassMethods)
+        mod.include(Accessors)
+      end
+    end
+
+    # @!parse extend ClassMethods
+    # @!parse include Accessors
+
+    # @!visibility private
+    attr_reader :native
+
+    # @!visibility private
+    def initialize(native = self.class.native_struct.new)
+      @native = native
+    end
+
+    # Get attribute
+    def [](member_or_attr)
+      @native[self.class.ffi_attr_readers.fetch(member_or_attr, member_or_attr)]
+    end
+
+    # Set attribute
+    def []=(member_or_attr, val)
+      @native[self.class.ffi_attr_writers.fetch(member_or_attr, member_or_attr)] = val
+    end
+  end
+end

data/sample/memory_fs.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'ffi/libfuse'
+
+# 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
+
+  include FFI::Libfuse::Adapter::Fuse3Support
+  include FFI::Libfuse::Adapter::Ruby
+  include FFI::Libfuse::Adapter::Pathname
+
+  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