almalinux/pungi
14
1
Fork 0
Code Issues Pull Requests Releases Activity

Drop buildinstall method

Browse Source 
JIRA: RHELCMP-12388

Signed-off-by: Aditya Bisoi <abisoi@redhat.com>
This commit is contained in:
Aditya Bisoi 2023-10-09 14:35:46 +05:30 committed by lsedlar
parent 8cf1d98312
commit b513c8cd00
11 changed files with 4 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
TODO
View File

@ -47,7 +47,6 @@ Split Pungi into smaller well-defined tools
* create install images
* lorax
* buildinstall
* create isos
* isos

2
doc/configuration.rst
View File

@ -642,7 +642,7 @@ Options
-------
**buildinstall_method**
(*str*) -- "lorax" (f16+, rhel7+) or "buildinstall" (older releases)
(*str*) -- "lorax" (f16+, rhel7+)
**lorax_options**
(*list*) -- special options passed on to *lorax*.

7
doc/phases.rst
View File

@ -30,17 +30,14 @@ packages to architectures.
Buildinstall
------------
Spawns a bunch of threads, each of which runs either ``lorax`` or
``buildinstall`` command (the latter coming from ``anaconda`` package). The
Spawns a bunch of threads, each of which runs the ``lorax`` command. The
commands create ``boot.iso`` and other boot configuration files. The image is
finally linked into the ``compose/`` directory as netinstall media.
The created images are also needed for creating live media or other images in
later phases.
With ``lorax`` this phase runs one task per variant.arch combination. For
``buildinstall`` command there is only one task per architecture and
``product.img`` should be used to customize the results.
With ``lorax`` this phase runs one task per variant.arch combination.
Gather
------

3
pungi/checks.py
View File

@ -812,7 +812,7 @@ def make_schema():
"buildinstall_allow_reuse": {"type": "boolean", "default": False},
"buildinstall_method": {
"type": "string",
"enum": ["lorax", "buildinstall"],
"enum": ["lorax"],
},
"buildinstall_topdir": {"type": "string"},
"buildinstall_kickstart": {"$ref": "#/definitions/str_or_scm_dict"},
@ -1497,7 +1497,6 @@ def get_num_cpus():
CONFIG_DEPS = {
"buildinstall_method": {
"conflicts": (
(lambda val: val == "buildinstall", ["lorax_options"]),
(lambda val: not val, ["lorax_options", "buildinstall_kickstart"]),
),
},

4
pungi/createiso.py
View File

@ -67,10 +67,6 @@ def make_image(f, opts):
os.path.join("$TEMPLATE", "config_files/ppc"),
hfs_compat=opts.hfs_compat,
)
elif opts.buildinstall_method == "buildinstall":
mkisofs_kwargs["boot_args"] = iso.get_boot_options(
opts.arch, "/usr/lib/anaconda-runtime/boot"
)
# ppc(64) doesn't seem to support utf-8
if opts.arch in ("ppc", "ppc64", "ppc64le"):

23
pungi/phases/buildinstall.py
View File

