rfusefs 1.0.3 → 1.1.0.rc202009.34

data/TODO.txt

@@ -1,6 +0,0 @@
-
-= TODO
-
- Fix (or remove) samples
-
-

data/lib/fuse/fusedir.rb

@@ -1,328 +0,0 @@
-module FuseFS
-
-    # Helper for filesystem accounting
-    class StatsHelper
-
-        # @return [Integer] size of filesystem in bytes
-        attr_accessor :max_space
-        # @return [Integer] maximum number of (virtual) inodes
-        attr_accessor :max_nodes
-
-        # If set true, adjustments that cause space/nodes to exceed
-        # the maximums will raise ENOSPC (no space left on device)
-        # @return [Boolean]
-        attr_accessor :strict
-
-        # @return [Integer] used space in bytes
-        attr_reader :space
-
-        # @return [Integer] used inodes (typically count of files and directories)
-        attr_reader :nodes
-
-        #
-        # @param [Integer] max_space
-        # @param [Integer] max_nodes
-        # @param [Booleanr] strict
-        def initialize(max_space=nil,max_nodes=nil,strict=false)
-            @nodes = 0
-            @space = 0
-            @max_space = max_space
-            @max_nodes = max_nodes
-            @strict = strict
-        end
-
-        # Adjust accumlated statistics
-        # @param [Integer] delta_space change in {#space} usage
-        # @param [Integer] delta_nodes change in {#nodes} usage
-        #
-        # @return [void]
-        # @raise [Errno::ENOSPC] if {#strict} and adjusted {#space}/{#nodes} would exceed {#max_space} or {#max_nodes}
-        def adjust(delta_space,delta_nodes=0)
-            @nodes += delta_nodes
-            @space += delta_space
-            raise Errno::ENOSPC if @strict && ( @nodes >  @max_nodes ||  @space > @max_space )
-        end
-
-        # @overload to_statistics()
-        #   @return [Array<Integer>] in format expected by {FuseDir#statistics}
-        # @overload to_statistics(free_space,free_nodes)
-        #   Calculate total space so that free space remains fixed
-        #   @param [Integer] free_space available space in bytes
-        #   @param [Integer] free_nodes available (virtual) inodes
-        #   @return [Array<Integer>] in format expected by {FuseDir#statistics}
-        def to_statistics(free_space=nil,free_nodes=nil)
-            total_space = free_space ? space + free_space : max_space
-            total_nodes = free_nodes ? nodes + free_nodes : max_nodes
-            [ @space, @nodes, total_space, total_nodes ]
-        end
-    end
-
-    # This class is equivalent to using Object.new() as the virtual directory
-    # for target for {FuseFS.start}. It exists primarily to document the API
-    # but can also be used as a superclass for your filesystem providing sensible defaults
-    #
-    # == Method call sequences
-    #
-    # === Stat (getattr)
-    #
-    # FUSE itself will generally stat referenced files and validate the results
-    # before performing any file/directory operations so this sequence is called
-    # very often
-    #   
-    # 1. {#directory?} is checked first
-    #    * {#can_write?} OR {#can_mkdir?} with .\_rfusefs_check\_ to determine write permissions
-    #    * {#times} is called to determine atime,mtime,ctime info for the directory
-    #
-    # 2. {#file?} is checked next
-    #    * {#can_write?}, {#executable?}, {#size}, {#times} are called to fill out the details
-    #
-    # 3. otherwise we tell FUSE that the path does not exist
-    #
-    # === List directory 
-    # 
-    # FUSE confirms the path is a directory (via stat above) before we call {#contents}
-    #
-    # FUSE will generally go on to stat each directory entry in the results
-    #
-    # === Reading files
-    #
-    # FUSE confirms path is a file before we call {#read_file}
-    #
-    # For fine control of file access see  {#raw_open}, {#raw_read}, {#raw_close}
-    #
-    # === Writing files
-    #
-    # FUSE confirms path for the new file is a directory
-    #
-    # * {#can_write?} is checked at file open
-    # * {#write_to} is called when the file is synced, flushed or closed
-    #
-    # See also {#raw_open}, {#raw_truncate}, {#raw_write}, {#raw_sync}, {#raw_close}
-    #
-    # === Deleting files
-    #
-    # FUSE confirms path is a file before we call {#can_delete?} then {#delete}
-    #
-    # === Creating directories
-    #
-    # FUSE confirms parent is a directory before we call {#can_mkdir?} then {#mkdir}
-    #
-    # === Deleting directories
-    #
-    # FUSE confirms path is a directory before we call {#can_rmdir?} then {#rmdir}
-    #
-    # === Renaming files and directories
-    #
-    # FUSE confirms the rename is valid (eg. not renaming a directory to a file)
-    #
-    # * Try {#rename} to see if the virtual directory wants to handle this itself
-    # * If rename returns false/nil then we try to copy/delete (files only) ie.
-    #   * {#file?}(from), {#can_write?}(to), {#can_delete?}(from) and if all true
-    #   * {#read_file}(from), {#write_to}(to), {#delete}(from)
-    # * otherwise reject the rename
-    #
-    # === Signals
-    #
-    # The filesystem can handle a signal by providing a `sig<name>` method. eg 'sighup'
-    # {#sigint} and {#sigterm} are handled by default to provide a means to exit the filesystem
-    class FuseDir
-
-        # @!method sigint()
-        #   @return [void]
-        #   Handle the INT signal and exit the filesystem
-
-        # @!method sigterm()
-        #   @return [void]
-        #   Handle the TERM signal and exit the filesystem
-
-        INIT_TIMES = Array.new(3,0)
-
-        #   base,rest = split_path(path) 
-        # @return [Array<String,String>] base,rest. base is the first directory in
-        #                                path, and rest is nil> or the remaining path.
-        #                                Typically if rest is not nil? you should 
-        #                                recurse the paths 
-        def split_path(path)
-            cur, *rest = path.scan(/[^\/]+/)
-            if rest.empty?
-                [ cur, nil ]
-            else
-                [ cur, File::SEPARATOR + File.join(rest) ]
-            end
-        end
-
-        #   base,*rest = scan_path(path)
-        # @return [Array<String>] all directory and file elements in path. Useful
-        #                         when encapsulating an entire fs into one object
-        def scan_path(path)
-            path.scan(/[^\/]+/)
-        end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if path is a directory
-        def directory?(path);return false;end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if path is a file
-        def file?(path);end
-
-        # @abstract FuseFS api
-        # @return [Array<String>] array of file and directory names within path
-        def contents(path);return [];end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if path is an executable file
-        def executable?(path);return false;end
-
-        # File size
-        # @abstract FuseFS api
-        # @return [Integer] the size in byte of a file (lots of applications rely on this being accurate )
-        def size(path); read_file(path).length ;end
-
-        # File time information. RFuseFS extension.
-        # @abstract FuseFS api
-        # @return [Array<Integer, Time>] a 3 element array [ atime, mtime. ctime ] (good for rsync etc)
-        def times(path);return INIT_TIMES;end
-
-        # @abstract FuseFS api
-        # @return [String] the contents of the file at path
-        def read_file(path);return "";end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if the user can write to file at path
-        def can_write?(path);return false;end
-
-        # Write the contents of str to file at path
-        # @abstract FuseFS api
-        # @return [void]
-        def write_to(path,str);end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if the user can delete the file at path
-        def can_delete?(path);return false;end
-
-        # Delete the file at path
-        # @abstract FuseFS api
-        # @return [void]
-        def delete(path);end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if user can make a directory at path
-        def can_mkdir?(path);return false;end
-
-        # Make a directory at path
-        # @abstract FuseFS api
-        # @return [void]
-        def mkdir(path);end
-
-        # @abstract FuseFS api
-        # @return [Boolean] true if user can remove a directory at path
-        def can_rmdir?(path);return false;end
-
-        # Remove the directory at path
-        # @abstract FuseFS api
-        # @return [void]
-        def rmdir(path);end
-
-        # Neat toy. Called when a file is touched or has its timestamp explicitly modified
-        # @abstract FuseFS api
-        # @return [void]
-        def touch(path,modtime);end
-
-        # Move a file or directory.
-        # @abstract FuseFS api
-        # @return [Boolean] true to indicate the rename has been handled,
-        #                  otherwise will fallback to copy/delete
-        def rename(from_path,to_path);end
-
-        # Raw file access  
-        # @abstract FuseFS api
-        # @param mode [String] "r","w" or "rw", with "a" if file is opened for append
-        # @param rfusefs [Boolean] will be "true" if RFuseFS extensions are available
-        # @return [nil] to indicate raw operations are not implemented
-        # @return [Object] a filehandle
-        #                  Under RFuseFS this object will be passed back in to the other raw
-        #                  methods as the optional parameter _raw_
-        #
-        def raw_open(path,mode,rfusefs = nil);end
-
-        # RFuseFS extension.
-        # @abstract FuseFS api
-        #
-        # @overload raw_truncate(path,offset,raw)
-        #  Truncate an open file to offset bytes
-        #  @param [String] path
-        #  @param [Integer] offset
-        #  @param [Object] raw the filehandle returned from {#raw_open}
-        #  @return [void]
-        #
-        # @overload raw_truncate(path,offset)
-        #  Optionally truncate a file to offset bytes directly
-        #  @param [String] path
-        #  @param [Integer] offset
-        #  @return [Boolean]
-        #    if truncate has been performed, otherwise the truncation will be performed with {#read_file} and {#write_to}
-        #
-        def raw_truncate(path,offset,raw=nil);end
-
-        # Read _sz_ bytes from file at path (or filehandle raw) starting at offset off
-        #
-        # @param [String] path
-        # @param [Integer] offset
-        # @param [Integer] size
-        # @param [Object] raw the filehandle returned by {#raw_open}
-        # @abstract FuseFS api
-        # @return [void]
-        def raw_read(path,offset,size,raw=nil);end
-
-        # Write _sz_ bytes from file at path (or filehandle raw) starting at offset off
-        # @abstract FuseFS api
-        # @return [void]
-        def raw_write(path,off,sz,buf,raw=nil);end
-
-
-        # Sync buffered data to your filesystem
-        # @param [String] path
-        # @param [Boolena] datasync only sync user data, not metadata
-        # @param [Object] raw the filehandle return by {#raw_open}
-        def raw_sync(path,datasync,raw=nil);end
-
-        # Close the file previously opened at path (or filehandle raw)
-        # @abstract FuseFS api
-        # @return [void]
-        def raw_close(path,raw=nil);end
-
-        # RFuseFS extension.
-        # Extended attributes.
-        # @param [String] path
-        # @return [Hash] extended attributes for this path.
-        #   The returned object  will be manipulated directly using :[] :[]=,, :keys and :delete
-        #   so the default (a new empty hash on every call) will not retain attributes that are set
-        # @abstract FuseFS api
-        def xattr(path); {} ; end
-
-        # RFuseFS extensions.
-        # File system statistics
-        # @param [String] path
-        # @return [Array<Integer>] the statistics
-        #   used_space (in bytes), used_files, max_space, max_files
-        #   See {StatsHelper}
-        # @return [RFuse::StatVfs] or raw statistics
-        # @abstract FuseFS api
-        def statistics(path); [0,0,0,0]; end
-
-        # RFuseFS extension.
-        # Called when the filesystem is mounted
-        # @return [void]
-        def mounted();end
-
-        # RFuseFS extension.
-        # Called when the filesystem is unmounted
-        # @return [void]
-        def unmounted();end
-
-
-    end
-
-    DEFAULT_FS = FuseDir.new()
-end

