rfusefs 1.0.2.RC0 → 1.0.2.RC1

data/README.rdoc

@@ -36,23 +36,24 @@ explore the contents under <mountpoint>
 
 Happy Filesystem Hacking!
 
-=== the hello world filesystem in 16 LOC
+=== 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
-    def size(path)
-      read_file(path).size
-    end
+
   end
 
   # Usage: #{$0} mountpoint [mount_options]

data/Rakefile

@@ -2,6 +2,9 @@
 require "bundler/gem_tasks"
 require 'yard'
 require 'rspec/core/rake_task'
+require 'rake/clean'
+
+CLOBBER.include [ "pkg/","doc/" ]
 
 YARD::Rake::YardocTask.new do |t|
         # Need this because YardocTask does not read the gemspec

data/lib/fuse/fusedir.rb

@@ -1,11 +1,68 @@
 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
-    #  
+    # 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
@@ -38,10 +95,10 @@ module FuseFS
     # 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
+    # * {#write_to} is called when the file is synced, flushed or closed
+    #
+    # See also {#raw_open}, {#raw_truncate}, {#raw_write}, {#raw_sync}, {#raw_close}
     #
-    # 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}
@@ -105,12 +162,12 @@ module FuseFS
 
         # 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
+        # @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<Fixnum, Time>] a 3 element array [ atime, mtime. ctime ] (good for rsync etc)
+        # @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
@@ -176,21 +233,29 @@ module FuseFS
         def raw_open(path,mode,rfusefs = nil);end
 
         # RFuseFS extension.
+        # @abstract FuseFS api
         #
-        # Truncate file at path (or filehandle raw) to offset bytes. Called immediately after a file is opened
-        # for write without append.
+        # @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]
         #
-        # 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
+        # @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 [Fixnum] offset
-        # @param [Fixnum] size
+        # @param [Integer] offset
+        # @param [Integer] size
         # @param [Object] raw the filehandle returned by {#raw_open}
         # @abstract FuseFS api
         # @return [void]
@@ -201,17 +266,36 @@ module FuseFS
         # @return [void]
         def raw_write(path,off,sz,buf,raw=nil);end
 
+
+        # Sync buffered data to your filesystem
+        # @param [String] path
+        # @param [Boolena] datasync only sync user data, not metadata
+        # @param [Object] raw the filehandle return by {#raw_open}
+        def raw_sync(path,datasync,raw=nil);end
+
         # Close the file previously opened at path (or filehandle raw)
         # @abstract FuseFS api
         # @return [void]
         def raw_close(path,raw=nil);end
 
         # RFuseFS extension.
-        # Extended attributes. These will be set/retrieved/removed directly
+        # 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 [Hash] extended attributes for this 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 xattr(path); return {}; end
+        def statistics(path); [0,0,0,0]; end
 
         # RFuseFS extension.
         # Called when the filesystem is mounted

data/lib/fuse/rfusefs-fuse.rb

@@ -16,15 +16,23 @@ module FuseFS
             @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
@@ -92,6 +100,10 @@ module FuseFS
         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.
@@ -123,8 +135,8 @@ module FuseFS
 
             return wrap_context(ctx,__method__,path) if ctx
 
-            uid = Process.gid
-            gid = Process.uid
+            uid = Process.uid
+            gid = Process.gid
 
             if  path == "/" || @root.directory?(path)
                 #set "w" flag based on can_mkdir? || can_write? to path + "/._rfuse_check"
@@ -135,14 +147,13 @@ module FuseFS
                 #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 })
+                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 = @root.size(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
@@ -160,6 +171,7 @@ module FuseFS
             end
 
             @root.mkdir(path)
+            @adj_nodes += 1
         end #mkdir
 
         def mknod(ctx,path,mode,major,minor)
@@ -170,10 +182,15 @@ module FuseFS
                 raise Errno::EACCES.new(path)
             end
 
-            @created_files[path] = mode
+            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
@@ -182,10 +199,11 @@ module FuseFS
 
             if fh.raw
                 @root.raw_truncate(path,offset,fh.raw)
-            elsif (offset <= 0)
-                fh.contents = ""
-            else
-                fh.contents = fh.contents[0..offset]
+                if (offset <= 0)
+                    fh.contents = ""
+                else
+                    fh.contents = fh.contents[0..offset]
+                end
             end
         end
 
@@ -197,14 +215,16 @@ module FuseFS
                 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,"")
+                   @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
@@ -222,17 +242,15 @@ module FuseFS
             end
 
             unless fh.raw
-
                 if fh.rdonly?
                     fh.contents = @root.read_file(path)
-                elsif fh.rdwr? || fh.wronly?
+                elsif fh.writing?
                     unless @root.can_write?(path)
                         raise Errno::EACCES.new(path)
                     end
 
                     if @created_files.has_key?(path)
-                        #we have an empty file
-                        fh.contents = "";
+                        fh.create
                     else
                         if fh.rdwr? || fh.append?
                             fh.contents = @root.read_file(path)
@@ -245,9 +263,9 @@ module FuseFS
                     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)
@@ -285,7 +303,21 @@ module FuseFS
             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)
@@ -298,13 +330,11 @@ module FuseFS
                 #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
@@ -313,8 +343,10 @@ module FuseFS
                 else
                     @root.raw_close(path)
                 end
+            else
+                # Probably just had flush called, but no harm calling it again
+                flush(nil,path,ffi)
             end
-
         end
 
         #def chmod(path,mode)
@@ -327,9 +359,7 @@ module FuseFS
             return wrap_context(ctx,__method__,path,actime,modtime) if ctx
 
             #Touch...
