cmd: remove usage of ImageType.PackageSets()

Use the new manifest generation procedure in the cmd line tools.  The
new procedure doesn't rely on ImageType.PackageSets() to compute the
packages for the depsolving.  Instead, it calls Manifest() and depsolves
the packages attached to the returned object
(manifest.Content.PackageSets).

cmd/gen-manifests/main.go

@@ -161,7 +161,13 @@ func makeManifestJob(name string, imgType distro.ImageType, cr composeRequest, d
 			return fmt.Errorf("[%s] container resolution failed: %s", filename, err.Error())
 		}
 
-		packageSpecs, err := depsolve(cacheDir, imgType, bp, options, repos, distribution, archName)
+		manifest, _, err := imgType.Manifest(&bp, options, repos, nil, containerSpecs, seedArg)
+		if err != nil {
+			err = fmt.Errorf("[%s] failed: %s", filename, err)
+			return
+		}
+
+		packageSpecs, err := depsolve(cacheDir, manifest.Content.PackageSets, distribution, archName)
 		if err != nil {
 			err = fmt.Errorf("[%s] depsolve failed: %s", filename, err.Error())
 			return
@@ -174,11 +180,6 @@ func makeManifestJob(name string, imgType distro.ImageType, cr composeRequest, d
 		if cr.Blueprint != nil {
 			bp = blueprint.Blueprint(*cr.Blueprint)
 		}
-		manifest, _, err := imgType.Manifest(&bp, options, repos, packageSpecs, containerSpecs, seedArg)
-		if err != nil {
-			err = fmt.Errorf("[%s] failed: %s", filename, err)
-			return
-		}
 		mf, err := manifest.Serialize(packageSpecs)
 
 		request := composeRequest{
@@ -262,10 +263,9 @@ func resolveContainers(containers []blueprint.Container, archName string) ([]con
 	return resolver.Finish()
 }
 
-func depsolve(cacheDir string, imageType distro.ImageType, bp blueprint.Blueprint, options distro.ImageOptions, repos []rpmmd.RepoConfig, d distro.Distro, arch string) (map[string][]rpmmd.PackageSpec, error) {
+func depsolve(cacheDir string, packageSets map[string][]rpmmd.PackageSet, d distro.Distro, arch string) (map[string][]rpmmd.PackageSpec, error) {
 	solver := dnfjson.NewSolver(d.ModulePlatformID(), d.Releasever(), arch, d.Name(), cacheDir)
 	solver.SetDNFJSONPath("./dnf-json")
-	packageSets := imageType.PackageSets(bp, options, repos)
 	depsolvedSets := make(map[string][]rpmmd.PackageSpec)
 	for name, pkgSet := range packageSets {
 		res, err := solver.Depsolve(pkgSet)

cmd/osbuild-dnf-json-tests/main_test.go

@@ -45,8 +45,17 @@ func TestCrossArchDepsolve(t *testing.T) {
 				t.Run(imgTypeStr, func(t *testing.T) {
 					imgType, err := arch.GetImageType(imgTypeStr)
 					require.NoError(t, err)
-
-					packages := imgType.PackageSets(blueprint.Blueprint{},
+					// set up bare minimum args for image type
+					var customizations *blueprint.Customizations
+					if imgTypeStr == "edge-simplified-installer" {
+						customizations = &blueprint.Customizations{
+							InstallationDevice: "/dev/null",
+						}
+					}
+					manifest, _, err := imgType.Manifest(
+						&blueprint.Blueprint{
+							Customizations: customizations,
+						},
 						distro.ImageOptions{
 							OSTree: &ostree.ImageOptions{
 								URL:           "foo",
@@ -54,9 +63,10 @@ func TestCrossArchDepsolve(t *testing.T) {
 								FetchChecksum: "baz",
 							},
 						},
-						repos[archStr])
+						repos[archStr], nil, nil, 0)
+					assert.NoError(t, err)
 
-					for _, set := range packages {
+					for _, set := range manifest.Content.PackageSets {
 						_, err = solver.Depsolve(set)
 						assert.NoError(t, err)
 					}
@@ -91,7 +101,9 @@ func TestDepsolvePackageSets(t *testing.T) {
 	qcow2Image, err := x86Arch.GetImageType(qcow2ImageTypeName)
 	require.Nilf(t, err, "failed to get %q image type of %q/%q distro/arch", qcow2ImageTypeName, cs9.Name(), platform.ARCH_X86_64.String())
 
-	imagePkgSets := qcow2Image.PackageSets(blueprint.Blueprint{Packages: []blueprint.Package{{Name: "bind"}}}, distro.ImageOptions{}, x86Repos)
+	manifestSource, _, err := qcow2Image.Manifest(&blueprint.Blueprint{Packages: []blueprint.Package{{Name: "bind"}}}, distro.ImageOptions{}, x86Repos, nil, nil, 0)
+	require.Nilf(t, err, "failed to initialise manifest for %q image type of %q/%q distro/arch", qcow2ImageTypeName, cs9.Name(), platform.ARCH_X86_64.String())
+	imagePkgSets := manifestSource.Content.PackageSets
 
 	gotPackageSpecsSets := make(map[string][]rpmmd.PackageSpec, len(imagePkgSets))
 	for name, pkgSet := range imagePkgSets {

cmd/osbuild-package-sets/main.go

@@ -48,12 +48,15 @@ func main() {
 
 	encoder := json.NewEncoder(os.Stdout)
 	encoder.SetIndent("", "  ")
-	pkgset := image.PackageSets(blueprint.Blueprint{}, distro.ImageOptions{
+	manifest, _, err := image.Manifest(&blueprint.Blueprint{}, distro.ImageOptions{
 		OSTree: &ostree.ImageOptions{
 			URL:           "foo",
 			ImageRef:      "bar",
 			FetchChecksum: "baz",
 		},
-	}, nil)
-	_ = encoder.Encode(pkgset)
+	}, nil, nil, nil, 0)
+	if err != nil {
+		panic(err)
+	}
+	_ = encoder.Encode(manifest.Content.PackageSets)
 }

cmd/osbuild-pipeline/main.go

@@ -200,10 +200,23 @@ func main() {
 	// let the cache grow to fit much more repository metadata than we usually allow
 	solver.SetMaxCacheSize(3 * 1024 * 1024 * 1024)
 
-	packageSets := imageType.PackageSets(composeRequest.Blueprint, options, repos)
-	depsolvedSets := make(map[string][]rpmmd.PackageSpec)
+	containerSpecs, err := resolveContainers(composeRequest.Blueprint, arch.Name())
+	if err != nil {
+		panic("Could not resolve containers: " + err.Error())
+	}
 
-	for name, pkgSet := range packageSets {
+	manifest, _, err := imageType.Manifest(&composeRequest.Blueprint,
+		options,
+		repos,
+		nil,
+		containerSpecs,
+		seedArg)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	depsolvedSets := make(map[string][]rpmmd.PackageSpec)
+	for name, pkgSet := range manifest.Content.PackageSets {
 		res, err := solver.Depsolve(pkgSet)
 		if err != nil {
 			panic("Could not depsolve: " + err.Error())
@@ -218,26 +231,11 @@ func main() {
 			panic(err)
 		}
 	} else {
-
-		containerSpecs, err := resolveContainers(composeRequest.Blueprint, arch.Name())
-		if err != nil {
-			panic("Could not resolve containers: " + err.Error())
-		}
-
 		if composeRequest.OSTree.Ref == "" {
 			// use default OSTreeRef for image type
 			composeRequest.OSTree.Ref = imageType.OSTreeRef()
 		}
 
-		manifest, _, err := imageType.Manifest(&composeRequest.Blueprint,
-			options,
-			repos,
-			depsolvedSets,
-			containerSpecs,
-			seedArg)
-		if err != nil {
-			panic(err.Error())
-		}
 		ms, err := manifest.Serialize(depsolvedSets)
 		if err != nil {
 			panic(err.Error())

cmd/osbuild-store-dump/main.go

@@ -22,27 +22,26 @@ import (
 )
 
 func getManifest(bp blueprint.Blueprint, t distro.ImageType, a distro.Arch, d distro.Distro, cacheDir string, repos []rpmmd.RepoConfig) (manifest.OSBuildManifest, []rpmmd.PackageSpec) {
-	packageSets := t.PackageSets(bp, distro.ImageOptions{}, repos)
+	manifest, _, err := t.Manifest(&bp, distro.ImageOptions{}, repos, nil, nil, 0)
+	if err != nil {
+		panic(err)
+	}
 	pkgSpecSets := make(map[string][]rpmmd.PackageSpec)
 	solver := dnfjson.NewSolver(d.ModulePlatformID(), d.Releasever(), a.Name(), d.Name(), cacheDir)
-	for name, packages := range packageSets {
+	for name, packages := range manifest.Content.PackageSets {
 		res, err := solver.Depsolve(packages)
 		if err != nil {
 			panic(err)
 		}
 		pkgSpecSets[name] = res
 	}
-	mf, _, err := t.Manifest(&bp, distro.ImageOptions{}, repos, pkgSpecSets, nil, 0)
+
+	mf, err := manifest.Serialize(pkgSpecSets)
 	if err != nil {
 		panic(err)
 	}
 
-	manifest, err := mf.Serialize(pkgSpecSets)
-	if err != nil {
-		panic(err)
-	}
-
-	return manifest, pkgSpecSets["packages"]
+	return mf, pkgSpecSets["packages"]
 }
 
 func main() {