memfs: Add thread-safety to Memory

Make Memory thread safe for operations such as Create, Rename and Delete.
When compared with Memory without a mutex, the cost per op is roughly 50ns,
as per benchmark below:

goos: linux
goarch: amd64
pkg: github.com/go-git/go-billy/v6/test
cpu: AMD Ryzen 7 PRO 8840HS w/ Radeon 780M Graphics
BenchmarkCompare/stdlib_open-16         	  341277	      3303 ns/op	     152 B/op	       3 allocs/op
BenchmarkCompare/osfs.chrootOS_open-16  	  286580	      3806 ns/op	     360 B/op	       9 allocs/op
BenchmarkCompare/osfs.boundOS_open-16   	  209929	      5311 ns/op	     984 B/op	      20 allocs/op
BenchmarkCompare/memfs_open-16          	 1503024	       967.4 ns/op	     224 B/op	      10 allocs/op
BenchmarkCompare/memfs_mutex_open-16    	 1272890	       911.6 ns/op	     224 B/op	      10 allocs/op
BenchmarkCompare/stdlib_read-16         	  184956	      5957 ns/op	 171.88 MB/s	       0 B/op	       0 allocs/op
BenchmarkCompare/osfs.chrootOS_read-16  	  180552	      6207 ns/op	 164.97 MB/s	       0 B/op	       0 allocs/op
BenchmarkCompare/osfs.boundOS_read-16   	  179314	      6131 ns/op	 167.02 MB/s	       0 B/op	       0 allocs/op
BenchmarkCompare/memfs_read-16          	  792040	      1568 ns/op	 653.02 MB/s	       0 B/op	       0 allocs/op
BenchmarkCompare/memfs_mutex_read-16    	  783422	      1609 ns/op	 636.27 MB/s	       0 B/op	       0 allocs/op
BenchmarkCompare/stdlib_create-16       	  216717	      5232 ns/op	     152 B/op	       3 allocs/op
BenchmarkCompare/osfs.chrootOS_create-16         	  157268	      7017 ns/op	     616 B/op	      11 allocs/op
BenchmarkCompare/osfs.boundOS_create-16          	  123038	      9242 ns/op	    1335 B/op	      22 allocs/op
BenchmarkCompare/memfs_create-16                 	  880813	      1954 ns/op	     693 B/op	      12 allocs/op
BenchmarkCompare/memfs_mutex_create-16           	  559534	      1901 ns/op	     631 B/op	      12 allocs/op
PASS
ok  	github.com/go-git/go-billy/v6/test	118.368s

This change enables users to opt-out (memfs.WithoutMutex), in case speed
on a single thread is more important than being thread-safe.

Additional thread-safety will be required for memfs.file.

Signed-off-by: Paulo Gomes <[email protected]>

Author: pjbgf

.github/workflows/test.yml

@@ -2,7 +2,6 @@ name: Test
 
 on: 
   push:
-    branches: [ "master", "main" ]
   pull_request:
 
 permissions: {}

Makefile

@@ -14,7 +14,7 @@ $(GOLANGCI):
 
 .PHONY: test
 test:
-	$(GOTEST) -race -timeout 60s ./...
+	$(GOTEST) -race -timeout 300s ./...
 
 test-coverage:
 	echo "" > $(COVERAGE_REPORT); \

memfs/file.go

