rfusefs 1.0.2.RC0 → 1.1.0.rc202009.34

data/.gitignore

@@ -1,9 +0,0 @@
-#No hidden files (except for .gitignore)
-.*
-!.gitignore
-!.travis.yml
-#Files generated by rake
-doc
-pkg
-#Jedit stupid default backup settings
-*'`'

data/.travis.yml

@@ -1,8 +0,0 @@
-language: ruby
-rvm:
-  - "1.8.7"
-  - "1.9.3"
-  - "2.0.0"
-before_install:
-  - sudo apt-get update -qq
-  - sudo apt-get install -qq libfuse-dev

data/Gemfile

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in rfusefs.gemspec
-gemspec

data/History.rdoc

@@ -1,28 +0,0 @@
-=== 1.0.1 / 2013-12-19
-
-* Add FuseFS.main to create pretty usage messages
-
-* Support extended attributes in filesystems
-
-* Updates and cleanup of PathMapperFS
-
-* Provide SqliteMapperFS
-
-=== 1.0.0 / 2012-08-07
-
-* Depend on new rfuse 1.0.0, Ruby 1.9
-
-* API breaking changes
-
-  * order of arguments to {FuseFS.mount}, {FuseFS.start} changed 
-    to account for better option handling in RFuse
-
-=== 0.8.0 / 2011-02-19
-
-* Initial port from fusefs
-
-  * Improved raw methods
-  * new "times" api for including atime,mtime,ctime in stat results
-  * metadir allow mv directories
-  * includes PathMapperFS
-

data/README.rdoc

