rfusefs 1.0.0 → 1.0.1.RC0

data/lib/rfusefs.rb

@@ -8,6 +8,59 @@ require 'rfusefs/version'
 module FuseFS
     @mounts = { }
 
+    # Convenience method to launch a FuseFS filesystem with nice error messages
+    #
+    # @param [Array<String>] argv command line arguments
+    # @param [Array<Symbol>] options list of additional options
+    # @param [String] option_usage describing additional option usage
+    # @param [String] device a description of the device field
+    # @param [String] exec the executable file
+    #
+    # @yieldparam [Hash<Symbol,String>] options
+    #   options parsed from ARGV including...
+    #     * :device - the optional mount device
+    #     * :mountpoint - required mountpoint
+    #     * :help - true if -h was supplied
+    #
+    # @yieldreturn [FuseDir] an RFuseFS filesystem
+    #
+    # @example
+    #   MY_OPTIONS = [ :myfs ]
+    #   OPTION_USAGE = "  -o myfs=VAL how to use the myfs option"
+    #
+    #   # Normally from the command line...
+    #   ARGV = [ "some/device", "/mnt/point", "-h", "-o", "debug,myfs=aValue" ]
+    #
+    #   FuseFS.main(ARGV, MY_OPTIONS, OPTION_USAGE, "/path/to/somedevice", $0) do |options|
+    #
+    #       # options ==
+    #          { :device => "some/device",
+    #            :mountpoint => "/mnt/point",
+    #            :help => true,
+    #            :debug => true,
+    #            :myfs => "aValue"
+    #          }
+    #
+    #       fs = MyFS.new(options)
+    #   end
+    #
+    def FuseFS.main(argv=ARGV,options=[],option_usage="",device=nil,exec=File.basename($0))
+        options = RFuse.parse_options(argv,*options)
+
+        if options[:mountpoint]
+            fs = yield options
+
+            puts RFuse.usage(device,exec) if options[:help] || !fs
+            puts "Options:\n"  if options[:help]
+
+            FuseFS.start(fs,*argv) if fs || options[:help] 
+
+            puts option_usage if options[:help]
+        else
+            puts "rfusefs: failed, no mountpoint provided",RFuse.usage(device,exec)
+        end
+    end
+
     # Start the FuseFS root at mountpoint with opts. 
     # @param [Object] root see {set_root}
     # @param mountpoint [String] {mount_under}
@@ -15,7 +68,6 @@ module FuseFS
     # @note RFuseFS extension
     # @return [void]
     def FuseFS.start(root,mountpoint,*opts)
-        print "Starting FuseFS #{root} at #{mountpoint} with #{opts}\n"
         Signal.trap("TERM") { FuseFS.exit() }
         Signal.trap("INT") { FuseFS.exit() }
         FuseFS.set_root(root)
@@ -89,7 +141,9 @@ module FuseFS
     #       you cannot access your filesystem using ruby File operations.
     # @note RFuseFS extension
     def FuseFS.run
+        @fs.mounted()
         @fuse.loop if @fuse.mounted? 
+        @fs.unmounted()
     end
 
     #  Exit the run loop and teardown FUSE   

data/rfusefs.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rfusefs/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rfusefs"
+  s.version     = RFuseFS::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Grant Gardner"]
+  s.email       = ["grant@lastweekend.com.au"]
+  s.homepage    = "http://rubygems.org/gems/rfusefs"
+  s.summary     = %q{Filesystem in Ruby Userspace}
+  s.description = %q{A more Ruby like way to write FUSE filesystems - inspired by (compatible with) FuseFS, implemented over RFuse}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,spec-fusefs}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.has_rdoc = 'yard'
+  s_extra_rdoc_files = 'History.rdoc'
+
+  s.add_dependency("rfuse", ">= 1.0.4RC0")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("yard")
+  s.add_development_dependency("redcarpet")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("rb-inotify")
+end

data/spec/metadir_spec.rb

@@ -220,44 +220,44 @@ describe FuseFS::MetaDir do
     
   end
   context "in a mounted FUSE filesystem" do
