Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

refactor(runtime): extract restoreCheckpointEntry from RestoreWorkspaceCheckpointFrom (#470)

fx-kurumi0ab25ff59b29
diff --git a/internal/runtime/checkpoint_restore_entry_test.go b/internal/runtime/checkpoint_restore_entry_test.go
new file mode 100644
index 00000000..d238b836
--- /dev/null
+++ b/internal/runtime/checkpoint_restore_entry_test.go
@@ -0,0 +1,61 @@
+package runtime
+
+import (
+ "archive/tar"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+func openCheckpointTestRoot(t *testing.T) (*os.Root, string) {
+ t.Helper()
+ dir := t.TempDir()
+ base, err := os.OpenRoot(dir)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = base.Close() })
+ return base, dir
+}
+
+func TestRestoreCheckpointEntryMaterializesEntryTypes(t *testing.T) {
+ base, dir := openCheckpointTestRoot(t)
+ if err := restoreCheckpointEntry(base, "a/b", &tar.Header{Typeflag: tar.TypeDir, Mode: 0750}, nil); err != nil {
+ t.Fatal(err)
+ }
+ if info, err := os.Stat(filepath.Join(dir, "a", "b")); err != nil || !info.IsDir() {
+ t.Fatalf("directory not created: %v", err)
+ }
+ body := "hello"
+ if err := restoreCheckpointEntry(base, "nested/file.txt", &tar.Header{Typeflag: tar.TypeReg, Mode: 0640, Size: int64(len(body))}, strings.NewReader(body+"trailing")); err != nil {
+ t.Fatal(err)
+ }
+ got, err := os.ReadFile(filepath.Join(dir, "nested", "file.txt"))
+ if err != nil || string(got) != body {
+ t.Fatalf("file content = %q, %v", got, err)
+ }
+ if err := restoreCheckpointEntry(base, "link", &tar.Header{Typeflag: tar.TypeSymlink, Linkname: "../outside"}, nil); err != nil {
+ t.Fatal(err)
+ }
+ if target, err := os.Readlink(filepath.Join(dir, "link")); err != nil || target != "../outside" {
+ t.Fatalf("symlink target = %q, %v", target, err)
+ }
+}
+
+func TestRestoreCheckpointEntryRejectsInvalidEntries(t *testing.T) {
+ base, _ := openCheckpointTestRoot(t)
+ if err := restoreCheckpointEntry(base, "dev", &tar.Header{Typeflag: tar.TypeChar}, nil); err == nil || err.Error() != "unsupported checkpoint entry" {
+ t.Fatalf("unsupported entry error = %v", err)
+ }
+ header := &tar.Header{Typeflag: tar.TypeReg, Mode: 0600, Size: 1}
+ if err := restoreCheckpointEntry(base, "dup", header, strings.NewReader("x")); err != nil {
+ t.Fatal(err)
+ }
+ if err := restoreCheckpointEntry(base, "dup", header, strings.NewReader("y")); err == nil {
+ t.Fatal("existing file must not be overwritten")
+ }
+ if err := restoreCheckpointEntry(base, "short", &tar.Header{Typeflag: tar.TypeReg, Mode: 0600, Size: 10}, strings.NewReader("abc")); err == nil {
+ t.Fatal("truncated body must fail")
+ }
+}
diff --git a/internal/runtime/workspace_checkpoint.go b/internal/runtime/workspace_checkpoint.go
index 6cf265e9..4b5d4c3d 100644
--- a/internal/runtime/workspace_checkpoint.go
+++ b/internal/runtime/workspace_checkpoint.go
@@ -225,34 +225,7 @@ func RestoreWorkspaceCheckpointFrom(root string, source io.Reader) error {
if header.Size < 0 || expanded > workspaceCheckpointExpandedMax {
return fmt.Errorf("checkpoint expanded size exceeds limit")
}
- if err = base.MkdirAll(filepath.Dir(path), 0755); err != nil {
- return err
- }
- switch header.Typeflag {
- case tar.TypeDir:
- err = base.MkdirAll(path, os.FileMode(header.Mode)&0777)
- case tar.TypeReg:
- var file *os.File
- file, err = base.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, os.FileMode(header.Mode)&0777)
- if err == nil {
- _, err = io.CopyN(file, reader, header.Size)
- if err == nil {
- err = file.Sync()
- }
- closeErr := file.Close()
- if err == nil {
- err = closeErr
- }
- }
- case tar.TypeSymlink:
- // The target is restored as inert data, exactly like git checkout
- // does. os.Root refuses to traverse any link leaving the staging
- // root, so later entries can never be written through it.
- err = base.Symlink(header.Linkname, path)
- default:
- return fmt.Errorf("unsupported checkpoint entry")
- }
- if err != nil {
+ if err = restoreCheckpointEntry(base, path, header, reader); err != nil {
return err
}
}
@@ -266,6 +239,41 @@ func RestoreWorkspaceCheckpointFrom(root string, source io.Reader) error {
return os.Rename(stage, root)
}
+// restoreCheckpointEntry materializes one validated tar entry at path inside
+// the staging root. Regular file content is read from reader, which must be
+// positioned at the entry body.
+func restoreCheckpointEntry(base *os.Root, path string, header *tar.Header, reader io.Reader) error {
+ if err := base.MkdirAll(filepath.Dir(path), 0755); err != nil {
+ return err
+ }
+ mode := os.FileMode(header.Mode) & 0777
+ switch header.Typeflag {
+ case tar.TypeDir:
+ return base.MkdirAll(path, mode)
+ case tar.TypeReg:
+ file, err := base.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode)
+ if err != nil {
+ return err
+ }
+ _, err = io.CopyN(file, reader, header.Size)
+ if err == nil {
+ err = file.Sync()
+ }
+ closeErr := file.Close()
+ if err == nil {
+ err = closeErr
+ }
+ return err
+ case tar.TypeSymlink:
+ // The target is restored as inert data, exactly like git checkout
+ // does. os.Root refuses to traverse any link leaving the staging
+ // root, so later entries can never be written through it.
+ return base.Symlink(header.Linkname, path)
+ default:
+ return fmt.Errorf("unsupported checkpoint entry")
+ }
+}
+
func EmptyWorkspaceCheckpoint() []byte {
var buffer bytes.Buffer
zipped := gzip.NewWriter(&buffer)