feat: add file and directory report skeleton

cmd/chisel/cmd_cut.go

@@ -99,11 +99,12 @@ func (cmd *cmdCut) Execute(args []string) error {
 		archives[archiveName] = openArchive
 	}
 
-	return slicer.Run(&slicer.RunOptions{
+	_, err = slicer.Run(&slicer.RunOptions{
 		Selection: selection,
 		Archives:  archives,
 		TargetDir: cmd.RootDir,
 	})
+	return err
 }
 
 // TODO These need testing, and maybe moving into a common file.

internal/archive/archive_test.go

@@ -19,7 +19,6 @@ import (
 	"github.com/canonical/chisel/internal/archive"
 	"github.com/canonical/chisel/internal/archive/testarchive"
 	"github.com/canonical/chisel/internal/deb"
-	"github.com/canonical/chisel/internal/fsutil"
 	"github.com/canonical/chisel/internal/testutil"
 )
 
@@ -501,7 +500,6 @@ func (s *S) testOpenArchiveArch(c *C, release ubuntuRelease, arch string) {
 				{Path: "/hostname"},
 			},
 		},
-		Creator: fsutil.NewCreator(),
 	})
 	c.Assert(err, IsNil)
 

internal/deb/extract.go

@@ -25,7 +25,7 @@ type ExtractOptions struct {
 	TargetDir string
 	Extract   map[string][]ExtractInfo
 	Globbed   map[string][]string
-	Creator   *fsutil.Creator
+	Create    func(options *fsutil.CreateOptions) error
 }
 
 type ExtractInfo struct {
@@ -34,16 +34,26 @@ type ExtractInfo struct {
 	Optional bool
 }
 
-func checkExtractOptions(options *ExtractOptions) error {
+func validateExtractOptions(options *ExtractOptions) (*ExtractOptions, error) {
 	for extractPath, extractInfos := range options.Extract {
 		isGlob := strings.ContainsAny(extractPath, "*?")
 		if isGlob {
 			if len(extractInfos) != 1 || extractInfos[0].Path != extractPath || extractInfos[0].Mode != 0 {
-				return fmt.Errorf("when using wildcards source and target paths must match: %s", extractPath)
+				return nil, fmt.Errorf("when using wildcards source and target paths must match: %s", extractPath)
 			}
 		}
 	}
-	return nil
+
+	if options.Create == nil {
+		validOpts := *options
+		validOpts.Create = func(o *fsutil.CreateOptions) error {
+			_, err := fsutil.Create(o)
+			return err
+		}
+		return &validOpts, nil
+	}
+
+	return options, nil
 }
 
 func Extract(pkgReader io.Reader, options *ExtractOptions) (err error) {
@@ -55,12 +65,12 @@ func Extract(pkgReader io.Reader, options *ExtractOptions) (err error) {
 
 	logf("Extracting files from package %q...", options.Package)
 
-	err = checkExtractOptions(options)
+	validOpts, err := validateExtractOptions(options)
 	if err != nil {
 		return err
 	}
 
-	_, err = os.Stat(options.TargetDir)
+	_, err = os.Stat(validOpts.TargetDir)
 	if os.IsNotExist(err) {
 		return fmt.Errorf("target directory does not exist")
 	} else if err != nil {
@@ -100,7 +110,7 @@ func Extract(pkgReader io.Reader, options *ExtractOptions) (err error) {
 			dataReader = zstdReader
 		}
 	}
-	return extractData(dataReader, options)
+	return extractData(dataReader, validOpts)
 }
 
 func extractData(dataReader io.Reader, options *ExtractOptions) error {
@@ -186,7 +196,7 @@ func extractData(dataReader io.Reader, options *ExtractOptions) error {
 				// Base directory for extracted content. Relevant mainly to preserve
 				// the metadata, since the extracted content itself will also create
 				// any missing directories unaccounted for in the options.
-				err := options.Creator.Create(&fsutil.CreateOptions{
+				err := options.Create(&fsutil.CreateOptions{
 					Path:        filepath.Join(options.TargetDir, sourcePath),
 					Mode:        tarHeader.FileInfo().Mode(),
 					MakeParents: true,
@@ -227,7 +237,7 @@ func extractData(dataReader io.Reader, options *ExtractOptions) error {
 			if extractInfo.Mode != 0 {
 				tarHeader.Mode = int64(extractInfo.Mode)
 			}
-			err := options.Creator.Create(&fsutil.CreateOptions{
+			err := options.Create(&fsutil.CreateOptions{
 				Path:        targetPath,
 				Mode:        tarHeader.FileInfo().Mode(),
 				Data:        pathReader,

internal/deb/extract_test.go

@@ -6,7 +6,6 @@ import (
 	. "gopkg.in/check.v1"
 
 	"github.com/canonical/chisel/internal/deb"
-	"github.com/canonical/chisel/internal/fsutil"
 	"github.com/canonical/chisel/internal/testutil"
 )
 
@@ -291,7 +290,6 @@ func (s *S) TestExtract(c *C) {
 		options := test.options
 		options.Package = "base-files"
 		options.TargetDir = dir
-		options.Creator = fsutil.NewCreator()
 
 		if test.globbed != nil {
 			options.Globbed = make(map[string][]string)

internal/fsutil/create.go

@@ -29,18 +29,9 @@ type Info struct {
 	Link string
 }
 
-type Creator struct {
-	// Created keeps track of information about the filesystem entries created.
-	// If an entry is created several times it only tracks the latest one.
-	Created map[string]Info
-}
-
-func NewCreator() *Creator {
-	return &Creator{Created: make(map[string]Info)}
-}
-
-// Create creates a filesystem entry according to the provided options.
-func (c *Creator) Create(options *CreateOptions) error {
+// Create creates a filesystem entry according to the provided options and returns
+// the information about the created entry.
+func Create(options *CreateOptions) (*Info, error) {
 	rp := &readerProxy{inner: options.Data, h: sha256.New()}
 	// Use the proxy instead of the raw Reader.
 	optsCopy := *options
@@ -50,7 +41,7 @@ func (c *Creator) Create(options *CreateOptions) error {
 	var err error
 	if o.MakeParents {
 		if err := os.MkdirAll(filepath.Dir(o.Path), 0755); err != nil {
-			return err
+			return nil, err
 		}
 	}
 	switch o.Mode & fs.ModeType {
@@ -64,18 +55,17 @@ func (c *Creator) Create(options *CreateOptions) error {
 		err = fmt.Errorf("unsupported file type: %s", o.Path)
 	}
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	info := Info{
+	info := &Info{
 		Path: o.Path,
 		Mode: o.Mode,
 		Hash: hex.EncodeToString(rp.h.Sum(nil)),
 		Size: rp.size,
 		Link: o.Link,
 	}
-	c.Created[o.Path] = info
-	return nil
+	return info, nil
 }
 
 func createDir(o *CreateOptions) error {

internal/fsutil/create_test.go

@@ -83,52 +83,45 @@ func (s *S) TestCreate(c *C) {
 		dir := c.MkDir()
 		options := test.options
 		options.Path = filepath.Join(dir, options.Path)
-		creator := fsutil.NewCreator()
-		err := creator.Create(&options)
+		info, err := fsutil.Create(&options)
+
 		if test.error != "" {
 			c.Assert(err, ErrorMatches, test.error)
-		} else {
-			c.Assert(err, IsNil)
+			continue
 		}
+
+		c.Assert(err, IsNil)
 		c.Assert(testutil.TreeDump(dir), DeepEquals, test.result)
-		if test.options.MakeParents {
-			// The creator does not record the parent directories created
-			// implicitly.
-			for path, info := range treeDumpFSCreator(creator, dir) {
-				c.Assert(info, Equals, test.result[path])
-			}
-		} else {
-			c.Assert(treeDumpFSCreator(creator, dir), DeepEquals, test.result)
-		}
+		// [fsutil.Create] does not return information about parent directories
+		// created implicitly. We only check for the requested path.
+		c.Assert(dumpFSInfo(info, dir)[test.options.Path], DeepEquals, test.result[test.options.Path])
 	}
 }
 
-// treeDumpFSCreator dumps the contents stored in Creator about the filesystem
-// entries created using the same format as [testutil.TreeDump].
-func treeDumpFSCreator(cr *fsutil.Creator, root string) map[string]string {
+// dumpFSInfo returns the file information in the same format as
+// [testutil.TreeDump].
+func dumpFSInfo(info *fsutil.Info, root string) map[string]string {
 	result := make(map[string]string)
-	for _, file := range cr.Created {
-		path := strings.TrimPrefix(file.Path, root)
-		fperm := file.Mode.Perm()
-		if file.Mode&fs.ModeSticky != 0 {
-			fperm |= 01000
-		}
-		switch file.Mode.Type() {
-		case fs.ModeDir:
-			result[path+"/"] = fmt.Sprintf("dir %#o", fperm)
-		case fs.ModeSymlink:
-			result[path] = fmt.Sprintf("symlink %s", file.Link)
-		case 0: // Regular
-			var entry string
-			if file.Size == 0 {
-				entry = fmt.Sprintf("file %#o empty", file.Mode.Perm())
-			} else {
-				entry = fmt.Sprintf("file %#o %s", fperm, file.Hash[:8])
-			}
-			result[path] = entry
-		default:
-			panic(fmt.Errorf("unknown file type %d: %s", file.Mode.Type(), path))
+	path := strings.TrimPrefix(info.Path, root)
+	fperm := info.Mode.Perm()
+	if info.Mode&fs.ModeSticky != 0 {
+		fperm |= 01000
+	}
+	switch info.Mode.Type() {
+	case fs.ModeDir:
+		result[path+"/"] = fmt.Sprintf("dir %#o", fperm)
+	case fs.ModeSymlink:
+		result[path] = fmt.Sprintf("symlink %s", info.Link)
+	case 0: // Regular
+		var entry string
+		if info.Size == 0 {
+			entry = fmt.Sprintf("file %#o empty", info.Mode.Perm())
+		} else {
+			entry = fmt.Sprintf("file %#o %s", fperm, info.Hash[:8])
 		}
+		result[path] = entry
+	default:
+		panic(fmt.Errorf("unknown file type %d: %s", info.Mode.Type(), path))
 	}
 	return result
 }

internal/setup/fetch.go

@@ -137,7 +137,7 @@ func extractTar(dataReader io.Reader, targetDir string) error {
 
 		//debugf("Extracting header: %#v", tarHeader)
 
-		err = fsutil.NewCreator().Create(&fsutil.CreateOptions{
+		_, err = fsutil.Create(&fsutil.CreateOptions{
 			Path:        filepath.Join(targetDir, sourcePath),
 			Mode:        tarHeader.FileInfo().Mode(),
 			Data:        tarReader,

internal/slicer/report.go

@@ -0,0 +1,64 @@
+package slicer
+
+import (
+	"fmt"
+	"io/fs"
+	"path/filepath"
+
+	"github.com/canonical/chisel/internal/fsutil"
+	"github.com/canonical/chisel/internal/setup"
+)
+
+type ReportEntry struct {
+	Path   string
+	Mode   fs.FileMode
+	Hash   string
+	Size   int
+	Slices map[*setup.Slice]bool
+	Link   string
+}
+
+// Report holds the information about files and directories created when slicing
+// packages.
+type Report struct {
+	// Root is the filesystem path where the all reported content is based.
+	Root string
+	// Entries holds all reported content, indexed by their path.
+	Entries map[string]ReportEntry
+}
+
+// NewReport returns an empty report for content that will be based at the
+// provided root path.
+func NewReport(root string) *Report {
+	return &Report{
+		Root:    root,
+		Entries: make(map[string]ReportEntry),
+	}
+}
+
+func (r *Report) Add(slice *setup.Slice, info *fsutil.Info) error {
+	relPath, err := filepath.Rel(r.Root, info.Path)
+	if err != nil {
+		return fmt.Errorf("internal error: cannot add path %q outside of root %q", info.Path, r.Root)
+	}
+	relPath = "/" + relPath
+
+	if entry, ok := r.Entries[relPath]; ok {
+		if info.Mode != entry.Mode || info.Link != entry.Link ||
+			info.Size != entry.Size || info.Hash != entry.Hash {
+			return fmt.Errorf("internal error: cannot add conflicting data for path %q", relPath)
+		}
+		entry.Slices[slice] = true
+		r.Entries[relPath] = entry
+	} else {
+		r.Entries[relPath] = ReportEntry{
+			Path:   relPath,
+			Mode:   info.Mode,
+			Hash:   info.Hash,
+			Size:   info.Size,
+			Slices: map[*setup.Slice]bool{slice: true},
+			Link:   info.Link,
+		}
+	}
+	return nil
+}