distro/rhel9: remove unused functions

- Pipelines.
- Stage options.
- Manifest and PackageSets implementations for ImageType.

internal/distro/rhel9/edge.go

@@ -288,38 +288,6 @@ var (
 
 // Package Sets
 
-// common edge image build package set
-func edgeBuildPackageSet(t *imageType) rpmmd.PackageSet {
-	return distroBuildPackageSet(t).Append(
-		rpmmd.PackageSet{
-			Include: []string{
-				"rpm-ostree",
-			},
-		})
-}
-
-func edgeEncryptionBuildPackageSet(t *imageType) rpmmd.PackageSet {
-	return rpmmd.PackageSet{
-		Include: []string{
-			"clevis",
-			"clevis-luks",
-			"cryptsetup",
-		},
-	}
-}
-
-func edgeSimplifiedInstallerBuildPackageSet(t *imageType) rpmmd.PackageSet {
-	return edgeInstallerBuildPackageSet(t).Append(
-		edgeEncryptionBuildPackageSet(t),
-	)
-}
-
-func edgeInstallerBuildPackageSet(t *imageType) rpmmd.PackageSet {
-	return anacondaBuildPackageSet(t).Append(
-		edgeBuildPackageSet(t),
-	)
-}
-
 // edge commit OS package set
 func edgeCommitPackageSet(t *imageType) rpmmd.PackageSet {
 	ps := rpmmd.PackageSet{

internal/distro/rhel9/imagetype.go

@@ -1,7 +1,6 @@
 package rhel9
 
 import (
-	"encoding/json"
 	"fmt"
 	"math/rand"
 	"strings"
@@ -14,9 +13,7 @@ import (
 	"github.com/osbuild/osbuild-composer/internal/environment"
 	"github.com/osbuild/osbuild-composer/internal/image"
 	"github.com/osbuild/osbuild-composer/internal/manifest"
-	"github.com/osbuild/osbuild-composer/internal/osbuild"
 	"github.com/osbuild/osbuild-composer/internal/oscap"
-	"github.com/osbuild/osbuild-composer/internal/ostree"
 	"github.com/osbuild/osbuild-composer/internal/platform"
 	"github.com/osbuild/osbuild-composer/internal/rpmmd"
 	"github.com/osbuild/osbuild-composer/internal/workload"
@@ -44,8 +41,6 @@ const (
 
 type imageFunc func(workload workload.Workload, t *imageType, customizations *blueprint.Customizations, options distro.ImageOptions, packageSets map[string]rpmmd.PackageSet, containers []container.Spec, rng *rand.Rand) (image.ImageKind, error)
 
-type pipelinesFunc func(t *imageType, customizations *blueprint.Customizations, options distro.ImageOptions, repos []rpmmd.RepoConfig, packageSetSpecs map[string][]rpmmd.PackageSpec, containers []container.Spec, rng *rand.Rand) ([]osbuild.Pipeline, error)
-
 type packageSetFunc func(t *imageType) rpmmd.PackageSet
 
 type imageType struct {
@@ -65,7 +60,6 @@ type imageType struct {
 	buildPipelines     []string
 	payloadPipelines   []string
 	exports            []string
-	pipelines          pipelinesFunc
 	image              imageFunc
 
 	// bootISO: installable ISO
@@ -115,101 +109,6 @@ func (t *imageType) Size(size uint64) uint64 {
 	return size
 }
 
-func (t *imageType) getPackages(name string) rpmmd.PackageSet {
-	getter := t.packageSets[name]
-	if getter == nil {
-		return rpmmd.PackageSet{}
-	}
-
-	return getter(t)
-}
-
-func (t *imageType) PackageSets(bp blueprint.Blueprint, options distro.ImageOptions, repos []rpmmd.RepoConfig) map[string][]rpmmd.PackageSet {
-	// TEMPORARY
-	// Use the new manifest generation function if the image type defines an
-	// imageFunc
-	// This is temporary until all image types are transitioned
-	if t.image != nil {
-		return t.PackageSetsNew(bp, options, repos)
-	}
-
-	// merge package sets that appear in the image type with the package sets
-	// of the same name from the distro and arch
-	mergedSets := make(map[string]rpmmd.PackageSet)
-
-	imageSets := t.packageSets
-
-	for name := range imageSets {
-		mergedSets[name] = t.getPackages(name)
-	}
-
-	if _, hasPackages := imageSets[osPkgsKey]; !hasPackages {
-		// should this be possible??
-		mergedSets[osPkgsKey] = rpmmd.PackageSet{}
-	}
-
-	// every image type must define a 'build' package set
-	if _, hasBuild := imageSets[buildPkgsKey]; !hasBuild {
-		panic(fmt.Sprintf("'%s' image type has no '%s' package set defined", t.name, buildPkgsKey))
-	}
-
-	// blueprint packages
-	bpPackages := bp.GetPackages()
-	timezone, _ := bp.Customizations.GetTimezoneSettings()
-	if timezone != nil {
-		bpPackages = append(bpPackages, "chrony")
-	}
-
-	// if we have file system customization that will need to a new mount point
-	// the layout is converted to LVM so we need to corresponding packages
-	if !t.rpmOstree {
-		archName := t.arch.Name()
-		pt := t.basePartitionTables[archName]
-		haveNewMountpoint := false
-
-		if fs := bp.Customizations.GetFilesystems(); fs != nil {
-			for i := 0; !haveNewMountpoint && i < len(fs); i++ {
-				haveNewMountpoint = !pt.ContainsMountpoint(fs[i].Mountpoint)
-			}
-		}
-
-		if haveNewMountpoint {
-			bpPackages = append(bpPackages, "lvm2")
-		}
-	}
-
-	// if we are embedding containers we need to have `skopeo` in the build root
-	if len(bp.Containers) > 0 {
-
-		extraPkgs := rpmmd.PackageSet{Include: []string{"skopeo"}}
-
-		if t.rpmOstree {
-			// for OSTree based images we need to configure the containers-storage.conf(5)
-			// via the org.osbuild.containers.storage.conf stage, which needs python3-toml
-			extraPkgs = extraPkgs.Append(rpmmd.PackageSet{Include: []string{"python3-toml"}})
-		}
-
-		mergedSets[buildPkgsKey] = mergedSets[buildPkgsKey].Append(extraPkgs)
-	}
-
-	// if oscap customizations are enabled we need to add
-	// `openscap-scanner` & `scap-security-guide` packages
-	// to build root
-	if bp.Customizations.GetOpenSCAP() != nil {
-		bpPackages = append(bpPackages, "openscap-scanner", "scap-security-guide")
-	}
-
-	// depsolve bp packages separately
-	// bp packages aren't restricted by exclude lists
-	mergedSets[blueprintPkgsKey] = rpmmd.PackageSet{Include: bpPackages}
-	kernel := bp.Customizations.GetKernel().Name
-
-	// add bp kernel to main OS package set to avoid duplicate kernels
-	mergedSets[osPkgsKey] = mergedSets[osPkgsKey].Append(rpmmd.PackageSet{Include: []string{kernel}})
-
-	return distro.MakePackageSetChains(t, mergedSets, repos)
-}
-
 func (t *imageType) BuildPipelines() []string {
 	return t.buildPipelines
 }
@@ -243,14 +142,6 @@ func (t *imageType) getBootType() distro.BootType {
 	return bootType
 }
 
-func (t *imageType) supportsUEFI() bool {
-	bootType := t.getBootType()
-	if bootType == distro.HybridBootType || bootType == distro.UEFIBootType {
-		return true
-	}
-	return false
-}
-
 func (t *imageType) getPartitionTable(
 	mountpoints []blueprint.FilesystemCustomization,
 	options distro.ImageOptions,
@@ -333,68 +224,6 @@ func (t *imageType) initializeManifest(bp *blueprint.Blueprint,
 }
 
 func (t *imageType) Manifest(customizations *blueprint.Customizations,
-	options distro.ImageOptions,
-	repos []rpmmd.RepoConfig,
-	packageSpecSets map[string][]rpmmd.PackageSpec,
-	containers []container.Spec,
-	seed int64) (distro.Manifest, error) {
-
-	// TEMPORARY
-	// Use the new manifest generation function if the image type defines an
-	// imageFunc
-	// This is temporary until all image types are transitioned
-	if t.image != nil {
-		return t.ManifestNew(customizations, options, repos, packageSpecSets, containers, seed)
-	}
-
-	if err := t.checkOptions(customizations, options, containers); err != nil {
-		return distro.Manifest{}, err
-	}
-
-	source := rand.NewSource(seed)
-	// math/rand is good enough in this case
-	/* #nosec G404 */
-	rng := rand.New(source)
-
-	pipelines, err := t.pipelines(t, customizations, options, repos, packageSpecSets, containers, rng)
-	if err != nil {
-		return distro.Manifest{}, err
-	}
-
-	// flatten spec sets for sources
-	allPackageSpecs := make([]rpmmd.PackageSpec, 0)
-	for _, specs := range packageSpecSets {
-		allPackageSpecs = append(allPackageSpecs, specs...)
-	}
-
-	// handle OSTree commit inputs
-	var commits []ostree.CommitSpec
-	if options.OSTree.FetchChecksum != "" && options.OSTree.URL != "" {
-		commit := ostree.CommitSpec{Checksum: options.OSTree.FetchChecksum, URL: options.OSTree.URL, ContentURL: options.OSTree.ContentURL}
-		if options.OSTree.RHSM {
-			commit.Secrets = "org.osbuild.rhsm.consumer"
-		}
-		commits = []ostree.CommitSpec{commit}
-	}
-
-	// handle inline sources
-	inlineData := []string{}
-
-	// FDO root certs, if any, are transmitted via an inline source
-	if fdo := customizations.GetFDO(); fdo != nil && fdo.DiunPubKeyRootCerts != "" {
-		inlineData = append(inlineData, fdo.DiunPubKeyRootCerts)
-	}
-
-	return json.Marshal(
-		osbuild.Manifest{
-			Version:   "2",
-			Pipelines: pipelines,
-			Sources:   osbuild.GenSources(allPackageSpecs, commits, inlineData, containers),
-		},
-	)
-}
-
-func (t *imageType) ManifestNew(customizations *blueprint.Customizations,
 	options distro.ImageOptions,
 	repos []rpmmd.RepoConfig,
 	packageSets map[string][]rpmmd.PackageSpec,
@@ -416,7 +245,7 @@ func (t *imageType) ManifestNew(customizations *blueprint.Customizations,
 	return manifest.Serialize(packageSets)
 }
 
-func (t *imageType) PackageSetsNew(bp blueprint.Blueprint, options distro.ImageOptions, repos []rpmmd.RepoConfig) map[string][]rpmmd.PackageSet {
+func (t *imageType) PackageSets(bp blueprint.Blueprint, options distro.ImageOptions, repos []rpmmd.RepoConfig) map[string][]rpmmd.PackageSet {
 	// merge package sets that appear in the image type with the package sets
 	// of the same name from the distro and arch
 	packageSets := make(map[string]rpmmd.PackageSet)

internal/distro/rhel9/package_sets.go

@@ -116,29 +116,6 @@ func anacondaBootPackageSet(t *imageType) rpmmd.PackageSet {
 	return ps
 }
 
-func installerBuildPackageSet(t *imageType) rpmmd.PackageSet {
-	return distroBuildPackageSet(t).Append(
-		rpmmd.PackageSet{
-			Include: []string{
-				"isomd5sum",
-				"xorriso",
-			},
-		})
-}
-
-func anacondaBuildPackageSet(t *imageType) rpmmd.PackageSet {
-	ps := rpmmd.PackageSet{
-		Include: []string{
-			"squashfs-tools",
-		},
-	}
-
-	ps = ps.Append(installerBuildPackageSet(t))
-	ps = ps.Append(anacondaBootPackageSet(t))
-
-	return ps
-}
-
 // BOOT PACKAGE SETS
 
 func bootPackageSet(t *imageType) rpmmd.PackageSet {

internal/distro/rhel9/pipelines.go

@@ -1,372 +0,0 @@
-package rhel9
-
-import (
-	"fmt"
-	"math/rand"
-
-	"github.com/osbuild/osbuild-composer/internal/blueprint"
-	"github.com/osbuild/osbuild-composer/internal/container"
-	"github.com/osbuild/osbuild-composer/internal/disk"
-	"github.com/osbuild/osbuild-composer/internal/distro"
-	"github.com/osbuild/osbuild-composer/internal/osbuild"
-	"github.com/osbuild/osbuild-composer/internal/rpmmd"
-	"github.com/osbuild/osbuild-composer/internal/users"
-)
-
-func edgeImagePipelines(t *imageType, customizations *blueprint.Customizations, filename string, options distro.ImageOptions, rng *rand.Rand) ([]osbuild.Pipeline, string, error) {
-	pipelines := make([]osbuild.Pipeline, 0)
-	ostreeRepoPath := "/ostree/repo"
-	imgName := "image.raw"
-
-	partitionTable, err := t.getPartitionTable(nil, options, rng)
-	if err != nil {
-		return nil, "", err
-	}
-
-	// prepare ostree deployment tree
-	treePipeline := ostreeDeployPipeline(t, partitionTable, ostreeRepoPath, rng, customizations, options)
-	pipelines = append(pipelines, *treePipeline)
-
-	// make raw image from tree
-	imagePipeline := liveImagePipeline(treePipeline.Name, imgName, partitionTable, t.arch, "")
-	pipelines = append(pipelines, *imagePipeline)
-
-	// compress image
-	xzPipeline := xzArchivePipeline(imagePipeline.Name, imgName, filename)
-	pipelines = append(pipelines, *xzPipeline)
-
-	return pipelines, xzPipeline.Name, nil
-}
-
-func buildPipeline(repos []rpmmd.RepoConfig, buildPackageSpecs []rpmmd.PackageSpec, runner string) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "build"
-	p.Runner = runner
-	p.AddStage(osbuild.NewRPMStage(osbuild.NewRPMStageOptions(repos), osbuild.NewRpmStageSourceFilesInputs(buildPackageSpecs)))
-	p.AddStage(osbuild.NewSELinuxStage(selinuxStageOptions(true)))
-	return p
-}
-
-func edgeSimplifiedInstallerPipelines(t *imageType, customizations *blueprint.Customizations, options distro.ImageOptions, repos []rpmmd.RepoConfig, packageSetSpecs map[string][]rpmmd.PackageSpec, containers []container.Spec, rng *rand.Rand) ([]osbuild.Pipeline, error) {
-	pipelines := make([]osbuild.Pipeline, 0)
-	pipelines = append(pipelines, *buildPipeline(repos, packageSetSpecs[buildPkgsKey], t.arch.distro.runner.String()))
-	installerPackages := packageSetSpecs[installerPkgsKey]
-	kernelVer := rpmmd.GetVerStrFromPackageSpecListPanic(installerPackages, "kernel")
-	imgName := "disk.img.xz"
-	installDevice := customizations.GetInstallationDevice()
-
-	// create the raw image
-	imagePipelines, imgPipelineName, err := edgeImagePipelines(t, customizations, imgName, options, rng)
-	if err != nil {
-		return nil, err
-	}
-
-	pipelines = append(pipelines, imagePipelines...)
-
-	// create boot ISO with raw image
-	d := t.arch.distro
-	archName := t.Arch().Name()
-	installerTreePipeline := simplifiedInstallerTreePipeline(repos, installerPackages, kernelVer, archName, d.product, d.osVersion, "edge", customizations.GetFDO())
-	isolabel := fmt.Sprintf(d.isolabelTmpl, archName)
-	efibootTreePipeline := simplifiedInstallerEFIBootTreePipeline(installDevice, kernelVer, archName, d.vendor, d.product, d.osVersion, isolabel, customizations.GetFDO())
-	bootISOTreePipeline := simplifiedInstallerBootISOTreePipeline(imgPipelineName, kernelVer, rng)
-
-	pipelines = append(pipelines, *installerTreePipeline, *efibootTreePipeline, *bootISOTreePipeline)
-	pipelines = append(pipelines, *bootISOPipeline(t.Filename(), d.isolabelTmpl, t.Arch().Name(), false))
-
-	return pipelines, nil
-}
-
-func simplifiedInstallerBootISOTreePipeline(archivePipelineName, kver string, rng *rand.Rand) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "bootiso-tree"
-	p.Build = "name:build"
-
-	p.AddStage(osbuild.NewCopyStageSimple(
-		&osbuild.CopyStageOptions{
-			Paths: []osbuild.CopyStagePath{
-				{
-					From: "input://file/disk.img.xz",
-					To:   "tree:///disk.img.xz",
-				},
-			},
-		},
-		osbuild.NewFilesInputs(osbuild.NewFilesInputReferencesPipeline(archivePipelineName, "disk.img.xz")),
-	))
-
-	p.AddStage(osbuild.NewMkdirStage(
-		&osbuild.MkdirStageOptions{
-			Paths: []osbuild.Path{
-				{
-					Path: "images",
-				},
-				{
-					Path: "images/pxeboot",
-				},
-			},
-		},
-	))
-
-	pt := disk.PartitionTable{
-		Size: 20971520,
-		Partitions: []disk.Partition{
-			{
-				Start: 0,
-				Size:  20971520,
-				Payload: &disk.Filesystem{
-					Type:       "vfat",
-					Mountpoint: "/",
-					UUID:       disk.NewVolIDFromRand(rng),
-				},
-			},
-		},
-	}
-
-	filename := "images/efiboot.img"
-	loopback := osbuild.NewLoopbackDevice(&osbuild.LoopbackDeviceOptions{Filename: filename})
-	p.AddStage(osbuild.NewTruncateStage(&osbuild.TruncateStageOptions{Filename: filename, Size: fmt.Sprintf("%d", pt.Size)}))
-
-	for _, stage := range osbuild.GenMkfsStages(&pt, loopback) {
-		p.AddStage(stage)
-	}
-
-	inputName := "root-tree"
-	copyInputs := osbuild.NewPipelineTreeInputs(inputName, "efiboot-tree")
-	copyOptions, copyDevices, copyMounts := osbuild.GenCopyFSTreeOptions(inputName, "efiboot-tree", filename, &pt)
-	p.AddStage(osbuild.NewCopyStage(copyOptions, copyInputs, copyDevices, copyMounts))
-
-	inputName = "coi"
-	copyInputs = osbuild.NewPipelineTreeInputs(inputName, "coi-tree")
-	p.AddStage(osbuild.NewCopyStageSimple(
-		&osbuild.CopyStageOptions{
-			Paths: []osbuild.CopyStagePath{
-				{
-					From: fmt.Sprintf("input://%s/boot/vmlinuz-%s", inputName, kver),
-					To:   "tree:///images/pxeboot/vmlinuz",
-				},
-				{
-					From: fmt.Sprintf("input://%s/boot/initramfs-%s.img", inputName, kver),
-					To:   "tree:///images/pxeboot/initrd.img",
-				},
-			},
-		},
-		copyInputs,
-	))
-
-	inputName = "efi-tree"
-	copyInputs = osbuild.NewPipelineTreeInputs(inputName, "efiboot-tree")
-	p.AddStage(osbuild.NewCopyStageSimple(
-		&osbuild.CopyStageOptions{
-			Paths: []osbuild.CopyStagePath{
-				{
-					From: fmt.Sprintf("input://%s/EFI", inputName),
-					To:   "tree:///",
-				},
-			},
-		},
-		copyInputs,
-	))
-
-	return p
-}
-
-func simplifiedInstallerEFIBootTreePipeline(installDevice, kernelVer, arch, vendor, product, osVersion, isolabel string, fdo *blueprint.FDOCustomization) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "efiboot-tree"
-	p.Build = "name:build"
-	p.AddStage(osbuild.NewGrubISOStage(grubISOStageOptions(installDevice, kernelVer, arch, vendor, product, osVersion, isolabel, fdo)))
-	return p
-}
-
-func simplifiedInstallerTreePipeline(repos []rpmmd.RepoConfig, packages []rpmmd.PackageSpec, kernelVer, arch, product, osVersion, variant string, fdo *blueprint.FDOCustomization) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "coi-tree"
-	p.Build = "name:build"
-	p.AddStage(osbuild.NewRPMStage(osbuild.NewRPMStageOptions(repos), osbuild.NewRpmStageSourceFilesInputs(packages)))
-	p.AddStage(osbuild.NewBuildstampStage(buildStampStageOptions(arch, product, osVersion, variant)))
-	p.AddStage(osbuild.NewLocaleStage(&osbuild.LocaleStageOptions{Language: "C.UTF-8"}))
-	dracutStageOptions := dracutStageOptions(kernelVer, arch, []string{
-		"coreos-installer",
-		"fdo",
-	})
-	if fdo.HasFDO() && fdo.DiunPubKeyRootCerts != "" {
-		p.AddStage(osbuild.NewFDOStageForRootCerts(fdo.DiunPubKeyRootCerts))
-		dracutStageOptions.Install = []string{"/fdo_diun_pub_key_root_certs.pem"}
-	}
-	p.AddStage(osbuild.NewDracutStage(dracutStageOptions))
-	return p
-}
-
-func ostreeDeployPipeline(
-	t *imageType,
-	pt *disk.PartitionTable,
-	repoPath string,
-	rng *rand.Rand,
-	c *blueprint.Customizations,
-	options distro.ImageOptions,
-) *osbuild.Pipeline {
-
-	p := new(osbuild.Pipeline)
-	p.Name = "image-tree"
-	p.Build = "name:build"
-	osname := "redhat"
-	remote := "rhel-edge"
-
-	p.AddStage(osbuild.OSTreeInitFsStage())
-	p.AddStage(osbuild.NewOSTreePullStage(
-		&osbuild.OSTreePullStageOptions{Repo: repoPath, Remote: remote},
-		osbuild.NewOstreePullStageInputs("org.osbuild.source", options.OSTree.FetchChecksum, options.OSTree.ImageRef),
-	))
-	p.AddStage(osbuild.NewOSTreeOsInitStage(
-		&osbuild.OSTreeOsInitStageOptions{
-			OSName: osname,
-		},
-	))
-	p.AddStage(osbuild.NewOSTreeConfigStage(ostreeConfigStageOptions(repoPath, false)))
-	p.AddStage(osbuild.NewMkdirStage(efiMkdirStageOptions()))
-	kernelOpts := osbuild.GenImageKernelOptions(pt)
-	p.AddStage(osbuild.NewOSTreeDeployStage(
-		&osbuild.OSTreeDeployStageOptions{
-			OsName: osname,
-			Ref:    options.OSTree.ImageRef,
-			Remote: remote,
-			Mounts: []string{"/boot", "/boot/efi"},
-			Rootfs: osbuild.Rootfs{
-				Label: "root",
-			},
-			KernelOpts: kernelOpts,
-		},
-	))
-
-	if options.OSTree.URL != "" {
-		p.AddStage(osbuild.NewOSTreeRemotesStage(
-			&osbuild.OSTreeRemotesStageOptions{
-				Repo: "/ostree/repo",
-				Remotes: []osbuild.OSTreeRemote{
-					{
-						Name: remote,
-						URL:  options.OSTree.URL,
-					},
-				},
-			},
-		))
-	}
-
-	p.AddStage(osbuild.NewOSTreeFillvarStage(
-		&osbuild.OSTreeFillvarStageOptions{
-			Deployment: osbuild.OSTreeDeployment{
-				OSName: osname,
-				Ref:    options.OSTree.ImageRef,
-			},
-		},
-	))
-
-	fstabOptions := osbuild.NewFSTabStageOptions(pt)
-	fstabOptions.OSTree = &osbuild.OSTreeFstab{
-		Deployment: osbuild.OSTreeDeployment{
-			OSName: osname,
-			Ref:    options.OSTree.ImageRef,
-		},
-	}
-	p.AddStage(osbuild.NewFSTabStage(fstabOptions))
-
-	if bpUsers := c.GetUsers(); len(bpUsers) > 0 {
-		usersStage, err := osbuild.GenUsersStage(users.UsersFromBP(bpUsers), false)
-		if err != nil {
-			panic(err)
-		}
-		usersStage.MountOSTree(osname, options.OSTree.ImageRef, 0)
-		p.AddStage(usersStage)
-	}
-	if bpGroups := c.GetGroups(); len(bpGroups) > 0 {
-		groupsStage := osbuild.GenGroupsStage(users.GroupsFromBP(bpGroups))
-		groupsStage.MountOSTree(osname, options.OSTree.ImageRef, 0)
-		p.AddStage(groupsStage)
-	}
-
-	p.AddStage(bootloaderConfigStage(t, *pt, "", true, true))
-
-	p.AddStage(osbuild.NewOSTreeSelinuxStage(
-		&osbuild.OSTreeSelinuxStageOptions{
-			Deployment: osbuild.OSTreeDeployment{
-				OSName: osname,
-				Ref:    options.OSTree.ImageRef,
-			},
-		},
-	))
-	return p
-}
-
-func bootISOPipeline(filename, isolabel, arch string, isolinux bool) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "bootiso"
-	p.Build = "name:build"
-
-	p.AddStage(osbuild.NewXorrisofsStage(xorrisofsStageOptions(filename, isolabel, arch, isolinux), "bootiso-tree"))
-	p.AddStage(osbuild.NewImplantisomd5Stage(&osbuild.Implantisomd5StageOptions{Filename: filename}))
-
-	return p
-}
-
-func liveImagePipeline(inputPipelineName string, outputFilename string, pt *disk.PartitionTable, arch *architecture, kernelVer string) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "image"
-	p.Build = "name:build"
-
-	for _, stage := range osbuild.GenImagePrepareStages(pt, outputFilename, osbuild.PTSfdisk) {
-		p.AddStage(stage)
-	}
-
-	inputName := "root-tree"
-	copyOptions, copyDevices, copyMounts := osbuild.GenCopyFSTreeOptions(inputName, inputPipelineName, outputFilename, pt)
-	copyInputs := osbuild.NewPipelineTreeInputs(inputName, inputPipelineName)
-	p.AddStage(osbuild.NewCopyStage(copyOptions, copyInputs, copyDevices, copyMounts))
-
-	for _, stage := range osbuild.GenImageFinishStages(pt, outputFilename) {
-		p.AddStage(stage)
-	}
-
-	loopback := osbuild.NewLoopbackDevice(&osbuild.LoopbackDeviceOptions{Filename: outputFilename})
-	p.AddStage(bootloaderInstStage(outputFilename, pt, arch, kernelVer, copyDevices, copyMounts, loopback))
-	return p
-}
-
-func xzArchivePipeline(inputPipelineName, inputFilename, outputFilename string) *osbuild.Pipeline {
-	p := new(osbuild.Pipeline)
-	p.Name = "archive"
-	p.Build = "name:build"
-
-	p.AddStage(osbuild.NewXzStage(
-		osbuild.NewXzStageOptions(outputFilename),
-		osbuild.NewFilesInputs(osbuild.NewFilesInputReferencesPipeline(inputPipelineName, inputFilename)),
-	))
-
-	return p
-}
-
-func bootloaderConfigStage(t *imageType, partitionTable disk.PartitionTable, kernelVer string, install, greenboot bool) *osbuild.Stage {
-	if t.Arch().Name() == distro.S390xArchName {
-		return osbuild.NewZiplStage(new(osbuild.ZiplStageOptions))
-	}
-
-	uefi := t.supportsUEFI()
-	legacy := t.arch.legacy
-
-	options := osbuild.NewGrub2StageOptionsUnified(&partitionTable, kernelVer, uefi, legacy, t.arch.distro.vendor, install)
-	options.Greenboot = greenboot
-
-	return osbuild.NewGRUB2Stage(options)
-}
-
-func bootloaderInstStage(filename string, pt *disk.PartitionTable, arch *architecture, kernelVer string, devices *osbuild.Devices, mounts *osbuild.Mounts, disk *osbuild.Device) *osbuild.Stage {
-	platform := arch.legacy
-	if platform != "" {
-		return osbuild.NewGrub2InstStage(osbuild.NewGrub2InstStageOption(filename, pt, platform))
-	}
-
-	if arch.name == distro.S390xArchName {
-		return osbuild.NewZiplInstStage(osbuild.NewZiplInstStageOptions(kernelVer, pt), disk, devices, mounts)
-	}
-
-	return nil
-}

internal/distro/rhel9/stage_options.go

@@ -1,182 +0,0 @@
-package rhel9
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/osbuild/osbuild-composer/internal/blueprint"
-	"github.com/osbuild/osbuild-composer/internal/common"
-	"github.com/osbuild/osbuild-composer/internal/distro"
-	"github.com/osbuild/osbuild-composer/internal/osbuild"
-)
-
-// selinuxStageOptions returns the options for the org.osbuild.selinux stage.
-// Setting the argument to 'true' relabels the '/usr/bin/cp' and '/usr/bin/tar'
-// binaries with 'install_exec_t'. This should be set in the build root.
-func selinuxStageOptions(labelcp bool) *osbuild.SELinuxStageOptions {
-	options := &osbuild.SELinuxStageOptions{
-		FileContexts: "etc/selinux/targeted/contexts/files/file_contexts",
-	}
-	if labelcp {
-		options.Labels = map[string]string{
-			"/usr/bin/cp":  "system_u:object_r:install_exec_t:s0",
-			"/usr/bin/tar": "system_u:object_r:install_exec_t:s0",
-		}
-	}
-	return options
-}
-
-func buildStampStageOptions(arch, product, osVersion, variant string) *osbuild.BuildstampStageOptions {
-	return &osbuild.BuildstampStageOptions{
-		Arch:    arch,
-		Product: product,
-		Version: osVersion,
-		Variant: variant,
-		Final:   true,
-	}
-}
-
-func dracutStageOptions(kernelVer, arch string, additionalModules []string) *osbuild.DracutStageOptions {
-	kernel := []string{kernelVer}
-	modules := []string{
-		"bash",
-		"systemd",
-		"fips",
-		"systemd-initrd",
-		"modsign",
-		"nss-softokn",
-		"i18n",
-		"convertfs",
-		"network-manager",
-		"network",
-		"ifcfg",
-		"url-lib",
-		"drm",
-		"plymouth",
-		"prefixdevname",
-		"prefixdevname-tools",
-		"crypt",
-		"dm",
-		"dmsquash-live",
-		"kernel-modules",
-		"kernel-modules-extra",
-		"kernel-network-modules",
-		"livenet",
-		"lvm",
-		"mdraid",
-		"qemu",
-		"qemu-net",
-		"resume",
-		"rootfs-block",
-		"terminfo",
-		"udev-rules",
-		"dracut-systemd",
-		"pollcdrom",
-		"usrmount",
-		"base",
-		"fs-lib",
-		"img-lib",
-		"shutdown",
-		"uefi-lib",
-	}
-
-	if arch == distro.X86_64ArchName {
-		modules = append(modules, "biosdevname")
-	}
-
-	modules = append(modules, additionalModules...)
-	return &osbuild.DracutStageOptions{
-		Kernel:  kernel,
-		Modules: modules,
-		Install: []string{"/.buildstamp"},
-	}
-}
-
-func grubISOStageOptions(installDevice, kernelVer, arch, vendor, product, osVersion, isolabel string, fdo *blueprint.FDOCustomization) *osbuild.GrubISOStageOptions {
-	var architectures []string
-
-	if arch == distro.X86_64ArchName {
-		architectures = []string{"X64"}
-	} else if arch == distro.Aarch64ArchName {
-		architectures = []string{"AA64"}
-	} else {
-		panic("unsupported architecture")
-	}
-
-	grubISOStageOptions := &osbuild.GrubISOStageOptions{
-		Product: osbuild.Product{
-			Name:    product,
-			Version: osVersion,
-		},
-		ISOLabel: isolabel,
-		Kernel: osbuild.ISOKernel{
-			Dir: "/images/pxeboot",
-			Opts: []string{"rd.neednet=1",
-				"coreos.inst.crypt_root=1",
-				"coreos.inst.isoroot=" + isolabel,
-				"coreos.inst.install_dev=" + installDevice,
-				"coreos.inst.image_file=/run/media/iso/disk.img.xz",
-				"coreos.inst.insecure"},
-		},
-		Architectures: architectures,
-		Vendor:        vendor,
-	}
-	if fdo.HasFDO() {
-		grubISOStageOptions.Kernel.Opts = append(grubISOStageOptions.Kernel.Opts, "fdo.manufacturing_server_url="+fdo.ManufacturingServerURL)
-		if fdo.DiunPubKeyInsecure != "" {
-			grubISOStageOptions.Kernel.Opts = append(grubISOStageOptions.Kernel.Opts, "fdo.diun_pub_key_insecure="+fdo.DiunPubKeyInsecure)
-		}
-		if fdo.DiunPubKeyHash != "" {
-			grubISOStageOptions.Kernel.Opts = append(grubISOStageOptions.Kernel.Opts, "fdo.diun_pub_key_hash="+fdo.DiunPubKeyHash)
-		}
-		if fdo.DiunPubKeyRootCerts != "" {
-			grubISOStageOptions.Kernel.Opts = append(grubISOStageOptions.Kernel.Opts, "fdo.diun_pub_key_root_certs=/fdo_diun_pub_key_root_certs.pem")
-		}
-	}
-
-	return grubISOStageOptions
-}
-
-func xorrisofsStageOptions(filename, isolabel, arch string, isolinux bool) *osbuild.XorrisofsStageOptions {
-	options := &osbuild.XorrisofsStageOptions{
-		Filename: filename,
-		VolID:    fmt.Sprintf(isolabel, arch),
-		SysID:    "LINUX",
-		EFI:      "images/efiboot.img",
-		ISOLevel: 3,
-	}
-
-	if isolinux {
-		options.Boot = &osbuild.XorrisofsBoot{
-			Image:   "isolinux/isolinux.bin",
-			Catalog: "isolinux/boot.cat",
-		}
-
-		options.IsohybridMBR = "/usr/share/syslinux/isohdpfx.bin"
-	}
-
-	return options
-}
-
-func ostreeConfigStageOptions(repo string, readOnly bool) *osbuild.OSTreeConfigStageOptions {
-	return &osbuild.OSTreeConfigStageOptions{
-		Repo: repo,
-		Config: &osbuild.OSTreeConfig{
-			Sysroot: &osbuild.SysrootOptions{
-				ReadOnly:   common.BoolToPtr(readOnly),
-				Bootloader: "none",
-			},
-		},
-	}
-}
-
-func efiMkdirStageOptions() *osbuild.MkdirStageOptions {
-	return &osbuild.MkdirStageOptions{
-		Paths: []osbuild.Path{
-			{
-				Path: "/boot/efi",
-				Mode: os.FileMode(0700),
-			},
-		},
-	}
-}