rfuse 1.0.0

data/spec/basic_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require 'pathname'
+
+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() }
+
+    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"
+
+        it "should create and resolve hard links"
+
+    end
+
+    context "directories" do
+        it "should make directories" do
+
+            mockfs.stub(:getattr).and_return(nil)
+            mockfs.stub(:getattr).with(anything(),"/aDirectory").and_return(nil,dir_stat)
+            mockfs.should_receive(:mkdir).with(anything(),"/aDirectory",anything())
+
+            with_fuse(mountpoint,mockfs) do
+                Dir.mkdir("#{mountpoint}/aDirectory")
+            end
+        end
+
+        it "should list directories" do
+
+            mockfs.should_receive(:readdir) do | ctx, path, filler,offset,ffi | 
+                filler.push("hello",nil,0)
+                filler.push("world",nil,0)
+            end
+
+            with_fuse(mountpoint,mockfs) do
+                entries = Dir.entries(mountpoint)
+                entries.size.should == 2
+                entries.should include("hello")
+                entries.should include("world")
+            end
+        end
+    end
+
+    context "permissions" do
+        it "should process chmod" do
+            mockfs.stub(:getattr).with(anything(),"/myPerms").and_return(file_stat)
+
+            mockfs.should_receive(:chmod).with(anything(),"/myPerms",file_mode(0644))
+
+            with_fuse(mountpoint,mockfs) do
+                File.chmod(0644,"#{mountpoint}/myPerms").should == 1
+            end
+        end
+    end
+
+    context "timestamps" do
+
+        it "should support stat with subsecond resolution" do
+           begin
+               atime = Time.now() + 60
+               sleep(0.001)
+           end until atime.usec != 0
+
+           begin
+               mtime = Time.now() + 600
+               sleep(0.001)
+           end until mtime.usec != 0
+
+           begin
+                ctime = Time.now() + 3600
+                sleep(0.001)
+           end until ctime.usec != 0
+
+           file_stat.atime = atime
+           file_stat.mtime = mtime
+           file_stat.ctime = ctime
+
+
+           # ruby can't set file times with ns res, o we are limited to usecs
+           mockfs.stub(:getattr).with(anything(),"/nanos").and_return(file_stat)
+
+           with_fuse(mountpoint,mockfs) do
+               stat = File.stat("#{mountpoint}/nanos")
+               stat.atime.should == atime
+               stat.ctime.should == ctime
+               stat.mtime.should == mtime
+           end
+        end
+
+        it "should set file access and modification times" do
+
+            atime = Time.now()
+            mtime = atime + 1
+
+            mockfs.stub(:getattr).with(anything(),"/times").and_return(file_stat)
+            mockfs.should_receive(:utime).with(anything(),"/times",atime.to_i,mtime.to_i)
+
+            with_fuse(mountpoint,mockfs) do
+                File.utime(atime,mtime,"#{mountpoint}/times").should == 1
+            end
+        end
+
+    end
+
+    context "file io" do
+
+        it "should create files" do
+
+           mockfs.stub(:getattr).with(anything(),"/newfile").and_return(nil,file_stat)
+           mockfs.should_receive(:mknod).with(anything(),"/newfile",file_mode(0644),0,0)
+         
+           with_fuse(mountpoint,mockfs) do
+                File.open("#{mountpoint}/newfile","w",0644) { |f| }
+           end
+        end
+
+        # ruby doesn't seem to have a native method to create these
+        # maybe try ruby-mkfifo
+        it "should create special device files"
+
+        it "should read files" do
+
+            file_stat.size = 11
+            mockfs.stub(:getattr) { | ctx, path|
+                case path 
+                when "/test"
+                    file_stat
+                else
+                    raise Errno::ENOENT 
+                end
+
+            }
+            
+            reads = 0
+            mockfs.stub(:read) { |ctx,path,size,offset,ffi|
+                reads += 2
+                "hello world"[offset,reads]
+            }
+
+            with_fuse(mountpoint,mockfs) do
+                File.open("#{mountpoint}/test") do |f|
+                    val = f.gets
+                    val.should == "hello world"
+                end
+            end
+        end
+    end
+end

data/spec/fuse_file_info_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe RFuse::Fuse do
+    context "file handles" do
+        it "should retain file handles over GC" do
+            mockfs = mock("fuse")
+
+            file_stat = RFuse::Stat.file(0444,:size => 11)
+
+            mockfs.stub(:getattr) { | ctx, path|
+                case path 
+                when "/one","/two"
+                    file_stat
+                else
+                    nil
+                end
+
+            }
+
+            open_files = {}
+            mockfs.stub(:open) { |ctx,path,ffi|
+                ffi.fh = Object.new()
+                open_files[path] = ffi.fh.object_id
+            }
+
+            mockfs.stub(:read) { |ctx,path,size,offset,ffi|
+                GC.start()
+                open_files[path].should == ffi.fh.object_id
+                "hello world"
+            }
+
+            mountpoint = tempmount()
+            with_fuse(mountpoint,mockfs) do
+                f1 = File.new("#{mountpoint}/one")
+                f2 = File.new("#{mountpoint}/two")
+
+                val = f1.gets
+                val.should == "hello world" 
+                f2.gets.should == "hello world"
+
+                f1.close()
+                f2.close()
+            end
+        end
+    end
+end

