114 lines
5.2 KiB
Python
114 lines
5.2 KiB
Python
#!/usr/bin/env python3
|
|
"""Install the pinned SDK components, retrying downloads in fresh staging areas."""
|
|
from pathlib import Path
|
|
import argparse
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import time
|
|
import xml.etree.ElementTree as ET
|
|
import zipfile
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
|
|
|
|
def component_path(root, package):
|
|
if not re.fullmatch(r"(?:platforms;android-[0-9]+|(?:build-tools|ndk|cmake);[0-9]+\.[0-9]+\.[0-9]+)", package):
|
|
raise ValueError("invalid pinned SDK component: " + package)
|
|
return root.joinpath(*package.split(";"))
|
|
|
|
|
|
def valid(root, package):
|
|
directory = component_path(root, package)
|
|
try:
|
|
document = ET.parse(directory / "package.xml")
|
|
if not any(element.tag.rsplit("}", 1)[-1] == "localPackage" and
|
|
element.get("path") == package for element in document.iter()):
|
|
return False
|
|
kind, version = package.split(";")
|
|
if kind == "platforms":
|
|
with zipfile.ZipFile(directory / "android.jar") as archive:
|
|
return archive.testzip() is None
|
|
properties = (directory / "source.properties").read_text()
|
|
if not re.search(r"^Pkg\.Revision\s*=\s*" + re.escape(version) + r"\s*$", properties, re.M):
|
|
return False
|
|
if kind == "cmake":
|
|
command = [directory / "bin/cmake", "--version"]
|
|
elif kind == "build-tools":
|
|
command = [directory / "aapt2", "version"]
|
|
else:
|
|
command = [next(directory.glob("toolchains/llvm/prebuilt/*/bin/clang")), "--version"]
|
|
result = subprocess.run(command, capture_output=True, text=True, timeout=15)
|
|
if result.returncode != 0:
|
|
return False
|
|
if kind == "cmake":
|
|
expected = "cmake version " + re.escape(version) + r"(?:-[0-9A-Za-z.]+)?"
|
|
return re.fullmatch(expected, result.stdout.splitlines()[0]) is not None
|
|
return True
|
|
except (OSError, UnicodeError, ET.ParseError, zipfile.BadZipFile, StopIteration, IndexError,
|
|
subprocess.TimeoutExpired):
|
|
return False
|
|
|
|
|
|
def install(root, packages, manager, sleep=time.sleep):
|
|
root = Path(root).resolve()
|
|
manager = Path(manager).resolve(strict=True)
|
|
root.mkdir(parents=True, exist_ok=True)
|
|
for package in packages:
|
|
destination = component_path(root, package)
|
|
if valid(root, package):
|
|
print("Android SDK: verified cached " + package, flush=True)
|
|
continue
|
|
for attempt in range(1, 4):
|
|
print(f"Android SDK: install {package}, attempt {attempt}/3", flush=True)
|
|
# sdkmanager keeps partial archives beneath its SDK root. A new
|
|
# stage guarantees that a corrupt ZIP cannot survive the retry.
|
|
with tempfile.TemporaryDirectory(prefix=".inbe-sdk-", dir=root) as temporary:
|
|
stage = Path(temporary)
|
|
if (root / "licenses").is_dir():
|
|
shutil.copytree(root / "licenses", stage / "licenses")
|
|
environment = dict(os.environ, ANDROID_HOME=str(stage), ANDROID_SDK_ROOT=str(stage))
|
|
try:
|
|
result = subprocess.run([manager, "--sdk_root=" + str(stage), package],
|
|
input=b"y\n" * 128, env=environment, timeout=600)
|
|
except subprocess.TimeoutExpired:
|
|
result = None
|
|
if result is not None and result.returncode == 0 and valid(stage, package):
|
|
source = component_path(stage, package)
|
|
destination.parent.mkdir(parents=True, exist_ok=True)
|
|
if destination.exists():
|
|
destination.rename(stage / "incomplete-component")
|
|
source.rename(destination)
|
|
if (stage / "licenses").is_dir():
|
|
shutil.copytree(stage / "licenses", root / "licenses", dirs_exist_ok=True)
|
|
if not valid(root, package):
|
|
raise RuntimeError("SDK component failed validation after installation: " + package)
|
|
break
|
|
print("Android SDK: rejected incomplete or invalid " + package, flush=True)
|
|
if attempt == 3:
|
|
raise RuntimeError("Android SDK download failed after three fresh attempts: " + package)
|
|
sleep(attempt * 2)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--sdk-root", type=Path,
|
|
default=os.environ.get("ANDROID_SDK_ROOT") or os.environ.get("ANDROID_HOME"))
|
|
parser.add_argument("--sdkmanager", type=Path)
|
|
parser.add_argument("--packages", type=Path, default=ROOT / ".github/android-sdk-packages.txt")
|
|
args = parser.parse_args()
|
|
if args.sdk_root is None:
|
|
parser.error("ANDROID_SDK_ROOT or ANDROID_HOME must name the job's SDK")
|
|
manager = args.sdkmanager or args.sdk_root / "cmdline-tools/latest/bin/sdkmanager"
|
|
if args.sdkmanager is None and not manager.is_file():
|
|
manager = Path(shutil.which("sdkmanager") or manager)
|
|
packages = [line.strip() for line in args.packages.read_text().splitlines()
|
|
if line.strip() and not line.lstrip().startswith("#")]
|
|
install(args.sdk_root, packages, manager)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|