cgofuse/fs/fs.go

// Package fs provides generic interfaces and types for file and filesystem operations,
// abstracting over different file implementations and enabling flexible filesystem backends.
//
// The File interface defines a set of methods for file operations, including reading, writing,
// seeking, directory reading, file statistics, synchronization, and truncation.
//
// The FileSystem interface is a generic interface for filesystem operations, parameterized by a File type.
// It includes methods for opening files, creating directories, retrieving file statistics, renaming,
// removing files, and reading directory entries.
//
// Additional interfaces are provided for extended filesystem operations, such as unlinking, removing directories,
// creating links and symlinks, reading symlinks, changing permissions and ownership, and checking access permissions.
//
// The FileSystemMount interface abstracts mounting and unmounting of filesystems, providing access to the underlying FileSystem.
package fs

import (
	"io"
	"io/fs"
	"os"
)

type File interface {
	io.ReadWriteCloser
	io.ReaderAt
	io.WriterAt
	io.Seeker

	Fd() uintptr
	ReadDir(count int) ([]fs.DirEntry, error)
	Stat() (fs.FileInfo, error)
	Sync() error
	Truncate(size int64) error
}

type FileSystem[F File] interface {
	OpenFile(name string, flag int, perm fs.FileMode) (F, error)
	Mkdir(name string, perm fs.FileMode) error
	Stat(name string) (fs.FileInfo, error)
	Rename(source, target string) error
	Remove(name string) error
	ReadDir(name string) ([]fs.DirEntry, error)
}

type FileSystemMount[T File, F FileSystem[T]] interface {
	FS() F            // return filesystem implementation
	Mount() error     // Mount filesystem
	Unmount() error   // Unmount filesystem
	SetOption(...any) // Set option to fuse or winfsp
}

type FileSystemInitDestroy interface {
	Init()
	Destroy()
}
type FileSystemUnlink interface {
	Unlink(name string) error
}
type FileSystemRmdir interface {
	Rmdir(name string) error
}
type FileSystemLink interface {
	Link(oldpath string, newpath string) error
}
type FileSystemSymlink interface {
	Symlink(target string, newpath string) error
}
type FileSystemReadlink interface {
	Readlink(string) (string, error)
}
type FileSystemChmod interface {
	Chmod(name string, perm fs.FileMode) error
}
type FileSystemChown interface {
	Chown(name string, uid, gid int) error
}
type FileSystemAccess interface {
	Access(path string, mode uint32) error
}
type FileSystemStatFS interface {
	Statfs(path string) (total, free uint64, err error)
}

var (
	_ FileSystem[*os.File] = (*fileAssert)(nil)
	_ FileSystemLink       = (*fileAssert)(nil)
	_ FileSystemSymlink    = (*fileAssert)(nil)
	_ FileSystemReadlink   = (*fileAssert)(nil)
	_ FileSystemChmod      = (*fileAssert)(nil)
	_ FileSystemChown      = (*fileAssert)(nil)
	_ FileSystemUnlink     = (*fileAssert)(nil)
	_ FileSystemRmdir      = (*fileAssert)(nil)
	_ FileSystemAccess     = (*fileAssert)(nil)
	_                      = New("", (*fileAssert)(nil))
)

type fileAssert struct{}

func (*fileAssert) Unlink(name string) error                                   { return nil }
func (*fileAssert) Rmdir(name string) error                                    { return nil }
func (*fileAssert) Access(path string, mode uint32) error                      { return nil }
func (*fileAssert) Chmod(name string, perm fs.FileMode) error                  { return nil }
func (*fileAssert) Chown(name string, uid, gid int) error                      { return nil }
func (*fileAssert) Link(oldname string, newname string) error                  { return nil }
func (*fileAssert) Mkdir(name string, perm fs.FileMode) error                  { return nil }
func (*fileAssert) MkdirAll(name string, perm fs.FileMode) error               { return nil }
func (*fileAssert) Remove(name string) error                                   { return nil }
func (*fileAssert) RemoveAll(name string) error                                { return nil }
func (*fileAssert) Rename(oldpath, newpath string) error                       { return nil }
func (*fileAssert) Symlink(oldname string, newname string) error               { return nil }
func (*fileAssert) Truncate(name string, size int64) error                     { return nil }
func (*fileAssert) WriteFile(name string, data []byte, perm fs.FileMode) error { return nil }
func (*fileAssert) Create(name string) (*os.File, error)                       { return nil, nil }
func (*fileAssert) Lstat(name string) (stat fs.FileInfo, err error)            { return nil, nil }
func (*fileAssert) Open(name string) (file *os.File, err error)                { return nil, nil }
func (*fileAssert) ReadDir(name string) ([]fs.DirEntry, error)                 { return nil, nil }
func (*fileAssert) ReadFile(name string) ([]byte, error)                       { return nil, nil }
func (*fileAssert) Stat(name string) (stat fs.FileInfo, err error)             { return nil, nil }
func (*fileAssert) Readlink(name string) (string, error)                       { return "", nil }
func (*fileAssert) OpenFile(name string, flags int, perm fs.FileMode) (*os.File, error) {
	return nil, nil
}