pebble: github.com/cockroachdb/pebble/vfs Index | Files

package vfs

import "github.com/cockroachdb/pebble/vfs"

Index

Package Files

clone.go dir_unix.go fadvise_linux.go file_lock_unix.go mem_fs.go preallocate_linux.go syncing_file.go syncing_file_linux.go vfs.go

func Clone Uses

func Clone(srcFS, dstFS FS, srcPath, dstPath string) (bool, error)

Clone recursively copies a directory structure from srcFS to dstFS. srcPath specifies the path in srcFS to copy from and must be compatible with the srcFS path format. dstDir is the target directory in dstFS and must be compatible with the dstFS path format. Returns (true,nil) on a successful copy, (false,nil) if srcPath does not exist, and (false,err) if an error occurred.

func Copy Uses

func Copy(fs FS, oldname, newname string) error

Copy copies the contents of oldname to newname. If newname exists, it will be overwritten.

func LimitedCopy Uses

func LimitedCopy(fs FS, oldname, newname string, maxBytes int64) error

LimitedCopy copies up to maxBytes from oldname to newname. If newname exists, it will be overwritten.

func LinkOrCopy Uses

func LinkOrCopy(fs FS, oldname, newname string) error

LinkOrCopy creates newname as a hard link to the oldname file. If creating the hard link fails, LinkOrCopy falls back to copying the file (which may also fail if newname doesn't exist or oldname already exists).

type FS Uses

type FS interface {
    // Create creates the named file for writing, truncating it if it already
    // exists.
    Create(name string) (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)

    // 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) (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
    // has undefined behavior.
    //
    // 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 os.FileInfo describing the named file.
    Stat(name string) (os.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
}

FS is a namespace for files.

The names are filepath names: they may be / separated or \ separated, depending on the underlying operating system.

var Default FS = defaultFS{}

Default is a FS implementation backed by the underlying operating system's file system.

func NewMem Uses

func NewMem() FS

NewMem returns a new memory-backed FS implementation.

type File Uses

type File interface {
    io.Closer
    io.Reader
    io.ReaderAt
    io.Writer
    Stat() (os.FileInfo, error)
    Sync() error
}

File is a readable, writable sequence of bytes.

Typically, it will be an *os.File, but test code may choose to substitute memory-backed implementations.

func NewMemFile Uses

func NewMemFile(data []byte) File

NewMemFile returns a memory-backed File implementation. The memory-backed file takes ownership of data.

func NewSyncingFile Uses

func NewSyncingFile(f File, opts SyncingFileOptions) File

NewSyncingFile wraps a writable file and ensures that data is synced periodically as it is written. The syncing does not provide persistency guarantees for these periodic syncs, but is used to avoid latency spikes if the OS automatically decides to write out a large chunk of dirty filesystem buffers. The underlying file is fully synced upon close.

type OpenOption Uses

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

OpenOption provide an interface to do work on file handles in the Open() call.

var RandomReadsOption OpenOption = &randomReadsOption{}

RandomReadsOption is an OpenOption that optimizes opened file handle for random reads, by calling fadvise() with POSIX_FADV_RANDOM on Linux systems to disable readahead. Only works when specified to defaultFS.

type SyncingFileOptions Uses

type SyncingFileOptions struct {
    BytesPerSync    int
    PreallocateSize int
}

SyncingFileOptions holds the options for a syncingFile.

Package vfs imports 15 packages (graph) and is imported by 10 packages. Updated 2019-12-14. Refresh now. Tools for package owners.