@ -219,10 +219,6 @@ class BuildinstallPhase(PhaseBase):
return repos
def run(self):
lorax = LoraxWrapper()
product = self.compose.conf["release_name"]
version = self.compose.conf["release_version"]
release = self.compose.conf["release_version"]
disc_type = self.compose.conf["disc_types"].get("dvd", "dvd")
# Prepare kickstart file for final images.
@ -275,23 +271,6 @@ class BuildinstallPhase(PhaseBase):
),
)
)
elif self.buildinstall_method == "buildinstall":
volid = get_volid(self.compose, arch, disc_type=disc_type)
commands.append(
(
None,
lorax.get_buildinstall_cmd(
product,
version,
release,
repo_baseurls,
output_dir,
is_final=self.compose.supported,
buildarch=arch,
volid=volid,
),
)
)
else:
raise ValueError(
"Unsupported buildinstall method: %s" % self.buildinstall_method
@ -827,8 +806,6 @@ class BuildinstallThread(WorkerThread):
if buildinstall_method == "lorax":
packages += ["lorax"]
chown_paths.append(_get_log_dir(compose, variant, arch))
elif buildinstall_method == "buildinstall":
packages += ["anaconda"]
packages += get_arch_variant_data(
compose.conf, "buildinstall_packages", arch, variant
)

1
pungi/phases/createiso.py
View File

@ -546,7 +546,6 @@ def run_createiso_command(num, compose, bootable, arch, cmd, mounts, log_file):
if bootable:
extra_packages = {
"lorax": ["lorax", "which"],
"buildinstall": ["anaconda"],
}
packages.extend(extra_packages[compose.conf["buildinstall_method"]])

52
pungi/wrappers/lorax.py
View File

@ -109,55 +109,3 @@ class LoraxWrapper(object):
# TODO: workdir
return cmd
def get_buildinstall_cmd(
self,
product,
version,
release,
repo_baseurl,
output_dir,
variant=None,
bugurl=None,
nomacboot=False,
noupgrade=False,
is_final=False,
buildarch=None,
volid=None,
brand=None,
):
# RHEL 6 compatibility
# Usage: buildinstall [--debug] --version <version> --brand <brand> --product <product> --release <comment> --final [--output outputdir] [--discs <discstring>] <root> # noqa: E501
brand = brand or "redhat"
# HACK: ignore provided release
release = "%s %s" % (brand, version)
bugurl = bugurl or "https://bugzilla.redhat.com"
cmd = ["/usr/lib/anaconda-runtime/buildinstall"]
cmd.append("--debug")
cmd.extend(["--version", version])
cmd.extend(["--brand", brand])
cmd.extend(["--product", product])
cmd.extend(["--release", release])
if is_final:
cmd.append("--final")
if buildarch:
cmd.extend(["--buildarch", buildarch])
if bugurl:
cmd.extend(["--bugurl", bugurl])
output_dir = os.path.abspath(output_dir)
cmd.extend(["--output", output_dir])
for i in force_list(repo_baseurl):
if "://" not in i:
i = "file://%s" % os.path.abspath(i)
cmd.append(i)
return cmd

200
tests/test_buildinstall.py
View File

@ -473,70 +473,6 @@ class TestBuildinstallPhase(PungiTestCase):
],
)
@mock.patch("pungi.phases.buildinstall.ThreadPool")
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
@mock.patch("pungi.phases.buildinstall.get_volid")
def test_starts_threads_for_each_cmd_with_buildinstall(
self, get_volid, loraxCls, poolCls
):
compose = BuildInstallCompose(
self.topdir,
{
"bootable": True,
"release_name": "Test",
"release_short": "t",
"release_version": "1",
"buildinstall_method": "buildinstall",
"disc_types": {"dvd": "DVD"},
},
)
get_volid.return_value = "vol_id"
phase = BuildinstallPhase(compose, self._make_pkgset_phase(["p1"]))
phase.run()
# Two items added for processing in total.
pool = poolCls.return_value
self.assertEqual(2, len(pool.queue_put.mock_calls))
# Obtained correct lorax commands.
six.assertCountEqual(
self,
loraxCls.return_value.get_buildinstall_cmd.mock_calls,
[
mock.call(
"Test",
"1",
"1",
[self.topdir + "/work/x86_64/repo/p1"],
self.topdir + "/work/x86_64/buildinstall",
buildarch="x86_64",
is_final=True,
volid="vol_id",
),
mock.call(
"Test",
"1",
"1",
[self.topdir + "/work/amd64/repo/p1"],
self.topdir + "/work/amd64/buildinstall",
buildarch="amd64",
is_final=True,
volid="vol_id",
),
],
)
six.assertCountEqual(
self,
get_volid.mock_calls,
[
mock.call(compose, "x86_64", disc_type="DVD"),
mock.call(compose, "amd64", disc_type="DVD"),
],
)
@mock.patch("pungi.phases.buildinstall.get_file")
@mock.patch("pungi.phases.buildinstall.ThreadPool")
@mock.patch("pungi.phases.buildinstall.LoraxWrapper")
@ -1400,142 +1336,6 @@ class BuildinstallThreadTestCase(PungiTestCase):
],
)
@mock.patch("pungi.phases.buildinstall.link_boot_iso")
@mock.patch("pungi.phases.buildinstall.tweak_buildinstall")
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
@mock.patch("pungi.phases.buildinstall.run")
def test_buildinstall_thread_with_buildinstall_in_runroot(
self, run, get_buildroot_rpms, KojiWrapperMock, mock_tweak, mock_link
):
compose = BuildInstallCompose(
self.topdir,
{
"buildinstall_method": "buildinstall",
"runroot_tag": "rrt",
"koji_profile": "koji",
"koji_cache": "/tmp",
},
)
get_buildroot_rpms.return_value = ["bash", "zsh"]
get_runroot_cmd = KojiWrapperMock.return_value.get_runroot_cmd
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
run_runroot_cmd.return_value = {
"output": "Foo bar baz",
"retcode": 0,
"task_id": 1234,
}
t = BuildinstallThread(self.pool)
with mock.patch("time.sleep"):
pkgset_phase = self._make_pkgset_phase(["p1"])
t.process((compose, "amd64", None, self.cmd, pkgset_phase), 0)
destdir = os.path.join(self.topdir, "work/amd64/buildinstall")
self.assertEqual(
get_runroot_cmd.mock_calls,
[
mock.call(
"rrt",
"amd64",
self.cmd,
channel=None,
use_shell=True,
packages=["anaconda"],
mounts=[self.topdir],
weight=None,
chown_paths=[destdir],
)
],
)
self.assertEqual(
run_runroot_cmd.mock_calls,
[
mock.call(
get_runroot_cmd.return_value,
log_file=self.topdir + "/logs/amd64/buildinstall.amd64.log",
)
],
)
with open(self.topdir + "/logs/amd64/buildinstall-RPMs.amd64.log") as f:
rpms = f.read().strip().split("\n")
six.assertCountEqual(self, rpms, ["bash", "zsh"])
six.assertCountEqual(self, self.pool.finished_tasks, [(None, "amd64")])
six.assertCountEqual(
self,
mock_tweak.call_args_list,
[
mock.call(
compose,
destdir,
os.path.join(self.topdir, "compose", var, "amd64/os"),
"amd64",
var,
"",
"dummy-volid",
self.pool.kickstart_file,
)
for var in ["Client", "Server"]
],
)
six.assertCountEqual(
self,
mock_link.call_args_list,
[
mock.call(compose, "amd64", compose.variants["Client"], False),
mock.call(compose, "amd64", compose.variants["Server"], False),
],
)
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
@mock.patch("pungi.phases.buildinstall.run")
def test_buildinstall_fail_exit_code(
self, run, get_buildroot_rpms, KojiWrapperMock
):
compose = BuildInstallCompose(
self.topdir,
{
"buildinstall_method": "buildinstall",
"runroot_tag": "rrt",
"koji_profile": "koji",
"koji_cache": "/tmp",
"failable_deliverables": [("^.+$", {"*": ["buildinstall"]})],
},
)
get_buildroot_rpms.return_value = ["bash", "zsh"]
run_runroot_cmd = KojiWrapperMock.return_value.run_runroot_cmd
run_runroot_cmd.return_value = {
"output": "Foo bar baz",
"retcode": 1,
"task_id": 1234,
}
t = BuildinstallThread(self.pool)
with mock.patch("time.sleep"):
pkgset_phase = self._make_pkgset_phase(["p1"])
t.process((compose, "x86_64", None, self.cmd, pkgset_phase), 0)
compose._logger.error.assert_has_calls(
[
mock.call(
"[FAIL] Buildinstall (variant None, arch x86_64) failed, but going on anyway." # noqa: E501
),
mock.call(
"Runroot task failed: 1234. See %s/logs/x86_64/buildinstall.x86_64.log for more details." # noqa: E501
% self.topdir
),
]
)
self.assertEqual(self.pool.finished_tasks, set())
@mock.patch("pungi.wrappers.kojiwrapper.KojiWrapper")
@mock.patch("pungi.wrappers.kojiwrapper.get_buildroot_rpms")
@mock.patch("pungi.phases.buildinstall.run")