data/spec/ruby_loop_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe RFuse do
+
+    let(:mockfs) { m = mock("fuse"); m.stub(:getattr).and_return(nil) ; m }
+    let(:mountpoint) { tempmount() }
+
+    context "ruby 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 }
+            fuse.loop()
+            t.join
+            t = Thread.new { sleep 0.5;  fuse.exit }
+            fuse.loop
+            t.join
+            fuse.unmount
+            fuse.mounted?.should be_false
+        end
+
+
+        # This will never work!
+        #it "should allow threads to operate on the filesystem" 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
+                file_stat
+            }
+
+            mockfs.stub(:getattr).with(anything(),"/missing") {
+                puts "missing"
+                GC.start()
+                thread_ran.should be_true
+                file_stat
+            }
+
+            t = Thread.new() { sleep 1.5 ; thread_ran = true }
+            with_fuse(mountpoint,mockfs) do
+                File.stat("#{mountpoint}/before");
+                sleep 2;
+                File.stat("#{mountpoint}/missing");
+            end
+        end
+    end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+require 'rfuse'
+require 'tmpdir'
+
+class FileModeMatcher
+    def initialize(expected)
+        @expected = expected
+    end
+
+    def description
+        "file mode #{@expected}"
+    end
+
+    def ==(actual)
+        (actual | RFuse::Stat::S_IFMT) ==  (@expected | RFuse::Stat::S_IFMT)
+    end
+end
+
+module RFuseHelper
+    # Runs the single threaded fuse loop
+    # on a pre configured mock fuse filesystem
+    # Executes fork block in a separate process
+    # that is expected to return success
+    def with_fuse(mnt,mockfs,*options,&fork_block)
+
+        fpid = Kernel.fork() {
+            sleep 0.5
+            begin
+                fork_block.call() if fork_block
+            ensure
+                sleep 0.3
+                system("fusermount -u #{mnt}")
+            end
+        }
+
+        fuse = RFuse::FuseDelegator.new(mockfs,mnt,*options)
+        fuse.loop
+        pid,result = Process.waitpid2(fpid) 
+        result.should be_success
+        fuse.open_files.should be_empty()
+        fuse.mounted?.should be_false
+    end
+
+    def file_mode(mode)
+        FileModeMatcher.new(mode)
+    end
+
+    def tempmount()
+        Dir.mktmpdir("rfuse-spec")
+    end
+end
+include RFuseHelper

data/spec/xattr_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'ffi-xattr'
+
+describe RFuse::Fuse do
+        it "should handle extended attributes" do
+            mockfs = mock("fuse")
+
+            file_stat = RFuse::Stat.file(0444,:size => 11)
+
+            mockfs.stub(:getattr).and_return(file_stat)
+            mockfs.stub(:getxattr) { |ctx,path,name|
+                case name
+                when "user.one"
+                    "1"
+                when "user.two"
+                    "2"
+                end
+            }
+
+            mockfs.stub(:listxattr).with(anything(),"/myfile").and_return([ "user.one","user.two" ])
+            mockfs.should_receive(:setxattr).with(anything(),"/myfile","user.three","updated",anything())
+            mockfs.should_receive(:removexattr).with(anything(),"/myfile","user.one")
+
+            mountpoint = tempmount()
+
+            with_fuse(mountpoint,mockfs) do
+                xattr = Xattr.new("#{mountpoint}/myfile")
+                xattr.list.should include("user.one")
+                xattr.list.should include("user.two")
+                xattr.list.size.should == 2
+
+                xattr['user.one'].should == "1"
+                xattr['user.two'].should == "2"
+                xattr['user.three']= "updated"
+                xattr.remove('user.one')
+            end
+        end
+
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: rfuse
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Grant Gardner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi-xattr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby language binding for FUSE. It was forked from rfuse and modified
+  for Ruby 1.9.2.
+email:
+- grant@lastweekend.com.au
+executables: []
+extensions:
+- ext/rfuse/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/.gitignore
+- ext/rfuse/bufferwrapper.c
+- ext/rfuse/bufferwrapper.h
+- ext/rfuse/context.c
+- ext/rfuse/context.h
+- ext/rfuse/extconf.rb
+- ext/rfuse/file_info.c
+- ext/rfuse/file_info.h
+- ext/rfuse/filler.c
+- ext/rfuse/filler.h
+- ext/rfuse/helper.c
+- ext/rfuse/helper.h
+- ext/rfuse/intern_rfuse.c
+- ext/rfuse/intern_rfuse.h
+- ext/rfuse/pollhandle.c
+- ext/rfuse/pollhandle.h
+- ext/rfuse/rfuse.c
+- ext/rfuse/rfuse.h
+- ext/rfuse/rfuse_mod.c
+- lib/rfuse-ng.rb
+- lib/rfuse.rb
+- lib/rfuse/version.rb
+- lib/rfuse_ng.rb
+- rfuse.gemspec
+- sample/test-ruby.rb
+- spec/basic_spec.rb
+- spec/fuse_file_info_spec.rb
+- spec/ruby_loop_spec.rb
+- spec/spec_helper.rb
+- spec/xattr_spec.rb
+homepage: http://rubygems.org/gems/rfuse
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby language binding for FUSE
+test_files: []
+has_rdoc: