feat: add find 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_find.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/jessevdk/go-flags"
+
+	"github.com/canonical/chisel/internal/setup"
+	"github.com/canonical/chisel/internal/strdist"
+)
+
+var shortFindHelp = "Find existing slices"
+var longFindHelp = `
+The find command queries the chisel releases for available slices.
+
+With the --release flag, it queries for slices in a particular branch
+of the chisel-releases repository[1] or a particular directory. If left
+unspecified, it queries with the release info found in /etc/lsb-release.
+
+[1] https://github.com/canonical/chisel-releases
+`
+
+var findDescs = map[string]string{
+	"release": "Chisel release branch or directory",
+}
+
+type cmdFind struct {
+	Release string `long:"release" value-name:"<branch|dir>"`
+
+	Positional struct {
+		Query []string `positional-arg-name:"<query>" required:"yes"`
+	} `positional-args:"yes"`
+}
+
+func init() {
+	addCommand("find", shortFindHelp, longFindHelp, func() flags.Commander { return &cmdFind{} }, findDescs, nil)
+}
+
+func (cmd *cmdFind) Execute(args []string) error {
+	if len(args) > 0 {
+		return ErrExtraArgs
+	}
+
+	query := strings.TrimSpace(strings.Join(cmd.Positional.Query, " "))
+	if query == "" {
+		return fmt.Errorf("no search term specified")
+	}
+
+	release, releaseLabel, err := getRelease(cmd.Release)
+	if err != nil {
+		return err
+	}
+
+	slices, err := findSlices(release, query)
+	if err != nil {
+		return err
+	}
+	if slices == nil {
+		fmt.Fprintf(Stdout, "No matching slices for \"%s\"\n", query)
+		return nil
+	}
+
+	w := tabWriter()
+	fmt.Fprintf(w, "Slice\tPackage\tRelease\n")
+	for _, s := range slices {
+		fmt.Fprintf(w, "%s\t%s\t%s\n", s, s.Package, releaseLabel)
+	}
+	w.Flush()
+
+	return nil
+}
+
+// fuzzyMatchSlice reports whether a slice (partially) matches the query.
+func fuzzyMatchSlice(slice *setup.Slice, query string) bool {
+	const maxStrDist = 1
+
+	// check if the query is a substring of the pkg_slice slice name
+	if strings.Contains(slice.String(), query) {
+		return true
+	}
+	// check if the query string is at most ``maxStrDist`` Levenshtein [1]
+	// distance away from the pkg_slice slice name.
+	// [1] https://en.wikipedia.org/wiki/Levenshtein_distance
+	dist := strdist.Distance(slice.String(), query, strdist.StandardCost, maxStrDist+1)
+	return dist <= maxStrDist
+}
+
+// findSlices goes through the release searching for any slices that match
+// the query string. It returns a list of slices that match the query.
+func findSlices(release *setup.Release, query string) (slices []*setup.Slice, err error) {
+	if release == nil {
+		return nil, fmt.Errorf("cannot find slice: invalid release")
+	}
+	for _, pkg := range release.Packages {
+		for _, slice := range pkg.Slices {
+			if slice != nil && fuzzyMatchSlice(slice, query) {
+				slices = append(slices, slice)
+			}
+		}
+	}
+	sort.Slice(slices, func(i, j int) bool {
+		return slices[i].String() < slices[j].String()
+	})
+	return slices, nil
+}
+
+func tabWriter() *tabwriter.Writer {
+	return tabwriter.NewWriter(Stdout, 5, 3, 2, ' ', 0)
+}

cmd/chisel/cmd_find_test.go

