feat: upgrade existing filesystem

cmd/chisel/cmd_cut.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"slices"
 	"time"
 
@@ -11,6 +12,7 @@ import (
 	"github.com/canonical/chisel/internal/cache"
 	"github.com/canonical/chisel/internal/setup"
 	"github.com/canonical/chisel/internal/slicer"
+	"github.com/canonical/chisel/public/manifest"
 )
 
 var shortCutHelp = "Cut a tree with selected slices"
@@ -73,6 +75,27 @@ func (cmd *cmdCut) Execute(args []string) error {
 		}
 	}
 
+	var mfest *manifest.Manifest
+	// TODO: Remove this gating once the final upgrading strategy is in place.
+	if os.Getenv("CHISEL_RECUT_EXPERIMENTAL") != "" {
+		mfest, err := slicer.SelectValidManifest(cmd.RootDir, release)
+		if err != nil {
+			return err
+		}
+		if mfest != nil {
+			err = mfest.IterateSlices("", func(slice *manifest.Slice) error {
+				sk, err := setup.ParseSliceKey(slice.Name)
+				if err != nil {
+					return err
+				}
+				sliceKeys = append(sliceKeys, sk)
+				return nil
+			})
+			if err != nil {
+				return err
+			}
+		}
+	}
 	selection, err := setup.Select(release, sliceKeys, cmd.Arch)
 	if err != nil {
 		return err
@@ -125,6 +148,7 @@ func (cmd *cmdCut) Execute(args []string) error {
 		Selection: selection,
 		Archives:  archives,
 		TargetDir: cmd.RootDir,
+		Manifest:  mfest,
 	})
 	return err
 }

internal/fsutil/create.go

@@ -168,6 +168,10 @@ func createDir(o *CreateOptions) error {
 	}
 	err = os.Mkdir(path, o.Mode)
 	if os.IsExist(err) {
+		// TODO: Detect if existing content is a file. ErrExist is also returned
+		// if a file exists at this path, so returning nil here creates an
+		// inconsistency between our view of the content and the real content on
+		// disk which is a bug that must be fixed.
 		return nil
 	}
 	return err
@@ -179,6 +183,9 @@ func createFile(o *CreateOptions) error {
 	if err != nil {
 		return err
 	}
+	// TODO: Detect if existing content is a symlink and remove it if so. The
+	// current implementation resolves the symlink and will override the target
+	// and not the symlink itself which is a bug.
 	file, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, o.Mode)
 	if err != nil {
 		return err

internal/manifestutil/manifestutil.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
+	"maps"
 	"path/filepath"
 	"slices"
 	"sort"
@@ -34,6 +35,24 @@ func FindPaths(slices []*setup.Slice) map[string][]*setup.Slice {
 	return manifestSlices
 }
 
+// FindPathsInRelease finds all the paths marked with "generate:manifest"
+// for the given release.
+func FindPathsInRelease(r *setup.Release) []string {
+	manifestPaths := make(map[string]struct{})
+	for _, pkg := range r.Packages {
+		for _, slice := range pkg.Slices {
+			for path, info := range slice.Contents {
+				if info.Generate == setup.GenerateManifest {
+					dir := strings.TrimSuffix(path, "**")
+					path = filepath.Join(dir, DefaultFilename)
+					manifestPaths[path] = struct{}{}
+				}
+			}
+		}
+	}
+	return slices.Sorted(maps.Keys(manifestPaths))
+}
+
 type WriteOptions struct {
 	PackageInfo []*archive.PackageInfo
 	Selection   []*setup.Slice

internal/manifestutil/manifestutil_test.go

@@ -110,10 +110,121 @@ func (s *S) TestFindPaths(c *C) {
 	}
 }
 
+var findPathsInReleaseTests = []struct {
+	summary  string
+	release  *setup.Release
+	expected []string
+}{{
+	summary: "Single package with single slice",
+	release: &setup.Release{
+		Packages: map[string]*setup.Package{
+			"package1": {
+				Name: "package1",
+				Slices: map[string]*setup.Slice{
+					"slice1": {
+						Name: "slice1",
+						Contents: map[string]setup.PathInfo{
+							"/folder/**": {
+								Kind:     "generate",
+								Generate: "manifest",
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+	expected: []string{"/folder/manifest.wall"},
+}, {
+	summary: "No slices with generate:manifest",
+	release: &setup.Release{
+		Packages: map[string]*setup.Package{
+			"package1": {
+				Name: "package1",
+				Slices: map[string]*setup.Slice{
+					"slice1": {
+						Name:     "slice1",
+						Contents: map[string]setup.PathInfo{},
+					},
+				},
+			},
+		},
+	},
+	expected: nil,
+}, {
+	summary: "Multiple packages with multiple slices",
+	release: &setup.Release{
+		Packages: map[string]*setup.Package{
+			"package1": {
+				Name: "package1",
+				Slices: map[string]*setup.Slice{
+					"slice1": {
+						Name: "slice1",
+						Contents: map[string]setup.PathInfo{
+							"/folder/**": {
+								Kind:     "generate",
+								Generate: "manifest",
+							},
+						},
+					},
+					"slice2": {
+						Name: "slice2",
+						Contents: map[string]setup.PathInfo{
+							"/folder/**": {
+								Kind:     "generate",
+								Generate: "manifest",
+							},
+						},
+					},
+				},
+			},
+			"package2": {
+				Name: "package2",
+				Slices: map[string]*setup.Slice{
+					"slice3": {
+						Name:     "slice3",
+						Contents: map[string]setup.PathInfo{},
+					},
+					"slice4": {
+						Name: "slice4",
+						Contents: map[string]setup.PathInfo{
+							"/other-folder/**": {
+								Kind:     "generate",
+								Generate: "manifest",
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+	expected: []string{"/folder/manifest.wall", "/other-folder/manifest.wall"},
+}, {
+	summary: "Empty release",
+	release: &setup.Release{
+		Packages: map[string]*setup.Package{},
+	},
+	expected: nil,
+}}
+
+func (s *S) TestFindPathsInRelease(c *C) {
+	for _, test := range findPathsInReleaseTests {
+		c.Logf("Summary: %s", test.summary)
+
+		manifestPaths := manifestutil.FindPathsInRelease(test.release)
+
+		c.Assert(manifestPaths, HasLen, len(test.expected))
+		slices.Sort(manifestPaths)
+		slices.Sort(test.expected)
+		c.Assert(manifestPaths, DeepEquals, test.expected)
+	}
+}
+
 var slice1 = &setup.Slice{
 	Package: "package1",
 	Name:    "slice1",
 }
+
 var slice2 = &setup.Slice{
 	Package: "package2",
 	Name:    "slice2",