data/lib/fuse/rfusefs-fuse.rb

@@ -1,540 +0,0 @@
-# RFuseFS - FuseFS over RFuse
-require 'rfuse'
-require 'fcntl'
-require 'forwardable'
-
-module FuseFS
-  #Which raw api should we use?
-  RFUSEFS_COMPATIBILITY = true unless FuseFS.const_defined?(:RFUSEFS_COMPATIBILITY)
-
-  class FileHandle
-    @@fh = 0
-    attr_reader :id,:flags,:path
-    attr_accessor :raw,:contents
-    def initialize(path,flags)
-      @id = (@@fh += 1)
-      @flags = flags
-      @path = path
-      @modified = false
-      @contents = ""
-      @size = 0
-    end
-
-    def read(offset,size)
-      contents[offset,size]
-    end
-
-    def create
-      @contents = ""
-      @modified = true
-    end
-
-    def write(offset,data)
-      # TODO: why append?
-      if append? || offset >= contents.length
-        #ignore offset
-        #TODO: should this zero fill?
-        contents << data
-      else
-        contents[offset,data.length]=data
-      end
-      @modified = true
-      return data.length
-    end
-
-    def flush
-      @modified = false
-      contents
-    end
-
-    def modified?
-      @modified
-    end
-
-    def accmode
-      flags & Fcntl::O_ACCMODE
-    end
-
-    def rdwr?
-      accmode == Fcntl::O_RDWR
-    end
-
-    def wronly?
-      accmode == Fcntl::O_WRONLY
-    end
-
-    def rdonly?
-      accmode == Fcntl::O_RDONLY
-    end
-
-    def append?
-      writing? && (flags & Fcntl::O_APPEND != 0)
-    end
-
-    def reading?
-      rdonly? || rdwr?
-    end
-
-    def writing?
-      wronly? || rdwr?
-    end
-
-    def raw_mode
-      mode_str = case accmode
-                 when Fcntl::O_RDWR; "rw"
-                 when Fcntl::O_RDONLY; "r"
-                 when Fcntl::O_WRONLY; "w"
-                 end
-
-      mode_str << "a" if append?
-      return mode_str
-    end
-  end
-
-  # The real RFuse::Fuse object used by FuseFS
-  class Fuse < RFuse::FuseDelegator
-    def initialize(fs,*args)
-      @fs = fs
-      super
-    end
-
-    def run
-      begin
-        @fs.mounted
-        super
-      ensure
-        @fs.unmounted
-      end if mounted?
-    end
-
-    # Implements RFuseFS via RFuse
-    # The path supplied to these methods is generally validated by FUSE itself
-    # with a prior "getattr" call so we do not revalidate here.
-    # http://sourceforge.net/apps/mediawiki/fuse/index.php?title=FuseInvariants
-    class Root
-
-      # We forward some methods
-      include Forwardable
-
-      CHECK_FILE="/._rfuse_check_"
-
-      def initialize(root)
-        @root = root
-        @created_files = { }
-
-        # Keep track of changes to file counts and sizes made via Fuse - for #statfs
-        @adj_nodes = 0
-        @adj_size = 0
-
-        #Define method missing for our filesystem
-        #so we can just call all the API methods as required.
-        def @root.method_missing(method,*args)
-          # our filesystem might implement method_missing itself
-          super
-        rescue NoMethodError
-          DEFAULT_FS.send(method,*args)
-        end
-
-        # Define sig<name> methods to handle signals
-        sigmethods = Signal.list.keys.map { |sn| "sig#{sn.downcase}".to_sym }.select { |sm| @root.respond_to?(sm) }
-        def_delegators(:@root,*sigmethods)
-      end
-
-      def readdir(ctx,path,filler,offset,ffi)
-
-        return wrap_context(ctx,__method__,path,filler,offset,ffi) if ctx
-
-        #Always have "." and ".."
-        filler.push(".",nil,0)
-        filler.push("..",nil,0)
-
-        files = @root.contents(path)
-
-        files.each do | filename |
-          filler.push(filename,nil,0)
-        end
-
-      end
-
-      def getattr(ctx,path)
-
-        return wrap_context(ctx,__method__,path) if ctx
-
-        uid = Process.uid
-        gid = Process.gid
-
-        if  path == "/" || @root.directory?(path)
-          #set "w" flag based on can_mkdir? || can_write? to path + "/._rfuse_check"
-          write_test_path = (path == "/" ? "" : path) + CHECK_FILE
-
-          mode = (@root.can_mkdir?(write_test_path) || @root.can_write?(write_test_path)) ? 0777 : 0555
-          atime,mtime,ctime = @root.times(path)
-          #nlink is set to 1 because apparently this makes find work.
-          return RFuse::Stat.directory(mode,{ :uid => uid, :gid => gid, :nlink => 1, :atime => atime, :mtime => mtime, :ctime => ctime })
-        elsif @created_files.has_key?(path)
-          return @created_files[path]
-        elsif @root.file?(path)
-          #Set mode from can_write and executable
-          mode = 0444
-          mode |= 0222 if @root.can_write?(path)
-          mode |= 0111 if @root.executable?(path)
-          size = size(path)
-          atime,mtime,ctime = @root.times(path)
-          return RFuse::Stat.file(mode,{ :uid => uid, :gid => gid, :size => size, :atime => atime, :mtime => mtime, :ctime => ctime })
-        else
-          raise Errno::ENOENT.new(path)
-        end
-
-      end #getattr
-
-      def mkdir(ctx,path,mode)
-
-        return wrap_context(ctx,__method__,path,mode) if ctx
-
-        unless @root.can_mkdir?(path)
-          raise Errno::EACCES.new(path)
-        end
-
-        @root.mkdir(path)
-        @adj_nodes += 1
-      end #mkdir
-
-      def mknod(ctx,path,mode,major,minor)
-
-        return wrap_context(ctx,__method__,path,mode,major,minor) if ctx
-
-        unless ((RFuse::Stat::S_IFMT & mode) == RFuse::Stat::S_IFREG ) && @root.can_write?(path)
-          raise Errno::EACCES.new(path)
-        end
-
-        now = Time.now
-        stat = RFuse::Stat.file(mode,{ :uid => Process.uid, :gid => Process.gid, :atime => now, :mtime => now, :ctime => now })
-
-        @created_files[path] = stat
-        @adj_nodes += 1
-      end #mknod
-
-      #ftruncate - eg called after opening a file for write without append
-      #sizes are adjusted at file close
-      def ftruncate(ctx,path,offset,ffi)
-
-        return wrap_context(ctx,__method__,path,offset,ffi) if ctx
-
-        fh = ffi.fh
-
-        if fh.raw
-          @root.raw_truncate(path,offset,fh.raw)
-          if (offset <= 0)
-            fh.contents = ""
-          else
-            fh.contents = fh.contents[0..offset]
-          end
-        end
-      end
-
-      #truncate a file outside of open files
-      def truncate(ctx,path,offset)
-        return wrap_context(ctx,__method__,path,offset) if ctx
-
-        unless @root.can_write?(path)
-          raise Errno::EACESS.new(path)
-        end
-
-        current_size = size(path)
-        unless @root.raw_truncate(path,offset)
-          contents = @root.read_file(path)
-          if (offset <= 0)
-            @root.write_to(path,"")
-          elsif offset < contents.length
-            @root.write_to(path,contents[0..offset] )
-          end
-        end
-        @adj_size = @adj_size - current_size + (offset <= 0 ? 0 : offset)
-      end #truncate
-
-      # Open. Create a FileHandler and store in fuse file info
-      # This will be returned to us in read/write
-      # No O_CREATE (mknod first?), no O_TRUNC (truncate first)
-      def open(ctx,path,ffi)
-        return wrap_context(ctx,__method__,path,ffi) if ctx
-        fh = FileHandle.new(path,ffi.flags)
-
-        #Save the value return from raw_open to be passed back in raw_read/write etc..
-        if (FuseFS::RFUSEFS_COMPATIBILITY)
-          fh.raw = @root.raw_open(path,fh.raw_mode,true)
-        else
-          fh.raw = @root.raw_open(path,fh.raw_mode)
-        end
-
-        unless fh.raw
-          if fh.rdonly?
-            fh.contents = @root.read_file(path)
-          elsif fh.writing?
-            unless @root.can_write?(path)
-              raise Errno::EACCES.new(path)
-            end
-
-            if @created_files.has_key?(path)
-              fh.create
-            else
-              if fh.rdwr? || fh.append?
-                fh.contents = @root.read_file(path)
-              else #wronly && !append
-                #We should get a truncate 0, but might as well play it safe
-                fh.contents = ""
-              end
-            end
-          else
-            raise Errno::ENOPERM.new(path)
-          end
-        end
-
-        #If we get this far, save our filehandle in the FUSE structure
-        ffi.fh=fh
-      end
-
-      def read(ctx,path,size,offset,ffi)
-        return wrap_context(ctx,__method__,path,size,offset,ffi) if ctx
-
-        fh = ffi.fh
-
-        if fh.raw
-          if FuseFS::RFUSEFS_COMPATIBILITY
-            return @root.raw_read(path,offset,size,fh.raw)
-          else
-            return @root.raw_read(path,offset,size)
-          end
-        elsif offset >= 0
-          return fh.read(offset,size)
-        else
-          #TODO: Raise? what does a negative offset mean
-          return ""
-        end
-      rescue EOFError
-        return ""
-      end
-
-      def write(ctx,path,buf,offset,ffi)
-        return wrap_context(ctx,__method__,path,buf,offset,ffi) if ctx
-        fh = ffi.fh
-
-        if fh.raw
-          if FuseFS::RFUSEFS_COMPATIBILITY
-            return @root.raw_write(path,offset,buf.length,buf,fh.raw)
-          else
-            @root.raw_write(path,offset,buf.length,buf)
-            return buf.length
-          end
-        else
-          return fh.write(offset,buf)
-        end
-      end
-
-      def fsync(ctx,path,datasync,ffi)
-        return wrap_context(ctx,__method__,path,datasync,ffi) if ctx
-        fh = ffi.fh
-
-        if fh && fh.raw
-          if FuseFS::RFUSEFS_COMPATIBILITY
-            @root.raw_sync(path,datasync != 0,fh.raw)
-          else
-            @root.raw_sync(path,datasync != 0)
-          end
-        else
-          flush(nil,path,ffi)
-        end
-      end
-
-      def flush(ctx,path,ffi)
-        return wrap_context(ctx,__method__,path,ffi) if ctx
-        fh = ffi.fh
-
-        if fh && !fh.raw && fh.modified?
-          #write contents to the file and mark it unmodified
-          @root.write_to(path,fh.flush())
-          #if it was created with mknod it now exists in the filesystem...
-          @created_files.delete(path)
-        end
-      end
-
-      def release(ctx,path,ffi)
-        return wrap_context(ctx,__method__,path,ffi) if ctx
-
-
-        fh = ffi.fh
-        if fh && fh.raw
-          if (FuseFS::RFUSEFS_COMPATIBILITY)
-            @root.raw_close(path,fh.raw)
-          else
-            @root.raw_close(path)
-          end
-          # if was handled as raw, then assume the file has now been created (or not)
-          @created_files.delete(path)
-        else
-          # Probably just had flush called, but no harm calling it again
-          flush(nil,path,ffi)
-        end
-      end
-
-      #def chmod(path,mode)
-      #end
-
-      #def chown(path,uid,gid)
-      #end
-
-      def utime(ctx,path,actime,modtime)
-        return wrap_context(ctx,__method__,path,actime,modtime) if ctx
-
-        #Touch...
-        @root.touch(path,modtime) if @root.respond_to?(:touch)
-      end
-
-      def unlink(ctx,path)
-        return wrap_context(ctx,__method__,path) if ctx
-
-        unless @root.can_delete?(path)
-          raise Errno::EACCES.new(path)
-        end
-
-        @adj_size = @adj_size - size(path)
-
-        @created_files.delete(path)
-        @root.delete(path)
-      end
-
-      def rmdir(ctx,path)
-        return wrap_context(ctx,__method__,path) if ctx
-
-        unless @root.can_rmdir?(path)
-          raise Errno::EACCES.new(path)
-        end
-        @root.rmdir(path)
-      end
-
-      #def symlink(path,as)
-      #end
-
-      def rename(ctx,from,to)
-        return wrap_context(ctx,__method__,from,to) if ctx
-
-        if @root.rename(from,to)
-          # nothing to do
-        elsif @root.file?(from) && @root.can_write?(to) &&  @root.can_delete?(from)
-          contents = @root.read_file(from)
-          @root.write_to(to,contents)
-          @root.delete(from)
-        else
-          raise Errno::EACCES.new("Unable to move directory #{from}")
-        end
-      end
-
-      #def link(path,as)
-      #end
-
-      def setxattr(ctx,path,name,value,flags)
-        return wrap_context(ctx,__method__,path,name,value,flags) if ctx
-        @root.xattr(path)[name]=value
-      end
-
-      def getxattr(ctx,path,name)
-        return wrap_context(ctx,__method__,path,name) if ctx
-        result = @root.xattr(path)[name]
-        raise Errno::ENODATA.new("No attribute #{name}") unless result
-        result.to_s
-      end
-
-      def listxattr(ctx,path)
-        return wrap_context(ctx,__method__,path) if ctx
-        @root.xattr(path).keys
-      end
-
-      def removexattr(ctx,path,name)
-        return wrap_context(ctx,__method__,path,name) if ctx
-        @root.xattr(path).delete(name)
-      end
-
-      #def opendir(path,ffi)
-      #end
-
-      #def releasedir(path,ffi)
-      #end
-
-      #
-      #def fsyncdir(path,meta,ffi)
-      #end
-
-      # Some random numbers to show with df command
-      # bsize preferred block size = 1K unless @root provides something different
-      # frsize = bsize (but apparently unused)
-      # blocks = total number of blocks
-      # bfree = number of free blocks
-      # bavail = bfree if mounted -o allow_other
-      # files = count of all files
-      # ffree - count of free file inode
-      #
-      def statfs(ctx,path)
-        return wrap_context(ctx,__method__,path) if ctx
-        block_size = 1024
-
-        stats = @root.statistics(path)
-        case stats
-        when Array
-          used_space, used_files, total_space, total_files = stats
-          used_files ||= 0
-          used_space ||= 0
-          total_files ||= used_files
-          total_space ||= used_space
-          result = RFuse::StatVfs.new(
-            "bsize" => block_size,
-            "frsize" => block_size,
-            "blocks" => total_space / block_size,
-            "bfree" => (total_space - used_space)/block_size,
-            "bavail" => (total_space - used_space)/block_size,
-            "files" => total_files,
-            "ffree" => (total_files - used_files)
-          )
-          return result
-        else
-          #expected to quack like rfuse:statvfs
-          return stats
-        end
-      end
-
-      def mounted()
-        @root.mounted()
-      end
-
-      def unmounted()
-        @root.unmounted()
-      end
-
-      def self.context(ctx,&block)
-        begin
-          Thread.current[:fusefs_reader_uid] = ctx.uid
-          Thread.current[:fusefs_reader_gid] = ctx.gid
-          yield
-        ensure
-          Thread.current[:fusefs_reader_uid] = nil
-          Thread.current[:fusefs_reader_gid] = nil
-        end
-      end
-
-      # @private - no doc
-      def to_s
-        "RFuseFS::#{@root}"
-      end
-
-      private
-
-      def wrap_context(ctx,method,*args)
-        self.class.context(ctx) { send(method,nil,*args) }
-      end
-
-      def size(path)
-        @root.respond_to?(:size) ? @root.size(path) : @root.read_file(path).length
-      end
-
-    end #class Root
-
-  end #class Fuse
-end #Module FuseFS