rfusefs 1.0.2 → 1.1.3

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MzhlODUwNTJmNTNmNGM5OTZhNWU5Nzg0YjhkMTM2MWRmMmZmMzA5OQ==
-  data.tar.gz: !binary |-
-    YWRhODkyYzJjZGNjYzc2YzM4ZTc5NjJhYWUyNjlkM2FiYzNjMGI4Nw==
+SHA256:
+  metadata.gz: 7b262bbb9de179cfa71cc8b7c6c1b2e879557f364c2c6f923176fb607b7abeb0
+  data.tar.gz: 29566f13a740362789004fa7d865f0a9e6c3a75cd0f70551033a9b7b9b2ea092
 SHA512:
-  metadata.gz: !binary |-
-    OGMwYWQ3YzE4MDJlZTlhNmExMWQxZWYyOGUzZTcxMWZhYWZkNzI3N2MwNmYz
-    MWU1NTI5M2IyMjU2Y2Q2MjU3ZTQwNzcwN2EzYmQ2MzAwNzI1ZmFlNWJlYTll
-    Y2FkMDY5NmNkYThjNmZhYWUzMDQ2ZWQ4YmRkMmMwNTRkNzYxMWY=
-  data.tar.gz: !binary |-
-    OTgxN2NmMWQ3MjBlZTQwODU4NTBlMTdiNjQ3NTMwNTZiYjUzMjUxMTZhZDg4
-    MTllMGUwODliMGJjMDkzNTQwNDhiYTZhNzUzMzg0MjNiNmRjZWUwNGE1Yjdh
-    NWY2NmE2YzYwNDg4NWJhNGRmYzI5MjZiYjhjZjZhNzUwOTZiZWM=
+  metadata.gz: ed3bf064022e69c006714709755d49848fda697bfdc1bf3b27126d9fdf7db1aee724ca71ddd3c44d621a8b8411904675c2f6e2b9559032cf229007ec7a5e2adf
+  data.tar.gz: cdcdde923e4ce54e0eafc909a67c275b57f8b354baa3fe3c02976163201fcfe0049b35d7e8ea00aa3b016dd4b60fe8fd76d0b97b1bb89bf74678aa3055265bdd

data/.yardopts

@@ -0,0 +1,2 @@
+-
+CHANGES.md

data/CHANGES.md

@@ -0,0 +1,43 @@
+1.1.1 / 2020-11
+---------------
+  * fix gemspec
+  
+1.1.0 / 2020-10
+---------------
+
+ * With rfuse ~> 1.2
+ * Requires Ruby 2.5+
+ * Release via Travis CI
+
+1.0.3 / 2014-12-22
+----------------------
+
+ * Pushed some internals up to RFuse
+ * Allow filesystems to implement signal handlers
+
+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/LICENSE

@@ -0,0 +1,24 @@
+(The MIT License)
+
+*   Copyright (c) 2005 Greg Millam. (FuseFS)
+*   Copyright (c) 2009 Kyle Maxwell. (FuseFS)
+*   Copyright (c) 2012 - 2020 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/README.md

