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() click to toggle source

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
handle_editor(bool) click to toggle source

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
main(argv=ARGV,options=[],option_usage="",device=nil,exec=File.basename($0)) { |options| ... } click to toggle source

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
mount(root,mountpoint,*opts) click to toggle source

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
mount_under(mountpoint, *args) click to toggle source

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
reader_gid() click to toggle source

@return [Fixnum] the calling process gid

# File lib/rfusefs.rb, line 158
def self.reader_gid
    Thread.current[:fusefs_reader_gid]
end
reader_uid() click to toggle source

@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
run() click to toggle source

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_root(root) click to toggle source

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(root,mountpoint,*opts) click to toggle source

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(mountpoint=nil) click to toggle source

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