@@ -1,105 +0,0 @@
-= rfusefs
-
-* https://rubygems.org/gems/rfusefs
-* https://github.com/lwoggardner/rfusefs
-
-== DESCRIPTION
-
-RFuseFS is a port of the FuseFS[http://rubygems.org/gems/fusefs/]
-library aimed at allowing Ruby programmers to quickly and easily create
-virtual filesystems with little more than a few lines of code.
-
-RFuseFS is api compatible with FuseFS (0.7.0)
-
-== SYNOPSIS
-
-FuseFS provides a layer of abstraction to a programmer who wants to create a
-virtual filesystem via FUSE.
-
-First define a virtual directory by subclassing {FuseFS::FuseDir}
-
-See samples under /samples and also the following starter classes
-
-* {FuseFS::FuseDir}
-* {FuseFS::MetaDir}
-* {FuseFS::DirLink}
-* {FuseFS::PathMapperFS}
-* {FuseFS::SqliteMapperFS}
-
-Then start your filesystem with
-
-* {FuseFS.start}
-* {FuseFS.main}
-
-Finally to use the filesystem open up your favourite file browser/terminal and
-explore the contents under <mountpoint>
-
-Happy Filesystem Hacking!
-
-=== the hello world filesystem in 16 LOC
-
-  require 'rfusefs'
-
-  class HelloDir
-    def contents(path)
-      ['hello.txt']
-    end
-    def file?(path)
-      path == '/hello.txt'
-    end
-    def read_file(path)
-      "Hello, World!\n"
-    end
-    def size(path)
-      read_file(path).size
-    end
-  end
-
-  # Usage: #{$0} mountpoint [mount_options]
-  FuseFS.main() { |options| HelloDir.new }
-
-== REQUIREMENTS:
-
-* FUSE (http://fuse.sourceforge.org)
-* Ruby (>=1.9)
-* rfuse (~> 1.0)
-
-== INSTALL:
-
-* gem install rfusefs
-
-== DEVELOPERS:
-
-After checking out the source, run:
-
-  $ bundle install # install dependencies
-  $ rake spec # run tests
-  $ rake yard # generate docs
-
-
-== LICENSE:
-
-(The MIT License)
-
-* Copyright (c) 2005 Greg Millam. (FuseFS)
-* Copyright (c) 2009 Kyle Maxwell. (FuseFS)
-* Copyright (c) 2012 Grant Gardner. (RFuseFS)
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,19 +0,0 @@
-# -*- ruby -*-
-require "bundler/gem_tasks"
-require 'yard'
-require 'rspec/core/rake_task'
-
-YARD::Rake::YardocTask.new do |t|
-        # Need this because YardocTask does not read the gemspec
-        t.files   = ['lib/**/*.rb', '-','History.rdoc']   # optional
-end
-
-RSpec::Core::RakeTask.new(:spec)
-
-desc "FuseFS compatibility specs"
-RSpec::Core::RakeTask.new("spec:fusefs") do |t|
-  t.pattern = 'spec-fusefs/**/*_spec.rb'
-end
-
-task :default => ["spec","spec:fusefs"]
-# vim: syntax=ruby

data/TODO.txt

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

data/lib/fuse/fusedir.rb

@@ -1,229 +0,0 @@
-module FuseFS
-
-    # 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
-    #  
-    # == 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 flushed or closed
-    #
-    # See also {#raw_open}, {#raw_truncate}, {#raw_write}, {#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
-    class FuseDir
-        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 [Fixnum] the size in byte of a file (lots of applications rely on this being accurate )
-        def size(path);return 0;end
-
-        # File time information. RFuseFS extension.
-        # @abstract FuseFS api
-        # @return [Array<Fixnum, 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.
-        #
-        # Truncate file at path (or filehandle raw) to offset bytes. Called immediately after a file is opened
-        # for write without append.
-        #
-        # This method can also be invoked (without raw) outside of an open file context. See
-        # FUSE documentation on truncate() vs ftruncate()
-        # @abstract FuseFS api
-        # @return [void]
-        def raw_truncate(path,off,raw=nil);end
-
-        # Read _sz_ bytes from file at path (or filehandle raw) starting at offset off
-        # 
-        # @param [String] path
-        # @param [Fixnum] offset
-        # @param [Fixnum] 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
-
-        # 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. These will be set/retrieved/removed directly
-        # @param [String] path
-        # @return [Hash] extended attributes for this path
-        # @abstract FuseFS api
-        def xattr(path); return {}; 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,435 +0,0 @@
-# RFuseFS - FuseFS over RFuse
-require 'rfuse'
-require 'fcntl'
-
-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 = ""
-        end
-
-        def read(offset,size)
-            contents[offset,size]
-        end
-
-        def write(offset,data)
-            if append? || offset >= contents.length
-                #ignore offset
-                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
-
-    # Implements RFuseFS
-    # 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 RFuseFS
-        CHECK_FILE="/._rfuse_check_"
-
-        def initialize(root)
-            @root = root
-            @created_files = { }
-
-            #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
-        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.gid
-            gid = Process.uid
-
-            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)
-                now = Time.now.to_i
-                return RFuse::Stat.file(@created_files[path],{ :uid => uid, :gid => gid, :atime => now, :mtime => now, :ctime => now })
-            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 = @root.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)
-        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
-
-            @created_files[path] = mode
-        end #mknod
-
-        #ftruncate - eg called after opening a file for write without append
-        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)
-            elsif (offset <= 0)
-                fh.contents = ""
-            else
-                fh.contents = fh.contents[0..offset]
-            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
-
-            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
-        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.rdwr? || fh.wronly?
-                    unless @root.can_write?(path)
-                        raise Errno::EACCES.new(path)
-                    end
-
-                    if @created_files.has_key?(path)
-                        #we have an empty file
-                        fh.contents = "";
-                    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 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
-
-            flush(nil,path,ffi)
-
-            fh = ffi.fh
-            if fh && fh.raw
-                if (FuseFS::RFUSEFS_COMPATIBILITY)
-                    @root.raw_close(path,fh.raw)
-                else
-                    @root.raw_close(path)
-                end
-            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...
-            if @root.respond_to?(:touch)
-                @root.touch(path,modtime)
-            end
-        end
-
-        def unlink(ctx,path)
-            return wrap_context(ctx,__method__,path) if ctx
-
-            unless @root.can_delete?(path)
-                raise Errno::EACCES.new(path)
-            end
-            @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)
-            return wrap_context(ctx,__method__,path,name,value) 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
-        #def statfs(path)   
-        #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
-
-    def wrap_context(ctx,method,*args)
-        self.class.context(ctx) { send(method,nil,*args) }
-    end
-
-    end #class RFuseFS
-end #Module FuseFS