+
+    let(:mountpoint) { Pathname.new(Dir.mktmpdir(["rfusefs","metadir"])) }
+    let(:metadir) { FuseFS::MetaDir.new() }
+    let(:testdir) { mountpoint + "test" }
+    let(:testfile) { testdir + "hello.txt" }
+
 	before(:all) do
-		tmpdir = Pathname.new(Dir.tmpdir) + "rfusefs"
-		tmpdir.mkdir unless tmpdir.directory?
-		@mountpoint = tmpdir + "metadir_spec"
-        puts "#{@mountpoint}"
-		@mountpoint.mkdir unless @mountpoint.directory?
-		@metadir = FuseFS::MetaDir.new()
-        @metadir.mkdir("/test")
-        @metadir.write_to("/test/hello.txt","Hello World!\n")
-		FuseFS.mount(@metadir,@mountpoint)
-        @testdir = (@mountpoint + "test")
-        @testfile = (@testdir + "hello.txt")
+        metadir.mkdir("/test")
+        metadir.write_to("/test/hello.txt","Hello World!\n")
+		FuseFS.mount(metadir,mountpoint)
 		#Give FUSE some time to get started 
-		sleep(1)
+		sleep(0.5)
 	end
 	
 	after(:all) do
-		FuseFS.unmount(@mountpoint)
+		FuseFS.unmount(mountpoint)
+        sleep(0.5)
+        FileUtils.rm_r(mountpoint)
 	end
 	
     it "should list directory contents" do
-		@testdir.entries().should =~ pathnames(".","..","hello.txt")
+		testdir.entries().should =~ pathnames(".","..","hello.txt")
     end
 
     it "should read files" do
-        @testfile.file?.should be_true
-		@testfile.read().should == "Hello World!\n"
+        testfile.file?.should be_true
+		testfile.read().should == "Hello World!\n"
     end
 
     it "should create directories" do
-        newdir = @testdir + "newdir"
+        newdir = testdir + "newdir"
         newdir.mkdir()
         newdir.directory?.should be_true
-        @testdir.entries().should =~ pathnames(".","..","hello.txt","newdir")
+        testdir.entries().should =~ pathnames(".","..","hello.txt","newdir")
     end
 
     it "should create files" do
-        newfile = @testdir + "newfile"
+        newfile = testdir + "newfile"
         newfile.open("w") do |file|
             file << "A new file\n"
         end
@@ -265,14 +265,14 @@ describe FuseFS::MetaDir do
     end
 
     it "should move directories" do
-        fromdir = @testdir + "fromdir"
+        fromdir = testdir + "fromdir"
         fromdir.mkdir()
         subfile = fromdir + "afile"
         subfile.open("w") do |file|
            file << "testfile\n"
         end
 
-        movedir = (@mountpoint + "movedir")
+        movedir = (mountpoint + "movedir")
         movedir.directory?.should be_false
         fromdir.rename(movedir)
         movedir.directory?.should be_true
@@ -283,10 +283,10 @@ describe FuseFS::MetaDir do
     end
 
     it "should move files" do
-        movefile = (@mountpoint + "moved.txt")
+        movefile = (mountpoint + "moved.txt")
         movefile.file?.should be_false
-        @testfile.should be_true
-        @testfile.rename(movefile)
+        testfile.should be_true
+        testfile.rename(movefile)
         movefile.read.should == "Hello World!\n"
     end
 

data/spec/mount_unmount_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'rfusefs'
+require 'tmpdir'
+require 'pathname'
+
+describe "a mounted FuseFS" do
+    let(:mountpoint) { Pathname.new(Dir.mktmpdir("rfusefs_mount_unmount")) }
+
+    after(:each) { FileUtils.rmdir mountpoint }
+
+    it "should get mounted and unmounted callbacks" do
+        mock_fs = FuseFS::FuseDir.new()
+        mock_fs.should_receive(:mounted)
+        mock_fs.should_receive(:unmounted)
+
+        t = Thread.new { sleep 0.5 ; puts "exiting" ; FuseFS.exit }
+        FuseFS.start(mock_fs,mountpoint)
+        t.join
+    end
+end
+

data/spec/pathmapper_spec.rb

