rfusefs 1.0.0 → 1.0.1.RC0

data/.gitignore

@@ -1,8 +1,8 @@
 #No hidden files (except for .gitignore)
 .*
 !.gitignore
+!.travis.yml
 #Files generated by rake
-rfusefs.gemspec
 doc
 pkg
 #Jedit stupid default backup settings

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.3"
+  - "2.0.0"
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libfuse-dev

data/README.rdoc

@@ -16,22 +16,7 @@ RFuseFS is api compatible with FuseFS (0.7.0)
 FuseFS provides a layer of abstraction to a programmer who wants to create a
 virtual filesystem via FUSE.
 
-FuseFS programs consist of two parts:
-
-1. FuseFS, which is defined in 'rfusefs.rb'
-2. An object that defines a virtual directory by subclassing {FuseFS::FuseDir}
-
-To write a FuseFS program, you must:
-
-* Define and create a Directory object that responds to the methods required
-  by FuseFS for its desired use.
-
-* Call
-       
-       FuseFS.start <virtualdir> <mountpoint> [mount_options]
-
-  where <virtualdir> with an object defining your virtual directory.
-  and <mountpoint> is a real directory on your filesystem
+First define a virtual directory by subclassing {FuseFS::FuseDir}
 
 See samples under /samples and also the following starter classes
 
@@ -39,13 +24,19 @@ See samples under /samples and also the following starter classes
 * {FuseFS::MetaDir}
 * {FuseFS::DirLink}
 * {FuseFS::PathMapperFS}
+* {FuseFS::SqliteMapperFS}
 
-To use the filesystem open up your favourite file browser/terminal and
+Then start your filesystem with
+
+* {FuseFS.start}
+* {FuseFS.main}
+
+Finally to use the filesystem open up your favourite file browser/terminal and
 explore the contents under <mountpoint>
 
 Happy Filesystem Hacking!
 
-=== the hello world filesystem in 14 LOC
+=== the hello world filesystem in 16 LOC
 
   require 'rfusefs'
 
@@ -59,12 +50,13 @@ Happy Filesystem Hacking!
     def read_file(path)
       "Hello, World!\n"
     end
+    def size(path)
+      read_file(path).size
+    end
   end
 
-  hellodir = HelloDir.new
-
   # Usage: #{$0} mountpoint [mount_options]
-  FuseFS.start(hellodir,*ARGV)
+  FuseFS.main() { |options| HelloDir.new }
 
 == REQUIREMENTS:
 

data/Rakefile

@@ -15,4 +15,5 @@ RSpec::Core::RakeTask.new("spec:fusefs") do |t|
   t.pattern = 'spec-fusefs/**/*_spec.rb'
 end
 
+task :default => ["spec","spec:fusefs"]
 # vim: syntax=ruby

data/lib/fuse/fusedir.rb

@@ -196,6 +196,21 @@ module FuseFS
         # @abstract FuseFS api
         def raw_close(path,raw=nil);end
 
+        # RFuseFS extension.
+        # Extended attributes. These will be set/retrieved/removed directly
+        # @param [String] path
+        # @return [Hash] extended attributes for this path
+        # @abstract FuseFS api
+        def xattr(path); return {}; end
+
+        # RFuseFS extension.
+        # Called when the filesystem is mounted
+        def mounted();end
+
+        # RFuseFS extension.
+        # Called when the filesystem is unmounted
+        def unmounted();end
+
     end
 
     DEFAULT_FS = FuseDir.new()

data/lib/fuse/rfusefs-fuse.rb

@@ -371,17 +371,27 @@ module FuseFS
         #def link(path,as)
         #end
 
-        # def setxattr(path,name,value,size,flags)
-        # end
+        def setxattr(ctx,path,name,value)
+            return wrap_context(ctx,__method__,path,name,value) if ctx
+            @root.xattr(path)[name]=value
+        end
 
-        # def getxattr(path,name,size)
-        # end
+        def getxattr(ctx,path,name)
+            return wrap_context(ctx,__method__,path,name) if ctx
+            result = @root.xattr(path)[name]
+            raise Errno::ENODATA.new("No attribute #{name}") unless result
+            result
+        end
 
-        # def listxattr(path,size)
-        # end
+        def listxattr(ctx,path)
+            return wrap_context(ctx,__method__,path) if ctx
+            @root.xattr(path).keys
+        end
 
