rfusefs 1.0.2 → 1.1.3

data/samples/sqlfs.rb

@@ -1,134 +0,0 @@
-# sqlfs.rb
-#
-# The SQL-db proof of concept for FuseFS
-#
-# Author: Greg Millam
-
-require "rubygems"
-require 'fusefs'
-
-require 'mysql'
-
-class SqlFS < FuseFS::FuseDir
-  class DBTable
-    attr_accessor :name, :key, :fields
-  end
-  def initialize(host,user,pass,db)
-    @sql = Mysql.connect(host,user,pass,db)
-    @tables = Hash.new(nil)
-
-    tables = @sql.query('show tables')
-
-    tables.each do |i,|
-      table = DBTable.new
-      table.name = i
-      table.fields = {}
-      res = @sql.query("describe #{i}")
-      res.each do |field,type,null,key,default,extra|
-        table.fields[field] = type
-        if (key =~ /pri/i)
-          table.key = field
-        end
-      end
-      @tables[i] = table if table.key
-    end
-  end
-  def directory?(path)
-    tname, key, field = scan_path(path)
-    table = @tables[tname]
-    case
-    when tname.nil?
-      true # This means "/"
-    when table.nil?
-      false
-    when field
-      false # Always a file
-    when key
-      res = @sql.query("SELECT #{table.key}, 1 FROM #{table.name} WHERE #{table.key} = '#{Mysql.escape_string(key)}'")
-      res.num_rows > 0 # If there was a result, it exists.
-    else
-      true # It's just a table.
-    end
-  end
-  def file?(path)
-    tname, key, field = scan_path(path)
-    table = @tables[tname]
-    case
-    when field.nil?
-      false # Only field entries are files.
-    when table.nil?
-      false
-    when ! @tables[tname].fields.include?(field)
-      false # Invalid field.
-    when field
-      res = @sql.query("SELECT #{table.key}, 1 FROM #{table.name} WHERE #{table.key} = '#{Mysql.escape_string(key)}'")
-      res.num_rows > 0
-    end
-  end
-  def can_delete?(path)
-    # This helps editors, but we don't really use it.
-    true
-  end
-  def can_write?(path)
-    # Since this is basically only for editing files,
-    # we just call file?
-    file?(path)
-  end
-  def contents(path)
-    # since this is only called when directory? is true,
-    # We'll assume valid entries.
-    tname, key, field = scan_path(path)
-    table = @tables[tname]
-    case
-    when tname.nil?
-      @tables.keys.sort # Just the tables.
-    when key
-      table.fields.keys.sort
-    else
-      # I limit to 200 so 'ls' doesn't hang all the time :D
-      res = @sql.query("SELECT #{table.key}, 1 FROM #{table.name} ORDER BY #{table.key} LIMIT 100")
-      ret = []
-      res.each do |val,one|
-        ret << val if val.size > 0
-      end
-      ret
-    end
-  end
-  def write_to(path,body)
-    # Since this is only called after can_write?(), we assume
-    # Valid fields.
-    tname, key, field = scan_path(path)
-    table = @tables[tname]
-    res = @sql.query("UPDATE #{table.name} SET #{field} = '#{Mysql.escape_string(body)}' WHERE #{table.key} = '#{key}'")
-  end
-  def read_file(path)
-    # Again, as this is only called after file?, assume valid fields.
-    tname, key, field = scan_path(path)
-    table = @tables[tname]
-    res = @sql.query("SELECT #{field} FROM #{table.name} WHERE #{table.key} = '#{key}'")
-    res.fetch_row[0]
-  end
-end
-
-if (File.basename($0) == File.basename(__FILE__))
-  if ARGV.size != 5
-    puts "Usage: #{$0} <directory> <host> <user> <pass> <db>"
-    exit
-  end
-
-  dirname, host, user, pass, db = ARGV
-
-  if (! File.directory?(dirname))
-    puts "#{dirname} is not a directory"
-  end
-
-  root = SqlFS.new(host,user,pass,db)
-
-  # Set the root FuseFS
-  FuseFS.set_root(root)
-
-  # root.contents("/quotes")
-
-  FuseFS.mount_under(dirname)
-  FuseFS.run # This doesn't return until we're unmounted.
-end

data/samples/yamlfs.rb

