rfuse 1.0.5 → 1.1.0.RC0

data/spec/basic_spec.rb

@@ -12,7 +12,6 @@ describe RFuse::Fuse do
 
     context "links" do
         it "should create and resolve symbolic links"
-
         it "should create and resolve hard links"
 
     end
@@ -31,9 +30,9 @@ describe RFuse::Fuse do
 
         it "should list directories" do
 
-            mockfs.should_receive(:readdir) do | ctx, path, filler,offset,ffi | 
+            mockfs.should_receive(:readdir) do | ctx, path, filler,offset,ffi |
                 filler.push("hello",nil,0)
-            filler.push("world",nil,0)
+                filler.push("world",nil,0)
             end
 
             with_fuse(mountpoint,mockfs) do
@@ -93,7 +92,7 @@ describe RFuse::Fuse do
         it "should set file access and modification times subsecond resolution" do
             atime,mtime = usec_times(60,600)
 
-            atime_ns = (atime.to_i * (10**9)) + (atime.nsec) 
+            atime_ns = (atime.to_i * (10**9)) + (atime.nsec)
             mtime_ns = (mtime.to_i * (10**9)) + (mtime.nsec)
 
             mockfs.stub(:getattr).with(anything(),"/usec").and_return(file_stat)
@@ -169,7 +168,6 @@ describe RFuse::Fuse do
                     val = f.gets
                     val.should == "\000\000"
                     val.size.should == 2
-                    puts val
                 end
             end
         end
@@ -192,7 +190,7 @@ describe RFuse::Fuse do
         it "should report filesystem statistics" do
             mockfs.stub(:getattr).with(anything(),"/test").and_return(dir_stat)
             mockfs.stub(:getattr).with(anything(),"/test/statfs").and_return(file_stat)
-            
+
             mockfs.should_receive(:statfs).with(anything(),"/test/statfs").and_return(statvfs)
 
             #also exercise StatVfs

data/spec/fuse_file_info_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe RFuse::Fuse do
-    
+
     let(:dir_stat) { RFuse::Stat.directory(0444) }
     let(:file_stat) { RFuse::Stat.file(0444) }
     let!(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil); m }
     let(:mountpoint) { tempmount() }
     let(:open_files) { Hash.new() }
-    
+
     it "should pass fileinfo to #release" do
 
         file_handle = Object.new()
@@ -18,15 +18,15 @@ describe RFuse::Fuse do
 
         mockfs.should_receive(:open).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
            stored_ffi = ffi
-           ffi.fh = file_handle 
+           ffi.fh = file_handle
         }
-      
+
         mockfs.should_receive(:release).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
             # the return value of release is ignore, so exceptions here are lost
             begin
                 ffi.fh.should == file_handle
                 ffi.should == stored_ffi
-            rescue Exception => ex
+            rescue => ex
                 captured_ex = ex
             end
         }
@@ -64,7 +64,7 @@ describe RFuse::Fuse do
                 f2 = File.new("#{mountpoint}/two")
 
                 val = f1.gets
-                val.should == "hello world" 
+                val.should == "hello world"
                 f2.gets.should == "hello world"
 
                 f1.close()