-        # def removexattr(path,name)
-        # end
+        def removexattr(ctx,path,name)
+            return wrap_context(ctx,__method__,path,name) if ctx
+            @root.xattr(path).delete(name)
+        end
 
         #def opendir(path,ffi)
         #end
@@ -396,6 +406,14 @@ module FuseFS
         #def statfs(path)   
         #end
 
+    def mounted()
+        @root.mounted()
+    end
+
+    def unmounted()
+        @root.unmounted()
+    end
+
     def self.context(ctx,&block)
         begin
             Thread.current[:fusefs_reader_uid] = ctx.uid

data/lib/fusefs/metadir.rb

@@ -189,7 +189,8 @@ module FuseFS
         end
 
         default_methods = FuseDir.public_instance_methods.select { |m| 
-            !self.public_method_defined?(m) && FuseDir.instance_method(m).owner == FuseDir
+            ![:mounted,:unmounted].include?(m) &&
+                !self.public_method_defined?(m) && FuseDir.instance_method(m).owner == FuseDir
         }
 
         default_methods.each do |m|

data/lib/fusefs/pathmapper.rb

@@ -1,10 +1,78 @@
 
 module FuseFS
 
-    # A FuseFS that maps files from files from their original location into a new path
+    # A FuseFS that maps files from their original location into a new path
     # eg tagged audio files can be mapped by title etc...
+    #
     class PathMapperFS < FuseDir
-        # Convert raw_mode strings to IO open mode strings
+
+        # Represents a mappted file or directory
+        class MNode
+            
+            # @return [Hash<String,MNode>] list of files in a directory, nil for file nodes
+            attr_reader :files
+
+            # @return [MNode] parent directory
+            attr_reader :parent
+
+            # @return [Hash] metadata for this node
+            attr_reader :options
+
+            # @return [String] path to backing file, or nil for directory nodes
+            attr_reader :real_path
+
+            # @!visibility private
+            def initialize(parent_dir)
+                @parent = parent_dir
+                @files = {}
+                @options = {}
+            end
+
+            # @!visibility private
+            def init_file(real_path,options)
+                @options = options
+                @real_path = real_path
+                @files = nil
+            end
+
+            # @return [Boolean] true if node represents a file, otherwise false
+            def file?
+                real_path && true
+            end
+
+            # @return [Boolean] true if node represents a directory, otherwise false
+            def directory?
+                files && true
+            end
+
+            # @return [Boolean] true if node is the root directory
+            def root?
+                @parent.nil?
+            end
+
+            # Compatibility and convenience method
+            # @param [:pm_real_path,String,Symbol] key 
+            # @return [String] {#real_path} if key == :pm_real_path 
+            # @return [MNode] the node representing the file named key
+            # @return [Object] shortcut for {#options}[key] 
+            def[](key)
+                case key
+                when :pm_real_path
+                    real_path
+                when String
+                    files[key]
+                else
+                    options[key]
+                end
+            end
+
+            # Convenience method to set metadata into {#options}
+            def[]=(key,value)
+                options[key]=value
+            end
+        end
+
+        # Convert FuseFS raw_mode strings to IO open mode strings
         def self.open_mode(raw_mode)
             case raw_mode
             when "r"
@@ -12,107 +80,163 @@ module FuseFS
             when "ra"
                 "r" #not really sensible..
             when "rw"
-                "w+"
+                "r+"
             when "rwa"
                 "a+"
-            when
+            when "w"
                 "w"
             when "wa"
                 "a"
             end
         end
-        attr_accessor :use_raw_file_access, :allow_write 
-        #Creates a PathMapperFS
-        #See #mapDirectory
+
+        # should raw file access should be used - useful for binary files
+        # @return [Boolean]
+        #   default is false
+        attr_accessor :use_raw_file_access
+
+        # should filesystem support writing through to the real files
+        # @return [Boolean]
+        #     default is false
+        attr_accessor  :allow_write
+
+        # Creates a new Path Mapper filesystem over an existing directory
+        # @param [String] dir
+        # @param [Hash] options
+        # @yieldparam [String] file path to map
+        # @yieldreturn [String] 
+        # @see #initialize
+        # @see #map_directory
         def PathMapperFS.create(dir,options={ },&block)
             pm_fs = PathMapperFS.new(options)
-            pm_fs.mapDirectory(dir) do |file|
-                block.call(file)
-            end
+            pm_fs.map_directory(dir,&block) 
             return pm_fs
         end
 
