Class: FuseFS::FuseDir

This class is equivalent to using Object.new() as the virtual directory for target for {FuseFS.start}. It exists primarily to document the API but can also be used as a superclass for your filesystem providing sensible defaults

Method call sequences

Stat (getattr)

FUSE itself will generally stat referenced files and validate the results before performing any file/directory operations so this sequence is called very often

{directory?} is checked first
- {can_write?} OR {can_mkdir?} with ._rfusefs_check_ to determine write permissions
- {times} is called to determine atime,mtime,ctime info for the directory
{file?} is checked next
- {can_write?}, {executable?}, {size}, {times} are called to fill out the details
otherwise we tell FUSE that the path does not exist

List directory

FUSE confirms the path is a directory (via stat above) before we call {contents}

FUSE will generally go on to stat each directory entry in the results

Reading files

FUSE confirms path is a file before we call {read_file}

For fine control of file access see {raw_open}, {raw_read}, {raw_close}

Writing files

FUSE confirms path for the new file is a directory

{can_write?} is checked at file open
{write_to} is called when the file is synced, flushed or closed

See also {raw_open}, {raw_truncate}, {raw_write}, {raw_sync}, {raw_close}

Deleting files

FUSE confirms path is a file before we call {can_delete?} then {delete}

Creating directories

FUSE confirms parent is a directory before we call {can_mkdir?} then {mkdir}

Deleting directories

FUSE confirms path is a directory before we call {can_rmdir?} then {rmdir}

Renaming files and directories

FUSE confirms the rename is valid (eg. not renaming a directory to a file)

Try {rename} to see if the virtual directory wants to handle this itself
If rename returns false/nil then we try to copy/delete (files only) ie.
- {file?}(from), {can_write?}(to), {can_delete?}(from) and if all true
- {read_file}(from), {write_to}(to), {delete}(from)
otherwise reject the rename

Signals

The filesystem can handle a signal by providing a `sig<name>` method. eg ‘sighup’ {sigint} and {sigterm} are handled by default to provide a means to exit the filesystem

Constants

INIT_TIMES

Array.new(3,0)

@!method sigterm()

  @return [void]
  Handle the TERM signal and exit the filesystem

Public Instance methods

can_delete?(path)

@abstract FuseFS api @return [Boolean] true if the user can delete the file at path

can_mkdir?(path)

@abstract FuseFS api @return [Boolean] true if user can make a directory at path

can_rmdir?(path)

@abstract FuseFS api @return [Boolean] true if user can remove a directory at path

can_write?(path)

@abstract FuseFS api @return [Boolean] true if the user can write to file at path

contents(path)

@abstract FuseFS api @return [Array<String>] array of file and directory names within path

delete(path)

Delete the file at path @abstract FuseFS api @return [void]

directory?(path)

@abstract FuseFS api @return [Boolean] true if path is a directory

executable?(path)

@abstract FuseFS api @return [Boolean] true if path is an executable file

file?(path)

@abstract FuseFS api @return [Boolean] true if path is a file

mkdir(path)

Make a directory at path @abstract FuseFS api @return [void]

mounted()

RFuseFS extension. Called when the filesystem is mounted @return [void]

raw_close(path,raw=nil)

Close the file previously opened at path (or filehandle raw) @abstract FuseFS api @return [void]

raw_open(path,mode,rfusefs = nil)

Raw file access @abstract FuseFS api @param mode [String] "r","w" or "rw", with "a" if file is opened for append @param rfusefs [Boolean] will be "true" if RFuseFS extensions are available @return [nil] to indicate raw operations are not implemented @return [Object] a filehandle

                 Under RFuseFS this object will be passed back in to the other raw
                 methods as the optional parameter _raw_

raw_read(path,offset,size,raw=nil)

Read sz bytes from file at path (or filehandle raw) starting at offset off

@param [String] path @param [Integer] offset @param [Integer] size @param [Object] raw the filehandle returned by {raw_open} @abstract FuseFS api @return [void]

raw_sync(path,datasync,raw=nil)

Sync buffered data to your filesystem @param [String] path @param [Boolena] datasync only sync user data, not metadata @param [Object] raw the filehandle return by {raw_open}

raw_truncate(path,offset,raw=nil)

RFuseFS extension. @abstract FuseFS api

@overload raw_truncate(path,offset,raw)

 Truncate an open file to offset bytes
 @param [String] path
 @param [Integer] offset
 @param [Object] raw the filehandle returned from {#raw_open}
 @return [void]

@overload raw_truncate(path,offset)

 Optionally truncate a file to offset bytes directly
 @param [String] path
 @param [Integer] offset
 @return [Boolean]
   if truncate has been performed, otherwise the truncation will be performed with {#read_file} and {#write_to}

raw_write(path,off,sz,buf,raw=nil)

Write sz bytes from file at path (or filehandle raw) starting at offset off @abstract FuseFS api @return [void]

read_file(path)

@abstract FuseFS api @return [String] the contents of the file at path

rename(from_path,to_path)

Move a file or directory. @abstract FuseFS api @return [Boolean] true to indicate the rename has been handled,

                 otherwise will fallback to copy/delete

rmdir(path)

Remove the directory at path @abstract FuseFS api @return [void]

scan_path(path)

  base,*rest = scan_path(path)

@return [Array<String>] all directory and file elements in path. Useful

                        when encapsulating an entire fs into one object

size(path)

File size @abstract FuseFS api @return [Integer] the size in byte of a file (lots of applications rely on this being accurate )

split_path(path)

  base,rest = split_path(path)

@return [Array<String,String>] base,rest. base is the first directory in

                               path, and rest is nil> or the remaining path.
                               Typically if rest is not nil? you should
                               recurse the paths

statistics(path)

RFuseFS extensions. File system statistics @param [String] path @return [Array<Integer>] the statistics

  used_space (in bytes), used_files, max_space, max_files
  See {StatsHelper}

@return [RFuse::StatVfs] or raw statistics @abstract FuseFS api

times(path)

File time information. RFuseFS extension. @abstract FuseFS api @return [Array<Integer, Time>] a 3 element array [ atime, mtime. ctime ] (good for rsync etc)

touch(path,modtime)

Neat toy. Called when a file is touched or has its timestamp explicitly modified @abstract FuseFS api @return [void]

unmounted()

RFuseFS extension. Called when the filesystem is unmounted @return [void]

write_to(path,str)

Write the contents of str to file at path @abstract FuseFS api @return [void]

xattr(path)

RFuseFS extension. Extended attributes. @param [String] path @return [Hash] extended attributes for this path.

  The returned object  will be manipulated directly using :[] :[]=,, :keys and :delete
  so the default (a new empty hash on every call) will not retain attributes that are set

@abstract FuseFS api