filesystem: add lockfile write function

Add 'WriteLockFileFunc()' to provide a mechanism for updating files
semi-atomically. The function takes a filename and a function (the logic
perform the write to a given file pointer, executes the write function on
'<filename>.lock', then returns a 'LockFile' object. That returned
'LockFile' can then either invoke 'Commit()' (to rename '<filename>.lock' to
'<filename>') or 'Rollback()' (to delete '<filename>.lock'). If
'WriteLockFileFunc()' encounters any error in its operation, it tries to
rollback the lockfile before returning the error.

This function is mainly useful for writing files that may be read
concurrently with the write operation. Writing the file to a lockfile, then
atomically renaming the file avoids avoids the possibility of another
process reading a half-written update to the file.

Example usage:

---
lockFile, err := fileSystem.WriteLockFileFunc("myfile.txt", func(f io.Writer) error {
    f.Write([]byte("my text"))
})
if err != nil {
    return err
}
lockFile.Commit()
---

Signed-off-by: Victoria Dye <[email protected]>

Author: vdye

cmd/utils/container-helpers.go

@@ -33,6 +33,7 @@ func BuildGitBundleServerContainer(logger log.TraceLogger) *DependencyContainer
 	registerDependency(container, func(ctx context.Context) bundles.BundleProvider {
 		return bundles.NewBundleProvider(
 			logger,
+			GetDependency[common.FileSystem](ctx, container),
 			GetDependency[git.GitHelper](ctx, container),
 		)
 	})

internal/common/filesystem.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
+	"io"
 	"io/fs"
 	"os"
 	"path"
@@ -16,11 +17,30 @@ const (
 	DefaultDirPermissions  fs.FileMode = 0o755
 )
 
+type LockFile interface {
+	Commit() error
+	Rollback() error
+}
+
+type lockFile struct {
+	filename     string
+	lockFilename string
+}
+
+func (l *lockFile) Commit() error {
+	return os.Rename(l.lockFilename, l.filename)
+}
+
+func (l *lockFile) Rollback() error {
+	return os.Remove(l.lockFilename)
+}
+
 type FileSystem interface {
 	GetLocalExecutable(name string) (string, error)
 
 	FileExists(filename string) (bool, error)
 	WriteFile(filename string, content []byte) error
+	WriteLockFileFunc(filename string, writeFunc func(io.Writer) error) (LockFile, error)
 	DeleteFile(filename string) (bool, error)
 	ReadFileLines(filename string) ([]string, error)
 }
@@ -86,6 +106,37 @@ func (f *fileSystem) WriteFile(filename string, content []byte) error {
 	return nil
 }
 
+func (f *fileSystem) WriteLockFileFunc(filename string, writeFunc func(io.Writer) error) (LockFile, error) {
+	err := f.createLeadingDirs(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	lockFilename := filename + ".lock"
+	lock, err := os.OpenFile(lockFilename, os.O_WRONLY|os.O_CREATE, DefaultFilePermissions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %w", err)
+	}
+	lockFile := &lockFile{filename: filename, lockFilename: lockFilename}
+
+	err = writeFunc(lock)
+	if err != nil {
+		// Try to close & rollback - don't worry about errors, we're already failing.
+		lock.Close()
+		lockFile.Rollback()
+		return nil, err
+	}
+
+	err = lock.Close()
+	if err != nil {
+		// Try to rollback - don't worry about errors, we're already failing.
+		lockFile.Rollback()
+		return nil, fmt.Errorf("failed to close lock file: %w", err)
+	}
+
+	return lockFile, nil
+}
+
 func (f *fileSystem) DeleteFile(filename string) (bool, error) {
 	err := os.Remove(filename)
 	if err == nil {

internal/testhelpers/mocks.go

@@ -3,11 +3,13 @@ package testhelpers
 import (
 	"context"
 	"fmt"
+	"io"
 	"os/exec"
 	"os/user"
 	"runtime"
 
 	"github.com/github/git-bundle-server/internal/cmd"
+	"github.com/github/git-bundle-server/internal/common"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -165,6 +167,11 @@ func (m *MockFileSystem) WriteFile(filename string, content []byte) error {
 	return fnArgs.Error(0)
 }
 
+func (m *MockFileSystem) WriteLockFileFunc(filename string, writeFunc func(io.Writer) error) (common.LockFile, error) {
+	fnArgs := m.Called(filename, writeFunc)
+	return fnArgs.Get(0).(common.LockFile), fnArgs.Error(1)
+}
+
 func (m *MockFileSystem) DeleteFile(filename string) (bool, error) {
 	fnArgs := m.Called(filename)
 	return fnArgs.Bool(0), fnArgs.Error(1)