rfusefs 0.8.0

data/lib/fusefs/metadir.rb

@@ -0,0 +1,244 @@
+module FuseFS
+  
+  
+  
+  # A full in-memory filesystem defined with hashes. It is writable to the
+  # user that mounted it 
+  # may create and edit files within it, as well as the programmer
+  # === Usage
+  #   root = Metadir.new()
+  #   root.mkdir("/hello")
+  #   root.write_to("/hello/world","Hello World!\n")
+  #   root.write_to("/hello/everybody","Hello Everyone!\n")
+  #
+  #   FuseFS.start(mntpath,root)
+  #
+  # Because Metadir is fully recursive, you can mount your own or other defined
+  # directory structures under it. For example, to mount a dictionary filesystem
+  # (see samples/dictfs.rb), use:
+  #   
+  #   root.mkdir("/dict",DictFS.new())
+  # 
+  class MetaDir < FuseDir
+    
+    def initialize()
+      @subdirs  = Hash.new(nil)
+      @files    = Hash.new(nil)
+    end
+    
+    def directory?(path)
+      pathmethod(:directory?,path) do |filename|
+        !filename || filename == "/" || @subdirs.has_key?(filename)
+      end
+    end
+    
+    def file?(path)
+      pathmethod(:file?,path) do |filename|
+        @files.has_key?(filename)
+      end
+    end
+    
+    #List directory contents
+    def contents(path)
+      pathmethod(:contents,path) do | filename |
+        if !filename
+          (@files.keys + @subdirs.keys).sort.uniq
+        else
+          @subdirs[filename].contents("/")
+        end
+      end
+    end
+    
+    def read_file(path)
+      pathmethod(:read_file,path) do |filename|
+        @files[filename].to_s
+      end
+    end
+    
+    def size(path)
+      pathmethod(:size,path) do | filename |
+        return @files[filename].to_s.length
+      end
+    end
+    
+    #can_write only applies to files... see can_mkdir for directories...
+    def can_write?(path)
+      # we have to recurse here because it might not be a MetaDir at
+      # the end of the path, but we don't have to check it is a file
+      # as the API guarantees that
+      pathmethod(:can_write?,path) do |filename|
+        return mount_user?
+      end
+    end
+    
+    def write_to(path,contents)
+      pathmethod(:write_to,path,contents) do |filename, filecontents |
+        @files[filename] = filecontents
+      end
+    end
+    
+    # Delete a file
+    def can_delete?(path)
+      pathmethod(:can_delete?,path) do |filename|
+        return mount_user?
+      end
+    end
+    
+    def delete(path)
+      pathmethod(:delete,path) do |filename|
+        @files.delete(filename)
+      end
+    end
+    
+    
+    #mkdir - does not make intermediate dirs!
+    def can_mkdir?(path)
+      pathmethod(:can_mkdir?,path) do |dirname|
+        return mount_user?
+      end
+    end
+    
+    def mkdir(path,dir=nil)
+      pathmethod(:mkdir,path,dir) do | dirname,dirobj |
+        dirobj ||= MetaDir.new
+        @subdirs[dirname] = dirobj
+      end
+    end
+    
+    # Delete an existing directory make sure it is not empty
+    def can_rmdir?(path)
+      pathmethod(:can_rmdir?,path) do |dirname|
+        return mount_user? && @subdirs.has_key?(dirname) && @subdirs[dirname].contents("/").empty?
+      end
+    end
+    
+    def rmdir(path)
+      pathmethod(:rmdir,path) do |dirname|
+        @subdirs.delete(dirname)
+      end
+    end
+    
+    def rename(from_path,to_path,to_fusefs = self)
+      
+      from_base,from_rest = split_path(from_path)
+      
+      case
+      when !from_base
+        # Shouldn't ever happen.
+        raise Errno::EACCES.new("Can't move root")
+      when !from_rest
+        # So now we have a file or directory to move
+        if @files.has_key?(from_base)
+          return false unless can_delete?(from_base) && to_fusefs.can_write?(to_path)
+          to_fusefs.write_to(to_path,@files[from_base])
+          @files.delete(from_base)
+        elsif @subdirs.has_key?(from_base)
+          # we don't check can_rmdir? because that would prevent us 
+          # moving non empty directories
+          return false unless mount_user? && to_fusefs.can_mkdir?(to_path)
+          begin
+            to_fusefs.mkdir(to_path,@subdirs[from_base])
+            @subdirs.delete(from_base)
+          rescue ArgumentError
+            # to_rest does not support mkdir with an arbitrary object
+            return false
+          end
+        else
+          #We shouldn't get this either
+          return false
+        end
+      when @subdirs.has_key?(from_base)
+        begin
+          if to_fusefs != self
+            #just keep recursing..
+            return @subdirs[from_base].rename(from_rest,to_path,to_fusefs)
+          else
+            to_base,to_rest = split_path(to_path)
+            if from_base == to_base
+              #mv within a subdir, just pass it on
+              return @subdirs[from_base].rename(from_rest,to_rest)
+            else
+              #OK, this is the tricky part, we want to move something further down
+              #our tree into something in another part of the tree.
+              #from this point on we keep a reference to the fusefs that owns
+              #to_path (ie us) and pass it down, but only if the eventual path
+              #is writable anyway!
+              if (file?(to_path))
+                return false unless can_write?(to_path)
+              else
+                return false unless can_mkdir?(to_path)
+              end
+              
+              return @subdirs[from_base].rename(from_rest,to_path,self)
+            end
+          end
+          
+          
+        rescue NoMethodError
+          #sub dir doesn't support rename
+          return false
+        rescue ArgumentError
+          #sub dir doesn't support rename with additional to_fusefs argument
+          return false
+        end
+      else
+        return false
+      end
+    end
+    
+    private
+    
+    # If api method not explicitly defined above, then pass it on
+    # to a potential FuseFS further down the chain
+    # If that turns out to be one of us then return the default
+    def method_missing(method,*args)
+      if (RFuseFSAPI::API_METHODS.has_key?(method))
+        pathmethod(method,*args) do
+          return RFuseFS::API_METHODS[method]
+        end
+      else
+        super
+      end
+    end
+    # is the accessing user the same as the user that mounted our FS?, used for
+    # all write activity
+    def mount_user?
+      return Process.uid == FuseFS.reader_uid
+    end
+    
+    #All our FuseFS methods follow the same pattern...
+    def pathmethod(method, path,*args)
+      base,rest = split_path(path)
+      case
+      when ! base
+        #request for the root of our fs
+        yield(nil,*args)
+      when ! rest
+        #base is the filename, no more directories to traverse
+        yield(base,*args)
+      when @subdirs.has_key?(base)
+        #base is a subdirectory, pass it on if we can
+        begin
+          @subdirs[base].send(method,rest,*args)
+        rescue NoMethodError
+          #Oh well
+          return RFuseFSAPI::API_METHODS[method]
+        rescue ArgumentError
+          #can_mkdir,mkdir
+          if args.pop.nil?
+            #possibly a default arg, try sending again with one fewer arg
+            @subdirs[base].send(method,rest,*args)
+          else
+            #definitely not a default arg, reraise
+            Kernel.raise
+          end
+        end
+      else
+        #return the default response
+        return RFuseFSAPI::API_METHODS[method]
+      end
+    end
+    
+    
+  end
+end

