bib: add support for --type bootc-installer

This commit adds support for the new `bootc-installer` image
type that will take a bootc container and create an ISO out
of it. It also adds a new `--installer-payload-ref` option
so that the user can specify a different payload container
to install.

See osbuild/images#1906 for details.

This is the equivalent of
osbuild/image-builder-cli#341
for bootc-image-builder and allows us to build these kinds
of images with bib now too.

Author: mvo5

README.md

@@ -133,7 +133,7 @@ Flags:
       --progress string       type of progress bar to use (e.g. verbose,term) (default "auto")
       --rootfs string         Root filesystem type. If not given, the default configured in the source container image is used.
       --target-arch string    build for the given target architecture (experimental)
-      --type stringArray      image types to build [ami, anaconda-iso, gce, iso, qcow2, raw, vhd, vmdk] (default [qcow2])
+      --type stringArray      image types to build [ami, anaconda-iso, bootc-installer, gce, iso, qcow2, raw, vhd, vmdk] (default [qcow2])
       --version               version for bootc-image-builder
 
 Global Flags:
@@ -172,7 +172,8 @@ The following image types are currently available via the `--type` argument:
 | `ami`                 | [Amazon Machine Image](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html) |
 | `qcow2` **(default)** | [QEMU](https://www.qemu.org/)                                                         |
 | `vmdk`                | [VMDK](https://en.wikipedia.org/wiki/VMDK) usable in vSphere, among others            |
-| `anaconda-iso`        | An unattended Anaconda installer that installs to the first disk found.               |
+| `bootc-installer`     | An installer ISO image based on the specified bootc container image.                  |
+| `anaconda-iso`        | (legacy) an unattended Anaconda installer that installs to the first disk found build from RPMs. |
 | `raw`                 | Unformatted [raw disk](https://en.wikipedia.org/wiki/Rawdisk).                        |
 | `vhd`                 | [vhd](https://en.wikipedia.org/wiki/VHD_(file_format)) usable in Virtual PC, among others |
 | `gce`                 | [GCE](https://cloud.google.com/compute/docs/images#custom_images) |

bib/cmd/bootc-image-builder/main.go

@@ -25,6 +25,7 @@ import (
 	"github.com/osbuild/images/pkg/bib/blueprintload"
 	"github.com/osbuild/images/pkg/cloud"
 	"github.com/osbuild/images/pkg/cloud/awscloud"
+	"github.com/osbuild/images/pkg/distro"
 	"github.com/osbuild/images/pkg/distro/bootc"
 	"github.com/osbuild/images/pkg/experimentalflags"
 	"github.com/osbuild/images/pkg/manifest"
@@ -93,6 +94,7 @@ func manifestFromCobra(cmd *cobra.Command, args []string, pbar progress.Progress
 	targetArch, _ := cmd.Flags().GetString("target-arch")
 	rootFs, _ := cmd.Flags().GetString("rootfs")
 	buildImgref, _ := cmd.Flags().GetString("build-container")
+	installerPayloadRef, _ := cmd.Flags().GetString("installer-payload-ref")
 	useLibrepo, _ := cmd.Flags().GetBool("use-librepo")
 
 	// If --local was given, warn in the case of --local or --local=true (true is the default), error in the case of --local=false
@@ -153,21 +155,21 @@ func manifestFromCobra(cmd *cobra.Command, args []string, pbar progress.Progress
 	if imageTypes.Legacy() {
 		return manifestFromCobraForLegacyISO(imgref, buildImgref, imgType, rootFs, rpmCacheRoot, config, useLibrepo, cntArch)
 	}
-	return manifestFromCobraForDisk(imgref, buildImgref, imgType, rootFs, rpmCacheRoot, config, useLibrepo, cntArch)
+	return manifestFromCobraForDisk(imgref, buildImgref, installerPayloadRef, imgType, rootFs, rpmCacheRoot, config, useLibrepo, cntArch)
 }
 
-func manifestFromCobraForDisk(imgref, buildImgref, imgTypeStr, rootFs, rpmCacheRoot string, config *blueprint.Blueprint, useLibrepo bool, cntArch arch.Arch) ([]byte, *mTLSConfig, error) {
-	distro, err := bootc.NewBootcDistro(imgref)
+func manifestFromCobraForDisk(imgref, buildImgref, installerPayloadRef, imgTypeStr, rootFs, rpmCacheRoot string, config *blueprint.Blueprint, useLibrepo bool, cntArch arch.Arch) ([]byte, *mTLSConfig, error) {
+	distri, err := bootc.NewBootcDistro(imgref)
 	if err != nil {
 		return nil, nil, err
 	}
-	if err := distro.SetBuildContainer(buildImgref); err != nil {
+	if err := distri.SetBuildContainer(buildImgref); err != nil {
 		return nil, nil, err
 	}
-	if err := distro.SetDefaultFs(rootFs); err != nil {
+	if err := distri.SetDefaultFs(rootFs); err != nil {
 		return nil, nil, err
 	}
-	archi, err := distro.GetArch(cntArch.String())
+	archi, err := distri.GetArch(cntArch.String())
 	if err != nil {
 		return nil, nil, err
 	}
@@ -193,7 +195,12 @@ func manifestFromCobraForDisk(imgref, buildImgref, imgTypeStr, rootFs, rpmCacheR
 	if err != nil {
 		return nil, nil, err
 	}
-	manifest, err := mg.Generate(config, imgType, nil)
+	imgOpts := &distro.ImageOptions{
+		Bootc: &distro.BootcImageOptions{
+			InstallerPayloadRef: installerPayloadRef,
+		},
+	}
+	manifest, err := mg.Generate(config, imgType, imgOpts)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -504,6 +511,9 @@ func buildCobraCmdline() (*cobra.Command, error) {
 	manifestCmd.Flags().String("rpmmd", "/rpmmd", "rpm metadata cache directory")
 	manifestCmd.Flags().String("target-arch", "", "build for the given target architecture (experimental)")
 	manifestCmd.Flags().String("build-container", "", "Use a custom container for the image build")
+	// XXX: add --bootc-installer-payload-ref as alias to make it
+	// cmdline compatible with ibcli(?)
+	manifestCmd.Flags().String("installer-payload-ref", "", "bootc installer payload ref")
 	manifestCmd.Flags().StringArray("type", []string{"qcow2"}, fmt.Sprintf("image types to build [%s]", imagetypes.Available()))
 	manifestCmd.Flags().Bool("local", true, "DEPRECATED: --local is now the default behavior, make sure to pull the container image before running bootc-image-builder")
 	if err := manifestCmd.Flags().MarkHidden("local"); err != nil {

bib/internal/imagetypes/imagetypes.go

@@ -17,13 +17,14 @@ var supportedImageTypes = map[string]imageType{
 	// XXX: ideally we would look how to consolidate all
 	// knownledge about disk based image types into the images
 	// library
-	"ami":   imageType{Export: "image"},
-	"qcow2": imageType{Export: "qcow2"},
-	"raw":   imageType{Export: "image"},
-	"vmdk":  imageType{Export: "vmdk"},
-	"vhd":   imageType{Export: "vpc"},
-	"gce":   imageType{Export: "gce"},
-	"ova":   imageType{Export: "archive"},
+	"ami":             imageType{Export: "image"},
+	"qcow2":           imageType{Export: "qcow2"},
+	"raw":             imageType{Export: "image"},
+	"vmdk":            imageType{Export: "vmdk"},
+	"vhd":             imageType{Export: "vpc"},
+	"gce":             imageType{Export: "gce"},
+	"ova":             imageType{Export: "archive"},
+	"bootc-installer": imageType{Export: "bootiso", ISO: true},
 	// the iso image types are RPM based and legacy/deprecated
 	"anaconda-iso": imageType{Export: "bootiso", ISO: true, Legacy: true},
 	"iso":          imageType{Export: "bootiso", ISO: true, Legacy: true},

bib/internal/imagetypes/imagetypes_test.go

@@ -57,21 +57,25 @@ func TestImageTypes(t *testing.T) {
 			imageTypes:  []string{"vmdk", "anaconda-iso"},
 			expectedErr: errors.New("cannot mix ISO/disk images in request [vmdk anaconda-iso]"),
 		},
-		"bad-mix-part-2": {
+		"bad-mix-2": {
+			imageTypes:  []string{"vmdk", "bootc-installer"},
+			expectedErr: errors.New("cannot mix ISO/disk images in request [vmdk bootc-installer]"),
+		},
+		"bad-mix-3": {
 			imageTypes:  []string{"ami", "iso"},
 			expectedErr: errors.New("cannot mix ISO/disk images in request [ami iso]"),
 		},
 		"bad-image-type": {
 			imageTypes:  []string{"bad"},
-			expectedErr: errors.New(`unsupported image type "bad", valid types are ami, anaconda-iso, gce, iso, ova, qcow2, raw, vhd, vmdk`),
+			expectedErr: errors.New(`unsupported image type "bad", valid types are ami, anaconda-iso, bootc-installer, gce, iso, ova, qcow2, raw, vhd, vmdk`),
 		},
 		"bad-in-good": {
 			imageTypes:  []string{"ami", "raw", "vmdk", "qcow2", "something-else-what-is-this"},
-			expectedErr: errors.New(`unsupported image type "something-else-what-is-this", valid types are ami, anaconda-iso, gce, iso, ova, qcow2, raw, vhd, vmdk`),
+			expectedErr: errors.New(`unsupported image type "something-else-what-is-this", valid types are ami, anaconda-iso, bootc-installer, gce, iso, ova, qcow2, raw, vhd, vmdk`),
 		},
 		"all-bad": {
 			imageTypes:  []string{"bad1", "bad2", "bad3", "bad4", "bad5", "bad42"},
-			expectedErr: errors.New(`unsupported image type "bad1", valid types are ami, anaconda-iso, gce, iso, ova, qcow2, raw, vhd, vmdk`),
+			expectedErr: errors.New(`unsupported image type "bad1", valid types are ami, anaconda-iso, bootc-installer, gce, iso, ova, qcow2, raw, vhd, vmdk`),
 		},
 	}
 

test/test_manifest.py

@@ -53,7 +53,7 @@ def test_manifest_smoke(build_container, tc):
 
 
 @pytest.mark.parametrize("tc", gen_testcases("anaconda-iso"))
-def test_iso_manifest_smoke(build_container, tc):
+def test_rpm_iso_manifest_smoke(build_container, tc):
     testutil.pull_container(tc.container_ref, tc.target_arch)
 
     output = subprocess.check_output([
@@ -71,6 +71,31 @@ def test_iso_manifest_smoke(build_container, tc):
     assert [pipeline["name"] for pipeline in manifest["pipelines"]] == expected_pipeline_names
 
 
+def test_bootc_iso_manifest_smoke(build_container):
+    container_ref = "quay.io/centos-bootc/centos-bootc:stream9"
+    # Note that this is not a realistic ref, a generic bootc
+    # image does not contain anaconda so this won't produce a
+    # working installer. For the purpose of the test to validate
+    # that we get a manifest with the right refs its good enough.
+    installer_payload_ref = "quay.io/centos-bootc/centos-bootc:stream10"
+    testutil.pull_container(container_ref)
+    testutil.pull_container(installer_payload_ref)
+
+    output = subprocess.check_output([
+        *testutil.podman_run_common,
+        build_container,
+        "manifest",
+        "--type=bootc-installer",
+        f"{container_ref}",
+        f"--installer-payload-ref={installer_payload_ref}",
+    ])
+    manifest = json.loads(output)
+    # just some basic validation
+    expected_pipeline_names = ["build", "anaconda-tree", "efiboot-tree", "bootiso-tree", "bootiso"]
+    assert manifest["version"] == "2"
+    assert [pipeline["name"] for pipeline in manifest["pipelines"]] == expected_pipeline_names
+
+
 @pytest.mark.parametrize("tc", gen_testcases("manifest"))
 def test_manifest_disksize(tmp_path, build_container, tc):
     testutil.pull_container(tc.container_ref, tc.target_arch)