feat(cli): add restore transaction core

2026-08-16 02:05:21 +02:00
parent cbb18acc4d
commit 69dca0820b
2 changed files with 365 additions and 0 deletions
@@ -0,0 +1,107 @@
+package backup
+
+import (
+	"archive/zip"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/aritmolab/thothii/tools/tht/internal/config"
+)
+
+var ErrRestoreConfirmationRequired = errors.New("restore requires --yes")
+
+// RestoreRequest describes the deliberately-confirmed archive restoration.
+type RestoreRequest struct {
+	Archive string
+	Confirm bool
+	Drain   bool
+}
+
+// RestoreResult records the retained recovery point and the final service state.
+type RestoreResult struct {
+	Checkpoint string
+	Restarted  bool
+	Verified   bool
+}
+
+type restoreLock interface { Release() error }
+type restoreVerify func(context.Context, config.Installation, archiveRunner) error
+
+type restoreDependencies struct {
+	preflight     func(context.Context, config.Installation, PreflightRequest) (PreflightResult, error)
+	checkpoint    func(context.Context, config.Installation, CreateRequest) (Result, error)
+	acquireLock   func(config.Installation) (restoreLock, error)
+	runner        archiveRunner
+	sleep         func(duration time.Duration)
+	restoreFile   func(context.Context, config.Installation, ArchiveEntryMetadata, io.Reader) error
+	restoreVolume func(context.Context, config.Installation, VolumeMetadata, io.Reader) error
+	verify        map[string]restoreVerify
+}
+
+// Restore runs the host transaction. Concrete host dependencies are intentionally kept outside
+// the deterministic core so callers cannot bypass its preflight and checkpoint boundaries.
+func Restore(ctx context.Context, installation config.Installation, request RestoreRequest) (RestoreResult, error) {
+	return RestoreResult{}, errors.New("restore host dependencies are unavailable")
+}
+
+func restoreWithDependencies(ctx context.Context, installation config.Installation, request RestoreRequest, deps restoreDependencies) (result RestoreResult, resultErr error) {
+	if !request.Confirm { return RestoreResult{}, ErrRestoreConfirmationRequired }
+	if request.Archive == "" { return RestoreResult{}, errors.New("restore archive is required") }
+	if deps.preflight == nil || deps.checkpoint == nil || deps.acquireLock == nil || deps.runner == nil || deps.restoreFile == nil || deps.restoreVolume == nil || deps.verify == nil {
+		return RestoreResult{}, errors.New("restore dependencies are incomplete")
+	}
+	preflight, err := deps.preflight(ctx, installation, PreflightRequest{Archive: request.Archive, Confirm: true, AllowExternalSecrets: true})
+	if err != nil { return RestoreResult{}, err }
+	defer preflight.CloseArchive()
+	archive, err := preflight.RevalidateArchive()
+	if err != nil { return RestoreResult{}, err }
+
+	checkpoint, err := deps.checkpoint(ctx, installation, CreateRequest{})
+	if err != nil { return RestoreResult{}, fmt.Errorf("create recovery checkpoint: %w", err) }
+	result.Checkpoint = checkpoint.Path
+	lock, err := deps.acquireLock(installation)
+	if err != nil { return result, err }
+	defer func() { if releaseErr := lock.Release(); releaseErr != nil && resultErr == nil { resultErr = releaseErr } }()
+
+	wasRunning, err := installationRunning(ctx, installation, deps.runner)
+	if err != nil { return result, err }
+	mutated := false
+	defer func() {
+		if resultErr != nil && mutated { _ = runCompose(context.Background(), installation, deps.runner, "stop") }
+	}()
+	if wasRunning {
+		if err := maintenance(ctx, installation, deps.runner, true); err != nil { return result, err }
+		if err := waitForNoActiveSessions(ctx, installation, deps.runner, request.Drain, deps.sleep); err != nil { return result, err }
+		if err := runCompose(ctx, installation, deps.runner, "stop"); err != nil { return result, err }
+	}
+	reader, err := zip.NewReader(archive, preflight.ArchiveSize)
+	if err != nil { return result, fmt.Errorf("read verified restore archive: %w", err) }
+	members := make(map[string]*zip.File, len(reader.File))
+	for _, member := range reader.File { members[member.Name] = member }
+	for _, entry := range preflight.Entries {
+		if entry.Kind == EntryVolume { continue }
+		member := members[entry.Path]
+		if member == nil { return result, fmt.Errorf("verified archive is missing %q", entry.Path) }
+		stream, openErr := member.Open()
+		if openErr != nil { return result, fmt.Errorf("open verified archive member %q: %w", entry.Path, openErr) }
+		mutated = true
+		restoreErr := deps.restoreFile(ctx, installation, entry, stream)
+		closeErr := stream.Close()
+		if restoreErr != nil { return result, restoreErr }
+		if closeErr != nil { return result, closeErr }
+	}
+	if wasRunning {
+		if err := composeStartAndVerify(ctx, installation, deps.runner); err != nil { return result, err }
+		result.Restarted = true
+	}
+	for _, name := range []string{"health", "doctor", "pi", "workspace"} {
+		check := deps.verify[name]
+		if check == nil { return result, fmt.Errorf("restore verification %q is unavailable", name) }
+		if err := check(ctx, installation, deps.runner); err != nil { return result, fmt.Errorf("restore verification %s: %w", name, err) }
+	}
+	result.Verified = true
+	return result, nil
+}