data/spec/main_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+class MockFuse < RFuse::Fuse; end
+class DuckFuse
+    def initialize(val); end;
+end
+
+describe RFuse do
+
+    # required to capture stderr output of help text from C: library functions
+    matcher :print_to_stderr do |expected|
+        supports_block_expectations
+
+        match do |actual|
+            #$stdout.puts "STDERR=#{$stderr} #{$stderr.fileno}"
+            @captured = File.open(Dir.tmpdir + "/rfuse.stderr","w+") do |f|
+                f.sync
+                old_stderr = STDERR.dup
+                old_f = f.dup
+                begin
+                    STDERR.reopen(f)
+                    actual.call
+                ensure
+                    STDERR.reopen(old_stderr)
+                end
+                old_f.rewind
+                old_f.read
+            end
+            expected.match(@captured)
+        end
+
+        match_when_negated do |actual|
+            !matches?(actual)
+        end
+
+        failure_message do
+            "Expected stderr output...\n#{@captured}\nto match RE - #{expected}"
+        end
+
+        failure_message_when_negated do
+            "Expected stderr output...\n#{@captured}\nto not match RE - #{expected}"
+        end
+    end
+
+    let(:mockfs) { m = double("fuse"); m.stub(:getattr).and_return(nil); m }
+    let(:mountpoint) { tempmount() }
+
+    describe ".main" do
+
+        let(:re_usage) { Regexp.new("^Usage:\n.*-h.*-d.*\n",Regexp::MULTILINE)  }
+        let(:re_help)  { Regexp.new("^Fuse options: \\(\\d.\\d\\)\n.*help.*\n.*debug.*\n\n",Regexp::MULTILINE) }
+        let(:re_fuse)  { Regexp.new(".*(^\\s+-o.*$)+.*",Regexp::MULTILINE) }
+        let(:re_extra_header) { Regexp.new("Filesystem options:\n",Regexp::MULTILINE) }
+
+        # self.main(argv=ARGV,extra_options=[],extra_option_usage="",device=nil,exec=File.basename($0))
+        context "with no mountpoint" do
+            it "prints usage information to stdout" do
+                expect { RFuse.main([]) { } }.to output(re_usage).to_stdout
+            end
+            it "prints mountpoint failure on stderr" do
+                expect { RFuse.main([]) { } }.to output("rfuse: failed, no mountpoint provided\n").to_stderr
+            end
+        end
+
+        context "with help option" do
+            it "does not start filesystem" do
+                expect(mockfs).to receive(:init).exactly(0).times
+                RFuse.main([mountpoint,"-h"]) { mockfs }
+            end
+
+            it "prints usage and kernel options" do
+                # TODO: In Fuse 3.0, this will get complicated because help output moves to stdout
+                re = Regexp.new(re_help.to_s + re_fuse.to_s)
+                expect { RFuse.main([mountpoint,"-h"]) { mockfs } }.to print_to_stderr(re)
+            end
+
+            it "does not print filesystem options header if no extra options" do
+                re = Regexp.new(re_help.to_s + re_fuse.to_s + re_extra_header.to_s)
+                expect { RFuse.main([mountpoint,"-h"]) { mockfs } }.not_to print_to_stderr(re)
+            end
+
+            it "prints local option header if there are local options" do
+                re = Regexp.new(re_help.to_s + re_fuse.to_s + re_extra_header.to_s + "TestOptionUsage")
+                expect { RFuse.main([mountpoint,"-h"],[:myoption],"TestOptionUsage") { mockfs } }.to print_to_stderr(re)
+            end
+
+        end
+
+        it "yields parsed options and cleaned argv" do
+            # We know that main uses parse_options which is tested elsewhere
+            expect { |b| RFuse.main([mountpoint,"-o","myoption"],[:myoption],&b) }.to \
+                yield_with_args(a_hash_including(:mountpoint,:myoption),[mountpoint])
+        end
+
+        context "yield raises exception" do
+            it "prints usage output" do
+                expect { RFuse.main([mountpoint]) { raise RFuse::Error, "MyError"}}.to output(re_usage).to_stdout
+            end
+
+            it "prints the error message" do
+                expect { RFuse.main([mountpoint]) { raise RFuse::Error, "MyError"}}.to output("rfuse failed: MyError\n").to_stderr
+            end
+        end
+
+        it "creates and runs the yielded Fuse filesystem" do
+            # We test create and run separately
+            # expect RFuse.create then mounted? and run
+            fuse = double(fuse)
+            fuse.stub(:mounted?).and_return(true,false)
+            expect(fuse).to receive(:run)
+            expect(RFuse).to receive(:create).with(fuse,[mountpoint],{:mountpoint => mountpoint},[]) { fuse }
+            RFuse.main([mountpoint]) { fuse }
+        end
+    end
+
+    describe ".create" do
+        let(:argv) { [mountpoint] }
+        context "with a Fuse object" do
+            let(:fs) { MockFuse.new(mountpoint) }
+            it "returns the object" do
+                fuse = RFuse.create(fs)
+                expect(fuse).to be(fs)
+                expect(fuse).to be_mounted
+            end
+        end
+
+        context "with a subclass of Fuse" do
+            let(:fs) { MockFuse }
+
+            it "creates a new Fuse object from subclass of Fuse" do
+                fuse = RFuse.create(fs,[mountpoint])
+                expect(fuse).to be_kind_of(MockFuse)
+                expect(fuse.mountpoint).to eq(mountpoint)
+                expect(fuse).to be_mounted
+            end
+        end
+
+        context "with a Class" do
+            let(:fs) { DuckFuse }
+            it "creates a FuseDelegator around a new instance" do
+                expect(fs).to receive(:new).with("OptionValue").and_call_original()
+                expect(RFuse::FuseDelegator).to receive(:new).with(an_instance_of(DuckFuse),mountpoint).and_call_original()
+                fuse = RFuse.create(fs,[mountpoint],{:myopt => "OptionValue"},[:myopt])
+                expect(fuse).to be_kind_of(RFuse::FuseDelegator)
+                expect(fuse.mountpoint).to eq(mountpoint)
+                expect(fuse).to be_mounted
+            end
+        end
+        context "with a non-Fuse Object" do
+            let(:fs) { mockfs }
+            it "starts FuseDelegator with non Fuse object returned from yield" do
+                expect(RFuse::FuseDelegator).to receive(:new).with(mockfs,mountpoint).and_call_original()
+                fuse = RFuse.create(fs,[mountpoint])
+                expect(fuse).to be_kind_of(RFuse::FuseDelegator)
+                expect(fuse.mountpoint).to eq(mountpoint)
+                expect(fuse).to be_mounted
+            end
+        end
+
+    end
+end

