feat: search, load and validates manifests

cmd/chisel/cmd_cut.go

@@ -2,13 +2,16 @@ package main
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 	"slices"
 	"time"
 
 	"github.com/jessevdk/go-flags"
 
 	"github.com/canonical/chisel/internal/archive"
 	"github.com/canonical/chisel/internal/cache"
+	"github.com/canonical/chisel/internal/manifestutil"
 	"github.com/canonical/chisel/internal/setup"
 	"github.com/canonical/chisel/internal/slicer"
 )
@@ -73,6 +76,34 @@ func (cmd *cmdCut) Execute(args []string) error {
 		}
 	}
 
+	targetDir, err := nonEmptyDir(cmd.RootDir)
+	if err != nil {
+		return err
+	}
+
+	if len(targetDir) > 0 {
+		manifest, err := manifestutil.FromDir(release, targetDir)
+		if err != nil {
+			// TODO: When enabling the feature, error out.
+			logf("Warning: %v", err)
+		} else {
+			err = manifestutil.VerifyDir(manifest, targetDir)
+			if err != nil {
+				// TODO: When enabling the feature, error out.
+				logf("Warning: %v", err)
+			}
+			// Merge the slice keys used to build the existing rootfs with the ones
+			// explicitly requested slices.
+			// Previous slice keys contain both explicitly requested slices and slices
+			// resolved following essentials.
+			for _, s := range manifestutil.SliceKeys(manifest) {
+				if !slices.Contains(sliceKeys, s) {
+					sliceKeys = append(sliceKeys, s)
+				}
+			}
+		}
+	}
+
 	selection, err := setup.Select(release, sliceKeys, cmd.Arch)
 	if err != nil {
 		return err
@@ -128,3 +159,28 @@ func (cmd *cmdCut) Execute(args []string) error {
 	})
 	return err
 }
+
+// nonEmptyDir checks whether the given directory exists and is non-empty.
+func nonEmptyDir(rootdir string) (string, error) {
+	// Get targetDir path
+	// Note: This is already done in `slicer.Run`. Extract it and avoid doing it twice?
+	targetDir := filepath.Clean(rootdir)
+	if !filepath.IsAbs(targetDir) {
+		dir, err := os.Getwd()
+		if err != nil {
+			return "", fmt.Errorf("cannot obtain current directory: %w", err)
+		}
+		targetDir = filepath.Join(dir, targetDir)
+	}
+
+	entries, err := os.ReadDir(targetDir)
+	if err != nil {
+		return "", fmt.Errorf("cannot read root directory %q: %v", targetDir, err)
+	}
+
+	if len(entries) == 0 {
+		return "", nil
+	}
+
+	return targetDir, nil
+}

internal/manifestutil/manifestutil.go

