pfuse 0.7.5

data/lib/fusefs.rb

@@ -0,0 +1,114 @@
+# FuseFS.rb
+#
+# The ruby portion of FuseFS main library
+#
+# Helper functions
+
+# TODO sig handler?
+
+require File.dirname(__FILE__) + '/../ext/fusefs_lib'
+
+module FuseFS
+  S_IFDIR = 0o0040000
+  S_IFREG = 0o0100000
+
+  @running = true
+
+  class << self
+    def run
+      fd = fuse_fd
+
+      begin
+        io = IO.for_fd(fd)
+      rescue Errno::EBADF
+        raise "fuse is not mounted"
+      end
+
+      while @running
+        IO.select([io])
+        process
+      end
+    end
+
+    def unmount
+      system("umount #{@mountpoint}")
+    end
+
+    def exit
+      @running = false
+    end
+
+    def Entries(path, entries)
+      entries.map do |entry|
+        @root.getattr(File.join(path, entry))
+      end
+    end
+
+  end
+
+  class Stat
+    attr_accessor :st_mode
+    attr_accessor :st_nlink
+    attr_accessor :st_size
+    attr_accessor :st_uid
+    attr_accessor :st_gid
+    attr_accessor :st_mtime
+    attr_accessor :st_atime
+    attr_accessor :st_ctime
+    attr_accessor :name
+
+    def initialize(name='undefined')
+      @st_mode  = 0o755 | mode_mask
+      @st_nlink = 3
+      @st_size  = 0
+      @st_uid   = Process.uid
+      @st_gid   = Process.gid
+      @st_mtime = Time.now.to_i
+      @st_atime = Time.now.to_i
+      @st_ctime = Time.now.to_i
+      @name     = name
+    end
+
+    def mode_mask
+      self.class == FileEntry ? S_IFREG : S_IFDIR
+    end
+  end
+
+  class FileEntry < Stat
+  end
+
+  class DirEntry < Stat
+    def initialize(*args)
+      super(*args)
+      @st_size = 4096
+    end
+  end
+
+  class StatVFS
+    attr_accessor :f_bsize
+    attr_accessor :f_frsize
+    attr_accessor :f_blocks
+    attr_accessor :f_bfree
+    attr_accessor :f_bavail
+    attr_accessor :f_files
+    attr_accessor :f_ffree
+    attr_accessor :f_favail
+    attr_accessor :f_fsid
+    attr_accessor :f_flag
+    attr_accessor :f_namemax
+
+    def initialize
+      @f_bsize   = 0
+      @f_frsize  = 0
+      @f_blocks  = 0
+      @f_bfree   = 0
+      @f_bavail  = 0
+      @f_files   = 0
+      @f_ffree   = 0
+      @f_favail  = 0
+      @f_fsid    = 0
+      @f_flag    = 0
+      @f_namemax = 0
+    end
+  end
+end

