problem with remove lock file in windows

[allaVolkov]

The following code works without errors in Unix and ends with error Remove of lock file failed with: remove C:\Users\i019379\go\src\testLocking\lock.lock: The process cannot access the file because it is being used by another process. in Windows.
Thus in Windows it's impossible to remove lock file if more then one process tried to make locking.

func main(){
	wd, _ := os.Getwd()
	lockfile :=  filepath.Join(wd, "lock.lock")
	lock1 := flock.New(lockfile)
	locked1, _ := lock1.TryLock()
	if !locked1{
		fmt.Println("Error - First tryLock failed")
		return
	}
	lock2 := flock.New(lockfile)
	locked2, _ := lock2.TryLock()
	if locked2{
		fmt.Println("Second tryLock succeeded")
		return
	}
	err := lock2.Unlock()
	if err!=nil {
		fmt.Println("Unlock of second lock failed")
		return
	}
	err = lock1.Unlock()
	if err!=nil {
		fmt.Println("Unlock of first lock failed")
		return
	}
	err = os.Remove(lockfile)
	if err!=nil {
		fmt.Println("Remove of lock file failed with: "+err.Error())
		return
	}
}

[theckman]

@allaVolkov is this still present on v0.7.3? I don't have a Windows system I can test on.

[Integralist]

I'm seeing this error using Windows via GitHub Actions:

profile_test.go:790: want no error, have error saving config file: error writing to config file: write C:\Users\RUNNER~1\AppData\Local\Temp\fastly-temp-2402719425\config.toml: The process cannot access the file because another process has locked a portion of the file.
[139](https://github.com/fastly/cli/runs/7153347993?check_suite_focus=true#step:11:140)

I'm using version 0.8.1

[ldez]

I tried to reproduce the problem (I use the code in the issue description) on GitHub Action (Windows), but I could not get the error with v0.7.2, v0.7.3, v0.8.0, v0.8.1, and v0.9.0, etc.

I tried:

Version	Status
v0.7.0	🔴
v0.7.1	🔴
v0.7.2	🟢
v0.7.3	🟢
v0.8.0	🟢
v0.8.1	🟢
v0.9.0	🟢

So I don't know what to do: the Windows FS is a parallel world where even Go needs a dedicated internal package to "eliminate spurious errors".
https://github.com/golang/go/blob/master/src/cmd/go/internal/robustio/robustio.go

I need something to reproduce the problem with the current version.

[ssbanjo]

anyone found a solution to this? currently having this issue and don't know what to do. thanks

[ldez]

Could you let me know if you have a reproducible example?

[ssbanjo]

Details

package test

import (
	"os"
	"sync"

	"github.com/gofrs/flock"
)

type swapsCache struct {
	sync.Mutex
	fLock   *flock.Flock
	cacheFp string
}

func (s *swapsCache) fromCache() error {

	s.Lock()
	defer s.Unlock()

	_, err := os.ReadFile(s.cacheFp)

	if err != nil {
		return err
	}

	// do work

	return nil
}

func NewSwapsCache(cache_fp string) (*swapsCache, error) {

	var swaps_cache *swapsCache = &swapsCache{
		cacheFp: cache_fp,
		fLock:   flock.New(cache_fp),
	}

	swaps_cache.fLock.Lock()
	defer swaps_cache.fLock.Unlock()

	err := swaps_cache.fromCache()

	if err != nil {
		return nil, err
	}

	return swaps_cache, nil

}

func main() {

	// create cache files using os.Create

	_, err := NewSwapsCache("./cache1.json")

	if err != nil {
		panic(err)
	}

	_, err = NewSwapsCache("./cache2.json")

	if err != nil {
		panic(err)
	}

	// do work
}

For some reason, the first swapsCache initialization works well, but it fails with The process cannot access the file because it is being used by another process on the second one. Let me know if you need anything more.

[ldez]

Can you use a different file for the lock and your cache?

Something like that:

Details

package main

import (
	"log"
	"os"

	"github.com/gofrs/flock"
)

type SwapsCache struct {
	fLock   *flock.Flock
	cacheFp string
}

func (s *SwapsCache) fromCache() error {
	_, err := os.ReadFile(s.cacheFp)
	if err != nil {
		return err
	}

	// do work

	return nil
}

func NewSwapsCache(cacheFp string) (*SwapsCache, error) {
	sc := &SwapsCache{
		cacheFp: cacheFp,
		fLock:   flock.New(cacheFp + ".lock"),
	}

	err := sc.fLock.Lock()
	if err != nil {
		return nil, err
	}

	defer func() {
		errU := sc.fLock.Unlock()
		if errU != nil {
			log.Println(err)
		}
	}()

	_, err = os.Stat(cacheFp)
	if os.IsNotExist(err) {
		file, err := os.Create(cacheFp)
		if err != nil {
			return nil, err
		}
		_ = file.Close()
	}

	err = sc.fromCache()
	if err != nil {
		return nil, err
	}

	return sc, nil

}

func main() {
	// create cache files using os.Create

	_, err := NewSwapsCache("./cache1.json")
	if err != nil {
		panic(err)
	}

	_, err = NewSwapsCache("./cache2.json")

	if err != nil {
		panic(err)
	}

	// do work
}

[ssbanjo]

Looks like there's no issues now. So if I understand correctly, now, the lock is just based on a blank .lock file, which I guess does the same job as any other but this way we keep the locks isolated from the file were I will actually write?

[ldez]

In your example, you were not handling the Lock/Unlock error, so the error comes from the os.ReadFile.
You are trying to read a locked file before unlocking it.
So you have to use 2 files: one for the lock, and one for the cache.

So if I understand correctly, now, the lock is just based on a blank .lock file, which I guess does the same job as any other but this way we keep the locks isolated from the file were I will actually write?

yes, flock creates a lock stored as a file, this allows a global locking system.
The lock file should not be used to store data.

In your context, I think a classic sync.Mutex should be enough, you don't need flock.

[ssbanjo]

makes all sense, now I can picture it on my mind. Thanks for the quick help!
have a nice rest of your day :)