mirror of
https://gitea.com/Lydanne/buildx.git
synced 2025-10-31 08:03:43 +08:00
128 lines
3.6 KiB
Go
128 lines
3.6 KiB
Go
// Copyright 2015 Tim Heckman. All rights reserved.
|
|
// Use of this source code is governed by the BSD 3-Clause
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package flock implements a thread-safe sync.Locker interface for file locking.
|
|
// It also includes a non-blocking TryLock() function to allow locking
|
|
// without blocking execution.
|
|
//
|
|
// Package flock is released under the BSD 3-Clause License. See the LICENSE file
|
|
// for more details.
|
|
//
|
|
// While using this library, remember that the locking behaviors are not
|
|
// guaranteed to be the same on each platform. For example, some UNIX-like
|
|
// operating systems will transparently convert a shared lock to an exclusive
|
|
// lock. If you Unlock() the flock from a location where you believe that you
|
|
// have the shared lock, you may accidently drop the exclusive lock.
|
|
package flock
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Flock is the struct type to handle file locking. All fields are unexported,
|
|
// with access to some of the fields provided by getter methods (Path() and Locked()).
|
|
type Flock struct {
|
|
path string
|
|
m sync.RWMutex
|
|
fh *os.File
|
|
l bool
|
|
r bool
|
|
}
|
|
|
|
// New returns a new instance of *Flock. The only parameter
|
|
// it takes is the path to the desired lockfile.
|
|
func New(path string) *Flock {
|
|
return &Flock{path: path}
|
|
}
|
|
|
|
// NewFlock returns a new instance of *Flock. The only parameter
|
|
// it takes is the path to the desired lockfile.
|
|
//
|
|
// Deprecated: Use New instead.
|
|
func NewFlock(path string) *Flock {
|
|
return New(path)
|
|
}
|
|
|
|
// Close is equivalent to calling Unlock.
|
|
//
|
|
// This will release the lock and close the underlying file descriptor.
|
|
// It will not remove the file from disk, that's up to your application.
|
|
func (f *Flock) Close() error {
|
|
return f.Unlock()
|
|
}
|
|
|
|
// Path returns the path as provided in NewFlock().
|
|
func (f *Flock) Path() string {
|
|
return f.path
|
|
}
|
|
|
|
// Locked returns the lock state (locked: true, unlocked: false).
|
|
//
|
|
// Warning: by the time you use the returned value, the state may have changed.
|
|
func (f *Flock) Locked() bool {
|
|
f.m.RLock()
|
|
defer f.m.RUnlock()
|
|
return f.l
|
|
}
|
|
|
|
// RLocked returns the read lock state (locked: true, unlocked: false).
|
|
//
|
|
// Warning: by the time you use the returned value, the state may have changed.
|
|
func (f *Flock) RLocked() bool {
|
|
f.m.RLock()
|
|
defer f.m.RUnlock()
|
|
return f.r
|
|
}
|
|
|
|
func (f *Flock) String() string {
|
|
return f.path
|
|
}
|
|
|
|
// TryLockContext repeatedly tries to take an exclusive lock until one of the
|
|
// conditions is met: TryLock succeeds, TryLock fails with error, or Context
|
|
// Done channel is closed.
|
|
func (f *Flock) TryLockContext(ctx context.Context, retryDelay time.Duration) (bool, error) {
|
|
return tryCtx(f.TryLock, ctx, retryDelay)
|
|
}
|
|
|
|
// TryRLockContext repeatedly tries to take a shared lock until one of the
|
|
// conditions is met: TryRLock succeeds, TryRLock fails with error, or Context
|
|
// Done channel is closed.
|
|
func (f *Flock) TryRLockContext(ctx context.Context, retryDelay time.Duration) (bool, error) {
|
|
return tryCtx(f.TryRLock, ctx, retryDelay)
|
|
}
|
|
|
|
func tryCtx(fn func() (bool, error), ctx context.Context, retryDelay time.Duration) (bool, error) {
|
|
if ctx.Err() != nil {
|
|
return false, ctx.Err()
|
|
}
|
|
for {
|
|
if ok, err := fn(); ok || err != nil {
|
|
return ok, err
|
|
}
|
|
select {
|
|
case <-ctx.Done():
|
|
return false, ctx.Err()
|
|
case <-time.After(retryDelay):
|
|
// try again
|
|
}
|
|
}
|
|
}
|
|
|
|
func (f *Flock) setFh() error {
|
|
// open a new os.File instance
|
|
// create it if it doesn't exist, and open the file read-only.
|
|
fh, err := os.OpenFile(f.path, os.O_CREATE|os.O_RDONLY, os.FileMode(0600))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// set the filehandle on the struct
|
|
f.fh = fh
|
|
return nil
|
|
}
|