objectfs

package
v0.0.0-...-0c20f4c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 19, 2021 License: BSD-3-Clause, Apache-2.0 Imports: 13 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func CopyFile 

func CopyFile(srcFs, destFs FileSystem, srcFile, destFile string, context *fuse.Context) fuse.Status

Types

type FileSystem 

type FileSystem interface {
	// Used for pretty printing.
	String() string

	// Attributes.  This function is the main entry point, through
	// which FUSE discovers which files and directories exist.
	//
	// If the filesystem wants to implement hard-links, it should
	// return consistent non-zero FileInfo.Ino data.  Using
	// hardlinks incurs a performance hit.
	GetAttr(name string, context *fuse.Context) (*ObjectFile, fuse.Status)

	// These should update the file's ctime too.
	Chmod(name string, mode uint32, context *fuse.Context) (code fuse.Status)
	Chown(name string, uid uint32, gid uint32, context *fuse.Context) (code fuse.Status)
	Utimens(name string, Atime *time.Time, Mtime *time.Time, context *fuse.Context) (code fuse.Status)

	Truncate(name string, size uint64, context *fuse.Context) (code fuse.Status)

	Access(name string, mode uint32, context *fuse.Context) (code fuse.Status)

	// Tree structure
	Link(oldName string, newName string, context *fuse.Context) (code fuse.Status)
	Mkdir(name string, mode uint32, context *fuse.Context) fuse.Status
	Mknod(name string, mode uint32, dev uint32, context *fuse.Context) fuse.Status
	Rename(oldName string, newName string, context *fuse.Context) (code fuse.Status)
	Rmdir(name string, context *fuse.Context) (code fuse.Status)
	Unlink(name string, context *fuse.Context) (code fuse.Status)

	// Extended attributes.
	GetXAttr(name string, attribute string, context *fuse.Context) (data []byte, code fuse.Status)
	ListXAttr(name string, context *fuse.Context) (attributes []string, code fuse.Status)
	RemoveXAttr(name string, attr string, context *fuse.Context) fuse.Status
	SetXAttr(name string, attr string, data []byte, flags int, context *fuse.Context) fuse.Status

	// Called after mount.
	OnMount(nodeFs *Objectfs)
	OnUnmount()

	// File handling.  If opening for writing, the file's mtime
	// should be updated too.
	Open(name string, flags uint32, context *fuse.Context) (file *ObjectFile, code fuse.Status)
	Create(name string, flags uint32, mode uint32, context *fuse.Context) (file *ObjectFile, code fuse.Status)
	Read(name string, dest []byte, off int64, size int64, context *fuse.Context) (fuse.ReadResult, fuse.Status)
	Write(name string, data []byte, off int64, context *fuse.Context) (written uint32, code fuse.Status)
	Release(file *ObjectFile)
	Flush(file *ObjectFile) fuse.Status
	Fsync(name string, data []byte) (code fuse.Status)

	// Directory handling
	OpenDir(name string, context *fuse.Context) (stream []*ObjectFile, code fuse.Status)

	// Symlinks.
	Symlink(value string, linkName string, context *fuse.Context) (code fuse.Status)
	Readlink(name string, context *fuse.Context) (string, fuse.Status)

	StatFs(name string) *fuse.StatfsOut
}

A filesystem API that uses paths rather than inodes. A minimal file system should have at least a functional GetAttr method. Typically, each call happens in its own goroutine, so take care to make the file system thread-safe.

NewDefaultFileSystem provides a null implementation of required methods.

type FileSystemConnector 

type FileSystemConnector struct {
	// contains filtered or unexported fields
}

FilesystemConnector translates the raw FUSE protocol (serialized structs of uint32/uint64) to operations on Go objects representing files and directories.

func MountRoot 

func MountRoot(mountpoint string, root Node, opts *Options) (*fuse.Server, *FileSystemConnector, error)

Mounts a filesystem with the given root node on the given directory

func NewFileSystemConnector 

func NewFileSystemConnector(root Node, opts *Options) (c *FileSystemConnector)

NewFileSystemConnector creates a FileSystemConnector with the given options.

func (*FileSystemConnector) DeleteNotify 

func (c *FileSystemConnector) DeleteNotify(dir *Inode, child *Inode, name string) fuse.Status

DeleteNotify signals to the kernel that the named entry in dir for the child disappeared. No filesystem related locks should be held when calling this.

func (*FileSystemConnector) EntryNotify 

func (c *FileSystemConnector) EntryNotify(node *Inode, name string) fuse.Status

