rfuse 1.0.2 → 1.0.3

data/lib/rfuse/version.rb

@@ -1,3 +1,3 @@
 module RFuse
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end

data/lib/rfuse.rb

@@ -19,6 +19,91 @@ module RFuse
         end
     end
 
+    # Parse mount arguments and options
+    #
+    # @param [Array<String>] argv
+    #        normalised fuse options
+    #
+    # @param [Array<Symbol>] local_opts local options
+    #        if these are found in the argv entry following "-o" they are removed
+    #        from argv, ie so argv is a clean set of options that can be passed
+    #        to {RFuse::Fuse} or {RFuse::FuseDelegator}
+    #
+    # 
+    # @return [Hash{Symbol => String,Boolean}]
+    #         the extracted options
+    #
+    # @since 1.0.3
+    # 
+    # Fuse itself will normalise arguments
+    #
+    #    mount -t fuse </path/to/fs>#<device> mountpoint [options...]
+    #    mount.fuse </path/to/fs>#<device> mountpoint [options...]
+    #
+    # both result in a call to /path/to/fs with arguments...
+    #
+    #    [device] mountpoint [-h] [-o [opt,optkey=value,...]]
+    #
+    # which this method will parse into a Hash with the following special keys
+    #
+    #  :device - the optional mount device, removed from argv if present
+    #  :mountpoint - required mountpoint
+    #  :help - true if -h was supplied
+    #
+    # and any other supplied options.
+    #
+    # @example
+    #   ARGV = [ "some/device", "/mnt/point", "-h", "-o", "debug,myfs=aValue" ]
+    #   options = RFuse.parse_options(ARGV,:myfs)
+    # 
+    #   # options == 
+    #   { :device => "some/device",
+    #     :mountpoint => "/mnt/point",
+    #     :help => true,
+    #     :debug => true,
+    #     :myfs => "aValue"
+    #   }
+    #   # and ARGV == 
+    #   [ "/mnt/point","-h","-o","debug" ]
+    #
+    #   fs = create_filesystem(options)
+    #   fuse = RFuse::FuseDelegator.new(fs,*ARGV)
+    #  
+    def self.parse_options(argv,*local_opts)
+        result = Hash.new(nil)
+        
+        first_opt_index = (argv.find_index() { |opt| opt =~ /-.*/ } || argv.length ) 
+
+        result[:device] = argv.shift if first_opt_index > 1
+        result[:mountpoint] = argv[0] if argv.length > 0
+        
+        if argv.include?("-h")
+            result[:help]  =  true
+        end
+
+        opt_index = ( argv.find_index("-o") || -1 ) + 1
+
+        if opt_index > 1 && opt_index < argv.length
+            options = argv[opt_index].split(",")
+
+            options.delete_if() do |opt| 
+                opt.strip!
+
+                opt,value = opt.split("=",2)
+                value = true unless value
+                opt_sym = opt.to_sym
+                result[opt_sym] = value
+
+                #result of delete if
+                local_opts.include?(opt_sym)
+            end
+
+            argv[opt_index] = options.join(",")
+        end
+
+        result
+    end
+
     class Fuse
 
         # Main processing loop
@@ -40,7 +125,7 @@ module RFuse
                     ready, ignore, errors  = IO.select([@fuse_io,@pr],[],[@fuse_io])
 
                     if ready.include?(@pr)
-                    
+
                         @pr.getc
                         @running = false
 
@@ -75,7 +160,7 @@ module RFuse
         # 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) 
@@ -219,5 +304,4 @@ module RFuse
             end
         end
     end
-
 end #Module RFuse

data/spec/basic_spec.rb

@@ -9,32 +9,6 @@ describe RFuse::Fuse do
     let!(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil); m }
     let(:mountpoint) { tempmount() }
 
-    context "mount options" do
-        it "should handle -h" do
-            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-h")
-            fuse.mounted?.should be_false
-            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
-            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
-            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.unmount()
-        end
-    end
-
     context "links" do
         it "should create and resolve symbolic links"
 