data/pfuse.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pfuse}
+  s.version = "0.7.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Turnbull", "Kyle Maxwell"]
+  s.date = %q{2010-02-26}
+  s.description = %q{Gemified}
+  s.email = %q{dsturnbull@gmail.com}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README",
+     "TODO"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "API.txt",
+     "Changes.txt",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "ext/extconf.rb",
+     "ext/fusefs_fuse.c",
+     "ext/fusefs_fuse.h",
+     "ext/fusefs_lib.c",
+     "ext/fusefs_lib.h",
+     "hello.sh",
+     "lib/fusefs.rb",
+     "pfuse.gemspec",
+     "sample/demo.rb",
+     "sample/dictfs.rb",
+     "sample/hello.rb",
+     "sample/openurifs.rb",
+     "sample/railsfs.rb",
+     "sample/sqlfs.rb",
+     "sample/yamlfs.rb",
+     "test/fusefs_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/dsturnbull/pfuse}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{fusefs}
+  s.test_files = [
+    "test/fusefs_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/sample/demo.rb

@@ -0,0 +1,100 @@
+require "rubygems"
+require 'fusefs'
+include FuseFS
+
+root = MetaDir.new
+
+# if (ARGV.size != 1)
+#   puts "Usage: #{$0} <directory>"
+#   exit
+# end
+
+dirname = ARGV.shift
+
+unless File.directory?(dirname)
+  puts "Usage: #{$0} <directory>"
+  exit
+end
+
+class DirLink
+  def initialize(dir)
+    File.directory?(dir) or raise ArgumentError, "DirLink.initialize expects a valid directory!"
+    @base = dir
+  end
+  def directory?(path)
+    File.directory?(File.join(@base,path))
+  end
+  def file?(path)
+    File.file?(File.join(@base,path))
+  end
+  def contents(path)
+    fn = File.join(@base,path)
+    Dir.entries(fn).map { |file|
+      file = file.sub(/^#{fn}\/?/,'')
+      if ['..','.'].include?(file)
+        nil
+      else
+        file
+      end
+    }.compact.sort
+  end
+  def read_file(path)
+    fn = File.join(@base,path)
+    if File.file?(fn)
+      IO.read(fn)
+    else
+      'No such file'
+    end
+  end
+end
+
+class Counter
+  def initialize
+    @counter = 0
+  end
+  def to_s
+    @counter += 1
+    @counter.to_s + "\n"
+  end
+  def size
+    @counter.to_s.size
+  end
+end
+
+class Randwords
+  def initialize(*ary)
+    @ary = ary.flatten
+  end
+  def to_s
+    @ary[rand(@ary.size)].to_s + "\n"
+  end
+  def size
+    @size ||= @ary.map{|v| v.size}.max
+  end
+end
+
+root.write_to('/hello',"Hello, World!\n")
+
+progress = '.'
+
+root.write_to('/progress',progress)
+
+Thread.new do
+  20.times do
+    sleep 5
+    progress << '.'
+  end
+end
+
+root.write_to('/counter',Counter.new)
+root.write_to('/color',Randwords.new('red','blue','green','purple','yellow','bistre','burnt sienna','jade'))
+root.write_to('/animal',Randwords.new('duck','dog','cat','duck billed platypus','silly fella'))
+
+root.mkdir("/#{ENV['USER']}",DirLink.new(ENV['HOME']))
+
+# Set the root FuseFS
+FuseFS.set_root(root)
+
+FuseFS.mount_under(dirname, 'nolocalcaches', *ARGV)
+
+FuseFS.run # This doesn't return until we're unmounted.

data/sample/dictfs.rb

@@ -0,0 +1,84 @@
+# dictfs.rb
+#
+
+require "rubygems"
+require 'fusefs'
+include FuseFS
+
+require 'dict'
+
+class DictFS < FuseFS::FuseDir
+  def initialize
+    @servers = ['dict.org','alt0.dict.org']
+    @database = DICT::ALL_DATABASES
+    @strategy = 'exact'
+    @match_strategy = DICT::DEFAULT_MATCH_STRATEGY
+    @port = DICT::DEFAULT_PORT
+
+    @dict = DICT.new(@servers, @port, false, false)
+    @dict.client("%s v%s" % ["Dictionary","1.0"])
+  end
+  def contents(path)
+    # The 'readme' file
+    ['readme']
+  end
+  def file?(path)
+    base, rest = split_path(path)
+    rest.nil? # DictFS doesn't have subdirs.
+  end
+  def read_file(path)
+    word, rest = split_path(path)
+    word.downcase!
+    if word == "readme"
+      return %Q[
+DictFS: You may not see the files, but if you cat any file here, it will look
+that file up on dict.org!
+].lstrip
+    end
+    puts "Looking up #{word}"
+    m = @dict.match(@database, @strategy, word)
+    if m
+      contents = []
+      m.each do |db,words|
+        words.each do |w|
+          defs = @dict.define(db,w)
+          str = []
+          defs.each do |d|
+            str << "Definition of '#{w}' (by #{d.description})"
+            d.definition.each do |line|
+              str << "  #{line.strip}"
+            end
+            contents << str.join("\n")
+          end
+        end
+      end
+      contents << ''
+      contents.join("\n")
+    else
+      "No dictionary definitions found\n"
+    end
+  end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+  if (ARGV.size != 1)
+    puts "Usage: #{$0} <directory>"
+    exit
+  end
+
+  dirname = ARGV.shift
+
+  unless File.directory?(dirname)
+    puts "Usage: #{dirname} is not a directory."
+    exit
+  end
+
+  root = DictFS.new
+
+  # Set the root FuseFS
+  FuseFS.set_root(root)
+
+  FuseFS.mount_under(dirname)
+
+  FuseFS.run # This doesn't return until we're unmounted.
+end

data/sample/hello.rb

@@ -0,0 +1,27 @@
+require "rubygems"
+require 'fusefs'
+
+class HelloDir
+  def contents(path)
+    ['hello.txt']
+  end
+  
+  def file?(path)
+    path == '/hello.txt'
+  end
+  
+  def read_file(path)
+    "Hello, World!\n"
+  end
+
+  def size(path)
+    read_file(path).size
+  end
+end
+
+hellodir = HelloDir.new
+FuseFS.set_root( hellodir )
+
+# Mount under a directory given on the command line.
+FuseFS.mount_under ARGV.shift
+FuseFS.run

data/sample/openurifs.rb

@@ -0,0 +1,53 @@
+# openurifs.rb
+#
+
+require "rubygems"
+require 'fusefs'
+include FuseFS
+
+require 'open-uri'
+
+class OpenUriFS < FuseFS::FuseDir
+  def contents(path)
+    # The 'readme' file
+    []
+  end
+  def directory?(path)
+    uri = scan_path(path)
+    fn = uri.pop
+    return true if fn =~ /\.(com|org|net|us|de|jp|ru|uk|biz|info)$/
+    return true if fn =~ /^\d+\.\d+\.\d+\.\d+$/
+    ! (fn =~ /\./) # Does the last item doesn't contain a '.' ?
+  end
+  def file?(path)
+    !directory?(path)
+  end
+  def read_file(path)
+    proto, rest = split_path(path)
+    uri = "#{proto}://#{rest}"
+    open(uri).read
+  end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+  if (ARGV.size != 1)
+    puts "Usage: #{$0} <directory>"
+    exit
+  end
+
+  dirname = ARGV.shift
+
+  unless File.directory?(dirname)
+    puts "Usage: #{dirname} is not a directory."
+    exit
+  end
+
+  root = OpenUriFS.new
+
+  # Set the root FuseFS
+  FuseFS.set_root(root)
+
+  FuseFS.mount_under(dirname)
+
+  FuseFS.run # This doesn't return until we're unmounted.
+end

data/sample/railsfs.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+#
+# RailsFS, as written by _why_the_lucky_stiff
+#
+# Full instructions:
+#   http://redhanded.hobix.com/inspect/railsfsAfterACoupleMinutesOfToolingWithFuseWhoa.html
+#
+=begin
+Instructions cut and paste from _why's blog:
+
+Save the railfs.rb script as script/filesys in your Rails app. (If you'd
+rather not cut-and-paste the above, it's here.)
+
+Now, run mkdir ~/railsmnt. Then, script/filesys ~/railsmnt. The rules are as
+follows:
+
+    * ls ~/railsmnt will give you a list of tables.
+    * ls ~/railsmnt/table will list IDs from the table.
+    * cat ~/railsmnt/table/id will display a record in YAML.
+    * vim ~/railsmnt/table/id to edit the record in YAML!
+
+=end
+
+require "rubygems"
+require 'fusefs'
+require File.dirname(__FILE__) + '/../config/environment'
+
+class RailsFS < FuseFS::FuseDir
+    def initialize
+        @classes = {}
+        require 'find'
+        Find.find( File.join(RAILS_ROOT, 'app/models') ) do |model| 
+            if /(\w+)\.rb$/ =~ model
+                model = $1
+                ( @classes[model] = Kernel::const_get( Inflector.classify( model ) ) ).
+                    find :first rescue @classes.delete( model )
+            end
+        end
+    end
+    def directory? path
+        tname, key = scan_path path
+        table = @classes[tname]
+        if table.nil?; false  # /table
+        elsif key;     false  # /table/id
+        else; true end
+    end
+    def file? path
+        tname, key = scan_path path
+        table = @classes[tname]
+        key and table and table.find( key )
+    end
+    def can_delete?; true end
+    def can_write? path; file? path end
+    def contents path
+        tname, key = scan_path path
+        table = @classes[tname]
+        if tname.nil?; @classes.keys.sort  # /
+        else; table.find( :all ).map { |o| o.id.to_s } end  # /table
+    end
+    def write_to path, body
+        obj = YAML::load( body )
+        obj.save
+    end
+    def read_file path
+        tname, key = scan_path path
+        table = @classes[tname]
+        YAML::dump( table.find( key ) )
+    end
+end
+
+if (File.basename($0) == File.basename(__FILE__))
+    root = RailsFS.new
+    FuseFS.set_root(root)
+    FuseFS.mount_under(ARGV[0])
+    FuseFS.run # This doesn't return until we're unmounted.
+end
+

data/sample/sqlfs.rb

@@ -0,0 +1,134 @@
+# 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