rfusefs 1.0.2.RC1 → 1.1.0

data/lib/fusefs/sqlitemapper.rb

@@ -1,115 +0,0 @@
-require 'fusefs/pathmapper'
-require 'sqlite3'
-require 'thread'
-
-module FuseFS
-
-    class SqliteMapperFS < PathMapperFS
-
-        # The database file
-        attr_reader :db_path
-
-        # The database connection
-        attr_reader :db
-
-        # Maintains a count of the number of times through the scan loop
-        attr_reader :scan_id
-
-        # 
-        #
-        # @param [String] db_path Path to Sqlite database
-        # @param [String] sql query
-        # @param [Hash] options see {PathMapperFS#initialize}
-        # @yieldparam [Row] row to map
-        # @yieldreturn [String,String,Hash<Symbol,Object>] newpath, realpath, options
-        #   * newpath - the mapped path
-        #   * realpath -  path to the real file
-        #   * options -  additional information to store with this path
-        def initialize(db_path,sql,options = { },&row_mapper)
-            @db_path = db_path.to_s
-            @sql = sql.to_s
-            define_singleton_method(:map_row,row_mapper) if block_given?
-            super(options)
-        end
-
-        # Maps a row into a new filepath
-        #
-        # @param [Hash] row sqlite result hash for a row
-        # @return [String,String,Hash<Symbol,Object>] newpath, realpath, options
-        #   * newpath - the mapped path
-        #   * realpath -  path to the real file
-        #   * options -  additional information to store with this path
-        # @abstract
-        def map_row(row)
-            raise NotImplementedError, "abstract method #{__method__} not implemented"
-        end
-
-        # FuseFS callback when the filesystem is mounted
-        # Starts the scanning loop and performs the initial scan
-        # @api FuseFS
-        def mounted()
-            @mounted = true
-            @mutex = Mutex.new
-            @cv = ConditionVariable.new
-            @scan_thread = Thread.new() { scan_loop() }
-        end
-
-        # FuseFS callback when filesystem is unmounted
-        # 
-        # Stops the database watching threads
-        # @api FuseFS
-        def unmounted()
-            @mounted = false
-            @mutex.synchronize { @cv.signal() }
-            @scan_thread.join
-        end
-
-
-        # Trigger a rescan of the database
-        def rescan()
-            @mutex.synchronize { @cv.signal() }
-        end
-
-        # Executes the sql query and passes each row to map_row (or the block passed in {#initialize})
-        #
-        # Subclasses can override this method for pre/post scan processing, calling super as required
-        def scan()
-            db.execute(@sql) do |row|
-                new_path, real_path, options =  map_row(row)
-                options ||= {}
-                options[:sqlite_scan_id] = @scan_id
-                begin
-                    map_file(new_path, real_path, options)
-                rescue StandardError => e
-                    puts e
-                    puts e.backtrace.join("\n")
-                end
-            end
-            cleanup() { |file_node| file_node.options[:sqlite_scan_id] != @scan_id }
-        end
-
-        private
-
-        def scan_loop()
-            @mutex.synchronize() do
-                @scan_id = 0
-                while @mounted
-                    begin
-                        @db = SQLite3::Database.new(@db_path,:readonly => true)
-                        @db.results_as_hash = true
-                        @db.busy_timeout(10000)
-                        @scan_id = @scan_id + 1
-                        scan()
-                    rescue StandardError => e
-                        puts e
-                        puts e.backtrace.join("\n")
-                    ensure
-                        @db.close unless @db.closed?
-                        @db = nil
-                    end
-                    @cv.wait(@mutex) 
-                end
-            end
-        end
-    end
-end

data/lib/rfusefs/version.rb

@@ -1,3 +0,0 @@
-module RFuseFS
-    VERSION="1.0.2.RC1"
-end

data/rfusefs.gemspec

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "rfusefs/version"
-
-Gem::Specification.new do |s|
-  s.name        = "rfusefs"
-  s.version     = RFuseFS::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Grant Gardner"]
-  s.email       = ["grant@lastweekend.com.au"]
-  s.homepage    = "http://rubygems.org/gems/rfusefs"
-  s.summary     = %q{Filesystem in Ruby Userspace}
-  s.description = %q{A more Ruby like way to write FUSE filesystems - inspired by (compatible with) FuseFS, implemented over RFuse}
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,spec-fusefs}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.has_rdoc = 'yard'
-  s_extra_rdoc_files = 'History.rdoc'
-
-  s.add_dependency("rfuse", ">= 1.0.5RC0")
-  s.add_development_dependency("rake")
-  s.add_development_dependency("rspec")
-  s.add_development_dependency("yard")
-  s.add_development_dependency("redcarpet")
-  s.add_development_dependency("sqlite3")
-  s.add_development_dependency("sys-filesystem")
-  s.add_development_dependency("ffi-xattr", ">= 0.1.1")
-end

data/samples/demo.rb

@@ -1,57 +0,0 @@
-require "rubygems"
-require 'rfusefs'
-require 'fusefs/metadir'
-require 'fusefs/dirlink'
-
-include FuseFS
-
-root = MetaDir.new
-root.stats.total_space = 1024*1024
-root.stats.total_nodes = 1024
-root.stats.strict = true
-
-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']}",FuseFS::DirLink.new(ENV['HOME']))
-
-FuseFS.main(ARGV) { | options | root }

data/samples/dictfs.rb

@@ -1,74 +0,0 @@
-# dictfs.rb
-
-require "rubygems"
-require 'fusefs'
-include FuseFS
-
-#TODO: GG Don't know which "dict" this was referring to
-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__))
-  unless (ARGV.length > 0 && File.directory?(ARGV[0]))
-    puts "Usage: #{$0} <mountpoint> <mount_options>"
-    exit
-  end
-
-  root = DictFS.new
-
-  # Set the root FuseFS
-  FuseFS.start(root,*ARGV)
-
-end

data/samples/hello.rb

@@ -1,20 +0,0 @@
-class HelloDir
-  def contents(path)
-    ['hello.txt']
-  end
-  
-  def file?(path)
-    path == '/hello.txt'
-  end
-  
-  def read_file(path)
-    "Hello, World!\n"
-  end
-
-end
-
-if __FILE__ == $0
-	require 'rfusefs'
-	hellodir = HelloDir.new
-    FuseFS.start(hellodir,*ARGV)
-end

data/samples/openurifs.rb

@@ -1,53 +0,0 @@
-# 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/samples/railsfs.rb

@@ -1,77 +0,0 @@
-#!/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/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