data/spec/options_spec.rb

@@ -12,25 +12,25 @@ describe RFuse do
     context "mount options" do
         it "should handle -h" do
             fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-h")
-            fuse.mounted?.should be_false
+            fuse.mounted?.should be_falsey
             lambda { fuse.loop }.should raise_error(RFuse::Error)
         end
 
         it "should behave sensibly for bad mountpoint" do
             fuse = RFuse::FuseDelegator.new(mockfs,"bad/mount/point")
-            fuse.mounted?.should be_false
+            fuse.mounted?.should be_falsey
             lambda { fuse.loop }.should raise_error(RFuse::Error)
         end
 
         it "should behave sensibly for bad options" do
-            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-eviloption") 
-            fuse.mounted?.should be_false
+            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-eviloption")
+            fuse.mounted?.should be_falsey
             lambda { fuse.loop }.should raise_error(RFuse::Error)
         end
 
         it "should handle a Pathname as a mountpoint" do
             fuse = RFuse::FuseDelegator.new(mockfs,Pathname.new(mountpoint))
-            fuse.mounted?.should be_true
+            fuse.mounted?.should be(true)
             fuse.unmount()
         end
     end
@@ -40,46 +40,46 @@ describe RFuse do
         it "should detect -h" do
             argv = [ "/mountpoint","-h" ]
             result = RFuse.parse_options(argv)
-            
-            result[:help].should be_true
+
+            result[:help].should be(true)
             result[:mountpoint].should == "/mountpoint"
-            result[:debug].should be_false
+            result[:debug].should be_falsey
         end
 
         it "should detect -h mixed with -o" do
             argv = [ "/mountpoint","-h", "-o", "debug" ]
             result = RFuse.parse_options(argv)
-            
-            result[:help].should be_true
+
+            result[:help].should be(true)
             result[:mountpoint].should == "/mountpoint"
-            result[:debug].should be_true
+            result[:debug].should be(true)
         end
 
         it "should detect debug" do
             argv = [ "/mountpoint","-o","debug" ]
             result = RFuse.parse_options(argv)
 
-            result[:debug].should be_true
-            result[:help].should be_false
+            result[:debug].should be(true)
+            result[:help].should be_falsey
 
             argv = [ "/mountpoint","-o","default_permissions,debug" ]
             result = RFuse.parse_options(argv)
-            result[:debug].should be_true
+            result[:debug].should be(true)
         end
 
         it "detects debug as -d" do
             argv = [ "/mountpoint","-o","someopt","-d" ]
             result = RFuse.parse_options(argv)
-            result[:debug].should be_true
+            result[:debug].should be(true)
         end
 
         it "should remove local options" do
             argv = [ "/mountpoint","-o","debug,myoption" ]
-            
+
             result = RFuse.parse_options(argv,:myoption)
 
-            result[:debug].should be_true
-            result[:myoption].should be_true
+            result[:debug].should be(true)
+            result[:myoption].should be(true)
 
             argv.should == [ "/mountpoint", "-o", "debug" ]
         end
@@ -89,7 +89,7 @@ describe RFuse do
 
             result = RFuse.parse_options(argv,:myoption)
 
