Add new image type:vdh and gce support in bootc image builder

Add new image type:vdh and gce support in bootc image builder
vdh and gce are newly introduced support disk image type, and are only supported on upstream

Signed-off-by: chunfuwen <[email protected]>

provider/bootc_image_builder/bootc_image_build_utils.py

@@ -65,7 +65,10 @@ def podman_command_build(bib_image_url, disk_image_type, image_ref, config=None,
         os.makedirs("/var/lib/libvirt/images/output")
     cmd = "sudo podman run --rm -it --privileged --pull=newer --security-opt label=type:unconfined_t -v /var/lib/libvirt/images/output:/output"
     if config:
-        cmd += " -v %s:/config.json  " % config
+        if "toml" in config:
+            cmd += " -v %s:/config.toml  " % config
+        else:
+            cmd += " -v %s:/config.json  " % config
 
     if local_container:
         cmd += " -v /var/lib/containers/storage:/var/lib/containers/storage "
@@ -83,7 +86,10 @@ def podman_command_build(bib_image_url, disk_image_type, image_ref, config=None,
         " --type %s --tls-verify=%s " % (bib_image_url, disk_image_type, tls_verify)
 
     if config:
-        cmd += " --config /config.json "
+        if "toml" in config:
+            cmd += " --config /config.toml "
+        else:
+            cmd += " --config /config.json "
 
     if target_arch:
         cmd += " --target-arch=%s " % target_arch
@@ -173,6 +179,19 @@ def create_config_json_file(params):
     password = params.get("os_password")
     kickstart = "yes" == params.get("kickstart")
     public_key_path = os.path.join(os.path.expanduser("~/.ssh/"), "id_rsa.pub")
+    filesystem_size_set = "yes" == params.get("filesystem_size_set")
+
+    filesystem_dict = {"filesystem": [
+        {
+            "mountpoint": "/",
+            "minsize": "10 GiB"
+        },
+        {
+            "mountpoint": "/var/data",
+            "minsize": "15 GiB"
+        }
+        ]
+    }
     if not os.path.exists(public_key_path):
         LOG.debug("public key doesn't exist, will help create one")
         key_gen_cmd = "ssh-keygen -q -t rsa -N '' <<< $'\ny' >/dev/null 2>&1"
@@ -222,12 +241,84 @@ def create_config_json_file(params):
             }
         }
 
+    if filesystem_size_set:
+        cfg['blueprint']['customizations'].update(filesystem_dict)
+
     LOG.debug("what is cfg:%s", cfg)
     config_json_path = pathlib.Path(folder) / "config.json"
     config_json_path.write_text(json.dumps(cfg), encoding="utf-8")
     return os.path.join(folder, "config.json")
 
 
+def create_config_toml_file(params):
+    """
+    create toml configuration file
+
+    :param params: one dictionary to pass in configuration
+    """
+    folder = params.get("config_file_path")
+    username = params.get("os_username")
+    password = params.get("os_password")
+    kickstart = "yes" == params.get("kickstart")
+    public_key_path = os.path.join(os.path.expanduser("~/.ssh/"), "id_rsa.pub")
+    filesystem_size_set = "yes" == params.get("filesystem_size_set")
+    filesystem_size_str = ""
+
+    if not os.path.exists(public_key_path):
+        LOG.debug("public key doesn't exist, will help create one")
+        key_gen_cmd = "ssh-keygen -q -t rsa -N '' <<< $'\ny' >/dev/null 2>&1"
+        process.run(key_gen_cmd, shell=True, ignore_status=False)
+
+    with open(public_key_path, 'r') as ssh:
+        key_value = ssh.read().rstrip()
+
+    if filesystem_size_set:
+        filesystem_size_str = f"""
+            [[customizations.filesystem]]
+            mountpoint = "/"
+            minsize = "10 GiB"
+
+            [[customizations.filesystem]]
+            mountpoint = "/var/data"
+            minsize = "20 GiB"
+            """
+    if not kickstart:
+        container_file_content = f"""\n
+            [[customizations.user]]
+            name = "{username}"
+            password = "{password}"
+            key = "{key_value}"
+            groups = ["wheel"]
+            {filesystem_size_str}
+            [customizations.kernel]
+            append = "mitigations=auto,nosmt"
+            """
+    else:
+        kick_start = {"contents": "user --name %s --password %s --groups wheel\n"
+                      "sshkey --username %s \"%s\"\ntext --non-interactive\nzerombr\n"
+                      "clearpart --all --initlabel --disklabel=gpt\nautopart --noswap --type=lvm\n"
+                      "network --bootproto=dhcp --device=link --activate --onboot=on\n reboot" % (username, password, username, key_value)
+                      }
+        container_file_content = f"""\n
+            [customizations.kernel]
+            append = "mitigations=auto,nosmt"
+            [customizations.installer.modules]
+            enable = [
+              "org.fedoraproject.Anaconda.Modules.Localization"
+            ]
+            disable = [
+              "org.fedoraproject.Anaconda.Modules.Users"
+            ]
+            {filesystem_size_str}
+            [customizations.installer.kickstart]
+            contents = \"""{kick_start.get("contents")}\"""
+            """
+    LOG.debug("what is cfg:%s", cfg)
+    config_toml_path = pathlib.Path(folder) / "config.toml"
+    config_toml_path.write_text(textwrap.dedent(container_file_content), encoding="utf8")
+    return os.path.join(folder, "config.toml")
+
+
 def create_auth_json_file(params):
     """
     create authentication json configuration file
@@ -279,9 +370,12 @@ def create_and_build_container_file(params):
     folder = params.get("container_base_folder")
     build_container = params.get("build_container")
     container_tag = params.get("container_url")
+    manifest = params.get("manifest")
 
     # clean up existed image
     clean_image_cmd = "sudo podman rmi %s" % container_tag
+    if manifest:
+        clean_image_cmd = "sudo podman manifest rm %s" % container_tag
     process.run(clean_image_cmd, shell=True, ignore_status=True)
     etc_config = ''
     dnf_vmware_tool = ''
@@ -382,9 +476,16 @@ def create_and_build_container_file(params):
         {dnf_fips_install}
         Run dnf clean all
         """
