package lockedfile

import "cmd/go/internal/lockedfile"

Package lockedfile creates and manipulates files whose contents should only change atomically.

Index ¶

• func Read(name string) ([]byte, error)
• func Write(name string, content io.Reader, perm os.FileMode) (err error)
• type File
• func Create(name string) (*File, error)
• func Edit(name string) (*File, error)
• func Open(name string) (*File, error)
• func OpenFile(name string, flag int, perm os.FileMode) (*File, error)
• func (f *File) Close() error
• type Mutex
• func MutexAt(path string) *Mutex
• func (mu *Mutex) Lock() (unlock func(), err error)
• func (mu *Mutex) String() string

Package Files ¶

lockedfile.go lockedfile_filelock.go mutex.go

func Read ¶ Uses

func Read(name string) ([]byte, error)

Read opens the named file with a read-lock and returns its contents.

func Write ¶ Uses

func Write(name string, content io.Reader, perm os.FileMode) (err error)

Write opens the named file (creating it with the given permissions if needed), then write-locks it and overwrites it with the given content.

type File ¶ Uses

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

A File is a locked *os.File.

Closing the file releases the lock.

If the program exits while a file is locked, the operating system releases the lock but may not do so promptly: callers must ensure that all locked files are closed before exiting.

func Create ¶ Uses

func Create(name string) (*File, error)

Create is like os.Create, but returns a write-locked file.

func Edit ¶ Uses

func Edit(name string) (*File, error)

Edit creates the named file with mode 0666 (before umask), but does not truncate existing contents.

If Edit succeeds, methods on the returned File can be used for I/O. The associated file descriptor has mode O_RDWR and the file is write-locked.

func Open ¶ Uses

func Open(name string) (*File, error)

Open is like os.Open, but returns a read-locked file.

func OpenFile ¶ Uses

func OpenFile(name string, flag int, perm os.FileMode) (*File, error)

OpenFile is like os.OpenFile, but returns a locked file. If flag includes os.O_WRONLY or os.O_RDWR, the file is write-locked; otherwise, it is read-locked.

func (*File) Close ¶ Uses

func (f *File) Close() error

Close unlocks and closes the underlying file.

Close may be called multiple times; all calls after the first will return a non-nil error.

type Mutex ¶ Uses

type Mutex struct {
    Path string // The path to the well-known lock file. Must be non-empty.
    // contains filtered or unexported fields
}

A Mutex provides mutual exclusion within and across processes by locking a well-known file. Such a file generally guards some other part of the filesystem: for example, a Mutex file in a directory might guard access to the entire tree rooted in that directory.

Mutex does not implement sync.Locker: unlike a sync.Mutex, a lockedfile.Mutex can fail to lock (e.g. if there is a permission error in the filesystem).

Like a sync.Mutex, a Mutex may be included as a field of a larger struct but must not be copied after first use. The Path field must be set before first use and must not be change thereafter.

func MutexAt ¶ Uses

func MutexAt(path string) *Mutex

MutexAt returns a new Mutex with Path set to the given non-empty path.

func (*Mutex) Lock ¶ Uses

func (mu *Mutex) Lock() (unlock func(), err error)

Lock attempts to lock the Mutex.

If successful, Lock returns a non-nil unlock function: it is provided as a return-value instead of a separate method to remind the caller to check the accompanying error. (See https://golang.org/issue/20803..)

func (*Mutex) String ¶ Uses

func (mu *Mutex) String() string