refstore/files: Add new files backend

(And use it in repository)

1 files changed, 199 insertions, 0 deletions

diff --git a/refstore/files/transaction_write.go b/refstore/files/transaction_write.go
new file mode 100644
index 00000000..678994f0
--- /dev/null
+++ b/refstore/files/transaction_write.go
@@ -0,0 +1,199 @@
+package files
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"strings"
+)
+
+func (tx *Transaction) verifyCurrent(item preparedTxOp) error {
+	switch item.op.kind {
+	case txCreate:
+		if item.target.ref.kind != directMissing {
+			return fmt.Errorf("refstore/files: reference %q already exists", item.target.name)
+		}
+
+		return nil
+	case txUpdate, txDelete, txVerify:
+		if item.target.ref.kind == directMissing {
+			return fmt.Errorf("refstore/files: reference %q is missing", item.target.name)
+		}
+
+		if item.target.ref.kind != directDetached {
+			return fmt.Errorf("refstore/files: reference %q is not detached", item.target.name)
+		}
+
+		if item.target.ref.id != item.op.oldID {
+			return fmt.Errorf("refstore/files: reference %q is at %s but expected %s", item.target.name, item.target.ref.id, item.op.oldID)
+		}
+
+		return nil
+	case txCreateSymbolic:
+		if item.target.ref.kind != directMissing {
+			return fmt.Errorf("refstore/files: reference %q already exists", item.target.name)
+		}
+
+		return nil
+	case txUpdateSymbolic, txDeleteSymbolic, txVerifySymbolic:
+		if item.target.ref.kind == directMissing {
+			return fmt.Errorf("refstore/files: symbolic reference %q is missing", item.target.name)
+		}
+
+		if item.target.ref.kind != directSymbolic {
+			return fmt.Errorf("refstore/files: reference %q is not symbolic", item.target.name)
+		}
+
+		if strings.TrimSpace(item.target.ref.target) != strings.TrimSpace(item.op.oldTarget) {
+			return fmt.Errorf("refstore/files: reference %q points at %q, expected %q", item.target.name, item.target.ref.target, item.op.oldTarget)
+		}
+
+		return nil
+	default:
+		return fmt.Errorf("refstore/files: unsupported transaction operation %d", item.op.kind)
+	}
+}
+
+func (tx *Transaction) writeLoose(item preparedTxOp) error {
+	root := tx.store.rootFor(item.target.loc.root)
+	lockName := item.target.loc.path + ".lock"
+
+	lock, err := root.OpenFile(lockName, os.O_WRONLY|os.O_TRUNC, 0o644)
+	if err != nil {
+		return err
+	}
+
+	var content string
+
+	switch item.op.kind {
+	case txCreate, txUpdate:
+		content = item.op.newID.String() + "\n"
+	case txCreateSymbolic, txUpdateSymbolic:
+		content = "ref: " + strings.TrimSpace(item.op.newTarget) + "\n"
+	case txDelete, txVerify, txDeleteSymbolic, txVerifySymbolic:
+	default:
+		_ = lock.Close()
+
+		return fmt.Errorf("refstore/files: unsupported write operation %d", item.op.kind)
+	}
+
+	_, err = lock.WriteString(content)
+	if err != nil {
+		_ = lock.Close()
+
+		return err
+	}
+
+	err = lock.Close()
+	if err != nil {
+		return err
+	}
+
+	dir := path.Dir(item.target.loc.path)
+	if dir != "." {
+		err = root.MkdirAll(dir, 0o755)
+		if err != nil {
+			return err
+		}
+	}
+
+	err = tx.removeEmptyDirTree(item.target.loc)
+	if err != nil {
+		return err
+	}
+
+	return root.Rename(lockName, item.target.loc.path)
+}
+
+func (tx *Transaction) applyPackedDeletes(prepared []preparedTxOp) error {
+	_, err := tx.store.commonRoot.Stat("packed-refs.lock")
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil
+		}
+
+		return err
+	}
+
+	packed, err := tx.store.readPackedRefs()
+	if err != nil {
+		return err
+	}
+
+	deleted := make(map[string]struct{})
+	needed := false
+
+	for _, item := range prepared {
+		if item.op.kind != txDelete && item.op.kind != txDeleteSymbolic {
+			continue
+		}
+
+		deleted[item.target.name] = struct{}{}
+		if item.target.ref.isPacked {
+			needed = true
+		}
+	}
+
+	if !needed {
+		return nil
+	}
+
+	lock, err := tx.store.commonRoot.OpenFile("packed-refs.new", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
+	if err != nil {
+		return err
+	}
+
+	createdTemp := true
+
+	defer func() {
+		if !createdTemp {
+			return
+		}
+
+		_ = tx.store.commonRoot.Remove("packed-refs.new")
+	}()
+
+	_, err = lock.WriteString("# pack-refs with: peeled fully-peeled sorted\n")
+	if err != nil {
+		_ = lock.Close()
+
+		return err
+	}
+
+	for _, entry := range packed.ordered {
+		if _, skip := deleted[entry.Name()]; skip {
+			continue
+		}
+
+		_, err = lock.WriteString(entry.ID.String() + " " + entry.Name() + "\n")
+		if err != nil {
+			_ = lock.Close()
+
+			return err
+		}
+
+		if entry.Peeled != nil {
+			_, err = lock.WriteString("^" + entry.Peeled.String() + "\n")
+			if err != nil {
+				_ = lock.Close()
+
+				return err
+			}
+		}
+	}
+
+	err = lock.Close()
+	if err != nil {
+		return err
+	}
+
+	err = tx.store.commonRoot.Rename("packed-refs.new", "packed-refs")
+	if err != nil {
+		return err
+	}
+
+	createdTemp = false
+
+	return nil
+}