Add incremental Forgejo Actions build workflow

ci/build-plan.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Compute which packages to build based on git changes and tier ordering.
+
+Outputs a JSON object describing the build plan:
+  {"tiers": [{"tier": 1, "packages": ["pkg-a", "pkg-b"]}, ...]}
+
+Usage:
+  ci/build-plan.py [BASE_SHA] [HEAD_SHA]
+
+If no SHAs are given, outputs all packages (full rebuild).
+If BASE_SHA is given, only packages that changed OR transitively depend on a
+changed package are included.
+"""
+import glob
+import json
+import os
+import re
+import subprocess
+import sys
+from collections import defaultdict
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ORDER_FILE = os.path.join(REPO, "build-order.txt")
+
+
+def parse_build_order():
+    """Return list of (tier_number, [packages]) from build-order.txt."""
+    tiers = []
+    current_tier = None
+    current_pkgs = []
+    with open(ORDER_FILE) as f:
+        for line in f:
+            line = line.strip()
+            m = re.match(r"^\[tier(\d+)\]$", line)
+            if m:
+                if current_tier is not None:
+                    tiers.append((current_tier, current_pkgs))
+                current_tier = int(m.group(1))
+                current_pkgs = []
+            elif line and not line.startswith("#"):
+                current_pkgs.append(line)
+    if current_tier is not None:
+        tiers.append((current_tier, current_pkgs))
+    return tiers
+
+
+def build_dependency_graph():
+    """Return forward-dependency graph: pkg -> set of pkgs it depends on."""
+    specs = sorted(glob.glob(os.path.join(REPO, "*", "*.spec")))
+    specs = [s for s in specs
+             if os.path.basename(s)[:-5] == os.path.basename(os.path.dirname(s))]
+
+    provides = {}
+    brs = defaultdict(set)
+
+    for spec in specs:
+        pkg = os.path.basename(spec)[:-5]
+        out = subprocess.run(
+            ["rpmspec", "-P", spec], capture_output=True, text=True
+        ).stdout
+        if not out:
+            out = open(spec, errors="replace").read()
+        names = {pkg}
+        in_files = False
+        for line in out.splitlines():
+            s = line.strip()
+            m = re.match(r"%package\s+(?:-n\s+(\S+)|(\S+))", s)
+            if m:
+                names.add(m.group(1) or f"{pkg}-{m.group(2)}")
+                continue
+            if s.startswith("%files"):
+                in_files = True
+            elif s.startswith("%") and re.match(
+                r"%(prep|build|install|conf|check|changelog|description|post|pre)", s
+            ):
+                in_files = s.startswith("%files")
+            m = re.match(r"(Provides|BuildRequires)\s*:\s*(.+)", s)
+            if m:
+                for dep in re.split(r"\s+(?=[A-Za-z_%(/])", m.group(2).strip()):
+                    cap = dep.split()[0].replace("%{?_isa}", "").strip()
+                    if not cap or cap.startswith(("%", "(")):
+                        continue
+                    if m.group(1) == "Provides":
+                        names.add(cap)
+                    else:
+                        brs[pkg].add(cap)
+            if in_files:
+                for cm in re.findall(r"/cmake/([A-Za-z0-9_.+-]+)/?", s):
+                    names.add(f"cmake({cm})")
+                for pc in re.findall(r"/([A-Za-z0-9_.+-]+)\.pc\b", s):
+                    names.add(f"pkgconfig({pc})")
+        for n in names:
+            provides.setdefault(n, pkg)
+
+    forward = defaultdict(set)
+    for pkg, caps in brs.items():
+        for cap in caps:
+            owner = provides.get(cap)
+            if owner and owner != pkg:
+                forward[pkg].add(owner)
+
+    return forward
+
+
+def compute_affected(changed_pkgs, forward_graph):
+    """Given changed packages, compute all packages that need rebuilding."""
+    reverse = defaultdict(set)
+    for pkg, deps in forward_graph.items():
+        for dep in deps:
+            reverse[dep].add(pkg)
+
+    affected = set(changed_pkgs)
+    queue = list(changed_pkgs)
+    while queue:
+        pkg = queue.pop(0)
+        for dependent in reverse.get(pkg, ()):
+            if dependent not in affected:
+                affected.add(dependent)
+                queue.append(dependent)
+    return affected
+
+
+def main():
+    tiers = parse_build_order()
+    all_pkgs = [pkg for _, pkgs in tiers for pkg in pkgs]
+
+    if len(sys.argv) >= 3:
+        base, head = sys.argv[1], sys.argv[2]
+        changed_files = subprocess.run(
+            ["git", "diff", "--name-only", base, head],
+            capture_output=True, text=True, cwd=REPO,
+        ).stdout.split()
+        changed_pkgs = {
+            os.path.basename(f).replace(".spec", "")
+            for f in changed_files if f.endswith(".spec")
+        }
+        for f in changed_files:
+            if "/" in f and not f.endswith(".spec"):
+                pkg = f.split("/")[0]
+                if pkg in all_pkgs:
+                    changed_pkgs.add(pkg)
+    else:
+        changed_pkgs = set(all_pkgs)
+
+    if not changed_pkgs:
+        print(json.dumps({"tiers": [], "changed": [], "total": 0}))
+        return
+
+    forward = build_dependency_graph()
+    affected = compute_affected(changed_pkgs, forward)
+
+    plan = []
+    for tier_num, pkgs in tiers:
+        tier_affected = [p for p in pkgs if p in affected]
+        if tier_affected:
+            plan.append({"tier": tier_num, "packages": sorted(tier_affected)})
+
+    result = {
+        "tiers": plan,
+        "changed": sorted(changed_pkgs),
+        "total": sum(len(t["packages"]) for t in plan),
+    }
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()