vfs

type CloneOption func(*cloneOpts)

type CrashCloneCfg struct {
	// UnsyncedDataPercent is the probability that a data block or directory entry
	// that was not synced will be part of the clone. If 0, the clone will contain
	// exactly the data that was last synced. If 100, the clone will be identical
	// to the current filesystem.
	UnsyncedDataPercent int
	// RNG must be set if UnsyncedDataPercent > 0.
	RNG *rand.Rand
}

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

type DiskSlowInfo struct {
	// Path of file being written to.
	Path string
	// Operation being performed on the file.
	OpType OpType
	// Size of write in bytes, if the write is sized.
	WriteSize int
	// Duration that has elapsed since this disk operation started.
	Duration time.Duration
}

type DiskUsage struct {
	// Total disk space available to the current process in bytes.
	AvailBytes uint64 `zid:"0"`

	// Total disk space in bytes.
	TotalBytes uint64 `zid:"1"`

	// Used disk space in bytes.
	UsedBytes uint64 `zid:"2"`
}

type DiskWriteCategory string

type DiskWriteStatsAggregate struct {
	Category     DiskWriteCategory
	BytesWritten uint64
}

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

type FS interface {
	// Create creates the named file for reading and writing. If a file
	// already exists at the provided name, it's removed first ensuring the
	// resulting file descriptor points to a new inode.
	Create(name string, category DiskWriteCategory) (File, error)

	// Link creates newname as a hard link to the oldname file.
	Link(oldname, newname string) error

	// Open opens the named file for reading. openOptions provides
	Open(name string, opts ...OpenOption) (File, error)

	// OpenReadWrite opens the named file for reading and writing. If the file
	// does not exist, it is created.
	OpenReadWrite(name string, category DiskWriteCategory, opts ...OpenOption) (File, error)

	// OpenDir opens the named directory for syncing.
	OpenDir(name string) (File, error)

	// Remove removes the named file or directory.
	Remove(name string) error

	// Remove removes the named file or directory and any children it
	// contains. It removes everything it can but returns the first error it
	// encounters.
	RemoveAll(name string) error

	// Rename renames a file. It overwrites the file at newname if one exists,
	// the same as os.Rename.
	Rename(oldname, newname string) error

	// ReuseForWrite attempts to reuse the file with oldname by renaming it to newname and opening
	// it for writing without truncation. It is acceptable for the implementation to choose not
	// to reuse oldname, and simply create the file with newname -- in this case the implementation
	// should delete oldname. If the caller calls this function with an oldname that does not exist,
	// the implementation may return an error.
	ReuseForWrite(oldname, newname string, category DiskWriteCategory) (File, error)

	// MkdirAll creates a directory and all necessary parents. The permission
	// bits perm have the same semantics as in os.MkdirAll. If the directory
	// already exists, MkdirAll does nothing and returns nil.
	MkdirAll(dir string, perm os.FileMode) error

	// Lock locks the given file, creating the file if necessary, and
	// truncating the file if it already exists. The lock is an exclusive lock
	// (a write lock), but locked files should neither be read from nor written
	// to. Such files should have zero size and only exist to co-ordinate
	// ownership across processes.
	//
	// A nil Closer is returned if an error occurred. Otherwise, close that
	// Closer to release the lock.
	//
	// On Linux and OSX, a lock has the same semantics as fcntl(2)'s advisory
	// locks. In particular, closing any other file descriptor for the same
	// file will release the lock prematurely.
	//
	// Attempting to lock a file that is already locked by the current process
	// returns an error and leaves the existing lock untouched.
	//
	// Lock is not yet implemented on other operating systems, and calling it
	// will return an error.
	Lock(name string) (io.Closer, error)

	// List returns a listing of the given directory. The names returned are
	// relative to dir.
	List(dir string) ([]string, error)

	// Stat returns an FileInfo describing the named file.
	Stat(name string) (FileInfo, error)

	// PathBase returns the last element of path. Trailing path separators are
	// removed before extracting the last element. If the path is empty, PathBase
	// returns ".".  If the path consists entirely of separators, PathBase returns a
	// single separator.
	PathBase(path string) string

	// PathJoin joins any number of path elements into a single path, adding a
	// separator if necessary.
	PathJoin(elem ...string) string

	// PathDir returns all but the last element of path, typically the path's directory.
	PathDir(path string) string

	// GetDiskUsage returns disk space statistics for the filesystem where
	// path is any file or directory within that filesystem.
	GetDiskUsage(path string) (DiskUsage, error)

	// Unwrap is implemented by "wrapping" filesystems (those that add some
	// functionality on top of an underlying FS); it returns the wrapped FS.
	// It is used by vfs.Root.
	//
	// Returns nil if this is not a wrapping filesystem.
	Unwrap() FS

	// ReadDir reads the named directory, returning
	// all its directory entries sorted by filename.
	ReadDir(dirname string) ([]os.DirEntry, error)

	IsReal() bool

	WalkDir(path string, f iofs.WalkDirFunc) error

	// MountReadOnlyReadDir mounts fromRealDir inside the MemFS at mountPointInsideDir.
	// This is useful to avoid copying large test assets. Real directories can be
	// read-only mounted inside MemFS with this call. Attempts to write to
	// the read-only mount will return errors. The mount point cannot already
	// exist inside the target MemFS.
	MountReadOnlyRealDir(fromRealDir string, mountPointInsideDir string) error
}

