89 lines
3.3 KiB
Python
Executable file
89 lines
3.3 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""Builds the production images of the backend and the frontend with a version tag.
|
|
|
|
python scripts/release.py 0.0.1 # an exact version
|
|
python scripts/release.py patch # bump: patch | minor | major (0.0.1 -> 0.0.2)
|
|
python scripts/release.py patch --platform linux/arm64 # for a server of another architecture
|
|
python scripts/release.py --dry-run patch # only print what would be done
|
|
|
|
The version is kept in the VERSION file in the repository root (the bump starts from 0.0.0
|
|
when there is no such file). Images: fitness_parser_backend:<version> (target `prod`) and
|
|
fitness_parser_frontend:<version>.
|
|
"""
|
|
|
|
import argparse
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
VERSION_FILE = ROOT / "VERSION"
|
|
VERSION_PATTERN = re.compile(r"^\d+\.\d+\.\d+$")
|
|
|
|
# image name -> (build context, extra docker build arguments)
|
|
IMAGES = {
|
|
"fitness_parser_backend": ("backend", ["--target", "prod"]),
|
|
"fitness_parser_frontend": ("frontend", []),
|
|
}
|
|
|
|
|
|
def current_version() -> str:
|
|
if not VERSION_FILE.exists():
|
|
return "0.0.0"
|
|
return VERSION_FILE.read_text().strip()
|
|
|
|
|
|
def next_version(request: str) -> str:
|
|
if VERSION_PATTERN.match(request):
|
|
return request
|
|
major, minor, patch = (int(part) for part in current_version().split("."))
|
|
if request == "major":
|
|
return f"{major + 1}.0.0"
|
|
if request == "minor":
|
|
return f"{major}.{minor + 1}.0"
|
|
if request == "patch":
|
|
return f"{major}.{minor}.{patch + 1}"
|
|
sys.exit(f"Unknown version '{request}': use X.Y.Z, patch, minor or major")
|
|
|
|
|
|
def build_command(name: str, version: str, platform: str | None) -> list[str]:
|
|
context, extra = IMAGES[name]
|
|
if platform:
|
|
# buildx can build for another architecture; --load puts the image into local docker
|
|
command = ["docker", "buildx", "build", "--platform", platform, "--load"]
|
|
else:
|
|
command = ["docker", "build"]
|
|
return [*command, *extra, "-t", f"{name}:{version}", str(ROOT / context)]
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
|
parser.add_argument("version", help="X.Y.Z, or patch / minor / major to bump the current one")
|
|
parser.add_argument("--platform", help="target platform, e.g. linux/arm64 (default: this machine)")
|
|
parser.add_argument("--dry-run", action="store_true", help="print the commands, change nothing")
|
|
args = parser.parse_args()
|
|
|
|
version = next_version(args.version)
|
|
print(f"Version: {current_version()} -> {version}")
|
|
commands = [build_command(name, version, args.platform) for name in IMAGES]
|
|
|
|
if args.dry_run:
|
|
for command in commands:
|
|
print(" ".join(command))
|
|
return
|
|
|
|
for command in commands:
|
|
print("+", " ".join(command), flush=True)
|
|
if subprocess.run(command).returncode != 0:
|
|
sys.exit("Build failed, the VERSION file was not changed")
|
|
# Written only after both images were built
|
|
VERSION_FILE.write_text(version + "\n")
|
|
|
|
images = " ".join(f"{name}:{version}" for name in IMAGES)
|
|
print(f"\nBuilt {images}\nSend to the server:\n"
|
|
f" docker save {images} | gzip | ssh user@host 'gunzip | docker load'")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|