Cross Platform lock + windows encryption

.gitignore

@@ -13,3 +13,4 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+.vscode/

extensions/lock/lock.go

@@ -0,0 +1,76 @@
+package lock
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/AzureAD/microsoft-authentication-extensions-for-go/flock"
+)
+
+type Lock struct {
+	retries    int
+	retryDelay time.Duration
+
+	fLock *flock.Flock
+	mu    sync.Mutex
+}
+
+type Option func(l *Lock)
+
+func WithRetries(n int) Option {
+	return func(l *Lock) {
+		l.retries = n
+	}
+}
+func WithRetryDelay(t time.Duration) Option {
+	return func(l *Lock) {
+		l.retryDelay = t
+	}
+}
+
+func New(lockFileName string, options ...Option) (*Lock, error) {
+	l := &Lock{}
+	for _, o := range options {
+		o(l)
+	}
+	l.fLock = flock.New(lockFileName)
+	return l, nil
+}
+
+func (l *Lock) Lock() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	for tryCount := 0; tryCount < l.retries; tryCount++ {
+		locked, err := l.fLock.TryLock()
+		if err != nil || !locked {
+			time.Sleep(l.retryDelay * time.Millisecond)
+			continue
+		} else if locked {
+			// commenting this till we have flock merged in and ready to use with changes
+			// otherwise it would not compile
+			//l.fLock.Fh.WriteString(fmt.Sprintf("{%d} {%s}", os.Getpid(), os.Args[0]))
+			//l.fLock.Fh.Sync()
+			return nil
+		}
+	}
+	return errors.New("failed to acquire lock")
+}
+
+func (l *Lock) UnLock() error {
+	if l.fLock != nil {
+		if err := l.fLock.Unlock(); err != nil {
+			return err
+		}
+		err := os.Remove(l.fLock.Path())
+		if err != nil {
+			errVal := err.(*fs.PathError)
+			if errVal != fs.ErrNotExist || errVal != fs.ErrPermission {
+				return err
+			}
+		}
+	}
+	return nil
+}

extensions/lock/lock_test.go

@@ -0,0 +1,121 @@
+package lock
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/AzureAD/microsoft-authentication-extensions-for-go/internal"
+)
+
+const cacheFile = "cache.txt"
+
+func TestLocking(t *testing.T) {
+
+	tests := []struct {
+		desc          string
+		concurrency   int
+		sleepInterval time.Duration
+		cacheFile     string
+	}{
+		{"Normal", 4, 50 * time.Millisecond, "cache_normal"},
+		{"High", 40, 50 * time.Millisecond, "cache_high"},
+	}
+
+	for _, test := range tests {
+		tmpfile, err := ioutil.TempFile("", test.cacheFile)
+		defer os.Remove(tmpfile.Name())
+		if err != nil {
+			t.Fatalf("TestLocking(%s): Could not create cache file", test.desc)
+		}
+		err = spin(test.concurrency, time.Duration(test.sleepInterval), tmpfile.Name())
+		if err != nil {
+			t.Fatalf("TestLocking(%s): %s", test.desc, err)
+		}
+	}
+
+}
+func acquire(threadNo int, sleepInterval time.Duration, cacheFile string) {
+	cacheAccessor := internal.NewFileAccessor(cacheFile)
+	lockfileName := cacheFile + ".lockfile"
+	l, err := New(lockfileName, WithRetries(60), WithRetryDelay(100))
+	if err := l.Lock(); err != nil {
+		log.Println("Couldn't acquire lock", err.Error())
+		return
+	}
+	defer l.UnLock()
+	data, err := cacheAccessor.Read()
+	if err != nil {
+		log.Println(err)
+	}
+	var buffer bytes.Buffer
+	buffer.Write(data)
+	buffer.WriteString(fmt.Sprintf("< %d \n", threadNo))
+	time.Sleep(sleepInterval)
+	buffer.WriteString(fmt.Sprintf("> %d \n", threadNo))
+	cacheAccessor.Write(buffer.Bytes())
+}
+
+func spin(concurrency int, sleepInterval time.Duration, cacheFile string) error {
+	var wg sync.WaitGroup
+	wg.Add(concurrency)
+	for i := 0; i < concurrency; i++ {
+		go func(i int) {
+			defer wg.Done()
+			acquire(i, sleepInterval, cacheFile)
+		}(i)
+	}
+	wg.Wait()
+	i, err := validate(cacheFile)
+	if err != nil {
+		return err
+	}
+	if i != concurrency*2 {
+		return fmt.Errorf("should have seen %d line entries, found %d", concurrency*2, i)
+	}
+	return nil
+}
+
+func validate(cacheFile string) (int, error) {
+	var (
+		count               int
+		prevProc, tag, proc string
+	)
+	data, err := os.ReadFile(cacheFile)
+	if err != nil {
+		log.Println(err)
+	}
+	temp := strings.Split(string(data), "\n")
+
+	for _, s := range temp {
+		if strings.TrimSpace(s) == "" {
+			continue
+		}
+		count += 1
+		split := strings.Split(s, " ")
+		tag = split[0]
+		proc = split[1]
+		if prevProc == "" {
+			if tag != "<" {
+				return 0, errors.New("opening bracket not found")
+			}
+			prevProc = proc
+			continue
+		}
+		if proc != prevProc {
+			return 0, errors.New("process overlap found")
+		}
+		if tag != ">" {
+			return 0, errors.New("process overlap found")
+		}
+		prevProc = ""
+	}
+	return count, nil
+}

go.mod

@@ -0,0 +1,10 @@
+module github.com/AzureAD/microsoft-authentication-extensions-for-go
+
+go 1.14
+
+require (
+	github.com/AzureAD/microsoft-authentication-library-for-go v0.3.0
+	github.com/billgraziano/dpapi v0.4.0
+	github.com/gofrs/flock v0.8.1
+
+)