feat: support slice definition files for bins

cmd/chisel/cmd_info.go

@@ -123,9 +123,12 @@ func selectPackageSlices(release *setup.Release, queries []string) (packages []*
 		} else {
 			releasePkg := release.Packages[pkgName]
 			pkg = &setup.Package{
-				Name:    releasePkg.Name,
-				Archive: releasePkg.Archive,
-				Slices:  make(map[string]*setup.Slice),
+				Name:         releasePkg.Name,
+				RealName:     releasePkg.RealName,
+				Archive:      releasePkg.Archive,
+				Store:        releasePkg.Store,
+				DefaultTrack: releasePkg.DefaultTrack,
+				Slices:       make(map[string]*setup.Slice),
 			}
 			for _, sliceName := range pkgSlices[pkgName] {
 				pkg.Slices[sliceName] = releasePkg.Slices[sliceName]

internal/setup/setup.go

@@ -16,13 +16,22 @@ import (
 	"github.com/canonical/chisel/internal/strdist"
 )
 
+// Store is the location from which packages are obtained via a store API.
+type Store struct {
+	Name          string
+	Kind          string
+	Version       string
+	DefaultPrefix string
+}
+
 // Release is a collection of package slices targeting a particular
 // distribution version.
 type Release struct {
 	Format      string
 	Path        string
 	Packages    map[string]*Package
 	Archives    map[string]*Archive
+	Stores      map[string]*Store
 	Maintenance *Maintenance
 }
 
@@ -51,10 +60,16 @@ type Archive struct {
 
 // Package holds a collection of slices that represent parts of themselves.
 type Package struct {
-	Name    string
-	Path    string
-	Archive string
-	Slices  map[string]*Slice
+	// Name is the unique package identifier (e.g. "bin-curl" for store packages,
+	// "curl" for archive packages).
+	Name string
+	// RealName is the bare name visible in the Debian archive (e.g. "curl").
+	RealName     string
+	Path         string
+	Archive      string
+	Store        string
+	DefaultTrack string
+	Slices       map[string]*Slice
 }
 
 // Slice holds the details about a package slice.
@@ -441,20 +456,20 @@ func readSlices(release *Release, baseDir, dirName string) error {
 
 		pkgName := match[1]
 		pkgPath := filepath.Join(dirName, entry.Name())
-		if pkg, ok := release.Packages[pkgName]; ok {
-			return fmt.Errorf("package %q slices defined more than once: %s and %s", pkgName, pkg.Path, stripBase(baseDir, pkgPath))
-		}
 		data, err := os.ReadFile(pkgPath)
 		if err != nil {
 			// Errors from package os generally include the path.
 			return fmt.Errorf("cannot read slice definition file: %v", err)
 		}
 
-		pkg, err := parsePackage(release.Format, pkgName, stripBase(baseDir, pkgPath), data)
+		pkg, err := parsePackage(release, pkgName, stripBase(baseDir, pkgPath), data)
 		if err != nil {
 			return err
 		}
 
+		if existing, ok := release.Packages[pkg.Name]; ok {
+			return fmt.Errorf("package %q slices defined more than once: %s and %s", pkg.Name, existing.Path, stripBase(baseDir, pkgPath))
+		}
 		release.Packages[pkg.Name] = pkg
 	}
 	return nil
@@ -502,6 +517,21 @@ func Select(release *Release, slices []SliceKey, arch string) (*Selection, error
 					new, newPath, newInfo.Generate)
 			}
 		}
+		// An invalid store kind should only throw an error if a slice references it.
+		// Hence, the check is here.
+		pkg := release.Packages[new.Package]
+		if pkg.Store == "" {
+			continue
+		}
+		store, ok := selection.Release.Stores[pkg.Store]
+		if !ok {
+			return nil, fmt.Errorf("internal error: slice %s refers to missing store %q", new, pkg.Store)
+		}
+		switch store.Kind {
+		case "bin":
+		default:
+			return nil, fmt.Errorf("slice %s refers to store %q with unknown kind %q", new, pkg.Store, store.Kind)
+		}
 	}
 
 	return selection, nil