@@ -1,112 +1,202 @@
 #Pathmapper is hard to test because it is difficult to mock Dir/Pathname/File etc...
 require "spec_helper"
 require "fusefs/pathmapper"
+require 'tmpdir'
+require 'pathname'
 
-describe FuseFS::PathMapperFS do
-  before(:all) do 
-	   @tmpdir = mktmpdir("pathmapper")
-       #create directory
-       pathmap(@tmpdir + "hello.txt","/textfiles/hello")
-       pathmap(@tmpdir + "mysong.mp3","/artist/album/mysong.mp3")
-       pathmap(@tmpdir + "apicture.jpeg","/pictures/201103/apicture.jpg")
-       @pathmapFS = FuseFS::PathMapperFS.create(@tmpdir) do |file|
+class PMFixture
+    attr_reader :tmpdir
+
+    def initialize()
+        @tmpdir = Pathname.new(Dir.mktmpdir("rfusefs_pathmapper"))
+        pathmap(@tmpdir + "hello.txt","/textfiles/hello")
+        pathmap(@tmpdir + "mysong.mp3","/artist/album/mysong.mp3")
+        pathmap(@tmpdir + "apicture.jpeg","/pictures/201103/apicture.jpg")
+    end
+
+    def pathmap(real_file,mapped_path)
+        File.open(real_file.to_s,"w") do |f|
+            f << mapped_path
+        end
+    end
+
+    def fs
+        @fs ||= FuseFS::PathMapperFS.create(@tmpdir) do |file|
             File.file?(file) ? IO.read(file.to_s) : nil
-       end
-  end
-
-  context "in ruby" do
-   
-    context "standard mapping" do
-       
-        it "should map files and directories" do
+        end
+    end
+
+    def mount()
+        return @mountpoint if @mountpoint
+        @mountpoint = Pathname.new(Dir.mktmpdir("rfusefs_pathmapper_mnt"))
+        FuseFS.mount(fs,@mountpoint)
+        sleep(0.5) 
+        @mountpoint
+    end
+
+    def cleanup
+        if @mountpoint
+            FuseFS.unmount(@mountpoint) 
+            sleep(0.5)
+            FileUtils.rmdir(@mountpoint)
+        end
+        FileUtils.rm_r(@tmpdir)
+    end
+end
+
+
+describe FuseFS::PathMapperFS do
+    before(:each) do 
+        @fixture = PMFixture.new
+        @tmpdir = @fixture.tmpdir
+        @pathmapFS = @fixture.fs
+    end
+
+    after(:each) do
+        @fixture.cleanup
+    end
+
+    context "fusefs api" do
+
+        it "maps files and directories" do
             @pathmapFS.directory?("/").should be_true
             @pathmapFS.directory?("/textfiles").should be_true
             @pathmapFS.directory?("/pictures/201103").should be_true
             @pathmapFS.file?("/textfiles/hello").should be_true
+            @pathmapFS.directory?("/textfiles/hello").should be_false
             @pathmapFS.file?("/artist/album/mysong.mp3").should be_true
+            @pathmapFS.directory?("/artist/album/mysong.mp3").should be_false
+            @pathmapFS.file?("/some/unknown/path").should be_false
+            @pathmapFS.directory?("/some/unknown/path").should be_false
         end
-            
-        it "should list the mapped contents of directories" do
+
+        it "lists the mapped contents of directories" do
             @pathmapFS.contents("/").should =~ [ "textfiles","artist","pictures" ]
             @pathmapFS.contents("/artist").should =~ [ "album" ]
             @pathmapFS.contents("/textfiles").should =~ [ "hello" ]
         end
 
-        it "should report the size of a file" do
+        it "reports the size of a file" do
             @pathmapFS.size("/textfiles/hello").should == 16
         end
 
-        it "should report the atime,mtime and ctime of the mapped file" do
+        it "reads the contents of a file" do
+            @pathmapFS.read_file("/textfiles/hello").should == "/textfiles/hello"
+        end
+
+        it "does not allow writes" do
+            @pathmapFS.can_write?("/textfiles/hello").should be_false
+        end
+
+        it "reports the atime,mtime and ctime of the mapped file" do
             atime,mtime,ctime = @pathmapFS.times("/pictures/201103/apicture.jpg")
             picture = @tmpdir + "apicture.jpeg"
             atime.should == picture.atime()
             mtime.should == picture.mtime()
             ctime.should == picture.ctime()
         end