-            result[:myoption].should be_true
+            result[:myoption].should be(true)
             argv.should == [ "/mountpoint" ]
         end
 
@@ -124,9 +124,9 @@ describe RFuse do
 
             result[:device].should == "a device"
             result[:mountpoint].should == "/mountpoint"
-            result[:rw].should be_true
-            result[:debug].should be_true
-            result[:default_permissions].should be_true
+            result[:rw].should be(true)
+            result[:debug].should be(true)
+            result[:default_permissions].should be(true)
 
             argv.should == [ "/mountpoint" , "-o", "rw,debug,default_permissions" ]
         end

data/spec/ruby_loop_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
-describe RFuse do
+describe RFuse::Fuse do
 
     let(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil) ; m }
     let(:mountpoint) { tempmount() }
 
-    context "ruby loop" do
+    context "#loop" do
         it "should exit from another thread and allow multiple loops" do
-           
+
             fuse = RFuse::FuseDelegator.new(mockfs,mountpoint)
-            t = Thread.new { sleep 0.5;  fuse.exit }
+            t = Thread.new { sleep 0.2;  fuse.exit }
             fuse.loop()
             t.join
-            t = Thread.new { sleep 0.5;  fuse.exit }
+            t = Thread.new { sleep 0.2;  fuse.exit }
             fuse.loop
             t.join
             fuse.unmount
-            fuse.mounted?.should be_false
+            fuse.mounted?.should be(false)
         end
 
 
@@ -25,38 +25,36 @@ describe RFuse do
         #
         #    mockfs = mock("fuse")
         #    mockfs.stub(:getattr).and_return(nil)
-
+        #
         #    fuse = RFuse::FuseDelegator.new(mockfs,"/tmp/rfuse-spec")
-
+        #
         #    t = Thread.new { sleep 0.5 ; File.stat("/tmp/rfuse-spec/thread") ; fuse.exit }
-            
+        #
         #    fuse.loop()
         #    fuse.unmount()
         #end
 
         it "should allow other threads to be scheduled" do
-            
+
             file_stat = RFuse::Stat.file(0444)
 
             thread_ran = false
 
             mockfs.stub(:getattr).with(anything(),"/before") {
-                puts "before"
-                thread_ran.should be_false
+                thread_ran.should be(false)
                 file_stat
             }
 
             mockfs.stub(:getattr).with(anything(),"/missing") {
-                puts "missing"
-                GC.start()
-                thread_ran.should be_true
+                #GC.start()
+                thread_ran.should be(true)
                 file_stat
             }
 
-            t = Thread.new() { sleep 1.5 ; thread_ran = true }
+            t = Thread.new() { sleep 0.5 ; thread_ran = true }
             with_fuse(mountpoint,mockfs) do
                 File.stat("#{mountpoint}/before");
-                sleep 2;
+                sleep 1;
                 File.stat("#{mountpoint}/missing");
             end
         end

data/spec/run_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe RFuse::Fuse do
+    context "#run" do
+
+        let(:file_stat) { RFuse::Stat.file(0444) }
+        let(:mountpoint) { tempmount() }
+        let(:mockfs) { m = double("fuse"); allow(m).to receive(:getattr) { |ctx,path| puts "#{ctx},#{path}"}; m }
+        let(:fuse) { RFuse::FuseDelegator.new(mockfs,mountpoint) }
+
+        it "runs a mounted filesystem with default traps" do
+
+            # expect traps to be set
+            expect(mockfs).to receive(:sighup) { }
+            expect(mockfs).to receive(:getattr).with(anything(),"/run").and_return(file_stat)
+
+            # Need to call this before we fork..
+            expect(fuse.mountpoint).to eq(mountpoint)
+
+            pid = Process.pid
+
+            fpid = Kernel.fork do
+                File.stat("#{mountpoint}/run")
+                Process.kill("HUP",pid)
+                sleep(0.1)
+                Process.kill("TERM",pid)
+            end
+
+            fuse.run
+
+            rpid,result = Process.waitpid2(fpid)
+            expect(result).to be_success
+
+            expect(fuse).not_to be_mounted
+            expect(Signal.trap("HUP","DEFAULT")).to eq("DEFAULT")
+        end
+
+        it "unmounts the filesystem and resets traps on exception" do
+            expect(mockfs).to receive(:getattr).with(anything(),"/run").and_return(file_stat)
+            # raising an error in a sighandler will exit the loop..
+            expect(mockfs).to receive(:sighup).and_raise("oh noes")
+            pid = Process.pid
+            # Need to call this before we fork..
+            expect(fuse.mountpoint).to eq(mountpoint)
+
+            fpid = Kernel.fork do
+                File.stat("#{mountpoint}/run")
+                Process.kill("HUP",pid)
+            end
+
+            expect { fuse.run }.to raise_error
+
+            pid,result = Process.waitpid2(fpid)
+
+            expect(fuse).not_to be_mounted
+            expect(Signal.trap("HUP","DEFAULT")).to eq("DEFAULT")
+        end
+
+    end
+end

