manifest.Write interface accepts a Writer

internal/manifest/manifest.go

@@ -10,8 +10,6 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/klauspost/compress/zstd"
-
 	"github.com/canonical/chisel/internal/archive"
 	"github.com/canonical/chisel/internal/jsonwall"
 	"github.com/canonical/chisel/internal/setup"
@@ -182,18 +180,18 @@ func LocateManifestSlices(slices []*setup.Slice, manifestFileName string) map[st
 	return manifestSlices
 }
 
-type GenerateManifestsOptions struct {
+type WriteOptions struct {
 	PackageInfo []*archive.PackageInfo
 	Selection   []*setup.Slice
-	Report      *Report
-	TargetDir   string
-	Filename    string
-	Mode        os.FileMode
+	// Map manifest path to all the slices that declare it. See
+	// LocateManifestSlices.
+	ManifestSlices map[string][]*setup.Slice
+	Report         *Report
+	ManifestMode   os.FileMode
 }
 
-func GenerateManifests(options *GenerateManifestsOptions) error {
-	manifestSlices := LocateManifestSlices(options.Selection, options.Filename)
-	if len(manifestSlices) == 0 {
+func Write(options *WriteOptions, writer io.Writer) error {
+	if len(options.ManifestSlices) == 0 {
 		// Nothing to do.
 		return nil
 	}
@@ -216,31 +214,12 @@ func GenerateManifests(options *GenerateManifestsOptions) error {
 		return err
 	}
 
-	err = manifestAddManifestPaths(dbw, options.Mode, manifestSlices)
+	err = manifestAddManifestPaths(dbw, options.ManifestMode, options.ManifestSlices)
 	if err != nil {
 		return err
 	}
 
-	files := []io.Writer{}
-	for relPath := range manifestSlices {
-		logf("Generating manifest at %s...", relPath)
-		absPath := filepath.Join(options.TargetDir, relPath)
-		if err := os.MkdirAll(filepath.Dir(absPath), 0755); err != nil {
-			return err
-		}
-		file, err := os.OpenFile(absPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, options.Mode)
-		if err != nil {
-			return err
-		}
-		files = append(files, file)
-		defer file.Close()
-	}
-	w, err := zstd.NewWriter(io.MultiWriter(files...))
-	if err != nil {
-		return err
-	}
-	defer w.Close()
-	_, err = dbw.WriteTo(w)
+	_, err = dbw.WriteTo(writer)
 	return err
 }
 

internal/manifest/manifest_test.go

@@ -1,20 +1,18 @@
 package manifest_test
 
 import (
-	"io/fs"
+	"bytes"
+	"io"
 	"os"
 	"path"
-	"path/filepath"
 	"slices"
 	"strings"
 
-	"github.com/klauspost/compress/zstd"
 	. "gopkg.in/check.v1"
 
 	"github.com/canonical/chisel/internal/archive"
 	"github.com/canonical/chisel/internal/manifest"
 	"github.com/canonical/chisel/internal/setup"
-	"github.com/canonical/chisel/internal/testutil"
 )
 
 type manifestContents struct {
@@ -321,10 +319,6 @@ func (s *S) TestGenerateManifests(c *C) {
 		SHA256:  "s2",
 	}}
 
-	expectedLocations := []string{
-		"/dir/manifest.wall",
-		"/other-dir/manifest.wall",
-	}
 	expected := &manifestContents{
 		Paths: []*manifest.Path{{
 			Kind:   "path",
@@ -394,59 +388,41 @@ func (s *S) TestGenerateManifests(c *C) {
 		}},
 	}
 
-	tmpDir := c.MkDir()
-	options := &manifest.GenerateManifestsOptions{
-		PackageInfo: packageInfo,
-		Selection:   []*setup.Slice{slice1, slice2},
-		Report:      report,
-		TargetDir:   tmpDir,
-		Filename:    "manifest.wall",
-		Mode:        0645,
+	options := &manifest.WriteOptions{
+		ManifestSlices: map[string][]*setup.Slice{
+			"/dir/manifest.wall":       {slice1},
+			"/other-dir/manifest.wall": {slice1},
+		},
+		PackageInfo:  packageInfo,
+		Selection:    []*setup.Slice{slice1, slice2},
+		Report:       report,
+		ManifestMode: 0645,
 	}
-	found := map[string]bool{}
-	err := manifest.GenerateManifests(options)
+	var buffer bytes.Buffer
+	err := manifest.Write(options, &buffer)
 	c.Assert(err, IsNil)
-	err = filepath.WalkDir(tmpDir, func(path string, d fs.DirEntry, err error) error {
-		c.Assert(err, IsNil)
-		if d.IsDir() {
-			return nil
-		}
-		c.Assert(expectedLocations, testutil.Contains, strings.TrimPrefix(path, tmpDir))
-		found[path] = true
-		file, err := os.Open(path)
-		c.Assert(err, IsNil)
-		reader, err := zstd.NewReader(file)
-		c.Assert(err, IsNil)
-		mfest, err := manifest.Read(reader)
-		c.Assert(err, IsNil)
-		err = manifest.Validate(mfest)
-		c.Assert(err, IsNil)
-		contents := dumpManifestContents(c, mfest)
-		c.Assert(contents, DeepEquals, expected)
-		return nil
-	})
+	mfest, err := manifest.Read(&buffer)
+	c.Assert(err, IsNil)
+	err = manifest.Validate(mfest)
 	c.Assert(err, IsNil)
-	c.Assert(found, HasLen, len(expectedLocations))
+	contents := dumpManifestContents(c, mfest)
+	c.Assert(contents, DeepEquals, expected)
 }
 
 func (s *S) TestGenerateNoManifests(c *C) {
-	tmpDir := c.MkDir()
-	options := &manifest.GenerateManifestsOptions{
-		PackageInfo: nil,
-		Selection:   nil,
-		Report:      nil,
-		TargetDir:   tmpDir,
-		Filename:    "manifest.wall",
-		Mode:        0645,
+	options := &manifest.WriteOptions{
+		PackageInfo:  nil,
+		Selection:    nil,
+		Report:       nil,
+		ManifestMode: 0645,
 	}
-	err := manifest.GenerateManifests(options)
-	c.Assert(err, IsNil)
-	err = filepath.WalkDir(tmpDir, func(path string, d fs.DirEntry, err error) error {
-		// If there is any regular file it means that a manifest was generated.
-		c.Assert(d.IsDir(), Equals, true)
-		return nil
-	})
+	var buffer bytes.Buffer
+	err := manifest.Write(options, &buffer)
 	c.Assert(err, IsNil)
+	var reader io.Reader = &buffer
+	var bs []byte
+	n, err := reader.Read(bs)
+	c.Assert(n, Equals, 0)
 }
 
 func dumpManifestContents(c *C, mfest *manifest.Manifest) *manifestContents {

internal/slicer/slicer.go

@@ -13,6 +13,8 @@ import (
 	"strings"
 	"syscall"
 
+	"github.com/klauspost/compress/zstd"
+
 	"github.com/canonical/chisel/internal/archive"
 	"github.com/canonical/chisel/internal/deb"
 	"github.com/canonical/chisel/internal/fsutil"
@@ -328,15 +330,38 @@ func Run(options *RunOptions) error {
 		return err
 	}
 
-	err = manifest.GenerateManifests(&manifest.GenerateManifestsOptions{
-		PackageInfo: pkgInfos,
-		Selection:   options.Selection.Slices,
-		Report:      report,
-		TargetDir:   targetDir,
-		Filename:    manifestFilename,
-		Mode:        manifestMode,
-	})
-	return err
+	manifestSlices := manifest.LocateManifestSlices(options.Selection.Slices, manifestFilename)
+	if len(manifestSlices) > 0 {
+		var files []io.Writer
+		for relPath := range manifestSlices {
+			logf("Generating manifest at %s...", relPath)
+			absPath := filepath.Join(options.TargetDir, relPath)
+			if err := os.MkdirAll(filepath.Dir(absPath), 0755); err != nil {
+				return err
+			}
+			file, err := os.OpenFile(absPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, manifestMode)
+			if err != nil {
+				return err
+			}
+			files = append(files, file)
+			defer file.Close()
+		}
+		w, err := zstd.NewWriter(io.MultiWriter(files...))
+		if err != nil {
+			return err
+		}
+		defer w.Close()
+		writeOptions := &manifest.WriteOptions{
+			ManifestSlices: manifestSlices,
+			PackageInfo:    pkgInfos,
+			Selection:      options.Selection.Slices,
+			Report:         report,
+			ManifestMode:   manifestMode,
+		}
+		err = manifest.Write(writeOptions, w)
+		return err
+	}
+	return nil
 }
 
 // removeAfterMutate removes entries marked with until: mutate. A path is marked