-    end
 
-    context "writing to a pathmapped FS" 
-    context "using raw access" 
+        it "reports filesystem statistics"
+
+        context "writing to a pathmapped FS" do
+            before(:each) do
+                @pathmapFS.allow_write=true
+                @pathmapFS.write_to("textfiles/hello","updated content")
+            end
+
+            it "updates the contents of the real file" do
+                hello_path = @tmpdir + "hello.txt"
+                hello_path.read.should == "updated content"
+            end
+
+            it "updates the contents of the mapped file" do
+                @pathmapFS.read_file("textfiles/hello").should == "updated content"
+            end
+
+            it "changes the reported file size" do
+                @pathmapFS.size("textfiles/hello").should == 15
+            end
+
+            it "changes the filesystem statistics"
+        end
+
+    end
 
     context "a real Fuse mounted filesystem" do
-        before(:all) do
-		    @mountpoint = Pathname.new(Dir.tmpdir) + "rfusefs-pathmapper"
-		    @mountpoint.mkdir unless @mountpoint.directory?
-            @pathmapFS.use_raw_file_access = true
-            FuseFS.mount(@pathmapFS,@mountpoint)
-            sleep(1)
+        before(:each) do
+            @pathmapFS.allow_write=true
+            @mountpoint = @fixture.mount
         end
 
-        it "should map files and directories" do
+        it "maps files and directories" do
             (@mountpoint + "textfiles").directory?.should be_true
-            (@mountpoint + "pictures/201103").directory?.should be_true
             (@mountpoint + "textfiles/hello").file?.should be_true
-            (@mountpoint + "artist/album/mysong.mp3").file?.should be_true
         end
 
-        it "should list the mapped contents of directories" do
-           (@mountpoint + "textfiles").entries.should =~ pathnames(".","..","hello")
+        it "lists the mapped contents of directories" do
+            (@mountpoint + "textfiles").entries.should =~ pathnames(".","..","hello")
         end
 
-        it "should represent the stat information of the underlying files" do
+        it "represents the stat information of the underlying files" do
             hellopath=(@mountpoint + "textfiles/hello")
             realpath=(@tmpdir + "hello.txt")
             mappedstat = hellopath.stat
             realstat = realpath.stat
             mappedstat.size.should == realstat.size
-            puts "#{realstat.atime.to_f},#{mappedstat.atime.to_f}"
             mappedstat.atime.should == realstat.atime 
             mappedstat.mtime.should == realstat.mtime
             mappedstat.ctime.should == realstat.ctime
         end
 
-        it "should read the files" do
-            hellopath = (@mountpoint + "textfiles/hello")
+        it "reads the files" do
+            hellopath= @mountpoint + "textfiles/hello"
             hellopath.read.should == "/textfiles/hello"
-            hellopath.open do |f|
+        end
+
+        it "writes the files" do
+            hellopath= @mountpoint + "textfiles/hello"
+            real_path = @tmpdir + "hello.txt"
+            hellopath.open("w") do |f|
+                f.print "updated content"
+            end 
+            hellopath.read.should == "updated content"
+            real_path.read.should == "updated content"
+        end
+    end
+
+    context "a real Fuse mount with raw file access" do
+
+        before(:each) do
+            @pathmapFS.use_raw_file_access = true
+            @pathmapFS.allow_write = true
+            @mountpoint = @fixture.mount
+        end
+
+        it "reads files" do
+            hello_path = (@mountpoint + "textfiles/hello")
+            hello_path.open do |f|
                 f.seek(2)
                 f.read(3).should == "ext"
             end
-            hellopath.sysopen do |f|
+
+            hello_path.sysopen do |f|
                 f.sysseek(1)
                 f.sysread(3).should == "tex"
             end
         end
 
