Files
planet/scripts/release_publish.py
T
linkong 842cba4dc7
ci / backend (push) Has been cancelled
ci / frontend (push) Has been cancelled
release / images (push) Has been cancelled
release / client_release (push) Has been cancelled
ci / delivery (push) Has been cancelled
release: bump version to 0.77.0
2026-11-20 16:59:38 +08:00

349 lines
11 KiB
Python

#!/usr/bin/env python3
"""Create or update a Gitea Release and stream binary attachments via Gitea API."""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import re
import subprocess
import sys
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
ASSET_SUFFIXES = (".zip", ".appimage", ".deb", ".exe", ".dmg")
def run_git_origin_url() -> str:
try:
output = subprocess.check_output(
["git", "remote", "get-url", "origin"],
text=True,
stderr=subprocess.DEVNULL,
)
return output.strip()
except (subprocess.CalledProcessError, FileNotFoundError):
return ""
def parse_server_and_repo(remote_url: str) -> tuple[str, str]:
"""Derive (server_url, owner/repo) from an HTTPS or SSH git remote URL."""
url = remote_url.strip()
if not url:
return "", ""
https_match = re.match(r"^(https?://[^/]+)/(.+?)(?:\.git)?/?$", url)
if https_match:
return https_match.group(1).rstrip("/"), https_match.group(2).strip("/")
ssh_match = re.match(r"^(?:ssh://)?[^@]+@([^:/]+)[:/](.+?)(?:\.git)?/?$", url)
if ssh_match:
host = ssh_match.group(1)
repo_path = ssh_match.group(2).strip("/")
return f"https://{host}", repo_path
return "", ""
def extract_release_notes(changelog_path: Path, tag: str) -> str:
"""Extract the matching version section from docs/CHANGELOG.md."""
if not changelog_path.is_file():
return f"Release {tag}"
version = tag.lstrip("vV")
text = changelog_path.read_text(encoding="utf-8")
lines = text.splitlines()
heading_pattern = re.compile(
rf"^##\s+(?:\[{re.escape(version)}\]|{re.escape(version)}|{re.escape(tag)})(?:\s|$)"
)
next_heading_pattern = re.compile(r"^##\s+")
start_idx: int | None = None
for idx, line in enumerate(lines):
if heading_pattern.match(line.strip()):
start_idx = idx + 1
break
if start_idx is None:
return f"Release {tag}"
collected: list[str] = []
for line in lines[start_idx:]:
if next_heading_pattern.match(line.strip()):
break
collected.append(line)
while collected and (not collected[-1].strip() or collected[-1].strip() == "---"):
collected.pop()
while collected and not collected[0].strip():
collected.pop(0)
notes = "\n".join(collected).strip()
return notes or f"Release {tag}"
def compute_sha256(file_path: Path) -> str:
digest = hashlib.sha256()
with file_path.open("rb") as handle:
while chunk := handle.read(1024 * 1024):
digest.update(chunk)
return digest.hexdigest()
def collect_release_assets(assets_dir: Path) -> list[tuple[Path, str]]:
"""Collect distributable assets directly under assets_dir and write SHA256SUMS.txt."""
if not assets_dir.is_dir():
return []
distributables = sorted(
(
entry
for entry in assets_dir.iterdir()
if entry.is_file() and entry.name.lower().endswith(ASSET_SUFFIXES)
),
key=lambda p: p.name,
)
if not distributables:
return []
records: list[tuple[Path, str]] = []
checksum_lines: list[str] = []
for artifact in distributables:
sha = compute_sha256(artifact)
records.append((artifact, sha))
checksum_lines.append(f"{sha} {artifact.name}")
sums_path = assets_dir / "SHA256SUMS.txt"
sums_path.write_text("\n".join(checksum_lines) + "\n", encoding="utf-8")
sums_sha = compute_sha256(sums_path)
records.append((sums_path, sums_sha))
return records
def api_request(
method: str,
url: str,
token: str,
payload: dict | None = None,
) -> tuple[int, dict | list | str | None]:
headers = {
"Authorization": f"token {token}",
"Accept": "application/json",
}
data = None
if payload is not None:
headers["Content-Type"] = "application/json"
data = json.dumps(payload).encode("utf-8")
request = urllib.request.Request(url, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(request, timeout=30) as response:
raw = response.read().decode("utf-8", errors="replace")
return response.status, json.loads(raw) if raw.strip() else None
except urllib.error.HTTPError as exc:
raw = exc.read().decode("utf-8", errors="replace")
try:
body: dict | list | str | None = json.loads(raw) if raw.strip() else None
except json.JSONDecodeError:
body = raw
return exc.code, body
def upload_asset_with_curl(
upload_url: str,
token: str,
file_path: Path,
) -> None:
"""Stream multipart file upload using curl to avoid buffering ~200MB assets in memory."""
proc = subprocess.run(
[
"curl",
"-sS",
"-w",
"\n%{http_code}",
"-X",
"POST",
"-H",
f"Authorization: token {token}",
"-F",
f"attachment=@{file_path}",
upload_url,
],
text=True,
capture_output=True,
)
if proc.returncode != 0:
raise RuntimeError(
f"curl upload failed for {file_path.name} (exit={proc.returncode}): {proc.stderr.strip()}"
)
lines = proc.stdout.splitlines()
status_str = lines[-1].strip() if lines else ""
body = "\n".join(lines[:-1]).strip()
try:
status_code = int(status_str)
except ValueError as exc:
raise RuntimeError(f"Unexpected curl output for {file_path.name}: {proc.stdout}") from exc
if status_code == 413:
raise RuntimeError(
f"Upload rejected with HTTP 413 Payload Too Large for {file_path.name}. "
"Check Gitea app.ini [attachment] MAX_SIZE and Nginx/Ingress client_max_body_size (>= 300M)."
)
if status_code >= 400:
raise RuntimeError(
f"Upload failed for {file_path.name} (HTTP {status_code}): {body}"
)
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Publish Gitea Release and client binaries.")
parser.add_argument("--tag", required=True, help="Git release tag, e.g. v0.77.0")
parser.add_argument(
"--assets-dir",
default="client/release",
help="Directory containing packaged client binaries (default: client/release)",
)
parser.add_argument(
"--changelog",
default="docs/CHANGELOG.md",
help="Path to changelog markdown file (default: docs/CHANGELOG.md)",
)
parser.add_argument(
"--server",
default="",
help="Gitea base URL (defaults to GITHUB_SERVER_URL or origin remote host)",
)
parser.add_argument(
"--repo",
default="",
help="Repository slug owner/name (defaults to GITHUB_REPOSITORY or origin remote)",
)
parser.add_argument(
"--dry-run",
action="store_true",
help="Verify release notes and asset checksums without calling remote Gitea APIs",
)
return parser.parse_args(argv)
def main(argv: list[str] | None = None) -> int:
args = parse_args(argv)
derived_server, derived_repo = parse_server_and_repo(run_git_origin_url())
server = (args.server or os.environ.get("GITHUB_SERVER_URL") or derived_server).rstrip("/")
repo = (args.repo or os.environ.get("GITHUB_REPOSITORY") or derived_repo).strip("/")
if not server or not repo:
print("error: unable to resolve Gitea server URL or owner/repo slug", file=sys.stderr)
return 1
notes = extract_release_notes(Path(args.changelog), args.tag)
assets_dir = Path(args.assets_dir)
assets = collect_release_assets(assets_dir)
if args.dry_run:
print(f"server: {server}")
print(f"repo: {repo}")
print(f"tag: {args.tag}")
print(f"notes_length: {len(notes)}")
print(f"assets_count: {len(assets)}")
for path, sha in assets:
size_mb = path.stat().st_size / (1024 * 1024)
print(f" - {path.name} ({size_mb:.2f} MiB) sha256={sha}")
return 0
token = os.environ.get("GITEA_TOKEN") or os.environ.get("GITHUB_TOKEN") or ""
if not token:
print(
"error: GITEA_TOKEN or GITHUB_TOKEN must be set to publish a Gitea Release",
file=sys.stderr,
)
return 1
api_base = f"{server}/api/v1/repos/{repo}"
encoded_tag = urllib.parse.quote(args.tag, safe="")
status, existing = api_request("GET", f"{api_base}/releases/tags/{encoded_tag}", token)
if status == 404:
create_status, release_obj = api_request(
"POST",
f"{api_base}/releases",
token,
payload={
"tag_name": args.tag,
"name": args.tag,
"body": notes,
"draft": False,
"prerelease": False,
},
)
if create_status >= 400 or not isinstance(release_obj, dict):
print(
f"error: failed to create Gitea Release {args.tag} (HTTP {create_status}): {release_obj}",
file=sys.stderr,
)
return 1
print(f"created release {args.tag} (id={release_obj.get('id')})")
elif status == 200 and isinstance(existing, dict):
release_id = existing["id"]
patch_status, release_obj = api_request(
"PATCH",
f"{api_base}/releases/{release_id}",
token,
payload={"name": args.tag, "body": notes},
)
if patch_status >= 400 or not isinstance(release_obj, dict):
print(
f"error: failed to update Gitea Release {args.tag} (HTTP {patch_status}): {release_obj}",
file=sys.stderr,
)
return 1
print(f"updated release {args.tag} (id={release_obj.get('id')})")
else:
print(
f"error: failed querying release {args.tag} (HTTP {status}): {existing}",
file=sys.stderr,
)
return 1
release_id = release_obj["id"]
list_status, asset_list = api_request("GET", f"{api_base}/releases/{release_id}/assets", token)
existing_assets: dict[str, int] = {}
if list_status == 200 and isinstance(asset_list, list):
for item in asset_list:
if isinstance(item, dict) and "name" in item and "id" in item:
existing_assets[str(item["name"])] = int(item["id"])
for asset_path, _sha in assets:
existing_id = existing_assets.get(asset_path.name)
if existing_id is not None:
del_status, del_body = api_request(
"DELETE",
f"{api_base}/releases/{release_id}/assets/{existing_id}",
token,
)
if del_status >= 400:
print(
f"error: failed removing old asset {asset_path.name} (HTTP {del_status}): {del_body}",
file=sys.stderr,
)
return 1
encoded_name = urllib.parse.quote(asset_path.name, safe="")
upload_url = f"{api_base}/releases/{release_id}/assets?name={encoded_name}"
print(f"uploading {asset_path.name}...")
upload_asset_with_curl(upload_url, token, asset_path)
print(f"published release {args.tag} with {len(assets)} asset(s)")
return 0
if __name__ == "__main__":
raise SystemExit(main())