16
tests/test_config.py
View File

@ -223,22 +223,6 @@ class BuildinstallConfigTestCase(ConfigTestCase):
self.assertValidation(cfg, [])
def test_buildinstall_with_lorax_options(self):
cfg = load_config(
PKGSET_REPOS,
buildinstall_method="buildinstall",
lorax_options=[("^Server$", {})],
)
self.assertValidation(
cfg,
[
checks.CONFLICTS.format(
"buildinstall_method", "buildinstall", "lorax_options"
)
],
)
def test_lorax_with_lorax_options(self):
cfg = load_config(PKGSET_REPOS, buildinstall_method="lorax", lorax_options=[])

52
tests/test_createiso_script.py
View File

@ -267,58 +267,6 @@ class CreateIsoScriptTest(helpers.PungiTestCase):
]
)
def test_bootable_run_buildinstall(self):
createiso.write_script(
createiso.CreateIsoOpts(
output_dir=self.outdir,
iso_name="DP-1.0-20160405.t.3-ppc64.iso",
volid="DP-1.0-20160405.t.3",
graft_points="graft-list",
arch="ppc64",
buildinstall_method="buildinstall",
),
self.out,
)
self.assertScript(
[
" ".join(
[
"/usr/bin/genisoimage",
"-untranslated-filenames",
"-volid",
"DP-1.0-20160405.t.3",
"-J",
"-joliet-long",
"-rational-rock",
"-translation-table",
"-x",
"./lost+found",
"-part",
"-hfs",
"-r",
"-l",
"-sysid",
"PPC",
"-no-desktop",
"-allow-multidot",
"-chrp-boot",
"-map",
"/usr/lib/anaconda-runtime/boot/mapping",
"-hfs-bless",
"/ppc/mac",
"-o",
"DP-1.0-20160405.t.3-ppc64.iso",
"-graft-points",
"-path-list",
"graft-list",
]
),
" ".join(["/usr/bin/implantisomd5", "DP-1.0-20160405.t.3-ppc64.iso"]),
"isoinfo -R -f -i DP-1.0-20160405.t.3-ppc64.iso | grep -v '/TRANS.TBL$' | sort >> DP-1.0-20160405.t.3-ppc64.iso.manifest", # noqa: E501
]
)
@mock.patch("sys.stderr")
@mock.patch("kobo.shortcuts.run")
def test_run_with_jigdo_bad_args(self, run, stderr):