EntryNotify makes the kernel forget the entry data from the given name from a directory. After this call, the kernel will issue a new lookup request for the given name when necessary. No filesystem related locks should be held when calling this.

func (*FileSystemConnector) FileNotify 

func (c *FileSystemConnector) FileNotify(node *Inode, off int64, length int64) fuse.Status

FileNotify notifies the kernel that data and metadata of this inode has changed. After this call completes, the kernel will issue a new GetAttr requests for metadata and new Read calls for content. Use negative offset for metadata-only invalidation, and zero-length for invalidating all content.

func (*FileSystemConnector) InodeHandleCount 

func (c *FileSystemConnector) InodeHandleCount() int

InodeCount returns the number of inodes registered with the kernel.

func (*FileSystemConnector) LookupNode 

func (c *FileSystemConnector) LookupNode(parent *Inode, path string) *Inode

Follows the path from the given parent, doing lookups as necesary. The path should be '/' separated without leading slash.

func (*FileSystemConnector) Mount 

func (c *FileSystemConnector) Mount(parent *Inode, name string, root Node, opts *Options) fuse.Status

Mount() generates a synthetic directory node, and mounts the file system there. If opts is nil, the mount options of the root file system are inherited. The encompassing filesystem should pretend the mount point does not exist.

It returns ENOENT if the directory containing the mount point does not exist, and EBUSY if the intended mount point already exists.

func (*FileSystemConnector) Node 

func (c *FileSystemConnector) Node(parent *Inode, fullPath string) (*Inode, []string)

Finds a node within the currently known inodes, returns the last known node and the remaining unknown path components. If parent is nil, start from FUSE mountpoint.

func (*FileSystemConnector) RawFS 

func (c *FileSystemConnector) RawFS() fuse.RawFileSystem

Returns the RawFileSystem so it can be mounted.

func (*FileSystemConnector) Server 

func (c *FileSystemConnector) Server() *fuse.Server

Server returns the fuse.Server that talking to the kernel.

func (*FileSystemConnector) SetDebug 

func (c *FileSystemConnector) SetDebug(debug bool)

SetDebug toggles printing of debug information. This function is deprecated. Set the Debug option in the Options struct instead.

func (*FileSystemConnector) Unmount 

func (c *FileSystemConnector) Unmount(node *Inode) fuse.Status

Unmount() tries to unmount the given inode. It returns EINVAL if the path does not exist, or is not a mount point, and EBUSY if there are open files or submounts below this node.

type Inode 

type Inode struct {
	// contains filtered or unexported fields
}

An Inode reflects the kernel's idea of the inode. Inodes have IDs that are communicated to the kernel, and they have a tree structure: a directory Inode may contain named children. Each Inode object is paired with a Node object, which file system implementers should supply.

func (*Inode) AddChild 

func (n *Inode) AddChild(name string, child *Inode)

AddChild adds a child inode. The parent inode must be a directory node.

func (*Inode) AddChildren 

func (n *Inode) AddChildren(children map[string]*Inode)

add children

func (*Inode) AnyFile 

func (n *Inode) AnyFile() (file *ObjectFile)

Returns any open file, preferably a r/w one.

func (*Inode) Children 

func (n *Inode) Children() (out map[string]*Inode)

Children returns all children of this inode.

func (*Inode) ChildrenReset 

func (n *Inode) ChildrenReset(children map[string]*Inode)

remove not use and not exist in new add not exist keep handle is not null and not exist in new, keep exist still used after opendir

func (*Inode) Fileinfo 

func (n *Inode) Fileinfo() *ObjectFile

func (*Inode) Files 

func (n *Inode) Files(mask uint32) (files []*ObjectFile)

Files() returns an opens file that have bits in common with the give mask. Use mask==0 to return all files.

func (*Inode) FsChildren 

func (n *Inode) FsChildren() (out map[string]*Inode)

FsChildren returns all the children from the same filesystem. It will skip mountpoints.

func (*Inode) GetChild 

func (n *Inode) GetChild(name string) (child *Inode)

GetChild returns a child inode with the given name, or nil if it does not exist.

func (*Inode) IsDir 

func (n *Inode) IsDir() bool

IsDir returns true if this is a directory.

func (*Inode) NewChild 

func (n *Inode) NewChild(fileinfo *ObjectFile, fsi Node) *Inode

NewChild adds a new child inode to this inode.

func (*Inode) Node 

func (n *Inode) Node() Node

Node returns the file-system specific node.

func (*Inode) Parent 

func (n *Inode) Parent() (parent *Inode, name string)

Parent returns a random parent and the name this inode has under this parent. This function can be used to walk up the directory tree. It will not cross sub-mounts.

