taler-deployment

generic (7646B)

---

 #!/usr/bin/env python3
 # This file is in the public domain.
 # Helper script to build the latest DEB packages in the container.
 
 import os
 import sys
 import subprocess
 import glob
 import shutil
 import shlex
 
 def run_cmd(cmd, shell=False, cwd=None, env=None):
     """Helper to run commands and exit on failure (mimicking set -e)."""
     # If specific env vars are passed, update the current env, otherwise use current
     command_env = os.environ.copy()
     if env:
         command_env.update(env)
     
     # Flush stdout so logs appear in order
     sys.stdout.flush()
     
     subprocess.check_call(cmd, shell=shell, cwd=cwd, env=command_env)
 
 def get_output(cmd, shell=False, cwd=None):
     """Helper to get command output as string."""
     return subprocess.check_output(cmd, shell=shell, cwd=cwd, text=True).strip()
 
 def make_version(deb_version, build_codename):
     if "-" in deb_version:
         # We already have a dash, thus a debian version.
         # Append out build_codename to that.
         return f"{deb_version}+{build_codename}"
     # We don't have a debian version yet, start at zero, because by convention,
     # real / manually created debian release versions start at 1.
     return f"{deb_version}-0+{build_codename}"
 
 
 def main():
     if 'LD_LIBRARY_PATH' in os.environ:
         del os.environ['LD_LIBRARY_PATH']
 
     # Arguments
     if len(sys.argv) < 3:
         print("Usage: script.py <PACKAGE> <CODENAME> <ARCH>", file=sys.stderr)
         sys.exit(1)
 
     PACKAGE = sys.argv[1]
     CODENAME = sys.argv[2]
     ARCH = sys.argv[3]
 
     # Path of the debian/ folder in the repository
     DEBIANPATH = ""
     debpath_file = f"/buildconfig/{PACKAGE}.debpath"
     if os.path.exists(debpath_file):
         with open(debpath_file, 'r') as f:
             DEBIANPATH = f.read().strip()
 
     print(f"Building {PACKAGE} with generic build logic", file=sys.stderr)
 
     with open(f"/buildconfig/{PACKAGE}.tag", 'r') as f:
         TAG = f.read().strip()
 
     # 1. Setup Local Repo
     os.chdir("/pkgdir")
     # Using shell=True here to easily handle the pipe logic
     run_cmd("dpkg-scanpackages . | xz - > /pkgdir/Packages.xz", shell=True)
     
     with open("/etc/apt/sources.list.d/taler-packaging-local.list", "w") as f:
         f.write("deb [trusted=yes] file:/pkgdir ./\n")
     
     run_cmd(["apt-get", "update"])
 
     # 2. Prepare Build Directory
     if not os.path.exists("/build"):
         os.makedirs("/build")
     os.chdir("/build")
 
     with open(f"/buildconfig/{PACKAGE}.giturl", 'r') as f:
         GITURL = f.read().strip()
 
     run_cmd(["git", "config", "--global", "advice.detachedHead", "false"])
     run_cmd(["git", "clone", "--depth=1", f"--branch={TAG}", GITURL, PACKAGE])
 
     build_pkg_path = os.path.join("/build", PACKAGE, DEBIANPATH)
     os.chdir(build_pkg_path)
 
     # Get current version
     DEB_VERSION = get_output(["dpkg-parsechangelog", "-S", "Version"])
     print(f"Current version of {PACKAGE}/{DEBIANPATH} is {DEB_VERSION}")
 
     # 3. Bootstrap and Install Deps
     os.chdir(os.path.join("/build", PACKAGE))
     run_cmd(["./bootstrap"])
 
     os.chdir(build_pkg_path)
 
     # Install build-time dependencies
     # Note: Passing the tool command as a single string because it contains spaces/options
     tool_cmd = "apt-get -o Debug::pkgProblemResolver=yes --no-install-recommends --yes"
     run_cmd(["mk-build-deps", "--install", f"--tool={tool_cmd}", "debian/control"])
 
     # Sparse checkout hint
     with open(".version", "w") as f:
         f.write(f"{DEB_VERSION}\n")
 
     # 4. Configure Environment for Build
     deb_dbg_repo = "debian/.debhelper/"
     os.environ["DEB_DBG_SYMBOLS_REPO"] = deb_dbg_repo
     os.makedirs(deb_dbg_repo, exist_ok=True)
     
     # touch command
     open(os.path.join(deb_dbg_repo, "debian-symbols-pool"), 'a').close()
     
     os.environ["DEB_BUILD_MAINT_OPTIONS"] = "debug"
 
     # Add a codename-specific tag to the package.
     # We need this tag as reprepro doesn't support multiple packages (even for
     # different codenames like trixie/bookworm) per repo.
     # Examples of how it should work:
     # 1.2.3 => 1.2.3-0~trixie
     # 1.2.3-2 => 1.2.3-2~trixie
     # What we must not do:
     # WRONG: 1.2.3 => 1.2.3~trixie
     # Because 1.2.3~trixie <= 1.2.3, version requirements in dependencies would
     # not work.
 
     out_deb_version = make_version(DEB_VERSION, CODENAME)
 
     print(f"Building {PACKAGE} as version {out_deb_version}", file=sys.stderr)
 
     # Add distro/codename specific version trailer
     if CODENAME:
         env_vars = {
             "DEBEMAIL": "deb@taler.net",
             "NAME": "Taler Packaging Team"
         }
         run_cmd([
             "dch", "-b",
             "--distribution", "unstable",
             "--newversion", out_deb_version,
             f"Build for {CODENAME}"
         ], env=env_vars)
 
     # 5. Build Package
     run_cmd(["dpkg-buildpackage", "-rfakeroot", "-b", "-uc", "-us"])
 
     # Copy artifacts
     # Globs for ../*.deb and ../*.ddeb relative to current dir
     deb_files = glob.glob("../*.deb")
     ddeb_files = glob.glob("../*.ddeb")
 
     for f in deb_files:
         shutil.copy(f, "/pkgdir/")
     
     for f in ddeb_files:
         shutil.copy(f, "/pkgdir/")
 
     # Save built filenames
     built_current_path = f"/pkgdir/{PACKAGE}@{ARCH}.built.current"
     with open(built_current_path, 'w') as f:
         for deb in deb_files:
             f.write(os.path.basename(deb) + "\n")
         for ddeb in ddeb_files:
             f.write(os.path.basename(ddeb) + "\n")
 
     # 6. Testing
     # Re-scan
     os.chdir("/pkgdir")
     run_cmd("dpkg-scanpackages . | xz - > /pkgdir/Packages.xz", shell=True)
     
     with open("/etc/apt/sources.list.d/taler-packaging-local.list", "w") as f:
         f.write("deb [trusted=yes] file:/pkgdir ./\n")
         
     run_cmd(["apt-get", "update"])
 
     print(f"Installing built packages from {build_pkg_path}/..", file=sys.stderr)
 
     # Since we are in /pkgdir, and files were copied there, we glob current dir.
     pkgdir_debs = glob.glob(f"{build_pkg_path}/../*.deb")
     if pkgdir_debs:
         run_cmd(["apt", "install", "-y"] + pkgdir_debs)
 
     # Check Binaries
     # Iterate over original source locations (copied from logic `../*.deb`)
     # But since we are in /pkgdir now, let's use the files we just identified.
     for deb in pkgdir_debs:
         # Get contents: dpkg --contents
         contents = get_output(["dpkg", "--contents", deb])
         
         for line in contents.splitlines():
             parts = line.split()
             if len(parts) < 6: 
                 print("failed to read package contents", file=sys.stderr)
                 sys.exit(3)
             
             # dpkg --contents output format looks like:
             # drwxr-xr-x root/root 0 2023-01-01 12:00 ./usr/bin/
             fname = parts[5]
             
             if "bin" not in fname:
                 continue
                 
             # Convert to absolute path
             if fname.startswith("./"):
                 fname = fname[2:]
             if not fname.startswith("/"):
                 fname = "/" + fname
 
             # Check if ELF executable
             file_info = get_output(["file", fname])
             if "ELF" in file_info and "executable" in file_info:
                 print(f"checking {fname}")
                 try:
                     run_cmd(["ldd", fname])
                 except subprocess.CalledProcessError:
                     print(f"Installed binary {fname} has linker issue")
                     sys.exit(2)
 
     # Finalize tag
     with open(f"/pkgdir/{PACKAGE}@{ARCH}.built.tag", "w") as f:
         f.write(TAG + "\n")
 
 if __name__ == "__main__":
     main()