+        # Create a new Path Mapper filesystem
+        # @param [Hash]  options
+        # @option options [Boolean] :use_raw_file_access
+        # @option options [Boolean] :allow_write
         def initialize(options = { })
-            @root = { }
+            @root = MNode.new(nil)
             @use_raw_file_access = options[:use_raw_file_access]
             @allow_write = options[:allow_write]
         end
+        
+        # Recursively find all files and map according to the given block
+        # @param [String...] dirs directories to list
+        # @yieldparam [String] file path to map
+        # @yieldreturn [String] the mapped path
+        # @yieldreturn nil to skip mapping this file
+        def map_directory(*dirs)
+            require 'find'
+            Find.find(*dirs) do |file|
+                new_path = yield file
+                map_file(file,new_path) if new_path
+            end
+        end
+        alias :mapDirectory :map_directory
 
-        # Adds new_path to our list of mapped files
+
+        # Add (or replace) a mapped file
         #
-        # Returns a hash entry which stores the real_path under the :pm_real_path key.
-        def mapFile(real_path,new_path)
+        # @param [String] real_path pointing at the real file location
+        # @param [String] new_path the mapped path
+        # @param [Hash<Symbol,Object>] options metadata for this path
+        # @option options [Hash<String,String>] :xattr hash to be used as extended attributes
+        # @return [MNode]
+        #    a node representing the mapped path. See {#node}
+        def map_file(real_path,new_path,options = {})
             #split path into components 
-            components = new_path.scan(/[^\/]+/)
+            components = new_path.to_s.scan(/[^\/]+/)
 
             #create a hash of hashes to represent our directory structure