func (*Inode) RmChild 

func (n *Inode) RmChild(name string) (ch *Inode)

RmChild removes an inode by name, and returns it. It returns nil if child does not exist.

type Node 

type Node interface {
	// Inode and SetInode are basic getter/setters.  They are
	// called by the FileSystemConnector. You get them for free by
	// embedding the result of NewDefaultNode() in your node
	// struct.
	Inode() *Inode
	SetInode(node *Inode)

	// OnMount is called on the root node just after a mount is
	// executed, either when the actual root is mounted, or when a
	// filesystem is mounted in-process. The passed-in
	// FileSystemConnector gives access to Notify methods and
	// Debug settings.
	OnMount(conn *FileSystemConnector)

	// OnUnmount is executed just before a submount is removed,
	// and when the process receives a forget for the FUSE root
	// node.
	OnUnmount()

	// Lookup finds a child node to this node; it is only called
	// for directory Nodes.
	Lookup(out *fuse.Attr, name string, context *fuse.Context) (*Inode, fuse.Status)

	// Deletable() should return true if this node may be discarded once
	// the kernel forgets its reference.
	// If it returns false, OnForget will never get called for this node. This
	// is appropriate if the filesystem has no persistent backing store
	// (in-memory filesystems) where discarding the node loses the stored data.
	// Deletable will be called from within the treeLock critical section, so you
	// cannot look at other nodes.
	Deletable() bool

	// OnForget is called when the kernel forgets its reference to this node and
	// sends a FORGET request. It should perform cleanup and free memory as
	// appropriate for the filesystem.
	// OnForget is not called if the node is a directory and has children.
	// This is called from within a treeLock critical section.
	OnForget()

	// Misc.
	Access(mode uint32, context *fuse.Context) (code fuse.Status)
	Readlink(c *fuse.Context) ([]byte, fuse.Status)

	// Mknod should create the node, add it to the receiver's
	// inode, and return it
	Mknod(name string, mode uint32, dev uint32, context *fuse.Context) (newNode *Inode, code fuse.Status)

	// Mkdir should create the directory Inode, add it to the
	// receiver's Inode, and return it
	Mkdir(name string, mode uint32, context *fuse.Context) (newNode *Inode, code fuse.Status)
	Unlink(name string, context *fuse.Context) (code fuse.Status)
	Rmdir(name string, context *fuse.Context) (code fuse.Status)

	// Symlink should create a child inode to the receiver, and
	// return it.
	Symlink(name string, content string, context *fuse.Context) (*Inode, fuse.Status)
	Rename(oldName string, newParent Node, newName string, context *fuse.Context) (code fuse.Status)

	// Link should return the Inode of the resulting link. In
	// a POSIX conformant file system, this should add 'existing'
	// to the receiver, and return the Inode corresponding to
	// 'existing'.
	Link(name string, existing Node, context *fuse.Context) (newNode *Inode, code fuse.Status)

	// Create should return an open file, and the Inode for that file.
	Create(name string, flags uint32, mode uint32, context *fuse.Context) (file *ObjectFile, child *Inode, code fuse.Status)

	// Open opens a file, and returns a File which is associated
	// with a file handle. It is OK to return (nil, OK) here. In
	// that case, the Node should implement Read or Write
	// directly.
	Open(flags uint32, context *fuse.Context) (file *ObjectFile, code fuse.Status)
	OpenDir(context *fuse.Context) ([]fuse.DirEntry, fuse.Status)
	Read(file *ObjectFile, dest []byte, off int64, size int64, context *fuse.Context) (fuse.ReadResult, fuse.Status)
	Write(file *ObjectFile, data []byte, off int64, context *fuse.Context) (written uint32, code fuse.Status)

	// XAttrs
	GetXAttr(attribute string, context *fuse.Context) (data []byte, code fuse.Status)
	RemoveXAttr(attr string, context *fuse.Context) fuse.Status
	SetXAttr(attr string, data []byte, flags int, context *fuse.Context) fuse.Status
	ListXAttr(context *fuse.Context) (attrs []string, code fuse.Status)

	// Attributes
	GetAttr(out *fuse.Attr, file *ObjectFile, context *fuse.Context) (code fuse.Status)
	Chmod(file *ObjectFile, perms uint32, context *fuse.Context) (code fuse.Status)
	Chown(file *ObjectFile, uid uint32, gid uint32, context *fuse.Context) (code fuse.Status)
	Truncate(file *ObjectFile, size uint64, context *fuse.Context) (code fuse.Status)
	Utimens(file *ObjectFile, atime *time.Time, mtime *time.Time, context *fuse.Context) (code fuse.Status)
	Fallocate(file *ObjectFile, off uint64, size uint64, mode uint32, context *fuse.Context) (code fuse.Status)

	Fsync(openfile *openedFile) (code fuse.Status)

	StatFs() *fuse.StatfsOut
}

