// Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. See LICENSE in the project root for license information. package lock import ( "context" "errors" "fmt" "os" "path/filepath" "runtime" "syscall" "time" "github.com/AzureAD/microsoft-authentication-extensions-for-go/cache/internal/flock" ) // timeout lets tests set the default amount of time allowed to acquire the lock var timeout = 5 * time.Second // flocker helps tests fake flock type flocker interface { Fh() *os.File Path() string TryLockContext(context.Context, time.Duration) (bool, error) Unlock() error } // Lock uses a file lock to coordinate access to resources shared with other processes. // Callers are responsible for preventing races within a process. Lock applies advisory // locks on Linux and macOS and is therefore unreliable on these platforms when several // processes concurrently try to acquire the lock. type Lock struct { f flocker retryDelay time.Duration } // New is the constructor for Lock. "p" is the path to the lock file. func New(p string, retryDelay time.Duration) (*Lock, error) { // ensure all dirs in the path exist before flock tries to create the file err := os.MkdirAll(filepath.Dir(p), os.ModePerm) if err != nil { return nil, err } return &Lock{f: flock.New(p), retryDelay: retryDelay}, nil } // Lock acquires the file lock on behalf of the process. The behavior of concurrent // and repeated calls is undefined. For example, Linux may or may not allow goroutines // scheduled on different threads to hold the lock simultaneously. func (l *Lock) Lock(ctx context.Context) error { if _, hasDeadline := ctx.Deadline(); !hasDeadline { var cancel context.CancelFunc ctx, cancel = context.WithTimeout(ctx, timeout) defer cancel() } for { // flock opens the file before locking it and returns errors due to an existing // lock or one acquired by another process after this process has opened the // file. We ignore some errors here because in such cases we want to retry until // the deadline. locked, err := l.f.TryLockContext(ctx, l.retryDelay) if err != nil { if !(errors.Is(err, os.ErrPermission) || isWindowsSharingViolation(err)) { return err } } else if locked { if fh := l.f.Fh(); fh != nil { s := fmt.Sprintf("{%d} {%s}", os.Getpid(), os.Args[0]) _, _ = fh.WriteString(s) } return nil } } } // Unlock releases the lock and deletes the lock file. func (l *Lock) Unlock() error { err := l.f.Unlock() if err == nil { err = os.Remove(l.f.Path()) } // ignore errors caused by another process deleting the file or locking between the above Unlock and Remove if errors.Is(err, os.ErrNotExist) || errors.Is(err, os.ErrPermission) || isWindowsSharingViolation(err) { return nil } return err } func isWindowsSharingViolation(err error) bool { return runtime.GOOS == "windows" && errors.Is(err, syscall.Errno(32)) }