CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Failing after 25m35s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Failing after 1s
CI / Deploy (pull_request) Skipped
286 lines
10 KiB
Python
Executable File
286 lines
10 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Publish immutable Crank release assets to Gitea, safely supporting retries."""
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
from urllib.error import HTTPError, URLError
|
|
from urllib.parse import quote, urlencode, urlsplit
|
|
from urllib.request import HTTPRedirectHandler, Request, build_opener
|
|
|
|
_REPO = re.compile(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+\Z")
|
|
_TAG = re.compile(r"v[A-Za-z0-9._+-]+\Z")
|
|
|
|
|
|
|
|
class PublishError(Exception):
|
|
"""Sanitized release publication failure safe to show in CI logs."""
|
|
|
|
|
|
class _NoRedirect(HTTPRedirectHandler):
|
|
def redirect_request(self, req, fp, code, msg, headers, newurl):
|
|
raise PublishError(
|
|
f"Gitea API redirected (HTTP {code}); refusing to forward credentials"
|
|
)
|
|
|
|
|
|
def _inputs(env):
|
|
raw_base = env.get("GITEA_SERVER_URL", "")
|
|
parts = urlsplit(raw_base)
|
|
if (
|
|
parts.scheme != "https"
|
|
or not parts.hostname
|
|
or parts.username
|
|
or parts.password
|
|
or parts.query
|
|
or parts.fragment
|
|
or parts.path not in ("", "/")
|
|
):
|
|
raise PublishError("GITEA_SERVER_URL must be the trusted HTTPS Gitea origin")
|
|
repo = env.get("GITEA_REPOSITORY", "")
|
|
if not _REPO.fullmatch(repo):
|
|
raise PublishError("GITEA_REPOSITORY must be owner/repository")
|
|
tag = env.get("RELEASE_TAG", "")
|
|
if not _TAG.fullmatch(tag):
|
|
raise PublishError("RELEASE_TAG is not a supported version tag")
|
|
token = env.get("GITEA_TOKEN", "")
|
|
if (
|
|
not token
|
|
or len(token) > 4096
|
|
or any(ord(char) < 32 or ord(char) == 127 for char in token)
|
|
):
|
|
raise PublishError("GITEA_TOKEN is unavailable or has invalid format")
|
|
origin = f"{parts.scheme}://{parts.netloc}"
|
|
owner, name = repo.split("/", 1)
|
|
api = f"{origin}/api/v1/repos/{quote(owner, safe='')}/{quote(name, safe='')}"
|
|
return origin, api, tag, token
|
|
|
|
|
|
def _json_request(opener, method, url, token, payload=None, allow_404=False):
|
|
body = None if payload is None else json.dumps(payload).encode("utf-8")
|
|
headers = {"Authorization": f"token {token}", "Accept": "application/json"}
|
|
if body is not None:
|
|
headers["Content-Type"] = "application/json"
|
|
request = Request(url, data=body, headers=headers, method=method)
|
|
try:
|
|
with opener.open(request, timeout=20) as response:
|
|
return json.loads(response.read()), response.status
|
|
except PublishError:
|
|
raise
|
|
except HTTPError as exc:
|
|
status = exc.code
|
|
exc.close()
|
|
if allow_404 and status == 404:
|
|
return None, 404
|
|
raise PublishError(f"Gitea release API request failed (HTTP {status})") from None
|
|
except (URLError, TimeoutError, OSError):
|
|
raise PublishError("Gitea release API request failed or timed out") from None
|
|
except (json.JSONDecodeError, UnicodeDecodeError):
|
|
raise PublishError("Gitea returned invalid release API data") from None
|
|
|
|
|
|
def _release_id(api, tag, token, opener):
|
|
tag_path = f"{api}/releases/tags/{quote(tag, safe='')}"
|
|
release, status = _json_request(opener, "GET", tag_path, token, allow_404=True)
|
|
if status == 404:
|
|
release, status = _json_request(
|
|
opener,
|
|
"POST",
|
|
f"{api}/releases",
|
|
token,
|
|
payload={
|
|
"tag_name": tag,
|
|
"name": f"Crank Community {tag}",
|
|
"body": "Checksums, evidence, and SBOM are attached to this release.",
|
|
},
|
|
)
|
|
if status not in (200, 201) or not isinstance(release, dict):
|
|
raise PublishError("Gitea did not return a release record")
|
|
if release.get("tag_name") != tag:
|
|
raise PublishError("Gitea returned a release for a different tag")
|
|
release_id = release.get("id")
|
|
if not isinstance(release_id, int) or release_id <= 0:
|
|
raise PublishError("Gitea returned an invalid release identifier")
|
|
return release_id
|
|
|
|
|
|
def _assets(api, release_id, token, opener):
|
|
collected = {}
|
|
page_size = 50
|
|
max_pages = 20
|
|
for page_num in range(1, max_pages + 1):
|
|
url = f"{api}/releases/{release_id}/assets?{urlencode({'page': page_num, 'limit': page_size})}"
|
|
result, status = _json_request(opener, "GET", url, token)
|
|
if status != 200 or not isinstance(result, list):
|
|
raise PublishError("Gitea returned invalid release asset data")
|
|
for item in result:
|
|
if (
|
|
not isinstance(item, dict)
|
|
or not isinstance(item.get("name"), str)
|
|
or not isinstance(item.get("id"), int)
|
|
or not isinstance(item.get("size"), int)
|
|
or not isinstance(item.get("browser_download_url"), str)
|
|
):
|
|
raise PublishError("Gitea returned a malformed release asset")
|
|
if item["name"] in collected:
|
|
raise PublishError(
|
|
f"Gitea returned duplicate release asset name {item['name']}"
|
|
)
|
|
collected[item["name"]] = item
|
|
if len(result) < page_size:
|
|
return collected
|
|
raise PublishError("Gitea release asset history exceeded the pagination limit")
|
|
|
|
|
|
def _same_bytes(origin, attachment, local_path, token, opener):
|
|
download = urlsplit(attachment["browser_download_url"])
|
|
trusted = urlsplit(origin)
|
|
if (
|
|
download.scheme != "https"
|
|
or download.netloc != trusted.netloc
|
|
or download.username
|
|
or download.password
|
|
or download.fragment
|
|
):
|
|
raise PublishError(
|
|
f"Existing asset {attachment['name']} has an untrusted download URL; refusing to replace it"
|
|
)
|
|
expected_size = local_path.stat().st_size
|
|
if attachment["size"] != expected_size:
|
|
return False
|
|
request = Request(
|
|
attachment["browser_download_url"],
|
|
headers={"Authorization": f"token {token}"},
|
|
)
|
|
try:
|
|
with opener.open(request, timeout=30) as response:
|
|
digest = hashlib.sha256()
|
|
total = 0
|
|
while True:
|
|
chunk = response.read(1024 * 1024)
|
|
if not chunk:
|
|
break
|
|
total += len(chunk)
|
|
if total > expected_size:
|
|
return False
|
|
digest.update(chunk)
|
|
except PublishError:
|
|
raise
|
|
except HTTPError as exc:
|
|
status = exc.code
|
|
exc.close()
|
|
if 300 <= status < 400:
|
|
raise PublishError(
|
|
f"Existing asset {attachment['name']} redirects; refusing to forward credentials"
|
|
) from None
|
|
raise PublishError(
|
|
f"Could not compare existing release asset (HTTP {status})"
|
|
) from None
|
|
except (URLError, TimeoutError, OSError):
|
|
raise PublishError("Could not download existing release asset for comparison") from None
|
|
return total == expected_size and digest.digest() == _hash_file(local_path)
|
|
|
|
|
|
def _hash_file(path):
|
|
digest = hashlib.sha256()
|
|
with path.open("rb") as source:
|
|
for chunk in iter(lambda: source.read(1024 * 1024), b""):
|
|
digest.update(chunk)
|
|
return digest.digest()
|
|
|
|
|
|
def _curl_config(token):
|
|
escaped = token.replace("\\", "\\\\").replace('"', '\\"')
|
|
config = tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False)
|
|
try:
|
|
config.write(f'header = "Authorization: token {escaped}"\n')
|
|
config.flush()
|
|
os.chmod(config.name, 0o600)
|
|
return config.name
|
|
finally:
|
|
config.close()
|
|
|
|
|
|
def _upload(api, release_id, path, token):
|
|
name = path.name
|
|
url = f"{api}/releases/{release_id}/assets?{urlencode({'name': name})}"
|
|
auth_config = _curl_config(token)
|
|
try:
|
|
result = subprocess.run(
|
|
[
|
|
"curl",
|
|
"--fail",
|
|
"--silent",
|
|
"--show-error",
|
|
"--max-time",
|
|
"180",
|
|
"--config",
|
|
auth_config,
|
|
"-F",
|
|
f"attachment=@{path}",
|
|
url,
|
|
],
|
|
check=False,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True,
|
|
)
|
|
except OSError:
|
|
raise PublishError("curl is unavailable for release asset upload") from None
|
|
finally:
|
|
Path(auth_config).unlink(missing_ok=True)
|
|
if result.returncode != 0:
|
|
raise PublishError(f"Gitea rejected release asset {name} (curl exit {result.returncode})")
|
|
|
|
|
|
def publish(env=None, assets=None, opener=None, upload=_upload):
|
|
env = os.environ if env is None else env
|
|
origin, api, tag, token = _inputs(env)
|
|
if not assets:
|
|
raise PublishError("No release assets were provided")
|
|
paths = [Path(item) for item in assets]
|
|
if any(not path.is_file() for path in paths):
|
|
raise PublishError("A requested release asset file is missing")
|
|
names = [path.name for path in paths]
|
|
if len(names) != len(set(names)):
|
|
raise PublishError("Release asset names must be unique")
|
|
opener = opener or build_opener(_NoRedirect())
|
|
release_id = _release_id(api, tag, token, opener)
|
|
existing = _assets(api, release_id, token, opener)
|
|
published = []
|
|
for path in paths:
|
|
attachment = existing.get(path.name)
|
|
if attachment is not None:
|
|
if not _same_bytes(origin, attachment, path, token, opener):
|
|
raise PublishError(
|
|
f"Release asset {path.name} already exists with different bytes; immutable asset left unchanged"
|
|
)
|
|
published.append((path.name, "already present with matching bytes"))
|
|
continue
|
|
upload(api, release_id, path, token)
|
|
published.append((path.name, "uploaded"))
|
|
return {"tag": tag, "release_id": release_id, "assets": published}
|
|
|
|
|
|
def main(argv=None):
|
|
argv = sys.argv[1:] if argv is None else argv
|
|
try:
|
|
result = publish(assets=argv)
|
|
except PublishError as exc:
|
|
print(f"Gitea release assets: {exc}", file=sys.stderr)
|
|
return 1
|
|
print(f"Gitea release {result['tag']} (id {result['release_id']}):")
|
|
for name, state in result["assets"]:
|
|
print(f"{state}: {name}")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|