rfuse 1.0.0

data/ext/rfuse/rfuse.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+void rfuse_init(VALUE module);

data/ext/rfuse/rfuse_mod.c

@@ -0,0 +1,12 @@
+#include "rfuse.h"
+#include "filler.h"
+#include "file_info.h"
+#include "context.h"
+
+void Init_rfuse() {
+  VALUE mRFuse=rb_define_module("RFuse");
+  file_info_init(mRFuse);
+  context_init(mRFuse);
+  rfiller_init(mRFuse);
+  rfuse_init(mRFuse);
+}

data/lib/rfuse/version.rb

@@ -0,0 +1,3 @@
+module RFuse
+  VERSION = "1.0.0"
+end

data/lib/rfuse-ng.rb

@@ -0,0 +1 @@
+require 'rfuse'

data/lib/rfuse.rb

@@ -0,0 +1,211 @@
+require 'fcntl'
+require 'rfuse/version'
+require 'rfuse/rfuse'
+
+# Ruby FUSE (Filesystem in USErspace) binding
+module RFuse
+
+    # Used by listxattr
+    def self.packxattr(xattrs)
+        case xattrs
+        when Array
+            xattrs.join("\000")
+        when String
+            #assume already \0 separated list of keys
+            xattrs
+        else
+            raise RFuse::Error, ":listxattr must return Array or String, got #{xattrs.inspect}"
+        end
+    end
+
+    class Fuse
+
+        # Main processing loop
+        #
+        # Use {#exit} to stop processing (or externally call fusermount -u)
+        #
+        #
+        # Other ruby threads can continue while loop is running, however
+        # no thread can operate on the filesystem itself (ie with File or Dir methods)
+        #
+        # @return [void]
+        # @raise [RFuse::Error] if already running or not mounted
+        #
+        def loop()
+            raise RFuse::Error, "Already running!" if @running
+            raise RFuse::Error, "FUSE not mounted" unless mounted?
+            @running = true
+            while @running do
+                begin
+                    ready, ignore, errors  = IO.select([@fuse_io,@pr],[],[@fuse_io])
+
+                    if ready.include?(@pr)
+                    
+                        @pr.getc
+                        @running = false
+
+                    elsif errors.include?(@fuse_io)
+
+                        @running = false
+                        raise RFuse::Error, "FUSE error"
+
+                    elsif ready.include?(@fuse_io)
+                        if process() < 0
+                            # Fuse has been unmounted externally
+                            # TODO: mounted? should now return false
+                            # fuse_exited? is not true...
+                            @running = false
+                        end
+                    end
+                rescue Interrupt
+                    #oh well...
+                end
+            end
+        end
+
+        # Stop processing {#loop}
+        # eg called from Signal handlers, or some other monitoring thread
+        def exit
+            @pw.putc(0) 
+        end
+
+        private
+
+        # Called by the C iniitialize
+        # afer the filesystem has been mounted successfully
+        def ruby_initialize
+            @pr,@pw = IO.pipe()
+            
+            # The FD was created by FUSE so we don't want
+            # ruby to do anything with it during GC
+            @fuse_io = IO.for_fd(fd(),"r",:autoclose => false) 
+        end
+    end
+
+    #This class is useful to make your filesystem implementation
+    #debuggable and testable without needing to mount an actual filesystem
+    #or inherit from {Fuse}
+    class FuseDelegator < Fuse
+
+        # Available fuse methods -see http://fuse.sourceforge.net/doxygen/structfuse__operations.html
+        #  Note :getdir and :utime are deprecated
+        #  :ioctl, :poll are not implemented in the C extension 
+        FUSE_METHODS = [ :getattr, :readlink, :getdir, :mknod, :mkdir,
+            :unlink, :rmdir, :symlink, :rename, :link,
+            :chmod, :chown, :truncate, :utime, :open,
+            :create, :read, :write, :statfs, :flush,
+            :release, :fsync, :setxattr, :getxattr, :listxattr,:removexattr,
+            :opendir, :readdir, :releasedir, :fsycndir,
+            :init, :destroy, :access, :ftruncate, :fgetattr, :lock,
+            :utimens, :bmap, :ioctl, :poll ]
+
+        # @param [Object] fuse_object your filesystem object that responds to fuse methods
+        # @param [String] mountpoint existing directory where the filesystem will be mounted
+        # @param [String...] options fuse mount options (use "-h" to see a list)
+        # 
+        # Create and mount a filesystem
+        #
+        # If ruby debug is enabled then each call to fuse_object will be represented on $stderr
+        def initialize(fuse_object,mountpoint,*options)
+            @fuse_delegate = fuse_object
+            define_fuse_methods(fuse_object)
+            super(mountpoint,options)
+        end
+
+        private
+        def define_fuse_methods(fuse_object)
+            #Wrap all the rfuse methods in a context block
+            FUSE_METHODS.each do |method|
+                if fuse_object.respond_to?(method)
+                    method_name = method.id2name
+                    instance_eval(<<-EOM, "(__FUSE_DELEGATE__)",1)
+                    def #{method_name} (*args,&block)
+                        begin
+                            $stderr.puts "==> #{ self }.#{ method_name }(\#{args.inspect })" if $DEBUG
+                            result = @fuse_delegate.send(:#{method_name},*args,&block)
+                                                         $stderr.puts "<== #{ self }.#{ method_name }()"  if $DEBUG
+                            result
+                        rescue Exception => ex
+                            $@.delete_if{|s| /^\\(__FUSE_DELEGATE__\\):/ =~ s}
+                            $stderr.puts(ex.message) unless ex.respond_to?(:errno) || $DEBUG
+                            Kernel::raise
+                        end
+                    end
+                    EOM
+                end
+            end
+        end
+
+    end #class FuseDelegator
+
+    # Helper class to return from :getattr method
+    class Stat
+        # Format mask
+        S_IFMT   = 0170000 
+        # Directory  
+        S_IFDIR  = 0040000
+        # Character device
+        S_IFCHR  = 0020000
+        # Block device
+        S_IFBLK  = 0060000
+        # Regular file 
+        S_IFREG  = 0100000
+        # FIFO. 
+        S_IFIFO  = 0010000
+        # Symbolic link 
+        S_IFLNK  = 0120000
+        # Socket 
+        S_IFSOCK = 0140000
+
+        # @param [Fixnum] mode file permissions
+        # @param [Hash<Symbol,Fixnum>] values initial values for other attributes
+        #
+        # @return [Stat] representing a directory
+        def self.directory(mode=0,values = { })
+            return self.new(S_IFDIR,mode,values)
+        end
+
+        # @param [Fixnum] mode file permissions
+        # @param [Hash<Symbol,Fixnum>] values initial values for other attributes
+        #
+        # @return [Stat] representing a regular file
+        def self.file(mode=0,values = { })
+            return self.new(S_IFREG,mode,values)
+        end
+
+        # @return [Integer] see stat(2)
+        attr_accessor :uid,:gid,:mode,:size, :dev,:ino,:nlink,:rdev,:blksize,:blocks
+
+        # @return [Integer, Time] see stat(2)
+        attr_accessor :atime,:mtime,:ctime
+
+        def initialize(type,permissions,values = { })
+            values[:mode] = ((type & S_IFMT) | (permissions & 07777))
+            @uid,@gid,@size,@mode,@atime,@mtime,@ctime,@dev,@ino,@nlink,@rdev,@blksize,@blocks = Array.new(13,0)
+            values.each_pair do |k,v|
+                instance_variable_set("@#{ k }",v)
+            end
+        end
+    end
+
+    # Helper class to return from :statfs (eg for df output)
+    # All attributes are Integers and default to 0
+    class StatVfs
+
+        # @return [Integer]
+        attr_accessor :f_bsize,:f_frsize,:f_blocks,:f_bfree,:f_bavail
+
+        # @return [Integer]
+        attr_accessor :f_files,:f_ffree,:f_favail,:f_fsid,:f_flag,:f_namemax
+
+        # values can be symbols or strings but drop the pointless f_ prefix
+        def initialize(values={ })
+            @f_bsize, @f_frsize, @f_blocks, @f_bfree, @f_bavail, @f_files, @f_ffree, @f_favail,@f_fsid, @f_flag,@f_namemax = Array.new(13,0)
+            values.each_pair do |k,v|
+                prefix = k.startswith?("f_") ? "" : "f_"
+                instance_variable_set("@#{prefix}#{k}",v)
+            end
+        end
+    end
+
+end #Module RFuse

data/lib/rfuse_ng.rb

@@ -0,0 +1,3 @@
+# only here because of old version with odd naming (dash/underscore)
+
+require 'rfuse'

data/rfuse.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rfuse/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rfuse"
+  s.version     = RFuse::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Grant Gardner"]
+  s.email       = ["grant@lastweekend.com.au"]
+  s.homepage    = "http://rubygems.org/gems/rfuse"
+  s.summary     = %q{Ruby language binding for FUSE}
+  s.description = %q{Ruby language binding for FUSE. It was forked from rfuse and modified for Ruby 1.9.2.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.extensions    = 'ext/rfuse/extconf.rb'
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("yard")
+  s.add_development_dependency("redcarpet")
+  s.add_development_dependency("ffi-xattr")
+end

data/sample/test-ruby.rb

@@ -0,0 +1,339 @@
+#!/usr/bin/ruby
+
+# TestFS for RFuse
+
+require "rfuse"
+
+class MyDir < Hash
+    attr_accessor :name, :mode , :actime, :modtime, :uid, :gid
+    def initialize(name,mode)
+        @uid=0
+        @gid=0
+        @actime=Time.now
+        @modtime=Time.now
+        @xattr=Hash.new
+        @name=name
+        @mode=mode
+    end
+
+    def stat
+        RFuse::Stat.directory(mode,:uid => uid, :gid => gid, :atime => actime, :mtime => modtime,
+                              :size => size)
+    end
+
+    def listxattr()
+        @xattr.keys()
+    end
+    def setxattr(name,value,flag)
+        @xattr[name]=value #TODO:don't ignore flag
+    end
+    def getxattr(name)
+        return @xattr[name]
+    end
+    def removexattr(name)
+        @xattr.delete(name)
+    end
+    def size
+        return 48 #for testing only
+    end
+    def isdir
+        true
+    end
+    def insert_obj(obj,path)
+        d=self.search(File.dirname(path))
+        if d.isdir then
+            d[obj.name]=obj
+        else
+            raise Errno::ENOTDIR.new(d.name)
+        end
+        return d
+    end
+    def remove_obj(path)
+        d=self.search(File.dirname(path))
+        d.delete(File.basename(path))
+    end
+    def search(path)
+        p=path.split('/').delete_if {|x| x==''}
+        if p.length==0 then
+            return self
+        else
+            return self.follow(p)
+        end
+    end
+    def follow (path_array)
+        if path_array.length==0 then
+            return self
+        else
+            d=self[path_array.shift]
+            if d then
+                return d.follow(path_array)
+            else
+                raise Errno::ENOENT.new
+            end
+        end
+    end
+    def to_s
+        return "Dir: " + @name + "(" + @mode.to_s + ")"
+    end
+end
+
+class MyFile
+    attr_accessor :name, :mode, :actime, :modtime, :uid, :gid, :content
+    def initialize(name,mode,uid,gid)
+        @actime=0
+        @modtime=0
+        @xattr=Hash.new
+        @content=""
+        @uid=uid
+        @gid=gid
+        @name=name
+        @mode=mode
+    end
+
+    def stat
+        RFuse::Stat.file(mode,:uid => uid, :gid => gid, :atime => actime, :mtime => modtime,
+                         :size => size)
+    end
+
+    def listxattr()
+        @xattr.keys
+    end
+
+    def setxattr(name,value,flag)
+        @xattr[name]=value #TODO:don't ignore flag
+    end
+
+    def getxattr(name)
+        return @xattr[name]
+    end
+    def removexattr(name)
+        @xattr.delete(name)
+    end
+    def size
+        return content.size
+    end 
+    def isdir
+        false
+    end
+    def follow(path_array)
+        if path_array.length != 0 then
+            raise Errno::ENOTDIR.new
+        else
+            return self
+        end
+    end
+    def to_s
+        return "File: " + @name + "(" + @mode.to_s + ")"
+    end
+end
+
+class MyFuse 
+
+    def initialize(root)
+        @root=root
+    end
+
+    # The new readdir way, c+p-ed from getdir
+    def readdir(ctx,path,filler,offset,ffi)
+        d=@root.search(path)
+        if d.isdir then
+            d.each {|name,obj| 
+                filler.push(name,obj.stat,0)
+            }
+        else
+            raise Errno::ENOTDIR.new(path)
+        end
+    end
+
+    def getattr(ctx,path)
+        d = @root.search(path)
+        return d.stat
+    end #getattr
+
+    def mkdir(ctx,path,mode)
+        @root.insert_obj(MyDir.new(File.basename(path),mode),path)
+    end #mkdir
+
+    def mknod(ctx,path,mode,major,minor)
+        @root.insert_obj(MyFile.new(File.basename(path),mode,ctx.uid,ctx.gid),path)
+    end #mknod
+
+    def open(ctx,path,ffi)
+    end
+
+    #def release(ctx,path,fi)
+    #end
+
+    #def flush(ctx,path,fi)
+    #end
+
+    def chmod(ctx,path,mode)
+        d=@root.search(path)
+        d.mode=mode
+    end
+
+    def chown(ctx,path,uid,gid)
+        d=@root.search(path)
+        d.uid=uid
+        d.gid=gid
+    end
+
+    def truncate(ctx,path,offset)
+        d=@root.search(path)
+        d.content = d.content[0..offset]
+    end
+
+    def utime(ctx,path,actime,modtime)
+        d=@root.search(path)
+        d.actime=actime
+        d.modtime=modtime
+    end
+
+    def unlink(ctx,path)
+        @root.remove_obj(path)
+    end
+
+    def rmdir(ctx,path)
+        @root.remove_obj(path)
+    end
+
+    #def symlink(ctx,path,as)
+    #end
+
+    def rename(ctx,path,as)
+        d = @root.search(path)
+        @root.remove_obj(path)
+        @root.insert_obj(d,path)
+    end
+
+    #def link(ctx,path,as)
+    #end
+
+    def read(ctx,path,size,offset,fi)
+        d = @root.search(path)
+        if (d.isdir) 
+            raise Errno::EISDIR.new(path)
+            return nil
+        else
+            return d.content[offset..offset + size - 1]
+        end
+    end
+
+    def write(ctx,path,buf,offset,fi)
+        d=@root.search(path)
+        if (d.isdir) 
+            raise Errno::EISDIR.new(path)
+        else
+            d.content[offset..offset+buf.length - 1] = buf
+        end
+        return buf.length
+    end
+
+    def setxattr(ctx,path,name,value,size,flags)
+        d=@root.search(path)
+        d.setxattr(name,value,flags)
+    end
+
+    def getxattr(ctx,path,name)
+        d=@root.search(path)
+        if (d) 
+            value=d.getxattr(name)
+            if (!value)
+                value=""
+                #raise Errno::ENOENT.new #TODO raise the correct error :
+                #NOATTR which is not implemented in Linux/glibc
+            end
+        else
+            raise Errno::ENOENT.new
+        end
+        return value
+    end
+
+    def listxattr(ctx,path)
+        d=@root.search(path)
+        value= d.listxattr()
+        return value
+    end
+
+    def removexattr(ctx,path,name)
+        d=@root.search(path)
+        d.removexattr(name)
+    end
+
+    #def opendir(ctx,path,ffi)
+    #end
+
+    #def releasedir(ctx,path,ffi)
+    #end
+
+    #def fsyncdir(ctx,path,meta,ffi)
+    #end
+
+    # Some random numbers to show with df command
+    def statfs(ctx,path)
+        s = RFuse::StatVfs.new()
+        s.f_bsize    = 1024
+        s.f_frsize   = 1024
+        s.f_blocks   = 1000000
+        s.f_bfree    = 500000
+        s.f_bavail   = 990000
+        s.f_files    = 10000
+        s.f_ffree    = 9900
+        s.f_favail   = 9900
+        s.f_fsid     = 23423
+        s.f_flag     = 0
+        s.f_namemax  = 10000
+        return s
+    end
+
+    def ioctl(ctx, path, cmd, arg, ffi, flags, data)
+        # FT: I was not been able to test it.
+        print "*** IOCTL: command: ", cmd, "\n"
+    end
+
+    def poll(ctx, path, ffi, ph, reventsp)
+        print "*** POLL: ", path, "\n"
+        # This is how we notify the caller if something happens:
+        ph.notifyPoll();
+        # when the GC harvests the object it calls fuse_pollhandle_destroy
+        # by itself.
+    end
+
+    def init(ctx,rfuseconninfo)
+        print "RFuse TestFS started\n"
+        print "init called\n"
+        print "proto_major:#{rfuseconninfo.proto_major}\n"
+    end
+
+end #class Fuse
+
+if ARGV.length == 0
+    print "\n"
+    print "Usage: [ruby [--debug]] #{$0} mountpoint [mount_options...]\n"
+    print "\n"
+    print "   mountpoint must be an existing directory\n"
+    print "   mount_option '-h' will list supported options\n"
+    print "\n"
+    print "   For verbose debugging output use --debug to ruby\n"
+    print "   and '-odebug' as mount_option\n"
+    print "\n"
+    exit(1)
+end
+
+fs = MyFuse.new(MyDir.new("",0777));
+
+fo = RFuse::FuseDelegator.new(fs,*ARGV)
+
+if fo.mounted?
+    Signal.trap("TERM") { print "Caught TERM\n" ; fo.exit }
+    Signal.trap("INT") { print "Caught INT\n"; fo.exit }
+
+    begin
+        fo.loop
+    rescue
+        print "Error:" + $!
+    ensure
+        fo.unmount if fo.mounted?
+        print "Unmounted #{ARGV[0]}\n"
+    end
+end