forked from Mirror/pmbootstrap
185973fd97
With this code path, pmbootstrap would start a distccd + sshd in the native chroot, and configure it so it runs the cross compiler. The foreign arch chroots would then call this cross compiler from localhost by calling the distcc client instead of gcc. This code has been obsoleted by the much simpler crossdirect in 2019. Let's finally remove it. Fixes: issue 2179 Reviewed-by: Luca Weiss <luca@z3ntu.xyz> Reviewed-by: Clayton Craft <clayton@craftyguy.net> Link: https://lists.sr.ht/~postmarketos/pmbootstrap-devel/%3C20230613161437.570196-4-ollieparanoid@postmarketos.org%3E
480 lines
17 KiB
Python
480 lines
17 KiB
Python
# Copyright 2023 Oliver Smith
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
""" Tests all functions from pmb.build._package """
|
|
import datetime
|
|
import glob
|
|
import os
|
|
import pytest
|
|
import shutil
|
|
import sys
|
|
|
|
import pmb_test # noqa
|
|
import pmb.build
|
|
import pmb.build._package
|
|
import pmb.config
|
|
import pmb.config.init
|
|
import pmb.helpers.logging
|
|
|
|
|
|
@pytest.fixture
|
|
def args(tmpdir, request):
|
|
import pmb.parse
|
|
sys.argv = ["pmbootstrap", "init"]
|
|
args = pmb.parse.arguments()
|
|
args.log = args.work + "/log_testsuite.txt"
|
|
pmb.helpers.logging.init(args)
|
|
request.addfinalizer(pmb.helpers.logging.logfd.close)
|
|
return args
|
|
|
|
|
|
def return_none(*args, **kwargs):
|
|
return None
|
|
|
|
|
|
def return_string(*args, **kwargs):
|
|
return "some/random/path.apk"
|
|
|
|
|
|
def return_true(*args, **kwargs):
|
|
return True
|
|
|
|
|
|
def return_false(*args, **kwargs):
|
|
return False
|
|
|
|
|
|
def return_fake_build_depends(*args, **kwargs):
|
|
"""
|
|
Fake return value for pmb.build._package.build_depends:
|
|
depends: ["alpine-base"], depends_built: []
|
|
"""
|
|
return (["alpine-base"], [])
|
|
|
|
|
|
def args_patched(monkeypatch, argv):
|
|
monkeypatch.setattr(sys, "argv", argv)
|
|
return pmb.parse.arguments()
|
|
|
|
|
|
def test_skip_already_built():
|
|
func = pmb.build._package.skip_already_built
|
|
assert pmb.helpers.other.cache["built"] == {}
|
|
assert func("test-package", "armhf") is False
|
|
assert pmb.helpers.other.cache["built"] == {"armhf": ["test-package"]}
|
|
assert func("test-package", "armhf") is True
|
|
|
|
|
|
def test_get_apkbuild(args):
|
|
func = pmb.build._package.get_apkbuild
|
|
|
|
# Valid aport
|
|
pkgname = "postmarketos-base"
|
|
assert func(args, pkgname, "x86_64")["pkgname"] == pkgname
|
|
|
|
# Valid binary package
|
|
assert func(args, "alpine-base", "x86_64") is None
|
|
|
|
# Invalid package
|
|
with pytest.raises(RuntimeError) as e:
|
|
func(args, "invalid-package-name", "x86_64")
|
|
assert "Could not find" in str(e.value)
|
|
|
|
|
|
def test_check_build_for_arch(monkeypatch, args):
|
|
# Fake APKBUILD data
|
|
apkbuild = {"pkgname": "testpkgname"}
|
|
|
|
def fake_helpers_pmaports_get(args, pkgname):
|
|
return apkbuild
|
|
monkeypatch.setattr(pmb.helpers.pmaports, "get", fake_helpers_pmaports_get)
|
|
|
|
# pmaport with arch exists
|
|
func = pmb.build._package.check_build_for_arch
|
|
apkbuild["arch"] = ["armhf"]
|
|
assert func(args, "testpkgname", "armhf") is True
|
|
apkbuild["arch"] = ["noarch"]
|
|
assert func(args, "testpkgname", "armhf") is True
|
|
apkbuild["arch"] = ["all"]
|
|
assert func(args, "testpkgname", "armhf") is True
|
|
|
|
# No binary package exists and can't build it
|
|
apkbuild["arch"] = ["x86_64"]
|
|
with pytest.raises(RuntimeError) as e:
|
|
func(args, "testpkgname", "armhf")
|
|
assert "Can't build" in str(e.value)
|
|
|
|
# pmaport can't be built for x86_64, but binary package exists in Alpine
|
|
apkbuild = {"pkgname": "mesa",
|
|
"arch": "armhf",
|
|
"pkgver": "9999",
|
|
"pkgrel": "0"}
|
|
assert func(args, "mesa", "x86_64") is False
|
|
|
|
|
|
def test_get_depends(monkeypatch):
|
|
func = pmb.build._package.get_depends
|
|
apkbuild = {"pkgname": "test", "depends": ["a"], "makedepends": ["c", "b"],
|
|
"checkdepends": "e", "subpackages": {"d": None}, "options": []}
|
|
|
|
# Depends + makedepends
|
|
args = args_patched(monkeypatch, ["pmbootstrap", "build", "test"])
|
|
assert func(args, apkbuild) == ["a", "b", "c", "e"]
|
|
args = args_patched(monkeypatch, ["pmbootstrap", "install"])
|
|
assert func(args, apkbuild) == ["a", "b", "c", "e"]
|
|
|
|
# Ignore depends (-i)
|
|
args = args_patched(monkeypatch, ["pmbootstrap", "build", "-i", "test"])
|
|
assert func(args, apkbuild) == ["b", "c", "e"]
|
|
|
|
# Package depends on its own subpackage
|
|
apkbuild["makedepends"] = ["d"]
|
|
args = args_patched(monkeypatch, ["pmbootstrap", "build", "test"])
|
|
assert func(args, apkbuild) == ["a", "e"]
|
|
|
|
# Package depends on itself
|
|
apkbuild["makedepends"] = ["c", "b", "test"]
|
|
args = args_patched(monkeypatch, ["pmbootstrap", "build", "test"])
|
|
assert func(args, apkbuild) == ["a", "b", "c", "e"]
|
|
|
|
|
|
def test_build_depends(args, monkeypatch):
|
|
# Shortcut and fake apkbuild
|
|
func = pmb.build._package.build_depends
|
|
apkbuild = {"pkgname": "test", "depends": ["a", "!c"],
|
|
"makedepends": ["b"], "checkdepends": [],
|
|
"subpackages": {"d": None}, "options": []}
|
|
|
|
# No depends built (first makedepends + depends, then only makedepends)
|
|
monkeypatch.setattr(pmb.build._package, "package", return_none)
|
|
assert func(args, apkbuild, "armhf", True) == (["!c", "a", "b"], [])
|
|
|
|
# All depends built (makedepends only)
|
|
monkeypatch.setattr(pmb.build._package, "package", return_string)
|
|
assert func(args, apkbuild, "armhf", False) == (["!c", "a", "b"],
|
|
["a", "b"])
|
|
|
|
|
|
def test_build_depends_no_binary_error(args, monkeypatch):
|
|
# Shortcut and fake apkbuild
|
|
func = pmb.build._package.build_depends
|
|
apkbuild = {"pkgname": "test", "depends": ["some-invalid-package-here"],
|
|
"makedepends": [], "checkdepends": [], "subpackages": {},
|
|
"options": []}
|
|
|
|
# pmbootstrap build --no-depends
|
|
args.no_depends = True
|
|
|
|
# Missing binary package error
|
|
with pytest.raises(RuntimeError) as e:
|
|
func(args, apkbuild, "armhf", True)
|
|
assert str(e.value).startswith("Missing binary package for dependency")
|
|
|
|
# All depends exist
|
|
apkbuild["depends"] = ["alpine-base"]
|
|
assert func(args, apkbuild, "armhf", True) == (["alpine-base"], [])
|
|
|
|
|
|
def test_build_depends_binary_outdated(args, monkeypatch):
|
|
""" pmbootstrap runs with --no-depends and dependency binary package is
|
|
outdated (#1895) """
|
|
# Override pmb.parse.apkindex.package(): pretend hello-world is missing
|
|
# and binutils-aarch64 is outdated
|
|
func_orig = pmb.parse.apkindex.package
|
|
|
|
def func_patch(args, package, *args2, **kwargs):
|
|
print(f"func_patch: called for package: {package}")
|
|
if package == "hello-world":
|
|
print("pretending that it does not exist")
|
|
return None
|
|
if package == "binutils-aarch64":
|
|
print("pretending that it is outdated")
|
|
ret = func_orig(args, package, *args2, **kwargs)
|
|
ret["version"] = "0-r0"
|
|
return ret
|
|
return func_orig(args, package, *args2, **kwargs)
|
|
monkeypatch.setattr(pmb.parse.apkindex, "package", func_patch)
|
|
|
|
# Build hello-world with --no-depends and expect failure
|
|
args.no_depends = True
|
|
pkgname = "hello-world"
|
|
arch = "aarch64"
|
|
force = False
|
|
strict = True
|
|
with pytest.raises(RuntimeError) as e:
|
|
pmb.build.package(args, pkgname, arch, force, strict)
|
|
assert "'binutils-aarch64' of 'gcc-aarch64' is outdated" in str(e.value)
|
|
|
|
|
|
def test_is_necessary_warn_depends(args, monkeypatch):
|
|
# Shortcut and fake apkbuild
|
|
func = pmb.build._package.is_necessary_warn_depends
|
|
apkbuild = {"pkgname": "test"}
|
|
|
|
# Necessary
|
|
monkeypatch.setattr(pmb.build, "is_necessary", return_true)
|
|
assert func(args, apkbuild, "armhf", False, []) is True
|
|
|
|
# Necessary (strict=True overrides is_necessary())
|
|
monkeypatch.setattr(pmb.build, "is_necessary", return_false)
|
|
assert func(args, apkbuild, "armhf", True, []) is True
|
|
|
|
# Not necessary (with depends: different code path that prints a warning)
|
|
assert func(args, apkbuild, "armhf", False, []) is False
|
|
assert func(args, apkbuild, "armhf", False, ["first", "second"]) is False
|
|
|
|
|
|
def test_init_buildenv(args, monkeypatch):
|
|
# First init native chroot buildenv properly without patched functions
|
|
pmb.build.init(args)
|
|
|
|
# Disable effects of functions we don't want to test here
|
|
monkeypatch.setattr(pmb.build._package, "build_depends",
|
|
return_fake_build_depends)
|
|
monkeypatch.setattr(pmb.build._package, "is_necessary_warn_depends",
|
|
return_true)
|
|
monkeypatch.setattr(pmb.chroot.apk, "install", return_none)
|
|
|
|
# Shortcut and fake apkbuild
|
|
func = pmb.build._package.init_buildenv
|
|
apkbuild = {"pkgname": "test", "depends": ["a"], "makedepends": ["b"],
|
|
"options": []}
|
|
|
|
# Build is necessary (various code paths)
|
|
assert func(args, apkbuild, "armhf", strict=True) is True
|
|
assert func(args, apkbuild, "armhf", cross="native") is True
|
|
|
|
# Build is not necessary (only builds dependencies)
|
|
monkeypatch.setattr(pmb.build._package, "is_necessary_warn_depends",
|
|
return_false)
|
|
assert func(args, apkbuild, "armhf") is False
|
|
|
|
|
|
def test_get_pkgver(monkeypatch):
|
|
# With original source
|
|
func = pmb.build._package.get_pkgver
|
|
assert func("1.0", True) == "1.0"
|
|
|
|
# Without original source
|
|
now = datetime.date(2018, 1, 1)
|
|
assert func("1.0", False, now) == "1.0_p20180101000000"
|
|
assert func("1.0_git20170101", False, now) == "1.0_p20180101000000"
|
|
|
|
|
|
def test_run_abuild(args, monkeypatch):
|
|
# Disable effects of functions we don't want to test here
|
|
monkeypatch.setattr(pmb.build, "copy_to_buildpath", return_none)
|
|
monkeypatch.setattr(pmb.chroot, "user", return_none)
|
|
|
|
# Shortcut and fake apkbuild
|
|
func = pmb.build._package.run_abuild
|
|
apkbuild = {"pkgname": "test", "pkgver": "1", "pkgrel": "2", "options": []}
|
|
|
|
# Normal run
|
|
output = "armhf/test-1-r2.apk"
|
|
env = {"CARCH": "armhf",
|
|
"GOCACHE": "/home/pmos/.cache/go-build",
|
|
"SUDO_APK": "abuild-apk --no-progress"}
|
|
cmd = ["abuild", "-D", "postmarketOS", "-d"]
|
|
assert func(args, apkbuild, "armhf") == (output, cmd, env)
|
|
|
|
# Force and strict
|
|
cmd = ["abuild", "-D", "postmarketOS", "-r", "-f"]
|
|
assert func(args, apkbuild, "armhf", True, True) == (output, cmd, env)
|
|
|
|
# cross=native
|
|
env = {"CARCH": "armhf",
|
|
"GOCACHE": "/home/pmos/.cache/go-build",
|
|
"SUDO_APK": "abuild-apk --no-progress",
|
|
"CROSS_COMPILE": "armv6-alpine-linux-musleabihf-",
|
|
"CC": "armv6-alpine-linux-musleabihf-gcc"}
|
|
cmd = ["abuild", "-D", "postmarketOS", "-d"]
|
|
assert func(args, apkbuild, "armhf", cross="native") == (output, cmd, env)
|
|
|
|
|
|
def test_finish(args, monkeypatch):
|
|
# Real output path
|
|
output = pmb.build.package(args, "hello-world", force=True)
|
|
|
|
# Disable effects of functions we don't want to test below
|
|
monkeypatch.setattr(pmb.chroot, "user", return_none)
|
|
|
|
# Shortcut and fake apkbuild
|
|
func = pmb.build._package.finish
|
|
apkbuild = {"options": []}
|
|
|
|
# Non-existing output path
|
|
with pytest.raises(RuntimeError) as e:
|
|
func(args, apkbuild, "armhf", "/invalid/path")
|
|
assert "Package not found" in str(e.value)
|
|
|
|
# Existing output path
|
|
func(args, apkbuild, pmb.config.arch_native, output)
|
|
|
|
|
|
def test_package(args):
|
|
# First build
|
|
assert pmb.build.package(args, "hello-world", force=True)
|
|
|
|
# Package exists
|
|
pmb.helpers.other.cache["built"] = {}
|
|
assert pmb.build.package(args, "hello-world") is None
|
|
|
|
# Force building again
|
|
pmb.helpers.other.cache["built"] = {}
|
|
assert pmb.build.package(args, "hello-world", force=True)
|
|
|
|
# Build for another architecture
|
|
assert pmb.build.package(args, "hello-world", "armhf", force=True)
|
|
|
|
# Upstream package, for which we don't have an aport
|
|
assert pmb.build.package(args, "alpine-base") is None
|
|
|
|
|
|
def test_build_depends_high_level(args, monkeypatch):
|
|
"""
|
|
"hello-world-wrapper" depends on "hello-world". We build both, then delete
|
|
"hello-world" and check that it gets rebuilt correctly again.
|
|
"""
|
|
# Patch pmb.build.is_necessary() to always build the hello-world package
|
|
def fake_build_is_necessary(args, arch, apkbuild, apkindex_path=None):
|
|
if apkbuild["pkgname"] == "hello-world":
|
|
return True
|
|
return pmb.build.other.is_necessary(args, arch, apkbuild,
|
|
apkindex_path)
|
|
monkeypatch.setattr(pmb.build, "is_necessary",
|
|
fake_build_is_necessary)
|
|
|
|
# Build hello-world to get its full output path
|
|
channel = pmb.config.pmaports.read_config(args)["channel"]
|
|
output_hello = pmb.build.package(args, "hello-world")
|
|
output_hello_outside = f"{args.work}/packages/{channel}/{output_hello}"
|
|
assert os.path.exists(output_hello_outside)
|
|
|
|
# Make sure the wrapper exists
|
|
pmb.build.package(args, "hello-world-wrapper")
|
|
|
|
# Remove hello-world
|
|
pmb.helpers.run.root(args, ["rm", output_hello_outside])
|
|
pmb.build.index_repo(args, pmb.config.arch_native)
|
|
pmb.helpers.other.cache["built"] = {}
|
|
|
|
# Ask to build the wrapper. It should not build the wrapper (it exists, not
|
|
# using force), but build/update its missing dependency "hello-world"
|
|
# instead.
|
|
assert pmb.build.package(args, "hello-world-wrapper") is None
|
|
assert os.path.exists(output_hello_outside)
|
|
|
|
|
|
def test_build_local_source_high_level(args, tmpdir):
|
|
"""
|
|
Test building a package with overriding the source code:
|
|
pmbootstrap build --src=/some/path hello-world
|
|
|
|
We use a copy of the hello-world APKBUILD here that doesn't have the
|
|
source files it needs to build included. And we use the original aport
|
|
folder as local source folder, so pmbootstrap should take the source files
|
|
from there and the build should succeed.
|
|
"""
|
|
# aports: Add deviceinfo (required by pmbootstrap to start)
|
|
tmpdir = str(tmpdir)
|
|
aports = tmpdir + "/aports"
|
|
aport = aports + "/device/testing/device-" + args.device
|
|
os.makedirs(aport)
|
|
path_original = pmb.helpers.pmaports.find(args, f"device-{args.device}")
|
|
shutil.copy(f"{path_original}/deviceinfo", aport)
|
|
|
|
# aports: Add modified hello-world aport (source="", uses $builddir)
|
|
aport = aports + "/main/hello-world"
|
|
os.makedirs(aport)
|
|
shutil.copy(pmb.config.pmb_src + "/test/testdata/build_local_src/APKBUILD",
|
|
aport)
|
|
|
|
# aports: Add pmaports.cfg, .git
|
|
shutil.copy(args.aports + "/pmaports.cfg", aports)
|
|
shutil.copytree(args.aports + "/.git", aports + "/.git")
|
|
|
|
# src: Copy hello-world source files
|
|
src = tmpdir + "/src"
|
|
os.makedirs(src)
|
|
shutil.copy(args.aports + "/main/hello-world/Makefile", src)
|
|
shutil.copy(args.aports + "/main/hello-world/main.c", src)
|
|
|
|
# src: Create unreadable file (rsync should skip it)
|
|
unreadable = src + "/_unreadable_file"
|
|
shutil.copy(args.aports + "/main/hello-world/main.c", unreadable)
|
|
pmb.helpers.run.root(args, ["chown", "root:root", unreadable])
|
|
pmb.helpers.run.root(args, ["chmod", "500", unreadable])
|
|
|
|
# Test native arch and foreign arch chroot
|
|
channel = pmb.config.pmaports.read_config(args)["channel"]
|
|
for arch in [pmb.config.arch_native, "armhf"]:
|
|
# Delete all hello-world --src packages
|
|
pattern = f"{args.work}/packages/{channel}/{arch}/hello-world-*_p*.apk"
|
|
for path in glob.glob(pattern):
|
|
pmb.helpers.run.root(args, ["rm", path])
|
|
assert len(glob.glob(pattern)) == 0
|
|
|
|
# Build hello-world --src package
|
|
pmb.helpers.run.user(args, [pmb.config.pmb_src + "/pmbootstrap.py",
|
|
"--aports", aports, "build", "--src", src,
|
|
"hello-world", "--arch", arch])
|
|
|
|
# Verify that the package has been built and delete it
|
|
paths = glob.glob(pattern)
|
|
assert len(paths) == 1
|
|
pmb.helpers.run.root(args, ["rm", paths[0]])
|
|
|
|
# Clean up: update index, delete temp folder
|
|
pmb.build.index_repo(args, pmb.config.arch_native)
|
|
pmb.helpers.run.root(args, ["rm", "-r", tmpdir])
|
|
|
|
|
|
def test_build_abuild_leftovers(args, tmpdir):
|
|
"""
|
|
Test building a package with having abuild leftovers, that will error if
|
|
copied:
|
|
pmbootstrap build hello-world
|
|
"""
|
|
# aports: Add deviceinfo (required by pmbootstrap to start)
|
|
tmpdir = str(tmpdir)
|
|
aports = f"{tmpdir}/aports"
|
|
aport = f"{aports}/device/testing/device-{args.device}"
|
|
os.makedirs(aport)
|
|
path_original = pmb.helpers.pmaports.find(args, f"device-{args.device}")
|
|
shutil.copy(f"{path_original}/deviceinfo", aport)
|
|
|
|
# aports: Add modified hello-world aport (source="", uses $builddir)
|
|
test_aport = "main/hello-world"
|
|
aport = f"{aports}/{test_aport}"
|
|
shutil.copytree(f"{args.aports}/{test_aport}", aport)
|
|
|
|
# aports: Add pmaports.cfg, .git
|
|
shutil.copy(f"{args.aports}/pmaports.cfg", aports)
|
|
shutil.copytree(f"{args.aports}/.git", f"{aports}/.git")
|
|
|
|
# aport: create abuild dir with broken symlink
|
|
src = f"{aport}/src"
|
|
os.makedirs(src)
|
|
os.symlink("/var/cache/distfiles/non-existent.tar.gz",
|
|
f"{src}/broken-tarball-symlink.tar.gz")
|
|
|
|
# Delete all hello-world packages
|
|
channel = pmb.config.pmaports.read_config(args)["channel"]
|
|
pattern = f"{args.work}/packages/{channel}/*/hello-world-*_p*.apk"
|
|
for path in glob.glob(pattern):
|
|
pmb.helpers.run.root(args, ["rm", path])
|
|
assert len(glob.glob(pattern)) == 0
|
|
|
|
# Build hello-world package
|
|
pmb.helpers.run.user(args, [f"{pmb.config.pmb_src}/pmbootstrap.py",
|
|
"--aports", aports, "build", "--src", src,
|
|
"hello-world", "--arch", pmb.config.arch_native])
|
|
|
|
# Verify that the package has been built and delete it
|
|
paths = glob.glob(pattern)
|
|
assert len(paths) == 1
|
|
pmb.helpers.run.root(args, ["rm", paths[0]])
|
|
|
|
# Clean up: update index, delete temp folder
|
|
pmb.build.index_repo(args, pmb.config.arch_native)
|
|
pmb.helpers.run.root(args, ["rm", "-r", tmpdir])
|