-            if @root.respond_to?(:touch)
-                @root.touch(path,modtime)
-            end
+            @root.touch(path,modtime) if @root.respond_to?(:touch)
         end
 
         def unlink(ctx,path)
@@ -338,7 +368,10 @@ module FuseFS
             unless @root.can_delete?(path)
                 raise Errno::EACCES.new(path)
             end
-            @created_files.delete(path) 
+
+            @adj_size = @adj_size - size(path)
+
+            @created_files.delete(path)
             @root.delete(path)
         end
 
@@ -371,8 +404,8 @@ module FuseFS
         #def link(path,as)
         #end
 
-        def setxattr(ctx,path,name,value)
-            return wrap_context(ctx,__method__,path,name,value) if ctx
+        def setxattr(ctx,path,name,value,flags)
+            return wrap_context(ctx,__method__,path,name,value,flags) if ctx
             @root.xattr(path)[name]=value
         end
 
@@ -399,12 +432,46 @@ module FuseFS
         #def releasedir(path,ffi)
         #end
 
+        #
         #def fsyncdir(path,meta,ffi)
         #end
 
         # Some random numbers to show with df command
-        #def statfs(path)   
-        #end
+        # 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()
@@ -431,5 +498,9 @@ module FuseFS
         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 RFuseFS
 end #Module FuseFS

data/lib/fusefs/metadir.rb

@@ -21,9 +21,15 @@ module FuseFS
 
         DEFAULT_FS = FuseDir.new()
 
-        def initialize()
+        # @return [StatsHelper] helper for filesystem accounting (df etc)
+        attr_reader :stats
+
+        def initialize(stats = nil)
             @subdirs  = Hash.new(nil)
             @files    = Hash.new(nil)
+            @xattr   = Hash.new() { |h,k| h[k] = Hash.new }
+            @stats = stats || StatsHelper.new()
+            @stats.adjust(0,1)
         end
 
         def split_path(path)
@@ -57,6 +63,13 @@ module FuseFS
             end
         end
 
+        # Extended attributes
+        def xattr(path)
+            pathmethod(:xattr,path) do | path |
+               @xattr[path] 
+            end
+        end
+
         def read_file(path)
             pathmethod(:read_file,path) do |filename|
                 @files[filename].to_s
@@ -78,6 +91,14 @@ module FuseFS
 
         def write_to(path,contents)
             pathmethod(:write_to,path,contents) do |filename, filecontents |
+                adj_size = filecontents.to_s.length
+                adj_nodes = 1
+                if @files.has_key?(filename)
+                    adj_size = adj_size - @files[filename].to_s.length
+                    adj_nodes = 0
+                end
+                @stats.adjust(adj_size,adj_nodes)
+
                 @files[filename] = filecontents
             end
         end
@@ -91,7 +112,8 @@ module FuseFS
 
         def delete(path)
             pathmethod(:delete,path) do |filename|
-                @files.delete(filename)
+                contents = @files.delete(filename)
+                @stats.adjust(-contents.to_s.length,-1)
             end
         end
 
@@ -104,7 +126,7 @@ module FuseFS
 
         def mkdir(path,dir=nil)
             pathmethod(:mkdir,path,dir) do | dirname,dirobj |
-                dirobj ||= MetaDir.new
+                dirobj ||= MetaDir.new(@stats)
                 @subdirs[dirname] = dirobj
             end
         end
@@ -119,6 +141,7 @@ module FuseFS
         def rmdir(path)
             pathmethod(:rmdir,path) do |dirname|
                 @subdirs.delete(dirname)
+                @stats.adjust(0,-1)
             end
         end
 
@@ -135,6 +158,8 @@ module FuseFS
                 if @files.has_key?(from_base)
                     return false unless can_delete?(from_base) && to_fusefs.can_write?(to_path)
                     to_fusefs.write_to(to_path,@files[from_base])
+                    to_fusefs.xattr(to_path).merge!(@xattr[from_base])
+                    @xattr.delete(from_base)
                     @files.delete(from_base)
                 elsif @subdirs.has_key?(from_base)
                     # we don't check can_rmdir? because that would prevent us 
@@ -142,7 +167,11 @@ module FuseFS
                     return false unless mount_user? && to_fusefs.can_mkdir?(to_path)
                     begin
                         to_fusefs.mkdir(to_path,@subdirs[from_base])
+                        to_fusefs.xattr(to_path).merge!(@xattr[from_base])
+                        @xattr.delete(from_base)
                         @subdirs.delete(from_base)
+                        @stats.adjust(0,-1)
+                        return true
                     rescue ArgumentError
                         # to_rest does not support mkdir with an arbitrary object
                         return false
@@ -188,7 +217,20 @@ module FuseFS
             end
         end
 
-        default_methods = FuseDir.public_instance_methods.select { |m| 
+        # path is ignored? - recursively calculate for all subdirs - but cache and then rely on fuse to keep count
+        def statistics(path)
+            pathmethod(:statistics,path) do |stats_path|
+                if @subdirs.has_key?(stats_path)
+                    #unlike all the other functions where this metadir applies
+                    #the function to @subdirs - we need to pass it on
+                    @subdirs[stats_path].statistics("/")
+                else
+                    @stats.to_statistics
+                end
+            end
+        end
+
+        default_methods = FuseDir.public_instance_methods.select { |m|
             ![:mounted,:unmounted].include?(m) &&
                 !self.public_method_defined?(m) && FuseDir.instance_method(m).owner == FuseDir
         }