@@ -175,13 +149,13 @@ describe RFuse::Fuse do
             reads = 0
             mockfs.stub(:read) { |ctx,path,size,offset,ffi|
                 reads += 2
-                "hello world"[offset,reads]
+                "hello\000world"[offset,reads]
             }
 
             with_fuse(mountpoint,mockfs) do
                 File.open("#{mountpoint}/test") do |f|
                     val = f.gets
-                    val.should == "hello world"
+                    val.should == "hello\000world"
                 end
             end
         end

data/spec/fuse_file_info_spec.rb

@@ -1,21 +1,51 @@
 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()
+        stored_ffi = nil
+        captured_ex = nil
+
+        mockfs.stub(:getattr).with(anything(),"/ffirelease").and_return(file_stat)
+
+        mockfs.should_receive(:open).with(anything(),"/ffirelease",anything()) { |ctx,path,ffi|
+           stored_ffi = ffi
+           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
+                captured_ex = ex
+            end
+        }
+
+        with_fuse(mountpoint,mockfs) do
+            f1 = File.new("#{mountpoint}/ffirelease")
+            f1.close()
+        end
+
+        raise captured_ex if captured_ex
+    end
+
     context "file handles" do
         it "should retain file handles over GC" do
-            mockfs = mock("fuse")
 
-            file_stat = RFuse::Stat.file(0444,:size => 11)
+            file_stat.size = 11
 
-            mockfs.stub(:getattr) { | ctx, path|
-                case path 
-                when "/one","/two"
-                    file_stat
-                else
-                    nil
-                end
-
-            }
+            mockfs.stub(:getattr).with(anything(),"/one").and_return(file_stat)
+            mockfs.stub(:getattr).with(anything(),"/two").and_return(file_stat)
 
             open_files = {}
             mockfs.stub(:open) { |ctx,path,ffi|
@@ -29,7 +59,6 @@ describe RFuse::Fuse do
                 "hello world"
             }
 
-            mountpoint = tempmount()
             with_fuse(mountpoint,mockfs) do
                 f1 = File.new("#{mountpoint}/one")
                 f2 = File.new("#{mountpoint}/two")

data/spec/options_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'pathname'
+require 'tempfile'
+
+describe RFuse 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() }
+
+    context "mount options" do
+        it "should handle -h" do
+            fuse = RFuse::FuseDelegator.new(mockfs,mountpoint,"-h")
+            fuse.mounted?.should be_false
+            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
+            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
+            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.unmount()
+        end
+    end
+
+    context "#parse_options" do
+
+        it "should detect -h" do
+            argv = [ "/mountpoint","-h" ]
+            result = RFuse.parse_options(argv)
+            
+            result[:help].should be_true
+            result[:mountpoint].should == "/mountpoint"
+            result[:debug].should be_false
+        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[:mountpoint].should == "/mountpoint"
+            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
+
+            argv = [ "/mountpoint","-o","default_permissions,debug" ]
+            result = RFuse.parse_options(argv)
+            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
+
+            argv[2].should == "debug"
+        end
+
+        it "should parse values from options" do
+            argv = [ "/mountpoint", "-o", "debug,someopt=somevalue" ]
+            result = RFuse.parse_options(argv)
+
+            result[:someopt].should == "somevalue"
+        end
+
+        it "should parse values and remove local options" do
+            argv = [ "/mountpoint", "-o", "debug,someopt=somevalue" ]
+            result = RFuse.parse_options(argv,:someopt)
+
+            result[:someopt].should == "somevalue"
+            argv[2].should == "debug"
+        end
+
+        it "should parse and remove optional device" do
+
+            argv = [ "a device", "/mountpoint" , "-o", "rw,debug,default_permissions" ]
+            result = RFuse.parse_options(argv)
+
+            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
+
+            argv.length.should == 3
+            argv.join(" ").should == "/mountpoint -o rw,debug,default_permissions"
+        end
+
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rfuse
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-09 00:00:00.000000000 Z
+date: 2012-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -135,6 +135,7 @@ files:
 - sample/test-ruby.rb
 - spec/basic_spec.rb
 - spec/fuse_file_info_spec.rb
+- spec/options_spec.rb
 - spec/ruby_loop_spec.rb
 - spec/spec_helper.rb
 - spec/xattr_spec.rb