sandcastle-ng

sandcastle-build-generic (6757B)

---

 #!/usr/bin/env python3
 # This file is in the public domain.
 """Build one generic package or a group from one pnpm workspace."""
 
 from __future__ import annotations
 
 import json
 import os
 import shutil
 import subprocess
 import sys
 from email.utils import formatdate
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from package_config import ConfigError, load_config
 
 
 def run_cmd(cmd, shell=False, cwd=None, env=None):
     command_env = os.environ.copy()
     if env:
         command_env.update(env)
     sys.stdout.flush()
     subprocess.check_call(cmd, shell=shell, cwd=cwd, env=command_env)
 
 
 def get_tag_debver(tag):
     if tag.startswith("v"):
         devsuff = "-dev."
         position = tag.find(devsuff)
         if position < 0:
             return tag[1:]
         return tag[1:position] + "~dev" + tag[position + len(devsuff) :]
     if tag.startswith("deb-v"):
         tag = tag[5:]
         if "-" in tag:
             version, revision = tag.split("-", 1)
             return version + "-" + revision
         return tag
     raise ValueError(f"unexpected tag format: {tag}")
 
 
 def make_codename_version(deb_version, codename):
     if "-" in deb_version:
         return f"{deb_version}+{codename}"
     return f"{deb_version}-0+{codename}"
 
 
 def scan_local_repository():
     os.chdir("/pkgdir")
     run_cmd(
         ["bash", "-o", "pipefail", "-c", "dpkg-scanpackages . /dev/null | xz - > Packages.xz"]
     )
     Path("/etc/apt/sources.list.d/taler-packaging-local.list").write_text(
         "deb [trusted=yes] file:/pkgdir ./\n", encoding="utf-8"
     )
     run_cmd(["apt-get", "update"])
 
 
 def validate_group(config, names):
     if not names or len(set(names)) != len(names):
         raise ConfigError("packages must be specified once")
     packages = []
     keys = set()
     for name in names:
         try:
             package = config.packages[name]
         except KeyError as exc:
             raise ConfigError(f"unknown package {name!r}") from exc
         repository = config.repository_for(package)
         builder = config.builder_for(package)
         keys.add((repository.url, package.tag, builder))
         packages.append(package)
     if len(keys) != 1:
         raise ConfigError("grouped packages must have the same repository, tag, and builder")
     repository_url, tag, builder = keys.pop()
     if builder == "generic" and len(packages) != 1:
         raise ConfigError("the generic builder accepts exactly one package")
     return packages, repository_url, tag, builder
 
 
 def install_build_dependencies(source_dir, package_paths):
     tool = "apt-get -o Debug::pkgProblemResolver=yes --no-install-recommends --yes"
     controls = [str(package_path / "debian" / "control") for package_path in package_paths]
     run_cmd(["mk-build-deps", "--install", f"--tool={tool}", *controls], cwd=source_dir)
 
 
 def prepare_pnpm_workspace(source_dir, package_paths):
     filters = []
     for package_path in package_paths:
         package_json = package_path / "package.json"
         with package_json.open(encoding="utf-8") as package_file:
             workspace_name = json.load(package_file).get("name")
         if not isinstance(workspace_name, str) or not workspace_name:
             raise ConfigError(f"{package_json} has no package name")
         filters.extend(["--filter", f"{workspace_name}..."])
     run_cmd(["pnpm", "install", "--frozen-lockfile", *filters], cwd=source_dir)
     run_cmd(["pnpm", "run", *filters, "build"], cwd=source_dir)
 
 
 def write_changelog(package_path, package_name, version):
     changelog = f"""\
 {package_name} ({version}) unstable; urgency=low
 
   * Release {version} (for sandcastle-ng).
 
  -- Taler Packaging Team <deb@taler.net>  {formatdate(localtime=True)}
 """
     (package_path / "debian" / "changelog").write_text(changelog, encoding="utf-8")
 
 
 def build_package(package, package_path, version, prebuilt):
     write_changelog(package_path, package.name, version)
     debug_repository = package_path / "debian" / ".debhelper"
     debug_repository.mkdir(parents=True, exist_ok=True)
     (debug_repository / "debian-symbols-pool").touch()
     environment = {
         "DEB_BUILD_MAINT_OPTIONS": "debug",
         "DEB_DBG_SYMBOLS_REPO": "debian/.debhelper/",
     }
     if prebuilt:
         environment["TALER_PACKAGING_PREBUILT"] = "1"
 
     output_dir = package_path.parent
     before = set(output_dir.glob("*.deb"))
     run_cmd(
         ["dpkg-buildpackage", "-rfakeroot", "-b", "-uc", "-us"],
         cwd=package_path,
         env=environment,
     )
     deb_files = sorted(set(output_dir.glob("*.deb")) - before)
     if not deb_files:
         raise RuntimeError(f"build of {package.name} produced no .deb packages")
     destination = Path("/out") / package.name
     for deb_file in deb_files:
         shutil.copy(deb_file, destination)
 
 
 def build_packages(codename, architecture, names):
     del architecture  # Package metadata determines whether outputs are arch-specific.
     os.environ.pop("LD_LIBRARY_PATH", None)
     config = load_config("/packages.toml")
     packages, repository_url, tag, builder = validate_group(config, names)
     print(f"Building {' '.join(names)} with {builder} build logic", file=sys.stderr)
 
     scan_local_repository()
     source_dir = Path("/build/source")
     source_dir.parent.mkdir(parents=True, exist_ok=True)
     run_cmd(["git", "config", "--global", "advice.detachedHead", "false"])
     run_cmd(
         ["git", "clone", "--depth=1", f"--branch={tag}", repository_url, str(source_dir)]
     )
     run_cmd(["./bootstrap"], cwd=source_dir)
 
     version = make_codename_version(get_tag_debver(tag), codename)
     package_paths = [source_dir / package.debian_path for package in packages]
     for package, package_path in zip(packages, package_paths):
         control = package_path / "debian" / "control"
         if not control.is_file():
             raise ConfigError(f"{package.name} has no debian/control at tag {tag}: {control}")
         (package_path / ".version").write_text(version + "\n", encoding="utf-8")
 
     install_build_dependencies(source_dir, package_paths)
     if builder == "pnpm-workspace":
         prepare_pnpm_workspace(source_dir, package_paths)
     for package, package_path in zip(packages, package_paths):
         build_package(package, package_path, version, builder == "pnpm-workspace")
 
 
 def main():
     if len(sys.argv) < 4:
         print(
             f"Usage: {sys.argv[0]} <CODENAME> <ARCH> <PACKAGE>...",
             file=sys.stderr,
         )
         return 1
     try:
         build_packages(sys.argv[1], sys.argv[2], sys.argv[3:])
     except ConfigError as exc:
         print(f"configuration error: {exc}", file=sys.stderr)
         return 1
     return 0
 
 
 if __name__ == "__main__":
     raise SystemExit(main())