@@ -0,0 +1,243 @@
+package memfs
+
+import (
+	"errors"
+	"io"
+	"io/fs"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/go-git/go-billy/v6"
+)
+
+type file struct {
+	name     string
+	content  *content
+	position int64
+	flag     int
+	mode     os.FileMode
+	modTime  time.Time
+
+	isClosed bool
+}
+
+func (f *file) Name() string {
+	return f.name
+}
+
+func (f *file) Read(b []byte) (int, error) {
+	n, err := f.ReadAt(b, f.position)
+	f.position += int64(n)
+
+	if errors.Is(err, io.EOF) && n != 0 {
+		err = nil
+	}
+
+	return n, err
+}
+
+func (f *file) ReadAt(b []byte, off int64) (int, error) {
+	if f.isClosed {
+		return 0, os.ErrClosed
+	}
+
+	if !isReadAndWrite(f.flag) && !isReadOnly(f.flag) {
+		return 0, errors.New("read not supported")
+	}
+
+	n, err := f.content.ReadAt(b, off)
+
+	return n, err
+}
+
+func (f *file) Seek(offset int64, whence int) (int64, error) {
+	if f.isClosed {
+		return 0, os.ErrClosed
+	}
+
+	switch whence {
+	case io.SeekCurrent:
+		f.position += offset
+	case io.SeekStart:
+		f.position = offset
+	case io.SeekEnd:
+		f.position = int64(f.content.Len()) + offset
+	}
+
+	return f.position, nil
+}
+
+func (f *file) Write(p []byte) (int, error) {
+	return f.WriteAt(p, f.position)
+}
+
+func (f *file) WriteAt(p []byte, off int64) (int, error) {
+	if f.isClosed {
+		return 0, os.ErrClosed
+	}
+
+	if !isReadAndWrite(f.flag) && !isWriteOnly(f.flag) {
+		return 0, errors.New("write not supported")
+	}
+
+	f.modTime = time.Now()
+	n, err := f.content.WriteAt(p, off)
+	f.position = off + int64(n)
+
+	return n, err
+}
+
+func (f *file) Close() error {
+	if f.isClosed {
+		return os.ErrClosed
+	}
+
+	f.isClosed = true
+	return nil
+}
+
+func (f *file) Truncate(size int64) error {
+	if size < int64(len(f.content.bytes)) {
+		f.content.bytes = f.content.bytes[:size]
+	} else if more := int(size) - len(f.content.bytes); more > 0 {
+		f.content.bytes = append(f.content.bytes, make([]byte, more)...)
+	}
+
+	return nil
+}
+
+func (f *file) Duplicate(filename string, mode fs.FileMode, flag int) billy.File {
+	n := &file{
+		name:    filename,
+		content: f.content,
+		mode:    mode,
+		flag:    flag,
+		modTime: f.modTime,
+	}
+
+	if isTruncate(flag) {
+		n.content.Truncate()
+	}
+
+	if isAppend(flag) {
+		n.position = int64(n.content.Len())
+	}
+
+	return n
+}
+
+func (f *file) Stat() (os.FileInfo, error) {
+	return &fileInfo{
+		name:    f.Name(),
+		mode:    f.mode,
+		size:    f.content.Len(),
+		modTime: f.modTime,
+	}, nil
+}
+
+// Lock is a no-op in memfs.
+func (f *file) Lock() error {
+	return nil
+}
+
+// Unlock is a no-op in memfs.
+func (f *file) Unlock() error {
+	return nil
+}
+
+type fileInfo struct {
+	name    string
+	size    int
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi *fileInfo) Name() string {
+	return fi.name
+}
+
+func (fi *fileInfo) Size() int64 {
+	return int64(fi.size)
+}
+
+func (fi *fileInfo) Mode() fs.FileMode {
+	return fi.mode
+}
+
+func (fi *fileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+
+func (fi *fileInfo) IsDir() bool {
+	return fi.mode.IsDir()
+}
+
+func (*fileInfo) Sys() interface{} {
+	return nil
+}
+
+type content struct {
+	name  string
+	bytes []byte
+
+	m sync.RWMutex
+}
+
+func (c *content) WriteAt(p []byte, off int64) (int, error) {
+	if off < 0 {
+		return 0, &os.PathError{
+			Op:   "writeat",
+			Path: c.name,
+			Err:  errors.New("negative offset"),
+		}
+	}
+
+	c.m.Lock()
+	prev := len(c.bytes)
+
+	diff := int(off) - prev
+	if diff > 0 {
+		c.bytes = append(c.bytes, make([]byte, diff)...)
+	}
+
+	c.bytes = append(c.bytes[:off], p...)
+	if len(c.bytes) < prev {
+		c.bytes = c.bytes[:prev]
+	}
+	c.m.Unlock()
+
+	return len(p), nil
+}
+
+func (c *content) ReadAt(b []byte, off int64) (n int, err error) {
+	if off < 0 {
+		return 0, &os.PathError{
+			Op:   "readat",
+			Path: c.name,
+			Err:  errors.New("negative offset"),
+		}
+	}
+
+	c.m.RLock()
+	size := int64(len(c.bytes))
+	if off >= size {
+		c.m.RUnlock()
+		return 0, io.EOF
+	}
+
+	l := int64(len(b))
+	if off+l > size {
+		l = size - off
+	}
+
+	btr := c.bytes[off : off+l]
+	n = copy(b, btr)
+
+	if len(btr) < len(b) {
+		err = io.EOF
+	}
+	c.m.RUnlock()
+
+	return
+}