rfusefs 1.1.0 → 1.1.1.rc20201114.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 660236e6a6dc3a765736e122e3e08d449685839332ec45d29afc0dc8a7420a00
-  data.tar.gz: 8e5bcffceda937d6e5e35fca6a0f6f407a85160e867167ff21a4fd42aa917496
+  metadata.gz: 56f162c21060ca29f73f4af1323d4e5913199fba944f63ae3de239467ef03898
+  data.tar.gz: 55e32321f1df3ad1c9f85f17b8b1a88fd2038d0fb713e7ba2996dc1f4e7c1546
 SHA512:
-  metadata.gz: 915e78c9df89edfa7b0bd4155f3348e9ae80a9e0063dfb5eaf1210c4bd5ee0646cf6a417e511ec5304442d033c0bc17a81907855bb977f043be03e77ab54c287
-  data.tar.gz: 9f871748305c9c7da9b58c2ccdb161dd065fa1a029ad4037ccb8b591f9da4bb9199a40d2d33e7fa2c81ae826bbbd6fa84d5cf4ff1ecefcfecaf901ca3fe07315
+  metadata.gz: 02620a1786ab417c1653596a2ee952235b8a2fd14d92ee05d089514e2420e15d15844c7991bc9b08f30f889dac5c8871949b0bd718515f1ac9a2a998f7fec390
+  data.tar.gz: 3cec6f71911dfbf1dbdc65424cf2a61c13dd96b4e2226396afa1c7684e6981e1f38663dd1eb44df79746d9b1c5994def790601dddbccf8dbed4cfe01f318349a

data/CHANGES.md

@@ -1,4 +1,7 @@
-
+1.1.1 / 2020-11
+---------------
+  * fix gemspec
+  
 1.1.0 / 2020-10
 ---------------
 

data/lib/fuse/fusedir.rb

@@ -0,0 +1,328 @@
+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 [String] _sz_ bytes contents from file at path (or filehandle raw) starting at offset off
+        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 [Boolean] 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

@@ -0,0 +1,540 @@
+# 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