-            new_file = components.inject(@root) { |directory, file|
-                directory[file] ||= Hash.new()
+            new_file = components.inject(@root) { |parent_dir, file|
+                parent_dir.files[file] ||= MNode.new(parent_dir)
             }
-            new_file[:pm_real_path] = real_path
+            new_file.init_file(real_path,options)
+          
             return new_file
         end
+        alias :mapFile :map_file
+        
+        # Retrieve in memory node for a mapped path
+        #
+        # @param [String] path
+        # @return [MNode] in memory node at path
+        # @return nil if path does not exist in the filesystem
+        def node(path)
+            path_components = scan_path(path)
 
-        # Convenience method to recursively map all files according to the given block
-        def mapDirectory(*dirs)
-            require 'find'
-            Find.find(*dirs) do |file|
-                new_path = yield file
-                mapFile(file,new_path) if new_path
-            end
+            #not actually injecting anything here, we're just following the hash of hashes...
+            path_components.inject(@root) { |dir,file|
+                break unless dir.files[file]
+                dir.files[file]
+            }
         end
 
         # Takes a mapped file name and returns the original real_path
         def unmap(path)
-            possible_file = node(path)
-            return possible_file ? possible_file[:pm_real_path] : nil
+            node = node(path)
+            (node && node.file?) ? node.real_path : nil
         end
+        
+        # Deletes files and directories.
+        # Yields each {#node} in the filesystem and deletes it if the block returns true
+        #
+        # Useful if your filesystem is periodically remapping the entire contents and you need
+        # to delete entries that have not been touched in the latest scan
+        #
+        # @yieldparam [Hash] filesystem node 
+        # @yieldreturn [true,false] should this node be deleted
+        def cleanup(&block)
+           recursive_cleanup(@root,&block) 
+        end
+
 
-        # Returns true for any directory referenced by a mapped file
-        # See FuseFS API.txt		
+        # @!visibility private
         def directory?(path)
             possible_dir = node(path)
-            possible_dir && !possible_dir[:pm_real_path]
+            possible_dir && possible_dir.directory?
         end
 
-        # See FuseFS API.txt
-        # expects to be called only if directory? returns true
+        # @!visibility private
         def contents(path)
-            node(path).keys
+            node(path).files.keys
         end
 
-        # See FuseFS API.txt
+        # @!visibility private
         def file?(path)
             filename = unmap(path)
             filename && File.file?(filename)
         end
 
-        # See FuseFS API.txt
+        # @!visibility private
         # only called if option :raw_reads is not set
         def read_file(path)
             IO.read(unmap(path))
         end
 
+        # @!visibility private
         # We can only write to existing files
         # because otherwise we don't have anything to back it
         def can_write?(path)
             @allow_write && file?(path)
         end
 
-        # TODO: This can't possibly work- the path is not unmapped
-        # and we don't open the file for writing
+        # @!visibility private
         def write_to(path,contents)
-            File.open(path) do |f|
+            File.open(unmap(path),"w") do |f|
                 f.print(contents)
             end
         end
 
-        # See FuseFS API.txt
+        # @!visibility private
         def size(path)
             File.size(unmap(path))
         end
 
-        # See RFuseFS API.txt
+        # @!visibility private
         def times(path)
             realpath = unmap(path)
             if (realpath)
@@ -124,7 +248,12 @@ module FuseFS
             end
         end
 
-        # See FuseFS API.txt
+        # @!visibility private
+        def xattr(path)
+            result = node(path).options[:xattr] || {}
+        end
+
+        # @!visibility private
         # Will create, store and return a File object for the underlying file
         # for subsequent use with the raw_read/raw_close methods
         # expects file? to return true before this method is called
@@ -132,7 +261,7 @@ module FuseFS
 
             return false unless @use_raw_file_access
 
-            return false if mode.include?("w") && (!@allow_writes)
+            return false if mode.include?("w") && (!@allow_write)
 
             @openfiles ||= Hash.new() unless rfusefs
 
@@ -154,21 +283,21 @@ module FuseFS
             return file
         end
 
-        # See (R)FuseFS API.txt			
+        # @!visibility private
         def raw_read(path,off,sz,file=nil)
             file = @openfiles[path] unless file
             file.sysseek(off)
             file.sysread(sz)
         end
 
-        # See (R)FuseFS API.txt					
+        # @!visibility private
         def raw_write(path,offset,sz,buf,file=nil)
             file = @openfiles[path] unless file
-            file.sysseek(off)
+            file.sysseek(offset)
             file.syswrite(buf[0,sz])
         end
 
-        # See (R)FuseFS API.txt			
+        # @!visibility private
         def raw_close(path,file=nil)
             unless file
                 file = @openfiles.delete(path)
@@ -177,16 +306,16 @@ module FuseFS
         end
 
         private
-        # returns a hash representing a given node, if we have a mapped entry for it, nil otherwise
-        # this entry is a file if it has_key?(:pm_real_path), otherwise it is a directory.
-        def node(path)
-            path_components = scan_path(path)
-
-            #not actually injecting anything here, we're just following the hash of hashes...
-            path_components.inject(@root) { |dir,file|
-                break unless dir[file]
-                dir[file]
-            }
+        
+        def recursive_cleanup(dir_node,&block)
+            dir_node.files.delete_if do |path,child| 
+                if child.file?
+                    yield child
+                else
+                    recursive_cleanup(child,&block) 
+                    child.files.size == 0
+                end
+            end
         end
     end
 

data/lib/fusefs/sqlitemapper.rb

@@ -0,0 +1,125 @@
+require 'fusefs/pathmapper'
+require 'sqlite3'
+require 'rb-inotify'
+require 'thread'
+
+module FuseFS
+
+    class SqliteMapperFS < PathMapperFS
+
+        # 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
+        # performs the initial scan and starts watching the database for changes
+        # @api FuseFS
+        def mounted()
+            @mutex = Mutex.new
+            @cv = ConditionVariable.new
+            @mounted = true
+
+            notifier = start_notifier
+
+
+            @scan_thread = Thread.new() do
+                scan_loop(notifier)
+            end
+        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
+
+        # 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
+                map_file(new_path, real_path, options)
+            end
+            cleanup() { |file_node| file_node.options[:sqlite_scan_id] != @scan_id }
+        end
+
+        private
+
+        def start_notifier
+            notifier = INotify::Notifier.new()
+            modified = false
+            notifier.watch(@db_path,:modify, :close_write) do |event|
+                modified = true if event.flags.include?(:modify)
+                if event.flags.include?(:close_write) && modified
+                    @mutex.synchronize {@cv.signal}
+                    modified = false
+                end
+            end
+
+            Thread.new { notifier.run }
+
+            notifier
+        end
+
+        def scan_loop(notifier)
+            @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
+                notifier.stop   
+            end
+        end
+    end
+end

data/lib/rfusefs/version.rb

@@ -1,3 +1,3 @@
 module RFuseFS
-    VERSION="1.0.0"
+    VERSION="1.0.1.RC0"
 end