Module: FuseFS

Classes and Modules

Class FuseFS::DirLink
Class FuseFS::FileHandle
Class FuseFS::Fuse
Class FuseFS::FuseDir
Class FuseFS::MetaDir
Class FuseFS::PathMapperFS
Class FuseFS::SqliteMapperFS
Class FuseFS::StatsHelper

Constants

 false
 Which raw api should we use?
 FuseDir.new()
 true
 false

Public Class methods

exit()

Exit the run loop and teardown FUSE Most useful from Signal.trap() or Kernel.at_exit()

handle_editor(bool)

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

main(argv=ARGV,options=[],option_usage="",device=nil,exec=File.basename($0)) {|options| ...}

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

mount(root,mountpoint,*opts)

Forks {FuseFS.start} so you can access your filesystem with ruby File operations (eg for testing). @note This is an RFuseFS extension @return [void]

mount_under(mountpoint, *args)

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"

reader_gid()

@return [Fixnum] the calling process gid

reader_uid()

@return [Fixnum] the calling process uid

    You can use this in determining your permissions, or even provide different files
    for different users.

run()

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

set_root(root)

Set the root virtual directory @param root [Object] an object implementing a subset of {FuseFS::API} @return [void]

start(root,mountpoint,*opts)

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]

unmount(mountpoint=nil)

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]

Methods

Classes and Modules

Constants

Public Class methods