@@ -0,0 +1,153 @@
+package main_test
+
+import (
+	. "gopkg.in/check.v1"
+
+	"github.com/canonical/chisel/internal/setup"
+
+	chisel "github.com/canonical/chisel/cmd/chisel"
+)
+
+type findTest struct {
+	summary   string
+	release   *setup.Release
+	query     string
+	expSlices []*setup.Slice
+	expError  string
+}
+
+var sampleRelease = &setup.Release{
+	DefaultArchive: "ubuntu",
+
+	Archives: map[string]*setup.Archive{
+		"ubuntu": {
+			Name:       "ubuntu",
+			Version:    "22.04",
+			Suites:     []string{"jammy", "jammy-security"},
+			Components: []string{"main", "other"},
+		},
+	},
+	Packages: map[string]*setup.Package{
+		"openjdk-8-jdk": {
+			Archive: "ubuntu",
+			Name:    "openjdk-8-jdk",
+			Path:    "slices/openjdk-8-jdk.yaml",
+			Slices: map[string]*setup.Slice{
+				"bins": {
+					Package: "openjdk-8-jdk",
+					Name:    "bins",
+				},
+				"config": {
+					Package: "openjdk-8-jdk",
+					Name:    "config",
+				},
+				"core": {
+					Package: "openjdk-8-jdk",
+					Name:    "core",
+				},
+				"libs": {
+					Package: "openjdk-8-jdk",
+					Name:    "libs",
+				},
+				"utils": {
+					Package: "openjdk-8-jdk",
+					Name:    "utils",
+				},
+			},
+		},
+		"python3.10": {
+			Archive: "ubuntu",
+			Name:    "python3.10",
+			Path:    "slices/python3.10.yaml",
+			Slices: map[string]*setup.Slice{
+				"bins": {
+					Package: "python3.10",
+					Name:    "bins",
+				},
+				"config": {
+					Package: "python3.10",
+					Name:    "config",
+				},
+				"core": {
+					Package: "python3.10",
+					Name:    "core",
+				},
+				"libs": {
+					Package: "python3.10",
+					Name:    "libs",
+				},
+				"utils": {
+					Package: "python3.10",
+					Name:    "utils",
+				},
+			},
+		},
+	},
+}
+
+var findTests = []findTest{{
+	summary: "Ensure search with package names",
+	release: sampleRelease,
+	query:   "python3.10",
+	expSlices: []*setup.Slice{
+		sampleRelease.Packages["python3.10"].Slices["bins"],
+		sampleRelease.Packages["python3.10"].Slices["config"],
+		sampleRelease.Packages["python3.10"].Slices["core"],
+		sampleRelease.Packages["python3.10"].Slices["libs"],
+		sampleRelease.Packages["python3.10"].Slices["utils"],
+	},
+}, {
+	summary: "Ensure search with slice names",
+	release: sampleRelease,
+	query:   "config",
+	expSlices: []*setup.Slice{
+		sampleRelease.Packages["openjdk-8-jdk"].Slices["config"],
+		sampleRelease.Packages["python3.10"].Slices["config"],
+	},
+}, {
+	summary: "Check substring matching",
+	release: sampleRelease,
+	query:   "ython",
+	expSlices: []*setup.Slice{
+		sampleRelease.Packages["python3.10"].Slices["bins"],
+		sampleRelease.Packages["python3.10"].Slices["config"],
+		sampleRelease.Packages["python3.10"].Slices["core"],
+		sampleRelease.Packages["python3.10"].Slices["libs"],
+		sampleRelease.Packages["python3.10"].Slices["utils"],
+	},
+}, {
+	summary: "Check partial matching",
+	release: sampleRelease,
+	query:   "python3.1x_bins",
+	expSlices: []*setup.Slice{
+		sampleRelease.Packages["python3.10"].Slices["bins"],
+	},
+}, {
+	summary:   "Check no matching slice",
+	release:   sampleRelease,
+	query:     "foo_bar",
+	expSlices: nil,
+}, {
+	summary:  "Ensure error for nil release",
+	query:    "foo",
+	expError: ".*invalid release",
+}}
+
+func (s *ChiselSuite) TestFindSlices(c *C) {
+	for _, test := range findTests {
+		c.Logf("Summary: %s", test.summary)
+
+		slices, err := chisel.FindSlices(test.release, test.query)
+		if test.expError == "" {
+			c.Assert(err, IsNil)
+		} else {
+			c.Assert(err, ErrorMatches, test.expError)
+		}
+		c.Assert(slices, DeepEquals, test.expSlices)
+	}
+}
+
+func (s *ChiselSuite) TestFindCommandEmptyQuery(c *C) {
+	_, err := chisel.Parser().ParseArgs([]string{"find", ""})
+	c.Assert(err, ErrorMatches, ".*no search term specified")
+}

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{"find", "help", "version"},
 }, {
 	Label:       "Action",
 	Description: "make things happen",

cmd/chisel/export_test.go

@@ -17,3 +17,5 @@ func FakeIsStdinTTY(t bool) (restore func()) {
 		isStdinTTY = oldIsStdinTTY
 	}
 }
+
+var FindSlices = findSlices