diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c9dd01..513413b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,11 @@ Alle nennenswerten Änderungen an NetClip. Format nach [Keep a Changelog](https: ## [Unreleased] +### Geändert +- Bauen und Releases über `./build.sh` (release, build, test): läuft komplett in temporären + Docker-Containern, auf dem Rechner wird außer Docker nichts mehr benötigt. +- Android-Build-Image enthält die Platform-Tools fest (schnellere Builds). + ## [1.0.1] - 2026-10-17 ### Hinzugefügt diff --git a/README.md b/README.md index 12a2015..684844c 100644 --- a/README.md +++ b/README.md @@ -79,7 +79,8 @@ python -m netclip ### Pakete bauen -PyInstaller baut immer für das System, auf dem es läuft – also einmal je Betriebssystem: +Windows, Linux und Android: `./build.sh build` (siehe [Bauen und Release erstellen](#bauen-und-release-erstellen)). +Ohne Docker baut PyInstaller immer für das System, auf dem es läuft: ```bash cd client-desktop @@ -152,21 +153,27 @@ cd client-android Das Release-APK ist zum Testen mit dem Debug-Schlüssel signiert; für die Verteilung in `app/build.gradle` einen eigenen Keystore eintragen. -## Release erstellen +## Bauen und Release erstellen -Die Version steht zentral in der Datei `VERSION`. Neue Änderungen kommen laufend in -`CHANGELOG.md` unter `## [Unreleased]`. Ein Release: +Auf dem Rechner wird **nur Docker** benötigt – Python, Git, JDK, Android-SDK, Wine usw. laufen in +temporären Containern, die nach jedem Lauf wieder verschwinden (`docker run --rm`). ```bash -python3 scripts/release.py # 1.0.0 -> 1.0.1 (patch), committen + taggen -python3 scripts/release.py minor --build # 1.0.1 -> 1.1.0 und alle Pakete bauen -python3 scripts/release.py --build-only # aktuellen Stand nur bauen +./build.sh release # Version 1.0.1 -> 1.0.2 (patch), committen + taggen +./build.sh release minor --build # -> 1.1.0 und alle Pakete bauen +./build.sh build # aktuellen Stand (HEAD) bauen, ohne Versionswechsel +./build.sh build --targets windows,android +./build.sh test # Krypto-Kompatibilität Python <-> Kotlin prüfen git push --follow-tags ``` -Das Skript schreibt die neue Version in Server, Desktop-Client, Windows-Installer und Android-App +Die Version steht zentral in der Datei `VERSION`. Neue Änderungen kommen laufend in +`CHANGELOG.md` unter `## [Unreleased]`; ohne Einträge dort verweigert `release` den Release. +Das Release schreibt die neue Version in Server, Desktop-Client, Windows-Installer und Android-App (`versionName`, `versionCode` +1) und macht aus `[Unreleased]` den neuen Versionsabschnitt. -Mit `--build` wird ausschließlich in Docker gebaut (`docker-build/`), Ergebnis in `releases/v/`: + +Gebaut wird aus einem sauberen `git archive` (Release-Tag bzw. HEAD) – uncommittete Änderungen +fließen nicht ein. Ergebnis in `releases/v/`: | Datei | Inhalt | |---|---| @@ -177,8 +184,11 @@ Mit `--build` wird ausschließlich in Docker gebaut (`docker-build/`), Ergebnis | `netclip-server-.tar.gz` | Server-Image für `docker load -i …` (offline verteilbar) | | `RELEASE-NOTES.md`, `SHA256SUMS` | Änderungen und Prüfsummen | +Wie es funktioniert: `build.sh` startet einen Runner-Container (Python, Git, Docker-CLI), der über +den Docker-Socket des Hosts die Build-Container aus `docker-build/` startet. Der erste Lauf lädt +die Images (einige GB, vor allem Wine und Android-SDK), danach geht es aus dem Cache. + macOS kann nicht in Docker gebaut werden – dafür auf einem Mac in `client-desktop/` `python build.py`. -Mit `--targets windows,android` lassen sich einzelne Pakete bauen. **Android-Signatur:** Beim ersten Android-Build wird `secrets/netclip-release.jks` erzeugt (nicht im Git). Diesen Ordner sichern – ohne den Schlüssel lassen sich installierte Apps nicht mehr aktualisieren. @@ -186,10 +196,7 @@ Git). Diesen Ordner sichern – ohne den Schlüssel lassen sich installierte App ## Tests ```bash -# Kompatibilität der Verschlüsselung Python <-> Kotlin -python tools/interop.py gen /tmp/interop -(cd client-android && ./gradlew testDebugUnitTest -Pinterop=/tmp/interop) -python tools/interop.py check /tmp/interop +./build.sh test # Kompatibilität der Verschlüsselung Python <-> Kotlin (in Docker) ``` ## Protokoll (für eigene Clients) diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..8217cd9 --- /dev/null +++ b/build.sh @@ -0,0 +1,35 @@ +#!/bin/sh +# Bauen und Releases ohne lokale Abhaengigkeiten - auf dem Rechner wird nur Docker benoetigt. +# +# ./build.sh release [patch|minor|major] [--build] [--targets ...] Version hochzaehlen, committen, taggen +# ./build.sh build [--targets windows,android] aktuellen Stand (HEAD) bauen +# ./build.sh test Krypto-Kompatibilitaet Python <-> Kotlin +# +# Alles laeuft in temporaeren Containern (--rm). Ergebnis: releases/v/ +set -e +cd "$(dirname "$0")" +ROOT=$(pwd) + +case "${1:-}" in + release) shift ;; + build) shift; set -- --build-only "$@" ;; + test) shift; set -- --test "$@" ;; + *) sed -n '2,8p' "$0"; exit 1 ;; +esac + +docker build -q -f docker-build/runner.Dockerfile -t netclip-build-runner docker-build > /dev/null + +# Der Runner startet weitere Container ueber den Docker-Socket. Damit deren Bind-Mounts stimmen, +# liegt das Repo im Runner unter demselben absoluten Pfad wie auf dem Host. +SOCK=/var/run/docker.sock +TTY=""; [ -t 0 ] && [ -t 1 ] && TTY="-it" +GITCFG=""; [ -f "$HOME/.gitconfig" ] && GITCFG="-v $HOME/.gitconfig:/home/build/.gitconfig:ro" +# Ersatz-Identitaet fuer Commits, falls user.name/user.email nicht gesetzt sind (wie git auf dem Host) +GITNAME="" +grep -qs "^[[:space:]]*name[[:space:]]*=" "$HOME/.gitconfig" || GITNAME="-e GIT_AUTHOR_NAME=$(id -un) -e GIT_COMMITTER_NAME=$(id -un)" + +exec docker run --rm $TTY \ + --user "$(id -u):$(id -g)" --group-add "$(stat -c %g "$SOCK")" \ + -v "$SOCK:$SOCK" -v "$ROOT:$ROOT" -w "$ROOT" \ + -e HOME=/home/build $GITCFG $GITNAME -e EMAIL="$(id -un)@$(hostname -f 2>/dev/null || hostname)" \ + netclip-build-runner python3 scripts/release.py "$@" diff --git a/docker-build/android.Dockerfile b/docker-build/android.Dockerfile index 05ee132..eb76408 100644 --- a/docker-build/android.Dockerfile +++ b/docker-build/android.Dockerfile @@ -7,6 +7,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends unzip wget && r && unzip -q tools.zip -d $ANDROID_HOME/cmdline-tools && mv $ANDROID_HOME/cmdline-tools/cmdline-tools $ANDROID_HOME/cmdline-tools/latest \ && rm tools.zip \ && yes | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses > /dev/null \ - && $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "platforms;android-35" "build-tools;35.0.0" > /dev/null + && $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "platforms;android-35" "build-tools;35.0.0" "platform-tools" > /dev/null COPY docker-build/build-android.sh /usr/local/bin/build-android.sh CMD ["sh", "/usr/local/bin/build-android.sh"] diff --git a/docker-build/build-android.sh b/docker-build/build-android.sh old mode 100644 new mode 100755 diff --git a/docker-build/build-linux.sh b/docker-build/build-linux.sh old mode 100644 new mode 100755 diff --git a/docker-build/build-windows.sh b/docker-build/build-windows.sh old mode 100644 new mode 100755 diff --git a/docker-build/runner.Dockerfile b/docker-build/runner.Dockerfile new file mode 100644 index 0000000..d3c0da5 --- /dev/null +++ b/docker-build/runner.Dockerfile @@ -0,0 +1,6 @@ +# Temporaerer Steuer-Container fuer ./build.sh: Python + Git + Docker-CLI. +# Startet die eigentlichen Build-Container ueber den Docker-Socket des Hosts. +FROM python:3.12-slim-bookworm +COPY --from=docker:27-cli /usr/local/bin/docker /usr/local/bin/docker +RUN apt-get update && apt-get install -y --no-install-recommends git && rm -rf /var/lib/apt/lists/* \ + && git config --system --add safe.directory '*' diff --git a/scripts/release.py b/scripts/release.py index 5359491..dd84184 100755 --- a/scripts/release.py +++ b/scripts/release.py @@ -1,6 +1,10 @@ #!/usr/bin/env python3 """Release erstellen: Version hochzaehlen, CHANGELOG abschliessen, committen, taggen, optional bauen. +Normalerweise ueber ./build.sh aufrufen (laeuft komplett in Docker, nichts lokal zu installieren): + ./build.sh release [patch|minor|major] [--build] ./build.sh build ./build.sh test + +Direkt (benoetigt python3, git, docker auf dem Rechner): python3 scripts/release.py # patch: 1.0.0 -> 1.0.1 python3 scripts/release.py minor # 1.0.1 -> 1.1.0 python3 scripts/release.py major # 1.1.0 -> 2.0.0 @@ -131,7 +135,10 @@ def ensure_android_keystore(): def build(version: str, ref: str, targets: list[str]): out = ROOT / "releases" / f"v{version}" out.mkdir(parents=True, exist_ok=True) - with tempfile.TemporaryDirectory(prefix="netclip-release-") as tmp: + # Unterhalb des Repos statt /tmp: laeuft das Skript selbst im Runner-Container (build.sh), + # muessen die Pfade fuer die Bind-Mounts der Build-Container auch auf dem Host gelten. + (ROOT / "releases").mkdir(exist_ok=True) + with tempfile.TemporaryDirectory(prefix=".src-", dir=ROOT / "releases") as tmp: src = Path(tmp) / "src" src.mkdir() archive = subprocess.run(["git", "archive", "--format=tar", ref], cwd=ROOT, check=True, capture_output=True).stdout @@ -169,6 +176,30 @@ def build(version: str, ref: str, targets: list[str]): print(f" {f.name:45} {f.stat().st_size / 1024 / 1024:8.1f} MB") +def test(): + """Krypto-Kompatibilitaet Python <-> Kotlin, komplett in den Build-Containern.""" + (ROOT / "releases").mkdir(exist_ok=True) + with tempfile.TemporaryDirectory(prefix=".test-", dir=ROOT / "releases") as tmp: + src = Path(tmp) / "src" + data = Path(tmp) / "interop" + src.mkdir() + data.mkdir() + archive = subprocess.run(["git", "archive", "--format=tar", "HEAD"], cwd=ROOT, check=True, capture_output=True).stdout + subprocess.run(["tar", "-x", "-C", str(src)], input=archive, check=True) + for name in ("linux", "android"): + docker_image(name, src) + user = ["--user", f"{os.getuid()}:{os.getgid()}", "-e", "HOME=/tmp"] + py = ["docker", "run", "--rm", *user, "-v", f"{src}:/src:ro", "-v", f"{data}:/data", "netclip-build-linux", + "python", "/src/tools/interop.py"] + run(*py, "gen", "/data") + run("docker", "run", "--rm", "-v", f"{src}:/src:ro", "-v", f"{data}:/data", + "-v", "netclip-gradle-cache:/root/.gradle", "netclip-build-android", "sh", "-c", + "cp -r /src/client-android /work && cd /work && rm -f local.properties && " + "./gradlew --no-daemon -q testDebugUnitTest -Pinterop=/data; r=$?; " + f"chown -R {os.getuid()}:{os.getgid()} /data; exit $r") + run(*py, "check", "/data") + + # ---------------------------------------------------------------------------- Ablauf def main(): p = argparse.ArgumentParser(description="NetClip-Release erstellen") @@ -177,12 +208,17 @@ def main(): p.add_argument("--build-only", action="store_true", help="nur die aktuelle Version (HEAD) bauen") p.add_argument("--targets", default=",".join(TARGETS), help=f"Auswahl aus {','.join(TARGETS)}") p.add_argument("--allow-empty", action="store_true", help="auch ohne Eintraege unter [Unreleased]") + p.add_argument("--test", action="store_true", help="nur Kompatibilitaetstest Python <-> Kotlin") args = p.parse_args() + if args.test: + test() + return + targets = [t.strip() for t in args.targets.split(",") if t.strip()] if unknown := set(targets) - set(TARGETS): die(f"Unbekannte Ziele: {', '.join(unknown)}") - if (args.build or args.build_only) and not shutil.which("docker"): + if not shutil.which("docker"): die("docker nicht gefunden") current = (ROOT / "VERSION").read_text().strip() @@ -198,16 +234,25 @@ def main(): if not notes and not args.allow_empty: die("Keine Eintraege unter '## [Unreleased]' im CHANGELOG (oder --allow-empty).") + if subprocess.run(["git", "var", "GIT_COMMITTER_IDENT"], cwd=ROOT, capture_output=True).returncode: + die("Git kennt keinen Namen/E-Mail fuer Commits: git config --global user.name/user.email setzen") + new = bump(current, args.part) tag = f"v{new}" if run("git", "tag", "--list", tag, capture=True).strip(): die(f"Tag {tag} existiert bereits") print(f"Release {current} -> {new}") + files = ["CHANGELOG.md", *VERSION_SPOTS.keys()] write_versions(new) close_changelog(new) - run("git", "add", "VERSION", "CHANGELOG.md", "client-android/app/build.gradle", *VERSION_SPOTS.keys()) - run("git", "commit", "-q", "-m", f"Release {tag}\n\n{notes}".strip()) + try: + run("git", "add", *files) + run("git", "commit", "-q", "-m", f"Release {tag}\n\n{notes}".strip()) + except subprocess.CalledProcessError: + run("git", "reset", "-q", "--", *files) + run("git", "checkout", "--", *files) + die("Commit fehlgeschlagen – Versionsaenderungen wurden zurueckgenommen.") run("git", "tag", "-a", tag, "-m", f"NetClip {new}\n\n{notes}".strip()) if args.build: