feat: add info command

cmd/chisel/cmd_cut.go

@@ -54,25 +54,7 @@ func (cmd *cmdCut) Execute(args []string) error {
 		sliceKeys[i] = sliceKey
 	}
 
-	var release *setup.Release
-	var err error
-	if strings.Contains(cmd.Release, "/") {
-		release, err = setup.ReadRelease(cmd.Release)
-	} else {
-		var label, version string
-		if cmd.Release == "" {
-			label, version, err = readReleaseInfo()
-		} else {
-			label, version, err = parseReleaseInfo(cmd.Release)
-		}
-		if err != nil {
-			return err
-		}
-		release, err = setup.FetchRelease(&setup.FetchOptions{
-			Label:   label,
-			Version: version,
-		})
-	}
+	release, _, err := getRelease(cmd.Release)
 	if err != nil {
 		return err
 	}
@@ -136,3 +118,31 @@ func readReleaseInfo() (label, version string, err error) {
 	}
 	return "", "", fmt.Errorf("cannot infer release via /etc/lsb-release, see the --release option")
 }
+
+// getRelease returns the release and release label (e.g. ubuntu-22.04 or
+// /path/to/release/dir/ if a directory was passed as input).
+func getRelease(releaseStr string) (release *setup.Release, releaseLabel string, err error) {
+	if strings.Contains(releaseStr, "/") {
+		release, err = setup.ReadRelease(releaseStr)
+		releaseLabel = releaseStr
+	} else {
+		var label, version string
+		if releaseStr == "" {
+			label, version, err = readReleaseInfo()
+		} else {
+			label, version, err = parseReleaseInfo(releaseStr)
+		}
+		if err != nil {
+			return nil, "", err
+		}
+		release, err = setup.FetchRelease(&setup.FetchOptions{
+			Label:   label,
+			Version: version,
+		})
+		releaseLabel = label + "-" + version
+	}
+	if err != nil {
+		return nil, "", err
+	}
+	return release, releaseLabel, nil
+}

cmd/chisel/cmd_help.go

@@ -155,7 +155,7 @@ type helpCategory struct {
 var helpCategories = []helpCategory{{
 	Label:       "Basic",
 	Description: "general operations",
-	Commands:    []string{"help", "version"},
+	Commands:    []string{"help", "info", "version"},
 }, {
 	Label:       "Action",
 	Description: "make things happen",

cmd/chisel/cmd_info.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/jessevdk/go-flags"
+	"gopkg.in/yaml.v3"
+
+	"github.com/canonical/chisel/internal/setup"
+)
+
+var shortInfoHelp = "Show information about package slices"
+var longInfoHelp = `
+The info command shows detailed information about package slices.
+
+It accepts a whitespace-separated list of strings. The list can be
+composed of package names, slice names, or a combination of both. The
+default output format is YAML. When multiple arguments are provided,
+the output is a list of YAML documents, separated by three dashes ("---").
+
+Slice definitions are shown verbatim according to their definition in
+the Chisel Releases. For example, globs are not expanded.
+`
+
+var infoDescs = map[string]string{
+	"release": "Chisel Release (i.e. branch name) or directory",
+}
+
+type infoCmd struct {
+	Release string `long:"release" value-name:"<branch|dir>"`
+
+	Positional struct {
+		Queries []string `positional-arg-name:"<pkg|slice>" required:"yes"`
+	} `positional-args:"yes"`
+}
+
+func init() {
+	addCommand("info", shortInfoHelp, longInfoHelp, func() flags.Commander { return &infoCmd{} }, infoDescs, nil)
+}
+
+func (cmd *infoCmd) Execute(args []string) error {
+	if len(args) > 0 {
+		return ErrExtraArgs
+	}
+
+	release, _, err := getRelease(cmd.Release)
+	if err != nil {
+		return err
+	}
+
+	packages, notFound := selectPackageSlices(release, cmd.Positional.Queries)
+
+	for i, pkg := range packages {
+		data, err := yaml.Marshal(pkg)
+		if err != nil {
+			return err
+		}
+		if i > 0 {
+			fmt.Fprintln(Stdout, "---")
+		}
+		fmt.Fprint(Stdout, string(data))
+	}
+
+	if len(notFound) > 0 {
+		for i := range notFound {
+			notFound[i] = strconv.Quote(notFound[i])
+		}
+		return fmt.Errorf("no slice definitions found for: " + strings.Join(notFound, ", "))
+	}
+
+	return nil
+}
+
+// selectPackageSlices takes in a release and a list of query strings
+// of package names and/or slice names, and returns a list of packages
+// containing the found slices.  It also returns a list of query
+// strings that were not found.
+func selectPackageSlices(release *setup.Release, queries []string) (packages []*setup.Package, notFound []string) {
+	var pkgOrder []string
+	pkgSlices := make(map[string][]string)
+	allPkgSlices := make(map[string]bool)
+
+	sliceExists := func(key setup.SliceKey) bool {
+		if _, ok := release.Packages[key.Package]; !ok {
+			return false
+		}
+		if _, ok := release.Packages[key.Package].Slices[key.Slice]; !ok {
+			return false
+		}
+		return true
+	}
+	for _, query := range queries {
+		var pkg, slice string
+		if strings.Contains(query, "_") {
+			key, err := setup.ParseSliceKey(query)
+			if err != nil || !sliceExists(key) {
+				notFound = append(notFound, query)
+				continue
+			}
+			pkg, slice = key.Package, key.Slice
+		} else {
+			if _, ok := release.Packages[query]; !ok {
+				notFound = append(notFound, query)
+				continue
+			}
+			pkg = query
+		}
+		if len(pkgSlices[pkg]) == 0 && !allPkgSlices[pkg] {
+			pkgOrder = append(pkgOrder, pkg)
+		}
+		if slice == "" {
+			allPkgSlices[pkg] = true
+		} else {
+			pkgSlices[pkg] = append(pkgSlices[pkg], slice)
+		}
+	}
+
+	for _, pkgName := range pkgOrder {
+		var pkg *setup.Package
+		if allPkgSlices[pkgName] {
+			pkg = release.Packages[pkgName]
+		} else {
+			releasePkg := release.Packages[pkgName]
+			pkg = &setup.Package{
+				Name:    releasePkg.Name,
+				Archive: releasePkg.Archive,
+				Slices:  make(map[string]*setup.Slice),
+			}
+			for _, sliceName := range pkgSlices[pkgName] {
+				pkg.Slices[sliceName] = releasePkg.Slices[sliceName]
+			}
+		}
+		packages = append(packages, pkg)
+	}
+	return
+}