data/lib/fusefs/pathmapper.rb

@@ -0,0 +1,193 @@
+
+module FuseFS
+  
+  # A FuseFS that maps files from 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
+    def self.open_mode(raw_mode)
+      case raw_mode
+      when "r"
+        "r"
+      when "ra"
+        "r" #not really sensible..
+      when "rw"
+        "w+"
+      when "rwa"
+        "a+"
+      when
+        "w"
+      when "wa"
+        "a"
+      end
+    end
+    attr_accessor :use_raw_file_access, :allow_write 
+    #Creates a PathMapperFS
+    #See #mapDirectory
+    def PathMapperFS.create(dir,options={ },&block)
+      pm_fs = PathMapperFS.new(options)
+      pm_fs.mapDirectory(dir) do |file|
+        block.call(file)
+      end
+      return pm_fs
+    end
+    
+    def initialize(options = { })
+      @root = { }
+      @use_raw_file_access = options[:use_raw_file_access]
+      @allow_write = options[:allow_write]
+    end
+    
+    # Adds new_path to our list of mapped files
+    #
+    # Returns a hash entry which stores the real_path under the :pm_real_path key.
+    def mapFile(real_path,new_path)
+      #split path into components 
+      components = new_path.scan(/[^\/]+/)
+      
+      #create a hash of hashes to represent our directory structure
+      new_file = components.inject(@root) { |directory, file|
+      directory[file] ||= Hash.new()
+      }
+      new_file[:pm_real_path] = real_path
+      return new_file
+    end
+    
+    # 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
+    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
+    end
+    
+    # Returns true for any directory referenced by a mapped file
+    # See FuseFS API.txt		
+    def directory?(path)
+      possible_dir = node(path)
+      possible_dir && !possible_dir[:pm_real_path]
+    end
+    
+    # See FuseFS API.txt
+    # expects to be called only if directory? returns true
+    def contents(path)
+      node(path).keys
+    end
+    
+    # See FuseFS API.txt
+    def file?(path)
+      filename = unmap(path)
+      filename && File.file?(filename)
+    end
+    
+    # See FuseFS API.txt
+    # only called if option :raw_reads is not set
+    def read_file(path)
+      IO.read(unmap(path))
+    end
+    
+    # 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
+    
+    def write_to(path,contents)
+      File.open(path) do |f|
+        f.print(contents)
+      end
+    end
+    
+    # See FuseFS API.txt
+    def size(path)
+      File.size(unmap(path))
+    end
+    
+    # See RFuseFS API.txt
+    def times(path)
+      realpath = unmap(path)
+      if (realpath)
+        stat = File.stat(realpath)
+        return [ stat.atime, stat.mtime, stat.ctime ]
+      else
+        # We're a directory
+        return [0,0,0]
+      end
+    end
+    
+    # See FuseFS API.txt
+    # 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
+    def raw_open(path,mode,rfusefs = nil)
+      
+      return false unless @use_raw_file_access
+      
+      return false if mode.include?("w") && (!@allow_writes)
+      
+      @openfiles ||= Hash.new() unless rfusefs
+      
+      real_path = unmap(path)
+      
+      unless real_path
+        if rfusefs
+          raise Errno::ENOENT.new(path)
+        else
+          #fusefs will go on to call file?
+          return false
+        end
+      end
+      
+      file =  File.new(real_path,PathMapperFS.open_mode(mode))
+      
+      @openfiles[path] = file unless rfusefs
+      
+      return file
+    end
+    
+    # See (R)FuseFS API.txt			
+    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					
+    def raw_write(path,offset,sz,buf,file=nil)
+      file = @openfiles[path] unless file
+      file.sysseek(off)
+      file.syswrite(buf[0,sz])
+    end
+    
+    # See (R)FuseFS API.txt			
+    def raw_close(path,file=nil)
+      unless file
+        file = @openfiles.delete(path)
+      end
+      file.close if file
+    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]
+      }
+    end
+  end
+  
+end
+

data/lib/fusefs.rb

@@ -0,0 +1,8 @@
+
+module FuseFS
+	RFUSEFS_COMPATIBILITY = false
+end
+
+require 'rfusefs'
+require 'fusefs/metadir'
+