@@ -1,168 +0,0 @@
-# yamlfs.rb
-#
-
-require "rubygems"
-require 'fusefs'
-include FuseFS
-
-require 'yaml'
-
-class YAMLFS < FuseFS::FuseDir
-  def initialize(filename)
-    @filename = filename
-    begin
-      @fs = YAML.load(IO.read(filename))
-    rescue Exception
-      @fs = Hash.new()
-    end
-  end
-  def save
-    File.open(@filename,'w') do |fout|
-      fout.puts(YAML.dump(@fs))
-    end
-  end
-  def contents(path)
-    items = scan_path(path)
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.keys.sort
-  end
-  def directory?(path)
-    items = scan_path(path)
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.is_a?(Hash)
-  end
-  def file?(path)
-    items = scan_path(path)
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.is_a?(String)
-  end
-  def touch(path)
-    puts "#{path} has been pushed like a button!"
-  end
-
-  # File reading
-  def read_file(path)
-    items = scan_path(path)
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.to_s
-  end
-  
-  def size(path)
-    read_file(path).size
-  end
-
-  # File writing
-  def can_write?(path)
-    items = scan_path(path)
-    name = items.pop # Last is the filename.
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.is_a?(Hash)
-  rescue Exception => er
-    puts "Error! #{er}"
-  end
-  def write_to(path,body)
-    items = scan_path(path)
-    name = items.pop # Last is the filename.
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node[name] = body
-    self.save
-  rescue Exception => er
-    puts "Error! #{er}"
-  end
-
-  # Delete a file
-  def can_delete?(path)
-    items = scan_path(path)
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.is_a?(String)
-  rescue Exception => er
-    puts "Error! #{er}"
-  end
-  def delete(path)
-    items = scan_path(path)
-    name = items.pop # Last is the filename.
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.delete(name)
-    self.save
-  rescue Exception => er
-    puts "Error! #{er}"
-  end
-
-  # mkdirs
-  def can_mkdir?(path)
-    items = scan_path(path)
-    name = items.pop # Last is the filename.
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.is_a?(Hash)
-  rescue Exception => er
-    puts "Error! #{er}"
-  end
-  def mkdir(path)
-    items = scan_path(path)
-    name = items.pop # Last is the filename.
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node[name] = Hash.new
-    self.save
-  end
-
-  # rmdir
-  def can_rmdir?(path)
-    items = scan_path(path)
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.is_a?(Hash) && node.empty?
-  end
-  def rmdir(path)
-    items = scan_path(path)
-    name = items.pop # Last is the filename.
-    node = items.inject(@fs) do |node,item|
-      item ? node[item] : node
-    end
-    node.delete(name)
-    self.save
-  end
-end
-
-if (File.basename($0) == File.basename(__FILE__))
-  if (ARGV.size < 2)
-    puts "Usage: #{$0} <directory> <yamlfile> <options>"
-    exit
-  end
-
-  dirname, yamlfile = ARGV.shift, ARGV.shift
-
-  unless File.directory?(dirname)
-    puts "Usage: #{dirname} is not a directory."
-    exit
-  end
-
-  root = YAMLFS.new(yamlfile)
-
-  # Set the root FuseFS
-  FuseFS.set_root(root)
-
-  FuseFS.mount_under(dirname, *ARGV)
-
-  FuseFS.run # This doesn't return until we're unmounted.
-end

data/spec-fusefs/fusefs_spec.rb

@@ -1,12 +0,0 @@
-require 'fusefs'
-
-describe "Using fusefs compatibility mode" do
-	describe FuseFS do
-		
-		it "should indicate FuseFS compatibility" do
-			FuseFS::RFUSEFS_COMPATIBILITY.should be_false
-		end
-		
-		it "should use FuseFS compatible raw calls" 
-	end
-end

data/spec/metadir_spec.rb