@@ -0,0 +1,83 @@
+# rfusefs
+
+*   https://rubygems.org/gems/rfusefs
+*   https://github.com/lwoggardner/rfusefs
+
+[<img src="https://badge.fury.io/rb/rfusefs.png" alt="Gem Version"
+/>](http://badge.fury.io/rb/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.main} or {FuseFS.start}
+
+
+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 14 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
+
+    end
+
+    # Usage: #{$0} mountpoint [mount_options]
+    FuseFS.main() { |options| HelloDir.new }
+
+## REQUIREMENTS:
+
+*   FUSE (http://fuse.sourceforge.net)
+*   Ruby (>= 2.5)
+*   rfuse (~> 1.2)
+
+
+## INSTALL:
+
+*   gem install rfusefs
+
+## DEVELOPERS:
+
+After checking out the source, run:
+
+    $ bundle install # install dependencies
+    $ rake spec # run tests
+    $ rake yard # generate docs
+

data/TODO.md

@@ -0,0 +1,7 @@
+
+TODO
+--------------
+
+ * Test (or remove) samples
+
+

data/lib/fuse/fusedir.rb

@@ -120,7 +120,21 @@ module FuseFS
     #   * {#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) 
@@ -258,7 +272,7 @@ module FuseFS
         # @param [Integer] size
         # @param [Object] raw the filehandle returned by {#raw_open}
         # @abstract FuseFS api
-        # @return [void]
+        # @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
@@ -269,7 +283,7 @@ module FuseFS
 
         # Sync buffered data to your filesystem
         # @param [String] path
-        # @param [Boolena] datasync only sync user data, not metadata
+        # @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
 
@@ -307,6 +321,7 @@ module FuseFS
         # @return [void]
         def unmounted();end
 
+
     end
 
     DEFAULT_FS = FuseDir.new()

data/lib/fuse/rfusefs-fuse.rb

@@ -1,508 +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
+  #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 read(offset,size)
+      contents[offset,size]
+    end
 
-        def create
-            @contents = ""
-            @modified = true
-        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 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 flush
+      @modified = false
+      contents
+    end
 
-        def modified?
-            @modified
-        end
+    def modified?
+      @modified
+    end
 
-        def accmode
-            flags & Fcntl::O_ACCMODE
-        end
+    def accmode
+      flags & Fcntl::O_ACCMODE
+    end
 
-        def rdwr?
-            accmode == Fcntl::O_RDWR
-        end
+    def rdwr?
+      accmode == Fcntl::O_RDWR
+    end
 
-        def wronly?
-            accmode == Fcntl::O_WRONLY
-        end
+    def wronly?
+      accmode == Fcntl::O_WRONLY
+    end
 
-        def rdonly?
-            accmode == Fcntl::O_RDONLY
-        end
+    def rdonly?
+      accmode == Fcntl::O_RDONLY
+    end
 
-        def append?
-            writing? && (flags & Fcntl::O_APPEND != 0)
-        end
+    def append?
+      writing? && (flags & Fcntl::O_APPEND != 0)
+    end
 
-        def reading?
-            rdonly? || rdwr?
-        end
+    def reading?
+      rdonly? || rdwr?
+    end
 
-        def writing?
-            wronly? || 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
+    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
+      mode_str << "a" if append?
+      return mode_str
     end
+  end
 
-    # Implements RFuseFS
+  # 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 RFuseFS
-        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
-        end
-
-        def readdir(ctx,path,filler,offset,ffi)
+    class Root
 
-            return wrap_context(ctx,__method__,path,filler,offset,ffi) if ctx
+      # We forward some methods
+      include Forwardable
 
-            #Always have "." and ".."
-            filler.push(".",nil,0)
-            filler.push("..",nil,0)
+      CHECK_FILE="/._rfuse_check_"
 
-            files = @root.contents(path)
+      def initialize(root)
+        @root = root
+        @created_files = { }
 
-            files.each do | filename |
-                filler.push(filename,nil,0)
-            end
+        # 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
 
-        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
+        # 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
 
-        end #getattr
+      def readdir(ctx,path,filler,offset,ffi)
 
-        def mkdir(ctx,path,mode)
+        return wrap_context(ctx,__method__,path,filler,offset,ffi) if ctx
 
-            return wrap_context(ctx,__method__,path,mode) if ctx
+        #Always have "." and ".."
+        filler.push(".",nil,0)
+        filler.push("..",nil,0)
 
-            unless @root.can_mkdir?(path)
-                raise Errno::EACCES.new(path)
-            end
+        files = @root.contents(path)
 
-            @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
+        files.each do | filename |
+          filler.push(filename,nil,0)
+        end
 
-            now = Time.now
-            stat = RFuse::Stat.file(mode,{ :uid => Process.uid, :gid => Process.gid, :atime => now, :mtime => now, :ctime => now })
+      end
 
-            @created_files[path] = stat
-            @adj_nodes += 1
-        end #mknod
+      def getattr(ctx,path)
 
-        #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) if ctx
 
-            return wrap_context(ctx,__method__,path,offset,ffi) if ctx
+        uid = Process.uid
+        gid = Process.gid
 
-            fh = ffi.fh
+        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
 
-            if fh.raw
-                @root.raw_truncate(path,offset,fh.raw)
-                if (offset <= 0)
-                    fh.contents = ""
-                else
-                    fh.contents = fh.contents[0..offset]
-                end
-            end
+          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
 
-        #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
+      end #getattr
 
-            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
+      def mkdir(ctx,path,mode)
 
-            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
+        return wrap_context(ctx,__method__,path,mode) if ctx
 
-            #If we get this far, save our filehandle in the FUSE structure
-            ffi.fh=fh
+        unless @root.can_mkdir?(path)
+          raise Errno::EACCES.new(path)
         end
 
-        def read(ctx,path,size,offset,ffi)
-            return wrap_context(ctx,__method__,path,size,offset,ffi) if ctx
+        @root.mkdir(path)
+        @adj_nodes += 1
+      end #mkdir
 
-            fh = ffi.fh
+      def mknod(ctx,path,mode,major,minor)
 
-            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
+        return wrap_context(ctx,__method__,path,mode,major,minor) if ctx
 
-        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
+        unless ((RFuse::Stat::S_IFMT & mode) == RFuse::Stat::S_IFREG ) && @root.can_write?(path)
+          raise Errno::EACCES.new(path)
         end
 
-        def fsync(ctx,path,datasync,ffi)
-            return wrap_context(ctx,__method__,path,datasync,ffi) if ctx
-            fh = ffi.fh
+        now = Time.now
+        stat = RFuse::Stat.file(mode,{ :uid => Process.uid, :gid => Process.gid, :atime => now, :mtime => now, :ctime => now })
 
-            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
+        @created_files[path] = stat
+        @adj_nodes += 1
+      end #mknod
 
-        def flush(ctx,path,ffi)
-            return wrap_context(ctx,__method__,path,ffi) if ctx
-            fh = ffi.fh
+      #ftruncate - eg called after opening a file for write without append
+      #sizes are adjusted at file close
+      def ftruncate(ctx,path,offset,ffi)
 
-            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
+        return wrap_context(ctx,__method__,path,offset,ffi) if ctx
 
-        def release(ctx,path,ffi)
-            return wrap_context(ctx,__method__,path,ffi) if ctx
+        fh = ffi.fh
 
-
-            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
+        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
 
-        #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
+      #truncate a file outside of open files
+      def truncate(ctx,path,offset)
+        return wrap_context(ctx,__method__,path,offset) if ctx
 
-            #Touch...
-            @root.touch(path,modtime) if @root.respond_to?(:touch)
+        unless @root.can_write?(path)
+          raise Errno::EACESS.new(path)
         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)
+        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
 
-        def rmdir(ctx,path)
-            return wrap_context(ctx,__method__,path) if ctx
+      # 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)
 
-            unless @root.can_rmdir?(path)
-                raise Errno::EACCES.new(path)
-            end
-            @root.rmdir(path)
+        #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
 
-        #def symlink(path,as)
-        #end
-
-        def rename(ctx,from,to)
-            return wrap_context(ctx,__method__,from,to) if ctx
+        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 @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)
+            if @created_files.has_key?(path)
+              fh.create
             else
