fslock

type Blocker func() error

type Handle interface {
	// Unlock releases the held lock.
	//
	// This can error if the underlying filesystem operations fail. This should
	// not happen unless something has gone externally wrong, or the lock was
	// mishandled.
	Unlock() error

	// LockFile returns the underlying lock File. This is not generally useful,
	// and should be used circumstantially. Operating on the file occurs outside
	// of the scope of this package, and can result in unintended consequences.
	//
	// The file should NOT be directly closed or modified.
	//
	// The file will be valid for the duration of the Handle. Once the Handle is
	// closed with Unlock, the file's state is implementation-specific and
	// unspecified.
	LockFile() *os.File

	// PreserveExec preserves the lock across execve syscall.
	//
	// The lock will be held even after call execve. It is not possible to
	// acquire a handle for the lock unless manually passing the fd as an
	// argument.
	//
	// On Windows, the behaviour is not promised unless CreateProcess with
	// bInheritHandles.
	PreserveExec() error
}

type L struct {
	// Path is the path of the file to lock.
	Path string

	// Shared, if true, indicates that this should be a shared lock rather than
	// an exclusive lock.
	//
	// See package documentation for details.
	Shared bool

	// Content, if populated, is the lock file content. Content is written to the
	// file when the lock call creates it, and only if the lock call actually
	// creates the file. Failure to write Content is non-fatal.
	//
	// Content should be used only as a convenience hint for users who want to
	// know what the lock file is, and not for actual programmatic management.
	// Several code paths can result in successful file locking and still fail to
	// write Content to that file.
	//
	// Content is not synchronized with the actual locking. Failure to write
	// Content to the lock file is considered non-fatal.
	Content []byte

	// Block is the configured blocking function.
	//
	// If not nil, an attempt to acquire the lock will loop indefinitely until an
	// error other than ErrLockHeld is encountered (fatal) or the lock is
	// acquired. Block will be called each time a lock attempt returns
	// ErrLockHeld, and should delay and/or cancel the acquisition by returning
	// nil or an error code respectively.
	//
	// If Block returns an error, it will be propagated as the error result of the
	// locking attempt.
	Block Blocker
}