@@ -1,364 +0,0 @@
-require 'spec_helper'
-require 'tmpdir'
-require 'sys/filesystem'
-require 'ffi-xattr'
-
-describe FuseFS::MetaDir do
-  
-  context "in ruby" do
-    
-    before(:each) do
-      @metadir = FuseFS::MetaDir.new()
-      @metadir.mkdir("/test")
-      @metadir.mkdir("/test/hello")
-      @metadir.mkdir("/test/hello/emptydir")
-      @metadir.write_to("/test/hello/hello.txt","Hello World!\n")
-    end
-    
-    context "general directory methods" do
-      it "should list directory contents" do
-        @metadir.contents("/").should =~ [ "test" ]
-        @metadir.contents("/test").should =~ [ "hello" ]
-        @metadir.contents("/test/hello").should =~ ["hello.txt", "emptydir" ]
-      end
-      
-      it "should indicate paths which are/are not directories" do
-        @metadir.directory?("/test").should be_true
-        @metadir.directory?("/test/hello").should be_true
-        @metadir.directory?("/test/hello/hello.txt").should be_false
-        @metadir.directory?("/nodir").should be_false
-        @metadir.directory?("/test/nodir").should be_false
-      end
-      
-      it "should indicate paths which are/are not files" do
-        @metadir.file?("/test").should be_false
-        @metadir.file?("/test/nodir").should be_false
-        @metadir.file?("/test/hello").should be_false
-        @metadir.file?("/test/hello/hello.txt").should be_true
-      end
-      
-      it "should indicate the size of a file" do
-        @metadir.size("/test/hello/hello.txt").should be "Hello World!\n".length
-      end
-
-      it "should report filesystem statistics" do
-          @metadir.statistics("/").should == [ 13, 5, nil, nil ]
-      end
-    end
-    
-    context "with write access" do
-      
-      around(:each) do |example|
-        FuseFS::RFuseFS.context(fuse_context(),&example)
-      end
-      
-      before(:each) do
-        FuseFS::reader_uid.should == Process.uid
-        FuseFS::reader_gid.should == Process.gid
-      end
-      
-      
-      it "should allow directory creation" do
-        @metadir.can_mkdir?("/test/otherdir").should be_true
-      end
-      
-      it "should allow file creation and update" do
-        @metadir.can_write?("/test/hello/newfile").should be_true
-        @metadir.can_write?("/test/hello/hello.txt").should be_true
-      end
-      
-      it "should read files" do
-        @metadir.read_file("/test/hello/hello.txt").should == "Hello World!\n"
-      end
-      
-      it "should update existing files" do
-        @metadir.write_to("/test/hello/hello.txt","new contents")
-        @metadir.read_file("/test/hello/hello.txt").should == "new contents"
-      end
-      
-      it "should not allow deletion of non empty directories" do
-        @metadir.can_rmdir?("/test/hello").should be_false
-      end
-      
-      it "should delete directories" do
-        @metadir.rmdir("/test/hello/emptydir")
-        @metadir.contents("/test/hello").should =~ ["hello.txt"]
-      end
-      
-      it "should allow and delete files" do
-        @metadir.can_delete?("/test/hello/hello.txt").should be_true
-        @metadir.delete("/test/hello/hello.txt")
-        @metadir.contents("/test/hello").should =~ ["emptydir"]
-      end
-      
-      it "should move directories at same level" do
-        before = @metadir.contents("/test/hello")
-        @metadir.rename("/test/hello","/test/moved").should be_true
-        @metadir.directory?("/test/moved").should be_true
-        @metadir.contents("/test/moved").should =~ before
-        @metadir.read_file("/test/moved/hello.txt").should == "Hello World!\n"
-      end
-
-      it "should move directories between different paths" do
-        @metadir.mkdir("/test/other")
-        @metadir.mkdir("/test/other/more")
-        before = @metadir.contents("/test/hello")
-        @metadir.rename("/test/hello","/test/other/more/hello").should be_true
-        @metadir.contents("/test/other/more/hello").should =~ before
-        @metadir.read_file("/test/other/more/hello/hello.txt").should == "Hello World!\n"
-      end
-
-      it "should maintain filesystem statistics" do
-        # remove a directory
-        @metadir.rmdir("/test/hello/emptydir")
-
-        # replace text for (the only)  existing file
-        @metadir.write_to("/test/hello/hello.txt","new text")
-        
-        @metadir.statistics("/").should == [ 8, 4, nil, nil ]
-      end
-    end
-    
-    context "with readonly access" do
-      around(:each) do |example|
-        #Simulate a different userid..
-        FuseFS::RFuseFS.context(fuse_context(-1,-1),&example)
-      end
-      
-      before(:each) do
-        FuseFS::reader_uid.should_not == Process.uid
-        FuseFS::reader_gid.should_not == Process.gid
-      end
-      
-      it "should not allow directory creation" do
-        @metadir.can_mkdir?("/test/anydir").should be_false
-        @metadir.can_mkdir?("/test/hello/otherdir").should be_false
-      end
-      
-      it "should not allow file creation or write access" do
-        @metadir.can_write?("/test/hello/hello.txt").should be_false
-        @metadir.can_write?("/test/hello/newfile").should be_false
-      end
-      
-      it "should not allow file deletion" do
-        @metadir.can_delete?("/test/hello/hello.txt").should be_false
-      end
-      
-      it "should not allow directory deletion" do
-        @metadir.can_rmdir?("/test/emptydir").should be_false
-      end
-      
-      it "should not allow directory renames" do
-        @metadir.rename("/test/emptydir","/test/otherdir").should be_false
-        #TODO and make sure it doesn't rename
-      end
-
-      it "should not allow file renames" do
-        @metadir.rename("test/hello/hello.txt","test/hello.txt2").should be_false
-        #TODO and make sure it doesn't rename
-      end
-    end
-    
-    context "with subdirectory containing another FuseFS" do
-      around(:each) do |example|
-        FuseFS::RFuseFS.context(fuse_context(),&example)
-      end
-
-      before(:each) do
-        @fusefs = mock("mock_fusefs")
-        @metadir.mkdir("/test")
-        @metadir.mkdir("/test/fusefs",@fusefs)
-      end
-
-      api_methods = [:directory?, :file?, :contents, :executable?, :size, :times, :read_file, :can_write?,  :can_delete?, :delete, :can_mkdir?, :can_rmdir?, :rmdir, :touch, :raw_open, :raw_truncate, :raw_read, :raw_write, :raw_close]
-      api_methods.each do |method|
-          it "should pass on #{method}" do
-             arity = FuseFS::FuseDir.instance_method(method).arity().abs - 1
-             args = Array.new(arity) { |i| i }
-             @fusefs.should_receive(method).with("/path/to/file",*args).and_return("anything")
-             @metadir.send(method,"/test/fusefs/path/to/file",*args)
-          end
-      end
-     
-      it "should pass on :write_to" do
-         @fusefs.should_receive(:write_to).with("/path/to/file","new contents\n")
-         @metadir.write_to("/test/fusefs/path/to/file","new contents\n")
-      end
-
-      it "should pass on :mkdir" do
-         @fusefs.should_receive(:mkdir).with("/path/to/file",nil).once().and_raise(ArgumentError)
-         @fusefs.should_receive(:mkdir).with("/path/to/file").once().and_return("true")
-         @metadir.mkdir("/test/fusefs/path/to/file")
-      end
-
-      it "should rename within same directory" do
-        @fusefs.should_receive(:rename).with("/oldfile","/newfile")
-        @metadir.rename("/test/fusefs/oldfile","/test/fusefs/newfile")
-      end
-
-      it "should pass rename down common directories" do
-        @fusefs.should_receive(:rename).with("/path/to/file" ,"/new/path/to/file")
-        @metadir.rename("/test/fusefs/path/to/file","/test/fusefs/new/path/to/file")
-      end
-
-      it "should rename across directories if from_path is a FuseFS object that accepts extended rename" do
-        @fusefs.should_receive(:rename).with("/path/to/file","/nonfusepath",
-                    an_instance_of(FuseFS::MetaDir)) do | myPath, extPath, extFS |
-                        extFS.write_to(extPath,"look Mum, no hands!")
-                    end
-
-        @metadir.rename("/test/fusefs/path/to/file","/test/nonfusepath").should be_true
-        @metadir.read_file("/test/nonfusepath").should == "look Mum, no hands!"
-      end
-
-      it "should quietly return false if from_path is a FuseFS object that does not accept extended rename" do
-        @fusefs.should_receive(:rename).
-            with("/path/to/file","/nonfusepath",an_instance_of(FuseFS::MetaDir)).
-                and_raise(ArgumentError)
-        @metadir.rename("/test/fusefs/path/to/file","/test/nonfusepath").should be_false
-
-      end
-
-      it "should not attempt rename file unless :can_write? the destination" do
-        @fusefs.should_receive(:can_write?).with("/newpath/to/file").and_return(false)
-        @metadir.write_to("/test/aFile","some contents")
-        @metadir.rename("/test/aFile","/test/fusefs/newpath/to/file").should be_false
-      end
-
-      it "should not attempt rename directory unless :can_mkdir? the destination" do
-        @fusefs.should_receive(:can_mkdir?).with("/newpath/to/dir").and_return(false)
-        @metadir.mkdir("/test/aDir","some contents")
-        @metadir.rename("/test/aDir","/test/fusefs/newpath/to/dir").should be_false
-      end
-
-      it "should pass on #statistics" do
-        @fusefs.should_receive(:statistics).with("/path/to/file")
-
-        @metadir.statistics("test/fusefs/path/to/file")
-      end
-
-      it "should pass on #statistics for root" do
-        @fusefs.should_receive(:statistics).with("/")
-
-        @metadir.statistics("test/fusefs")
-      end
-    end
-    
-  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
-        metadir.mkdir("/test")
-        metadir.write_to("/test/hello.txt","Hello World!\n")
-        metadir.xattr("/test/hello.txt")["user.test"] = "an extended attribute"
-        metadir.xattr("/test")["user.test"] = "a dir attribute"
-		FuseFS.mount(metadir,mountpoint)
-		#Give FUSE some time to get started 
-		sleep(0.5)
-	end
-	
-	after(:all) do
-		FuseFS.unmount(mountpoint)
-        sleep(0.5)
-        FileUtils.rm_r(mountpoint)
-	end
-	
-    it "should list directory contents" do
-		testdir.entries().should =~ pathnames(".","..","hello.txt")
-    end
-
-    it "should read files" do
-        testfile.file?.should be_true
-		testfile.read().should == "Hello World!\n"
-    end
-
-    it "should read and write extended attributes from files" do
-        x = Xattr.new(testfile.to_s)
-        x["user.test"].should == "an extended attribute"
-
-        x["user.new"] = "new"
-        
-        Xattr.new(testfile.to_s)["user.new"].should == "new"
-    end
-
-    it "should write extended attributes for directories" do
-        x = Xattr.new(testdir.to_s)
-
-        x["user.test"].should == "a dir attribute"
-        x["user.new"] = "new dir"
-        
-        Xattr.new(testdir.to_s)["user.new"].should == "new dir"
-    end
-
-
-    it "should create directories" do
-        newdir = testdir + "newdir"
-        newdir.mkdir()
-        newdir.directory?.should be_true
-        testdir.entries().should =~ pathnames(".","..","hello.txt","newdir")
-    end
-
-    it "should create files" do
-        newfile = testdir + "newfile"
-        newfile.open("w") do |file|
-            file << "A new file\n"
-        end
-        newfile.read.should == "A new file\n"
-    end
-
-    it "should move directories" do
-        fromdir = testdir + "fromdir"
-        fromdir.mkdir()
-        subfile = fromdir + "afile"
-        subfile.open("w") do |file|
-           file << "testfile\n"
-        end
-
-        movedir = (mountpoint + "movedir")
-        movedir.directory?.should be_false
-        fromdir.rename(movedir)
-        movedir.directory?.should be_true
-        
-        subfile = movedir + "afile"
-        subfile.file?.should be_true
-        subfile.read.should == "testfile\n"
-    end
-
-    it "should move files" do
-        movefile = (mountpoint + "moved.txt")
-        movefile.file?.should be_false
-        testfile.should be_true
-        testfile.rename(movefile)
-        movefile.read.should == "Hello World!\n"
-    end
-
-
-    it "should report filesystem statistics" do
-        bigfile = testdir + "bigfile"
-        bigfile.open("w") do |file|
-            file << ("x" * 2048)
-        end
-      
-        statfs = Sys::Filesystem.stat(mountpoint.to_s)
-
-        # These are fixed
-        statfs.block_size.should == 1024
-        statfs.fragment_size.should == 1024
-
-        # These are dependant on the tests above creating files/directories
-        statfs.files.should == 8
-        statfs.files_available == 8
-
-        # assume test are less than 1 block, so dependant on bigfile above
-        statfs.blocks.should == 2
-        statfs.blocks_available.should == 0
-        statfs.blocks_free.should == 0
-    end
-  end
-  
-end