The Node interface implements the user-defined file system functionality

type ObjectFile 

type ObjectFile struct {
	IsDir        bool
	Name         string
	LastModified string
	Size         int64
	ObjectAcl    string
	Etag         string
	Fid          string
	Expire       string
}

objectFile

func (*ObjectFile) Allocate 

func (o *ObjectFile) Allocate(off uint64, size uint64, mode uint32) (code fuse.Status)

func (*ObjectFile) Chmod 

func (o *ObjectFile) Chmod(perms uint32) fuse.Status

func (*ObjectFile) Chown 

func (o *ObjectFile) Chown(uid uint32, gid uint32) fuse.Status

func (*ObjectFile) Flush 

func (o *ObjectFile) Flush() fuse.Status

Flush is called for close() call on a file descriptor. In case of duplicated descriptor, it may be called more than once for a file.

func (*ObjectFile) Fsync 

func (o *ObjectFile) Fsync(flags int) (code fuse.Status)

func (*ObjectFile) GetAttr 

func (o *ObjectFile) GetAttr(out *fuse.Attr) fuse.Status

func (*ObjectFile) InnerFile 

func (o *ObjectFile) InnerFile() *ObjectFile

Wrappers around other File implementations, should return the inner file here.

func (*ObjectFile) Read 

func (o *ObjectFile) Read(dest []byte, off int64, size int64) (fuse.ReadResult, fuse.Status)

func (*ObjectFile) Release 

func (o *ObjectFile) Release()

This is called to before the file handle is forgotten. This method has no return value, so nothing can synchronizes on the call. Any cleanup that requires specific synchronization or could fail with I/O errors should happen in Flush instead.

func (*ObjectFile) SetInode 

func (o *ObjectFile) SetInode(*Inode)

Called upon registering the filehandle in the inode.

func (*ObjectFile) String 

func (o *ObjectFile) String() string

The String method is for debug printing.

func (*ObjectFile) Truncate 

func (o *ObjectFile) Truncate(size uint64) fuse.Status

The methods below may be called on closed files, due to concurrency. In that case, you should return EBADF.

func (*ObjectFile) Utimens 

func (o *ObjectFile) Utimens(atime *time.Time, mtime *time.Time) fuse.Status

func (*ObjectFile) Write 

func (o *ObjectFile) Write(data []byte, off int64) (written uint32, code fuse.Status)

type Objectfs 

type Objectfs struct {
	// contains filtered or unexported fields
}

PathNodeFs is the file system that can translate an inode back to a path. The path name is then used to call into an object that has the FileSystem interface.

Lookups (ie. FileSystem.GetAttr) may return a inode number in its return value. The inode number ("clientInode") is used to indicate linked files.

func NewObjectFs 

func NewObjectFs(fs FileSystem) *Objectfs

NewPathNodeFs returns a file system that translates from inodes to path names.

func (*Objectfs) Root 

func (fs *Objectfs) Root() *objectInode

Root returns the root node for the path filesystem.

type Options 

type Options struct {
	EntryTimeout    time.Duration
	AttrTimeout     time.Duration
	NegativeTimeout time.Duration

	// If set, replace all uids with given UID.
	// NewOptions() will set this to the daemon's
	// uid/gid.
	*fuse.Owner

	// This option exists for compatibility and is ignored.
	PortableInodes bool

	// If set, print debug information.
	Debug bool
}

Options contains time out options for a node FileSystem. The default copied from libfuse and set in NewMountOptions() is (1s,1s,0s).

func NewOptions 

func NewOptions() *Options

NewOptions generates FUSE options that correspond to libfuse's defaults.

type TreeWatcher 

type TreeWatcher interface {
	OnAdd(parent *Inode, name string)
	OnRemove(parent *Inode, name string)
}

TreeWatcher is an additional interface that Nodes can implement. If they do, the OnAdd and OnRemove are called for operations on the file system tree. These functions run under a lock, so they should not do blocking operations.

type WithFlags 

type WithFlags struct {

	// For debugging.
	Description string

	// Put FOPEN_* flags here.
	FuseFlags uint32

	// O_RDWR, O_TRUNCATE, etc.
	OpenFlags uint32
}

Wrap a File return in this to set FUSE flags. Also used internally to store open file data.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.