-
-        after(:all) do
-            FuseFS.unmount(@mountpoint)
+        it "writes files" do
+            hello_path = (@mountpoint + "textfiles/hello")
+            real_path = @tmpdir + "hello.txt"
+            hello_path.open("r+") do |f|
+                f.sysseek(2)
+                f.syswrite("zzz")
+                f.sysseek(0)
+                f.sysread(6).should == "/tzzzf"
+            end 
+
+            real_path.read.should == "/tzzzfiles/hello"   
         end
 
     end
-
-
-  
-  end
-  
-  after(:all) do
-    FileUtils.rm_rf(@tmpdir.to_s)
-  end
-
- 
 end

data/spec/rfusefs_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe FuseFS do
+  
   TEST_FILE = "/aPath/aFile" 
   TEST_DIR = "/aPath"
   ROOT_PATH = "/"
@@ -41,7 +42,7 @@ describe FuseFS do
       @mock_fuse = FuseFS::FuseDir.new()
       @fuse = FuseFS::RFuseFS.new(@mock_fuse)
     end
-    
+
     describe :readdir do
       before(:each) do
         @mock_fuse.should_receive(:contents).with("/apath").and_return(["afile"])
@@ -390,7 +391,28 @@ describe FuseFS do
         end
 
     end
+    context "extended attributes" do
+
+        let(:xattr) { {} }
+        before(:each) { @mock_fuse.stub!(:xattr).with(TEST_FILE).and_return(xattr) }
+
+        it "should get, set and list attributes" do
+           xattr["user.one"] = "xattr one"
+           
+           @fuse.getxattr(nil,TEST_FILE,"user.one").should == "xattr one"
+           @fuse.setxattr(nil,TEST_FILE,"user.two","xattr two")
+           xattr["user.two"].should == "xattr two"
+           @fuse.listxattr(nil,TEST_FILE).should =~ [ "user.one", "user.two" ]
+           @fuse.removexattr(nil,TEST_FILE,"user.two")
+           xattr.keys.should =~ [ "user.one" ]
+        end
+
+        it "should raise ENODATA is no attribute is available" do
+            lambda{@fuse.getxattr(nil,TEST_FILE,"user.xxxx") }.should raise_error(Errno::ENODATA)
+        end
 
+
+    end
   end
   
   describe "a FuseFS filesystem with gid/uid specific behaviour" do

data/spec/sample_spec.rb

@@ -5,26 +5,26 @@ require 'pathname'
 require 'hello'
 
 describe "Access Hello World sample from Ruby file operations" do
+    let(:mountpoint) { Pathname.new(Dir.mktmpdir("rfusefs_sample")) }
+
 	before(:all) do
-		tmpdir = Pathname.new(Dir.tmpdir) + "rfusefs"
-		tmpdir.mkdir unless tmpdir.directory?
-		@mountpoint = tmpdir + "sample_spec"
-		@mountpoint.mkdir unless @mountpoint.directory?
 		hello = HelloDir.new()
-		FuseFS.mount(hello,@mountpoint)
+		FuseFS.mount(hello,mountpoint)
 		#Give FUSE some time to get started 
-		sleep(1)
+		sleep(0.5)
 	end
 	
 	after(:all) do
-		FuseFS.unmount(@mountpoint)
+		FuseFS.unmount(mountpoint)
+        sleep(0.5)
+        FileUtils.rmdir(mountpoint)
 	end
 	
 	it "should list expected root directory contents" do
-		Dir.entries(@mountpoint.to_s).should =~ [".","..","hello.txt"]
+		Dir.entries(mountpoint.to_s).should =~ [".","..","hello.txt"]
 	end
 	
 	it "should output the expected sample contents" do
-		(@mountpoint + "hello.txt").read().should == "Hello, World!\n"
+		(mountpoint + "hello.txt").read().should == "Hello, World!\n"
 	end
 end

data/spec/spec_helper.rb

@@ -30,11 +30,6 @@ module RFuseFSHelper
        FuseContext.new(uid,gid)
     end
 
-    def pathmap(real_file,mapped_path)
-       File.open(real_file.to_s,"w") do |f|
-            f << mapped_path
-       end
-    end
 
     def mktmpdir(name)
 		tmpdir = Pathname.new(Dir.tmpdir) + "rfusefs"