-                raise Errno::EACCES.new("Unable to move directory #{from}")
+              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
-        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
 
-        #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
+        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 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 write(ctx,path,buf,offset,ffi)
+        return wrap_context(ctx,__method__,path,buf,offset,ffi) if ctx
+        fh = ffi.fh
 
-        def listxattr(ctx,path)
-            return wrap_context(ctx,__method__,path) if ctx
-            @root.xattr(path).keys
+        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 removexattr(ctx,path,name)
-            return wrap_context(ctx,__method__,path,name) if ctx
-            @root.xattr(path).delete(name)
-        end
+      def fsync(ctx,path,datasync,ffi)
+        return wrap_context(ctx,__method__,path,datasync,ffi) if ctx
+        fh = ffi.fh
 
-        #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
+        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
-
-    def mounted()
+      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
+      end
 
-    def unmounted()
+      def unmounted()
         @root.unmounted()
-    end
+      end
 
-    def self.context(ctx,&block)
+      def self.context(ctx,&block)
         begin
-            Thread.current[:fusefs_reader_uid] = ctx.uid
-            Thread.current[:fusefs_reader_gid] = ctx.gid
-            yield
+          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
+          Thread.current[:fusefs_reader_uid] = nil
+          Thread.current[:fusefs_reader_gid] = nil
         end
-    end
+      end
+
+      # @private - no doc
+      def to_s
+        "RFuseFS::#{@root}"
+      end
 
-    private
+      private
 
-    def wrap_context(ctx,method,*args)
+      def wrap_context(ctx,method,*args)
         self.class.context(ctx) { send(method,nil,*args) }
-    end
+      end
 
-    def size(path)
+      def size(path)
         @root.respond_to?(:size) ? @root.size(path) : @root.read_file(path).length
-    end
+      end
+
+    end #class Root
 
-    end #class RFuseFS
+  end #class Fuse
 end #Module FuseFS