data/spec/signals_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe RFuse::Fuse do
+
+    let(:mountpoint) { tempmount() }
+    let(:fuse) { RFuse::Fuse.new(mountpoint) }
+
+    before(:each) do
+        # Override traps (note rspec itself traps "INT") with "DEFAULT"
+        @traps = ["INT","TERM","HUP","USR1","USR2"].inject({}) { |h,signame| h[signame] = Signal.trap(signame,"DEFAULT"); h }
+    end
+
+    after(:each) do
+        fuse.unmount()
+        # Restore previously set traps
+        @traps.each_pair { |signame,prev_trap| Signal.trap(signame,prev_trap) }
+    end
+
+    context "#trap_signals" do
+
+        it "returns the list of signals trapped" do
+
+            allow(fuse).to receive(:sighup)
+
+            expect(fuse.trap_signals("HUP")).to include("HUP")
+            expect(Signal.trap("HUP","DEFAULT")).not_to eq("DEFAULT")
+        end
+
+        it "does not override previously set traps" do
+
+            allow(fuse).to receive(:sighup)
+
+            Signal.trap("HUP","HUPCOMMAND")
+
+            expect(fuse.trap_signals()).not_to include("HUP")
+            expect(Signal.trap("HUP","DEFAULT")).to eq("HUPCOMMAND")
+        end
+
+        it "only traps the specified signals" do
+
+            allow(fuse).to receive(:sighup)
+            allow(fuse).to receive(:sigusr2)
+
+            expect(fuse.trap_signals("HUP")).to include("HUP")
+            expect(Signal.trap("HUP","DEFAULT")).not_to eq("DEFAULT")
+            expect(Signal.trap("USR2","DEFAULT")).to eq("DEFAULT")
+        end
+
+        it "allows signals to be handled by the filesystem" do
+            expect(fuse).to receive(:sighup) { fuse.exit }
+
+            expect(fuse.trap_signals("HUP")).to include("HUP")
+
+            pid = Process.pid
+            fork_fuse(fuse) { Process.kill("HUP",pid) }
+            # Exitted loop, but still mounted - ie not with fusermount -u
+            expect(fuse).to be_mounted
+        end
+
+        it "exits on INT by default" do
+            pid = Process.pid
+            expect(fuse.trap_signals("INT")).to include("INT")
+
+            fork_fuse(fuse) { Process.kill("INT",pid) }
+            expect(fuse).to be_mounted
+        end
+
+        it "exits on TERM by default" do
+            pid = Process.pid
+            expect(fuse.trap_signals("TERM")).to include("TERM")
+
+            fork_fuse(fuse) { Process.kill("TERM",pid) }
+            expect(fuse).to be_mounted
+        end
+
+        context "with a delegated filesystem" do
+            let(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil); m }
+            let(:fuse) { RFuse::FuseDelegator.new(mockfs,mountpoint) }
+
+            it "enables FuseDelegator debugging on USR1" do
+
+                pid = Process.pid
+                expect(fuse.trap_signals("USR1","INT")).to include("USR1")
+
+                expect(fuse.debug?).to be(false)
+
+                fork_fuse(fuse) do
+                    Process.kill("USR1",pid)
+                    sleep(0.1)
+                    Process.kill("INT",pid)
+                end
+
+                expect(fuse.debug?).to be(true)
+            end
+
+            it "allows delegate filesystem to override default sig handler method" do
+                expect(mockfs).to receive(:sigint) { fuse.exit }
+
+                pid = Process.pid
+                fuse.trap_signals("INT")
+
+                fork_fuse(fuse) do
+                    Process.kill("INT",pid)
+                end
+            end
+        end
+    end
+end