type File interface {
	io.Closer
	io.Reader
	io.ReaderAt
	// Unlike the specification for io.Writer.Write(), the vfs.File.Write()
	// method *is* allowed to modify the slice passed in, whether temporarily
	// or permanently. Callers of Write() need to take this into account.
	io.Writer
	// WriteAt() is only supported for files that were opened with FS.OpenReadWrite.
	io.WriterAt

	// Preallocate optionally preallocates storage for `length` at `offset`
	// within the file. Implementations may choose to do nothing.
	Preallocate(offset, length int64) error
	Stat() (FileInfo, error)
	Sync() error

	// SyncTo requests that a prefix of the file's data be synced to stable
	// storage. The caller passes provides a `length`, indicating how many bytes
	// to sync from the beginning of the file. SyncTo is a no-op for
	// directories, and therefore always returns false.
	//
	// SyncTo returns a fullSync return value, indicating one of two possible
	// outcomes.
	//
	// If fullSync is false, the first `length` bytes of the file was queued to
	// be synced to stable storage. The syncing of the file prefix may happen
	// asynchronously. No persistence guarantee is provided.
	//
	// If fullSync is true, the entirety of the file's contents were
	// synchronously synced to stable storage, and a persistence guarantee is
	// provided. In this outcome, any modified metadata for the file is not
	// guaranteed to be synced unless that metadata is needed in order to allow
	// a subsequent data retrieval to be correctly handled.
	SyncTo(length int64) (fullSync bool, err error)

	// SyncData requires that all written data be persisted. File metadata is
	// not required to be synced. Unsophisticated implementations may call Sync.
	SyncData() error

	// Prefetch signals the OS (on supported platforms) to fetch the next length
	// bytes in file (as returned by os.File.Fd()) after offset into cache. Any
	// subsequent reads in that range will not issue disk IO.
	Prefetch(offset int64, length int64) error

	// Fd returns the raw file descriptor when a File is backed by an *os.File.
	// It can be used for specific functionality like Prefetch.
	// Returns InvalidFd if not supported.
	Fd() uintptr

	Truncate(size int64) error

	Name() string
}

type FileInfo interface {
	os.FileInfo
	// DeviceID returns the ID of the device on which the file resides.
	DeviceID() DeviceID
}

type LogFn func(fmt string, args ...interface{})

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

type OpType uint8

type OpenOption interface {
	// Apply is called on the file handle after it's opened.
	Apply(File)
}

type SerzMemFS struct {
	Root *SerzMemNode `zid:"0"`

	LockedFiles map[string]bool `zid:"1"`

	Crashable bool `zid:"2"`

	WindowsSemantics bool      `zid:"3"`
	Usage            DiskUsage `zid:"4"`

	Mounts map[string]string `zid:"5"`
}

type SerzMemNode struct {
	IsDir bool `zid:"0"`

	Data       []byte    `zid:"1"`
	SyncedData []byte    `zid:"2"`
	ModTime    time.Time `zid:"3"`

	Children       map[string]*SerzMemNode `zid:"4"`
	SyncedChildren map[string]*SerzMemNode `zid:"5"`
}

type SyncingFileOptions struct {
	// NoSyncOnClose elides the automatic Sync during Close if it's not possible
	// to sync the remainder of the file in a non-blocking way.
	NoSyncOnClose   bool
	BytesPerSync    int
	PreallocateSize int
}