module FuseFS
This is FuseFS
compatible module built over RFuse
Constants
- DEFAULT_FS
- HAS_FFI_XATTR
- RFUSEFS_COMPATIBILITY
Which raw api should we use?
Public Class Methods
Exit the run loop and teardown FUSE Most useful from Signal.trap() or Kernel.at_exit()
# File lib/rfusefs.rb, line 146 def FuseFS.exit @fuse.exit if @fuse end
Not supported in RFuseFS
.
The original FuseFS
had special handling for editor swap/backup files which appears to be a workaround for a bug where zero length files where never written to. This “bug” is fixed since RFuseFS
1.0.2
@deprecated
# File lib/rfusefs.rb, line 169 def self.handle_editor(bool) #do nothing end
Convenience method to launch a FuseFS
filesystem with nice error messages
@param [Array<String>] argv command line arguments @param [Array<Symbol>] options list of additional options @param [String] option_usage describing additional option usage @param [String] device a description of the device field @param [String] exec the executable file
@yieldparam [Hash<Symbol,String>] options
options parsed from ARGV including... * :device - the optional mount device * :mountpoint - required mountpoint * :help - true if -h was supplied
@yieldreturn [FuseDir] an RFuseFS
filesystem
@example
MY_OPTIONS = [ :myfs ] OPTION_USAGE = " -o myfs=VAL how to use the myfs option" # Normally from the command line... ARGV = [ "some/device", "/mnt/point", "-h", "-o", "debug,myfs=aValue" ] FuseFS.main(ARGV, MY_OPTIONS, OPTION_USAGE, "/path/to/somedevice", $0) do |options| # options == { :device => "some/device", :mountpoint => "/mnt/point", :help => true, :debug => true, :myfs => "aValue" } fs = MyFS.new(options) end
# File lib/rfusefs.rb, line 47 def FuseFS.main(argv=ARGV,options=[],option_usage="",device=nil,exec=File.basename($0)) RFuse.main(argv,options,option_usage,device,exec) do |options,argv| root = yield options FuseFS.set_root(root) FuseFS.mount_under(*argv) end end
Forks {FuseFS.start} so you can access your filesystem with ruby File operations (eg for testing). @note This is an RFuseFS extension @return [void]
# File lib/rfusefs.rb, line 79 def FuseFS.mount(root,mountpoint,*opts) pid = Kernel.fork do FuseFS.start(root,mountpoint,*opts) end @mounts[mountpoint] = pid pid end
This will cause FuseFS
to virtually mount itself under the given path. {set_root} must have been called previously. @param [String] mountpoint an existing directory where the filesystem will be virtually mounted @param [Array<String>] args @return [Fuse] the mounted fuse filesystem
These are as expected by the "mount" command. Note in particular that the first argument is expected to be the mount point. For more information, see http://fuse.sourceforge.net and the manual pages for "mount.fuse"
# File lib/rfusefs.rb, line 129 def FuseFS.mount_under(mountpoint, *args) @fuse = Fuse.new(@fs,mountpoint,*args) end
@return [Fixnum] the calling process gid
# File lib/rfusefs.rb, line 158 def self.reader_gid Thread.current[:fusefs_reader_gid] end
@return [Fixnum] the calling process uid
You can use this in determining your permissions, or even provide different files for different users.
# File lib/rfusefs.rb, line 153 def self.reader_uid Thread.current[:fusefs_reader_uid] end
This is the main loop waiting on, then executing, filesystem operations from the kernel.
Note: Running in a separate thread is generally not useful. In particular
you cannot use Ruby File operations to access your filesystem from within the ruby process that calls run.
@note RFuseFS
extension
# File lib/rfusefs.rb, line 140 def FuseFS.run @fuse.run() end
Set the root virtual directory @param root [Object] an object implementing a subset of {FuseFS::API} @return [void]
# File lib/rfusefs.rb, line 117 def FuseFS.set_root(root) @fs=Fuse::Root.new(root) end
Start the FuseFS
root at mountpoint with opts.
If not previously set, Signal traps for “TERM” and “INT” are added to exit the filesystem
@param [Object] root see {set_root} @param mountpoint [String] {mount_under} @param [String…] opts FUSE mount options see {mount_under} @note RFuseFS
extension @return [void]
# File lib/rfusefs.rb, line 65 def FuseFS.start(root,mountpoint,*opts) FuseFS.set_root(root) begin FuseFS.mount_under(mountpoint,*opts) FuseFS.run ensure FuseFS.unmount() end end
Unmount a filesystem @param mountpoint [String] If nil?, unmounts the filesystem started with {start}
otherwise signals the forked process started with {mount} to exit and unmount.
@note RFuseFS
extension @return [void]
# File lib/rfusefs.rb, line 94 def FuseFS.unmount(mountpoint=nil) if (mountpoint) if @mounts.has_key?(mountpoint) pid = @mounts[mountpoint] Process.kill("TERM",pid) Process.waitpid(pid) else raise "Unknown mountpoint #{mountpoint}" end else #Local unmount, make sure we only try to unmount once if @fuse && @fuse.mounted? print "Unmounting #{@fuse.mountname}\n" @fuse.unmount() end @fuse = nil end end