Add WaitLock function (#44)

* Add WaitLock function

WaitLock keeps trying to acquire the lock that is held by someone else, until the lock is acquired or until the context is canceled. Retires once per second. Logs warning on each retry.

- Update dependencies.
- Update error checks
- README.md to remove mention of gx
- Update example to close lock file

Author: gammazero

README.md

@@ -30,26 +30,8 @@
 go get github.com/ipfs/go-fs-lock
 ```
 
-Note that `go-fs-lock` is packaged with Gx, so it is recommended to use Gx to install and use it (see Usage section).
-
 ## Usage
 
-### Using Gx and Gx-go
-
-This module is packaged with [Gx](https://github.com/whyrusleeping/gx). In order to use it in your own project it is recommended that you:
-
-```sh
-go get -u github.com/whyrusleeping/gx
-go get -u github.com/whyrusleeping/gx-go
-cd <your-project-repository>
-gx init
-gx import github.com/ipfs/go-fs-lock
-gx install --global
-gx-go --rewrite
-```
-
-Please check [Gx](https://github.com/whyrusleeping/gx) and [Gx-go](https://github.com/whyrusleeping/gx-go) documentation for more information.
-
 ### Running tests
 
 Before running tests, please run:

example_test.go

@@ -9,8 +9,9 @@ import (
 )
 
 func ExampleLockedError() {
-	_, err := fslock.Lock(os.TempDir(), "foo.lock")
+	lockFile, err := fslock.Lock(os.TempDir(), "foo.lock")
 	fmt.Println("locked:", errors.As(err, new(fslock.LockedError)))
+	defer lockFile.Close()
 
 	_, err = fslock.Lock(os.TempDir(), "foo.lock")
 	fmt.Println("locked:", errors.As(err, new(fslock.LockedError)))

fslock.go

@@ -1,13 +1,15 @@
 package fslock
 
 import (
+	"context"
 	"errors"
 	"io"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
-	util "github.com/ipfs/go-ipfs-util"
 	logging "github.com/ipfs/go-log/v2"
 	lock "go4.org/lock"
 )
@@ -42,7 +44,7 @@ func Lock(confdir, lockFileName string) (io.Closer, error) {
 				Path: lockFilePath,
 				Err:  LockedError("lock is already held by us"),
 			}
-		case os.IsPermission(err) || isLockCreatePermFail(err):
+		case errors.Is(err, fs.ErrPermission) || isLockCreatePermFail(err):
 			// lock fails on permissions error
 
 			// Using a path error like this ensures that
@@ -60,7 +62,7 @@ func Lock(confdir, lockFileName string) (io.Closer, error) {
 // Locked checks if there is a lock already set.
 func Locked(confdir, lockFile string) (bool, error) {
 	log.Debugf("Checking lock")
-	if !util.FileExists(filepath.Join(confdir, lockFile)) {
+	if !fileExists(filepath.Join(confdir, lockFile)) {
 		log.Debugf("File doesn't exist: %s", filepath.Join(confdir, lockFile))
 		return false, nil
 	}
@@ -80,7 +82,46 @@ func Locked(confdir, lockFile string) (bool, error) {
 	return false, err
 }
 
+// WaitLock keeps trying to acquire the lock that is held by someone else,
+// until the lock is acquired or until the context is canceled. Retires once
+// per second. Logs warning on each retry.
+func WaitLock(ctx context.Context, confdir, lockFileName string) (io.Closer, error) {
+	var ticker *time.Ticker
+
+retry:
+	lk, err := Lock(confdir, lockFileName)
+	if err != nil {
+		var lkErr LockedError
+		if errors.As(err, &lkErr) && lkErr.Error() == "someone else has the lock" {
+			pe, ok := err.(*os.PathError)
+			if !ok {
+				return nil, err
+			}
+			log.Warnf("%s: %s. Retrying...", pe.Path, lkErr.Error())
+			if ticker == nil {
+				ticker = time.NewTicker(time.Second)
+				defer ticker.Stop()
+			}
+			select {
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			case <-ticker.C:
+				goto retry
+			}
+		}
+	}
+	return lk, err
+}
+
 func isLockCreatePermFail(err error) bool {
 	s := err.Error()
 	return strings.Contains(s, "Lock Create of") && strings.Contains(s, "permission denied")
 }
+
+func fileExists(filename string) bool {
+	fi, err := os.Lstat(filename)
+	if fi != nil || (err != nil && !errors.Is(err, fs.ErrNotExist)) {
+		return true
+	}
+	return false
+}

fslock_test.go

@@ -2,9 +2,12 @@ package fslock_test
 
 import (
 	"bufio"
+	"context"
+	"errors"
 	"os"
 	"os/exec"
-	"path"
+	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 	"time"
@@ -27,10 +30,7 @@ func assertLock(t *testing.T, confdir, lockFile string, expected bool) {
 
 func TestLockSimple(t *testing.T) {
 	lockFile := "my-test.lock"
-	confdir := os.TempDir()
-
-	// make sure we start clean
-	_ = os.Remove(path.Join(confdir, lockFile))
+	confdir := t.TempDir()
 
 	assertLock(t, confdir, lockFile, false)
 
@@ -66,11 +66,7 @@ func TestLockSimple(t *testing.T) {
 func TestLockMultiple(t *testing.T) {
 	lockFile1 := "test-1.lock"
 	lockFile2 := "test-2.lock"
-	confdir := os.TempDir()
-
-	// make sure we start clean
-	_ = os.Remove(path.Join(confdir, lockFile1))
-	_ = os.Remove(path.Join(confdir, lockFile2))
+	confdir := t.TempDir()
 
 	lock1, err := lock.Lock(confdir, lockFile1)
 	if err != nil {
@@ -116,11 +112,7 @@ func TestLockedByOthers(t *testing.T) {
 		return
 	}
 
-	confdir, err := os.MkdirTemp("", "go-fs-lock-test")
-	if err != nil {
-		t.Fatalf("creating temporary directory: %v", err)
-	}
-	defer os.RemoveAll(confdir)
+	confdir := t.TempDir()
 
 	// Execute a child process that locks the file.
 	cmd := exec.Command(os.Args[0], "-test.run=TestLockedByOthers", "--", confdir)
@@ -158,3 +150,116 @@ func TestLockedByOthers(t *testing.T) {
 		t.Fatalf("error %q does not contain %q", got, wantErr)
 	}
 }
+
+func TestWaitLock(t *testing.T) {
+	const (
+		lockedMsg = "locked\n"
+		lockFile  = "my-test.lock"
+		someFile  = "somefile"
+		permErr   = "permission denied"
+		heldErr   = "lock is already held by us"
+	)
+
+	confdir := t.TempDir()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 1500*time.Millisecond)
+	defer cancel()
+
+	// Acquire lock.
+	_, err := lock.WaitLock(ctx, confdir, confdir)
+	if err == nil {
+		t.Fatalf("acquired the lock on bad filename")
+	}
+
+	someFilePath := filepath.Join(confdir, someFile)
+	f, err := os.Create(someFilePath)
+	if err != nil {
+		t.Fatal("error opening file:", err)
+	}
+	f.Chmod(0444)
+	err = f.Close()
+	defer os.Remove(someFilePath)
+	if err != nil {
+		t.Fatal("error closing file:", err)
+	}
+	_, err = lock.WaitLock(ctx, confdir, someFile)
+	if err == nil {
+		t.Fatalf("acquired lock on read-only file")
+	}
+	if runtime.GOOS != "windows" {
+		pe, ok := err.(*os.PathError)
+		if !ok {
+			t.Fatalf("wrong error type %T: %s", err, err)
+		}
+		if got := pe.Error(); !strings.Contains(got, permErr) {
+			t.Fatalf("error %q does not contain %q", got, permErr)
+		}
+	}
+
+	// Acquire lock.
+	lk, err := lock.WaitLock(ctx, confdir, lockFile)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Try to acquire locked lock.
+	_, err = lock.WaitLock(ctx, confdir, lockFile)
+	if err == nil {
+		t.Fatalf("acquired the lock when already locked")
+	}
+	pe, ok := err.(*os.PathError)
+	if !ok {
+		t.Fatalf("wrong error type %T", err)
+	}
+	if got := pe.Error(); !strings.Contains(got, heldErr) {
+		t.Fatalf("error %q does not contain %q", got, heldErr)
+	}
+
+	// Release lock.
+	err = lk.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" { // child process
+		confdir := os.Args[3]
+		if _, err := lock.Lock(confdir, lockFile); err != nil {
+			t.Fatalf("child lock: %v", err)
+		}
+		os.Stdout.WriteString(lockedMsg)
+		time.Sleep(10 * time.Minute)
+		return
+	}
+
+	// Execute a child process that locks the file.
+	cmd := exec.Command(os.Args[0], "-test.run=TestLockedByOthers", "--", confdir)
+	cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1")
+	cmd.Stderr = os.Stderr
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		t.Fatalf("cmd.StdoutPipe: %v", err)
+	}
+	if err = cmd.Start(); err != nil {
+		t.Fatalf("cmd.Start: %v", err)
+	}
+	defer cmd.Process.Kill()
+
+	// Wait for the child to lock the file.
+	b := bufio.NewReader(stdout)
+	line, err := b.ReadString('\n')
+	if err != nil {
+		t.Fatalf("read from child: %v", err)
+	}
+	if got, want := line, lockedMsg; got != want {
+		t.Fatalf("got %q from child; want %q", got, want)
+	}
+
+	// Parent should not be able to lock the file.
+	_, err = lock.WaitLock(ctx, confdir, lockFile)
+	if err == nil {
+		t.Fatalf("parent successfully acquired the lock")
+	}
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("did not get expected error: %s", context.DeadlineExceeded)
+	}
+}

go.mod

@@ -1,24 +1,16 @@
 module github.com/ipfs/go-fs-lock
 
+go 1.23.8
+
 require (
-	github.com/ipfs/go-ipfs-util v0.0.2
-	github.com/ipfs/go-log/v2 v2.3.0
-	go4.org v0.0.0-20200411211856-f5505b9728dd
-	golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f
+	github.com/ipfs/go-log/v2 v2.5.1
+	go4.org v0.0.0-20230225012048-214862532bf5
+	golang.org/x/sys v0.32.0
 )
 
 require (
-	github.com/mattn/go-isatty v0.0.13 // indirect
-	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 // indirect
-	github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771 // indirect
-	github.com/mr-tron/base58 v1.1.3 // indirect
-	github.com/multiformats/go-multihash v0.0.13 // indirect
-	github.com/multiformats/go-varint v0.0.5 // indirect
-	github.com/spaolacci/murmur3 v1.1.0 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
-	go.uber.org/zap v1.16.0 // indirect
-	golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 // indirect
+	go.uber.org/zap v1.19.1 // indirect
 )
-
-go 1.23