@@ -1,9 +1,12 @@
 package manifestutil
 
 import (
+	"crypto/sha256"
 	"fmt"
 	"io"
 	"io/fs"
+	"os"
+	"path"
 	"path/filepath"
 	"slices"
 	"sort"
@@ -14,6 +17,7 @@ import (
 	"github.com/canonical/chisel/internal/setup"
 	"github.com/canonical/chisel/public/jsonwall"
 	"github.com/canonical/chisel/public/manifest"
+	"github.com/klauspost/compress/zstd"
 )
 
 const DefaultFilename = "manifest.wall"
@@ -34,6 +38,26 @@ 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 {
+	allSlices := []*setup.Slice{}
+	for _, pkg := range r.Packages {
+		for _, slice := range pkg.Slices {
+			allSlices = append(allSlices, slice)
+		}
+	}
+
+	manifestMap := FindPaths(allSlices)
+
+	paths := make([]string, 0, len(manifestMap))
+	for path := range manifestMap {
+		paths = append(paths, path)
+	}
+
+	return paths
+}
+
 type WriteOptions struct {
 	PackageInfo []*archive.PackageInfo
 	Selection   []*setup.Slice
@@ -340,3 +364,126 @@ func Validate(mfest *manifest.Manifest) (err error) {
 	}
 	return nil
 }
+
+// FromDir extracts, validates and returns the manifest from a targetDir
+func FromDir(release *setup.Release, targetDir string) (*manifest.Manifest, error) {
+	manifestPaths := FindPathsInRelease(release)
+	if len(manifestPaths) == 0 {
+		// No manifest in the release means it cannot produce a rootfs that can
+		// be recut. Treat this case as cutting a new rootfs.
+		return nil, fmt.Errorf("no manifest generated for this release")
+	}
+
+	// Select the first manifest of the list as the reference one for now.
+	// Another heuristic could be used (ex. select the one from base-files_chisel).
+	referenceRelPath := manifestPaths[0]
+	referencePath := path.Join(targetDir, referenceRelPath)
+	reference, err := load(referencePath)
+	if err != nil {
+		return nil, fmt.Errorf("cannot read manifest %q from the root directory: %v", referenceRelPath, err)
+	}
+
+	err = checkConsistency(referenceRelPath, targetDir, manifestPaths[1:])
+	if err != nil {
+		return nil, err
+	}
+
+	return reference, nil
+}
+
+// load reads, validates and returns a manifest.
+func load(manifestPath string) (*manifest.Manifest, error) {
+	f, err := os.Open(manifestPath)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	r, err := zstd.NewReader(f)
+	if err != nil {
+		return nil, err
+	}
+	defer r.Close()
+
+	mfest, err := manifest.Read(r)
+	if err != nil {
+		return nil, err
+	}
+
+	err = Validate(mfest)
+	if err != nil {
+		return nil, err
+	}
+
+	return mfest, nil
+}
+
+// checkConsistency checks consistency between a list of manifests and a
+// reference one.
+func checkConsistency(referenceRelPath string, targetDir string, manifests []string) error {
+	reference := path.Join(targetDir, referenceRelPath)
+	hashReference, err := hash(reference)
+	if err != nil {
+		return fmt.Errorf("internal error: cannot compute hash for %q: %w", referenceRelPath, err)
+	}
+
+	infoRef, err := os.Stat(reference)
+	if err != nil {
+		return fmt.Errorf("internal error: cannot get file info for %q: %w", referenceRelPath, err)
+	}
+
+	modeRef := infoRef.Mode()
+
+	for _, manifestRelPath := range manifests {
+		manifestPath := path.Join(targetDir, manifestRelPath)
+		infoManifest, err := os.Stat(manifestPath)
+		if err != nil {
+			return fmt.Errorf("internal error: cannot get file info for %q: %w", manifestRelPath, err)
+		}
+
+		modeManifest := infoManifest.Mode()
+		if modeManifest != modeRef {
+			return fmt.Errorf("invalid manifest: permissions on %s (%s) are different from the reference manifest %s (%s)", manifestRelPath, modeManifest, referenceRelPath, modeRef)
+		}
+
+		hashM, err := hash(manifestPath)
+		if err != nil {
+			return fmt.Errorf("internal error: cannot compute hash for %q: %w", manifestRelPath, err)
+		}
+		if !slices.Equal(hashM, hashReference) {
+			return fmt.Errorf("invalid manifest: %s is inconsistent with %s", manifestRelPath, referenceRelPath)
+		}
+	}
+
+	return nil
+}
+
+func hash(path string) ([]byte, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return nil, err
+	}
+
+	return h.Sum(nil), nil
+}
+
+// SliceKeys returns setup.SliceKeys from a manifest.
+func SliceKeys(mfest *manifest.Manifest) []setup.SliceKey {
+	sliceKeys := []setup.SliceKey{}
+	mfest.IterateSlices("", func(slice *manifest.Slice) error {
+		sk, err := apacheutil.ParseSliceKey(slice.Name)
+		if err != nil {
+			return err
+		}
+		sliceKeys = append(sliceKeys, sk)
+		return nil
+	})
+
+	return sliceKeys
+}