+    build_cmd = "sudo podman build -t %s -f %s" % (container_tag, str(container_path))
+    if manifest:
+        container_file_content = f"""\n
+        FROM {build_container}
+        {create_sudo_file}
+        {enable_root_ssh}
+        """
+        build_cmd = "sudo podman build  --platform linux/arm64,linux/amd64 --manifest %s -f %s" % (manifest, str(container_path))
 
     container_path.write_text(textwrap.dedent(container_file_content), encoding="utf8")
-    build_cmd = "sudo podman build -t %s -f %s" % (container_tag, str(container_path))
     process.run(build_cmd, shell=True, ignore_status=False)
 
 
@@ -843,6 +944,7 @@ def convert_vhd_to_qcow2(params):
     Convert vhd disk format into qcow2
 
     @param params: one dictionary wrapping various parameter
+    :return: Converted image path
     """
     original_image_path = params.get('vm_disk_image_path')
     converted_image_path = original_image_path.replace("vhd", "qcow2")
@@ -860,11 +962,11 @@ def untar_tgz_to_raw(params):
     @param params: one dictionary wrapping various parameter
     """
     original_image_path = params.get('vm_disk_image_path')
-    untar_image_path = original_image_path.replace("tgz", "raw").replace("image", "disk")
     tar_image_folder = os.path.dirname(original_image_path)
-    LOG.debug(f"untar image.tgz to gce output is : {untar_image_path}")
+    untar_image_path = os.path.join(tar_image_folder, "disk.raw")
+    LOG.debug(f"untar image.tgz to gce output is : {tar_image_folder}")
 
-    tar_cmd = f"tar -xvzf {original_image_path}  -C {converted_image_path}"
+    tar_cmd = f"tar -xvzf {original_image_path}  -C {tar_image_folder}"
     process.run(tar_cmd, shell=True, verbose=True, ignore_status=False)
     return untar_image_path
 

virttools/tests/cfg/bootc_image_builder/bootc_disk_image_build.cfg

@@ -23,10 +23,13 @@
         - use_config_json:
             os_username = "alice"
             os_password = "bob"
+            qcow..upstream_bib:
+                filesystem_size_set = "yes"
             anaconda-iso..upstream_bib..fedora_40:
                 kickstart = "yes"
             anaconda-iso..rhel_9.5_nightly_bib..local_image:
                 kickstart = "yes"
+                filesystem_size_set = "yes"
         - unuse_config_json:
     variants image_ref:
         - centos:
@@ -78,7 +81,11 @@
             only rhel_10.0_bib
             no anaconda-iso
         - cross_build:
-            container_url = "quay.io/centos-bootc/centos-bootc:stream9"
+            local_container = "yes"
+            manifest = "manifest-test"
+            container_base_folder = "/var/lib/libvirt/images"
+            build_container = "quay.io/centos-bootc/centos-bootc:stream9"
+            container_url = "localhost/manifest-test"
             target_arch = "aarch64"
             only qcow..upstream_bib..use_config_json..tls_verify_enable
     variants bib_ref:

virttools/tests/cfg/bootc_image_builder/bootc_disk_image_install.cfg

@@ -52,6 +52,8 @@
 				roofs = "xfs"
 			    anaconda-iso..upstream_bib:
 				kickstart = "yes"
+			    raw..upstream_bib:
+				filesystem_size_set = "yes"
 			- fedora_latest:
 			    only upstream_bib
 			    container_url = "quay.io/fedora/fedora-bootc:latest"

virttools/tests/src/bootc_image_builder/bootc_disk_image_install.py

@@ -52,6 +52,7 @@ def update_bib_env_info(params, test):
     if params.get("disk_image_type") == "gce":
         untar_raw_image = bib_utils.untar_tgz_to_raw(params)
         params.update({'vm_disk_image_path': untar_raw_image})
+        cleanup_files.append(untar_raw_image)
 
     iso_install_path = os.path.join(libvirt_base_folder, f"{disk_name}_{firmware}.qcow2")
     params.update({'iso_install_path': iso_install_path})
@@ -136,7 +137,7 @@ def run(test, params, env):
         update_bib_env_info(params, test)
         if disk_image_type in ["vmdk"]:
             bib_utils.create_and_start_vmware_vm(params)
-        elif disk_image_type in ["qcow2", "raw", "anaconda-iso", "vhd"]:
+        elif disk_image_type in ["qcow2", "raw", "anaconda-iso", "vhd", "gce"]:
             bib_utils.create_qemu_vm(params, env, test)
         elif disk_image_type in ["ami"]:
             if len(aws_config_dict) != 0: