taler-deployment

taler-repos (11656B)

---

 #!/usr/bin/env python3
 
 # This file is in the public domain.
 
 """Manage the local Taler stack and run commands in its repositories."""
 
 from __future__ import annotations
 
 import argparse
 import os
 import re
 import shlex
 import subprocess
 import sys
 from pathlib import Path
 
 ROOT = Path.cwd()
 REPOSITORIES = (
     "gnunet",
     "exchange",
     "merchant",
     "anastasis",
     "challenger",
     "donau",
     "paivana",
     "taler-mdb",
     "libeufin",
     "taler-merchant-demos",
     "taler-typescript-core",
     "taler-rust",
 )
 # Local build dependencies from taler-deployment/packaging/ng/packages.toml.
 # Keep this map embedded so no deployment checkout is needed at runtime.
 # Repositories omitted here have no dependencies within REPOSITORIES;
 # external dependencies such as libmicrohttpd must already be installed.
 BUILD_DEPENDENCIES = {
     "exchange": ("gnunet",),
     "merchant": ("gnunet", "exchange", "donau"),
     "anastasis": ("gnunet", "merchant"),
     "challenger": ("exchange",),
     "donau": ("gnunet", "exchange"),
     "paivana": ("merchant", "exchange", "gnunet"),
     "taler-mdb": ("gnunet", "exchange", "merchant"),
     "libeufin": ("taler-typescript-core",),
 }
 # The packaging tools support releases and numbered dev prereleases.
 VERSION_TAG = re.compile(
     r"v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"
     r"(?:-dev\.(0|[1-9][0-9]*))?"
 )
 
 
 class BuildError(RuntimeError):
     """A repository command or preflight check failed."""
 
 
 def capture(repo: Path, *command: str) -> str:
     try:
         result = subprocess.run(
             command,
             cwd=repo,
             check=False,
             capture_output=True,
             text=True,
         )
     except OSError as exc:
         rendered = shlex.join(command)
         raise BuildError(f"{repo.name}: could not run '{rendered}': {exc}") from exc
     if result.returncode != 0:
         detail = result.stderr.strip() or result.stdout.strip()
         rendered = shlex.join(command)
         raise BuildError(f"{repo.name}: '{rendered}' failed: {detail}")
     return result.stdout.strip()
 
 
 def run(repo: Path, *command: str) -> None:
     print(f"\n[{repo.name}] $ {shlex.join(command)}", flush=True)
     try:
         subprocess.run(command, cwd=repo, check=True)
     except subprocess.CalledProcessError as exc:
         rendered = shlex.join(command)
         raise BuildError(
             f"{repo.name}: '{rendered}' exited with status {exc.returncode}"
         ) from exc
     except OSError as exc:
         rendered = shlex.join(command)
         raise BuildError(f"{repo.name}: could not run '{rendered}': {exc}") from exc
 
 
 def repository(name: str) -> Path:
     repo = ROOT / name
     if not repo.is_dir():
         raise BuildError(f"{name}: repository directory not found at {repo}")
     top = Path(capture(repo, "git", "rev-parse", "--show-toplevel")).resolve()
     if top != repo.resolve():
         raise BuildError(f"{name}: {repo} is not a top-level Git repository")
     return repo
 
 
 def preflight(repos: list[Path]) -> None:
     problems: list[str] = []
     for repo in repos:
         try:
             capture(repo, "git", "rev-parse", "--verify", "@{upstream}")
             status = capture(
                 repo, "git", "status", "--porcelain", "--untracked-files=all"
             )
             if status:
                 problems.append(f"{repo.name}: worktree is not clean")
         except BuildError as exc:
             problems.append(str(exc))
     if problems:
         joined = "\n  - ".join(problems)
         raise BuildError(f"preflight failed:\n  - {joined}")
 
 
 def build_order() -> list[str]:
     """Order the local repositories using the embedded dependency graph."""
     for name, dependencies in BUILD_DEPENDENCIES.items():
         if name not in REPOSITORIES:
             raise BuildError(f"unknown repository in build dependencies: {name}")
         for dependency in dependencies:
             if dependency not in REPOSITORIES:
                 raise BuildError(f"{name}: unknown build dependency {dependency}")
 
     ordered: list[str] = []
     visiting: list[str] = []
 
     def visit(name: str) -> None:
         if name in ordered:
             return
         if name in visiting:
             cycle = visiting[visiting.index(name) :] + [name]
             raise BuildError(f"repository dependency cycle: {' -> '.join(cycle)}")
         visiting.append(name)
         for dependency in REPOSITORIES:
             if dependency in BUILD_DEPENDENCIES.get(name, ()):
                 visit(dependency)
         visiting.pop()
         ordered.append(name)
 
     for name in REPOSITORIES:
         visit(name)
     return ordered
 
 
 def build() -> None:
     repos = [repository(name) for name in build_order()]
     preflight(repos)
 
     print(f"Build order: {', '.join(repo.name for repo in repos)}", flush=True)
     print("Preflight passed; updating all repositories.", flush=True)
     for repo in repos:
         run(repo, "git", "pull", "--ff-only")
 
     home = Path.home()
     configure = (
         "./configure",
         f"--prefix={home / 'local'}",
         f"CFLAGS=-I{home / 'local' / 'include'}",
         f"LDFLAGS=-L{home / 'local' / 'lib64'}",
     )
     jobs = str(os.cpu_count() or 1)
 
     for repo in repos:
         run(repo, "./bootstrap")
         run(repo, *configure)
         run(repo, "make", f"-j{jobs}")
         run(repo, "make", "install")
 
 
 def foreach(command: list[str]) -> None:
     repos = [repository(name) for name in REPOSITORIES]
     for repo in repos:
         run(repo, *command)
 
 
 def versions() -> None:
     for name in REPOSITORIES:
         repo = repository(name)
         tags = capture(repo, "git", "tag", "--points-at", "HEAD").splitlines()
         version = ", ".join(sorted(tags))
         if not version:
             version = capture(repo, "git", "rev-parse", "--short=12", "HEAD")
         dirty = capture(repo, "git", "status", "--porcelain", "--untracked-files=all")
         suffix = " (dirty)" if dirty else ""
         print(f"{name:<24} {version}{suffix}")
 
 
 def next_tag(tags: list[str], dev: bool) -> str:
     """Advance the highest supported local version using SemVer precedence."""
     versions: list[tuple[int, int, int, bool, int]] = []
     for tag in tags:
         match = VERSION_TAG.fullmatch(tag)
         if match is None:
             continue
         major, minor, patch = (int(match[i]) for i in (1, 2, 3))
         prerelease = match[4]
         versions.append((major, minor, patch, prerelease is None, int(prerelease or 0)))
     if not versions:
         raise BuildError("no supported local version tag (vX.Y.Z or vX.Y.Z-dev.N)")
 
     major, minor, patch, release, number = max(versions)
     if release:
         patch += 1
         number = 0
     suffix = f"-dev.{number + 1}" if dev else ""
     return f"v{major}.{minor}.{patch}{suffix}"
 
 
 def bump(dev: bool = False, dry_run: bool = False) -> None:
     """Validate the whole stack before creating lightweight local tags."""
     changes: list[tuple[Path, str, str]] = []
     problems: list[str] = []
     for name in REPOSITORIES:
         try:
             repo = repository(name)
             head = capture(repo, "git", "rev-parse", "--verify", "HEAD^{commit}")
             head_tags = capture(
                 repo, "git", "tag", "--list", "v*", "--points-at", head
             ).splitlines()
             if head_tags:
                 print(f"{name:<24} skip: HEAD tagged {', '.join(sorted(head_tags))}")
                 continue
             status = capture(
                 repo, "git", "status", "--porcelain", "--untracked-files=all"
             )
             if status:
                 raise BuildError("worktree is not clean")
             tags = capture(repo, "git", "tag", "--list").splitlines()
             tag = next_tag(tags, dev)
             if tag in tags:
                 raise BuildError(f"tag {tag} already exists")
             changes.append((repo, tag, head))
             print(f"{name:<24} would tag {head[:12]} as {tag}")
         except BuildError as exc:
             detail = str(exc)
             problems.append(
                 detail if detail.startswith(f"{name}:") else f"{name}: {detail}"
             )
 
     if problems:
         joined = "\n  - ".join(problems)
         raise BuildError(f"bump preflight failed; no tags created:\n  - {joined}")
     if dry_run:
         print("Dry run complete; no tags created.")
         return
 
     created: list[str] = []
     for repo, tag, head in changes:
         try:
             # Override automatic signing so tags remain lightweight even when
             # the user's Git configuration enables tag.gpgSign.
             run(repo, "git", "-c", "tag.gpgSign=false", "tag", tag, head)
         except BuildError as exc:
             retained = ", ".join(created) or "none"
             raise BuildError(
                 f"{exc}; tags already created and retained: {retained}"
             ) from exc
         created.append(f"{repo.name}:{tag}")
     print(f"Created {len(created)} local tag(s).")
 
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
         "--root",
         type=Path,
         default=ROOT,
         help="directory containing the component repositories (default: current directory)",
     )
     subparsers = parser.add_subparsers(dest="command", required=True)
     subparsers.add_parser("build", help="pull, build, and install the Taler stack")
     subparsers.add_parser("versions", help="show each repository's tag or commit")
     foreach_parser = subparsers.add_parser(
         "foreach",
         help="run a command in each repository",
         description=(
             "Run PROGRAM with each configured repository as its working directory, "
             "in repository list order. Validate all repository paths first and "
             "stop at the first command failure. Use sh -c for shell expressions."
         ),
     )
     foreach_parser.add_argument(
         "argv",
         nargs=argparse.REMAINDER,
         metavar="PROGRAM [ARG ...]",
         help="program and arguments to execute; an optional -- may precede PROGRAM",
     )
     bump_parser = subparsers.add_parser(
         "bump",
         help="tag the next version of each untagged component HEAD",
         description=(
             "Create local lightweight tags from the highest local vX.Y.Z or "
             "vX.Y.Z-dev.N version, across all branches. Skip HEADs with any v* tag. "
             "By default, advance the patch release or promote a dev version to "
             "its release. Does not fetch, pull, push, or edit version files."
         ),
     )
     bump_parser.add_argument(
         "--dev",
         action="store_true",
         help="increment dev.N, or start the next patch at dev.1; still skip tagged HEADs",
     )
     bump_parser.add_argument(
         "--dry-run",
         action="store_true",
         help="validate and show changes without tagging",
     )
     args = parser.parse_args()
     if args.command == "foreach":
         if args.argv[:1] == ["--"]:
             args.argv = args.argv[1:]
         if not args.argv:
             foreach_parser.error("a program is required")
     return args
 
 
 def main() -> int:
     global ROOT
     args = parse_args()
     ROOT = args.root.resolve()
     try:
         if args.command == "build":
             build()
         elif args.command == "bump":
             bump(dev=args.dev, dry_run=args.dry_run)
         elif args.command == "foreach":
             foreach(args.argv)
         else:
             versions()
     except BuildError as exc:
         print(f"taler-repos: {exc}", file=sys.stderr)
         return 1
     return 0
 
 
 if __name__ == "__main__":
     sys.exit(main())