ci(release): port Agendula's 1.1.0 release pipeline, with betas
Brings the workflows, scripts and fastlane setup up to Agendula's
v1.1.0-beta.1 state:
- beta.yaml: a release/** branch carrying X.Y.Z-beta.N publishes a
Gitea + Codeberg pre-release with the signed APK. Never F-Droid or Play.
- scripts/version_info.sh derives versionCode from versionName for every
workflow and CI step. Clockula has no shipped 1.0.x codes, so it uses one
scheme: X*1000000 + Y*10000 + Z*100 + (beta N, or 99 for stable).
- CI checks the committed versionCode, blocks a beta from reaching main,
enforces the 500-char What's New and validates the store listing.
- Shared publish_gitea_release.sh / publish_codeberg_release.sh /
release_notes.sh replace the inline steps in release.yaml.
- Renovate also runs on every push to main to rebase conflicted PRs.
- jniLibs keepDebugSymbols, which the reproducibility guard now requires.
Fixes a bug present in Agendula too: the Codeberg tag lookups used
/git/refs/tags/{tag}, which matches by prefix, so v1.0.0 would have
"existed" as soon as v1.0.0-beta.1 did. That would have refused every
later beta and skipped the stable release. Both now use /tags/{tag}.
This commit is contained in:
1 parent
b5680bdc9e
commit
881f6b1286
18 files changed
+1206
-508
No files matched your search
@@ -17,6 +17,8 @@
|
||||
# 3. dependenciesInfo { includeInApk = false } — else AGP embeds a "Dependency
|
||||
# metadata" block (id 0x504b4453) in the APK Signing Block, which F-Droid's
|
||||
# binary scanner rejects as an extra signing block.
|
||||
# 4. jniLibs { keepDebugSymbols += "**/*.so" } — else AGP strips prebuilt .so
|
||||
# files only when an NDK is installed, so the bytes depend on the host.
|
||||
set -euo pipefail
|
||||
|
||||
APP="app/build.gradle.kts"
|
||||
@@ -62,6 +64,17 @@ else
|
||||
fail=1
|
||||
fi
|
||||
|
||||
# 4. Prebuilt native libs must not be stripped. AGP strips them only if an NDK is
|
||||
# installed, so the output would depend on the build host.
|
||||
if grep -Pzoq 'jniLibs\s*\{[^}]*keepDebugSymbols\s*\+=\s*"\*\*/\*\.so"' "$APP"; then
|
||||
echo "OK: jniLibs keepDebugSymbols — native libs ship unstripped on every host."
|
||||
else
|
||||
echo "ERROR: '$APP' is missing 'jniLibs { keepDebugSymbols += \"**/*.so\" }'." >&2
|
||||
echo " AGP strips .so files only when an NDK is present, so a from-source" >&2
|
||||
echo " rebuild would not match the published APK." >&2
|
||||
fail=1
|
||||
fi
|
||||
|
||||
if [ "$fail" -ne 0 ]; then
|
||||
echo >&2
|
||||
echo "Reproducible-release invariant(s) violated — official F-Droid publishing would" >&2
|
||||
|
||||
@@ -0,0 +1,203 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Validate fastlane/metadata/android against what BOTH stores accept.
|
||||
|
||||
The fastlane tree is the single source for the F-Droid listing (official repo
|
||||
harvests it, the self-hosted repo gets it via fastlane_to_fdroid_localized.sh)
|
||||
and for the Play listing (`bundle exec fastlane listing`). F-Droid accepts
|
||||
nearly anything; Play rejects a lot at upload time. Checking against Play's
|
||||
rules here is what keeps the graphics shippable to both from the same files.
|
||||
|
||||
scripts/check_store_listing.py validate what exists
|
||||
scripts/check_store_listing.py --complete also require everything a Play
|
||||
listing needs to go live
|
||||
|
||||
SDK- and dependency-free (PNG/JPEG headers are parsed by hand) so CI can run it
|
||||
without setup.
|
||||
"""
|
||||
import re
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
META = ROOT / "fastlane/metadata/android"
|
||||
RES = ROOT / "app/src/main/res"
|
||||
|
||||
# Play's limits; F-Droid truncates or recommends the same.
|
||||
TEXT_LIMITS = {"title.txt": 30, "short_description.txt": 80, "full_description.txt": 4000}
|
||||
CHANGELOG_LIMIT = 500
|
||||
|
||||
# The fallback locale of both stores: F-Droid always, Play as the app's default
|
||||
# language. It carries the full text and every graphic.
|
||||
REQUIRED_LOCALES = ("en-US",)
|
||||
IMAGE_LOCALE = "en-US"
|
||||
|
||||
SCREENSHOT_DIRS = ("phoneScreenshots", "sevenInchScreenshots", "tenInchScreenshots",
|
||||
"tvScreenshots", "wearScreenshots")
|
||||
# Play policy on the title: no ranking, price or promotional terms.
|
||||
TITLE_BANNED = re.compile(r"\b(best|top|#1|no\.? ?1|free|sale|discount|new|hot|download now)\b", re.I)
|
||||
|
||||
errors, warnings = [], []
|
||||
|
||||
|
||||
def err(path, msg):
|
||||
errors.append(f"{path.relative_to(ROOT)}: {msg}")
|
||||
|
||||
|
||||
def warn(path, msg):
|
||||
warnings.append(f"{path.relative_to(ROOT)}: {msg}")
|
||||
|
||||
|
||||
def image_info(path):
|
||||
"""(format, width, height, has_alpha) or None if unreadable."""
|
||||
data = path.read_bytes()
|
||||
if data[:8] == b"\x89PNG\r\n\x1a\n":
|
||||
w, h, _depth, color = struct.unpack(">IIBB", data[16:26])
|
||||
has_alpha = color in (4, 6) or b"tRNS" in data[:data.find(b"IDAT")]
|
||||
return "png", w, h, has_alpha
|
||||
if data[:2] == b"\xff\xd8":
|
||||
i = 2
|
||||
while i + 9 < len(data):
|
||||
if data[i] != 0xFF:
|
||||
i += 1
|
||||
continue
|
||||
marker = data[i + 1]
|
||||
seg_len = struct.unpack(">H", data[i + 2:i + 4])[0]
|
||||
if 0xC0 <= marker <= 0xCF and marker not in (0xC4, 0xC8, 0xCC):
|
||||
h, w = struct.unpack(">HH", data[i + 5:i + 9])
|
||||
return "jpeg", w, h, False
|
||||
i += 2 + seg_len
|
||||
return None
|
||||
|
||||
|
||||
def check_image(path, *, size=None, alpha=None, max_mb, screenshot=False):
|
||||
info = image_info(path)
|
||||
if info is None:
|
||||
err(path, "not a PNG or JPEG")
|
||||
return
|
||||
fmt, w, h, has_alpha = info
|
||||
if size and (w, h) != size:
|
||||
err(path, f"is {w}x{h}, Play requires exactly {size[0]}x{size[1]}")
|
||||
if alpha is True and (fmt != "png" or not has_alpha):
|
||||
err(path, "must be a 32-bit PNG (with alpha channel)")
|
||||
if alpha is False and has_alpha:
|
||||
err(path, "has an alpha channel; Play wants 24-bit PNG or JPEG")
|
||||
if screenshot:
|
||||
short, long_ = sorted((w, h))
|
||||
if short < 320 or long_ > 3840:
|
||||
err(path, f"is {w}x{h}; each side must be 320–3840 px")
|
||||
if long_ > 2 * short:
|
||||
err(path, f"is {w}x{h}; the long side may be at most twice the short side")
|
||||
if short < 1080:
|
||||
warn(path, f"is {w}x{h}; Play only features screenshots at 1080 px or more")
|
||||
mb = path.stat().st_size / 1_000_000
|
||||
if mb > max_mb:
|
||||
err(path, f"is {mb:.1f} MB, over Play's {max_mb} MB limit")
|
||||
|
||||
|
||||
def check_images(locale_dir):
|
||||
images = locale_dir / "images"
|
||||
if not images.is_dir():
|
||||
return
|
||||
if locale_dir.name != IMAGE_LOCALE:
|
||||
warn(images, f"graphics belong in {IMAGE_LOCALE} only; both stores fall back to it")
|
||||
for f in images.iterdir():
|
||||
if f.is_file() and f.stem not in ("icon", "featureGraphic", "promoGraphic", "tvBanner"):
|
||||
err(f, "unknown image; neither store will pick it up")
|
||||
icon = images / "icon.png"
|
||||
if icon.exists():
|
||||
check_image(icon, size=(512, 512), alpha=True, max_mb=1)
|
||||
for name, size in (("featureGraphic", (1024, 500)), ("promoGraphic", (180, 120)),
|
||||
("tvBanner", (1280, 720))):
|
||||
for f in images.glob(f"{name}.*"):
|
||||
check_image(f, size=size, alpha=False, max_mb=15)
|
||||
for d in SCREENSHOT_DIRS:
|
||||
shots = sorted(p for p in (images / d).glob("*") if p.is_file())
|
||||
if len(shots) > 8:
|
||||
err(images / d, f"{len(shots)} screenshots; Play takes at most 8")
|
||||
for s in shots:
|
||||
check_image(s, alpha=False, max_mb=8, screenshot=True)
|
||||
|
||||
|
||||
def version_code():
|
||||
"""The committed version's code, or None for a beta (it ships no What's New)."""
|
||||
def info(key):
|
||||
return subprocess.run(["bash", str(ROOT / "scripts/version_info.sh"), key],
|
||||
check=True, capture_output=True, text=True).stdout.strip()
|
||||
return None if info("channel") == "beta" else int(info("version_code"))
|
||||
|
||||
|
||||
def shipped_languages():
|
||||
langs = set()
|
||||
for d in RES.glob("values-*"):
|
||||
if (d / "strings.xml").exists():
|
||||
m = re.fullmatch(r"values-([a-z]{2,3})(?:-r([A-Z]{2}))?", d.name)
|
||||
if m:
|
||||
langs.add((m.group(1), m.group(2)))
|
||||
return langs
|
||||
|
||||
|
||||
def main():
|
||||
complete = "--complete" in sys.argv[1:]
|
||||
current = version_code()
|
||||
locales = sorted(d for d in META.iterdir() if d.is_dir())
|
||||
names = {d.name for d in locales}
|
||||
|
||||
for loc in REQUIRED_LOCALES:
|
||||
if loc not in names:
|
||||
err(META / loc, "missing; this locale is a store fallback and must exist")
|
||||
|
||||
for d in locales:
|
||||
has_text = any((d / f).exists() for f in TEXT_LIMITS)
|
||||
for fname, limit in TEXT_LIMITS.items():
|
||||
f = d / fname
|
||||
if not f.exists():
|
||||
if has_text or d.name in REQUIRED_LOCALES:
|
||||
err(f, "missing (a locale with any listing text needs all three files)")
|
||||
continue
|
||||
text = f.read_text(encoding="utf-8").strip()
|
||||
if not text:
|
||||
err(f, "empty")
|
||||
elif len(text) > limit:
|
||||
err(f, f"{len(text)} chars, limit {limit}")
|
||||
if fname == "title.txt" and TITLE_BANNED.search(text):
|
||||
warn(f, "promotional term in the title; Play policy forbids these")
|
||||
for f in sorted((d / "changelogs").glob("*.txt")):
|
||||
n = len(f.read_text(encoding="utf-8").strip())
|
||||
if f.stem == str(current) and n > CHANGELOG_LIMIT:
|
||||
err(f, f"{n} chars, limit {CHANGELOG_LIMIT}; Play would reject this release")
|
||||
elif n > CHANGELOG_LIMIT:
|
||||
warn(f, f"{n} chars, over {CHANGELOG_LIMIT} (already published)")
|
||||
check_images(d)
|
||||
|
||||
for lang, region in sorted(shipped_languages(), key=str):
|
||||
match = f"{lang}-{region}" if region else lang
|
||||
if not any(n == match or n.startswith(f"{lang}-") for n in names):
|
||||
warn(META, f"app ships values-{lang}{'-r' + region if region else ''} "
|
||||
"but there is no store locale for it")
|
||||
|
||||
if complete:
|
||||
images = META / IMAGE_LOCALE / "images"
|
||||
if not (images / "icon.png").exists():
|
||||
err(images / "icon.png", "required for Play")
|
||||
if not list(images.glob("featureGraphic.*")):
|
||||
err(images / "featureGraphic.png", "required for Play (1024x500, no alpha)")
|
||||
if len(list((images / "phoneScreenshots").glob("*"))) < 2:
|
||||
err(images / "phoneScreenshots", "Play requires at least 2 phone screenshots")
|
||||
for loc in REQUIRED_LOCALES if current is not None else []:
|
||||
if not (META / loc / "changelogs" / f"{current}.txt").exists():
|
||||
err(META / loc / "changelogs" / f"{current}.txt", "no What's New for this version")
|
||||
|
||||
for w in warnings:
|
||||
print(f"warning: {w}")
|
||||
for e in errors:
|
||||
print(f"ERROR: {e}", file=sys.stderr)
|
||||
if errors:
|
||||
return 1
|
||||
print(f"Store listing OK ({len(locales)} locales, {len(warnings)} warnings).")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -14,8 +14,8 @@
|
||||
# short_description.txt -> summary.txt
|
||||
# full_description.txt -> description.txt
|
||||
# title.txt -> name.txt
|
||||
# images/icon.png -> icon.png
|
||||
# images/phoneScreenshots/* -> phoneScreenshots/*
|
||||
# images/{icon,featureGraphic,promoGraphic,tvBanner}.* -> same name
|
||||
# images/<type>Screenshots/* -> <type>Screenshots/*
|
||||
# changelogs/<versionCode>.txt -> changelogs/<versionCode>.txt
|
||||
# (changelogs are seeded into the fastlane tree by
|
||||
# scripts/sync_changelog_to_fastlane.sh.)
|
||||
@@ -32,11 +32,14 @@ for locdir in "$SRC"/*/; do
|
||||
[ -f "$locdir/short_description.txt" ] && cp "$locdir/short_description.txt" "$dst/summary.txt"
|
||||
[ -f "$locdir/full_description.txt" ] && cp "$locdir/full_description.txt" "$dst/description.txt"
|
||||
[ -f "$locdir/title.txt" ] && cp "$locdir/title.txt" "$dst/name.txt"
|
||||
[ -f "$locdir/images/icon.png" ] && cp "$locdir/images/icon.png" "$dst/icon.png"
|
||||
if [ -d "$locdir/images/phoneScreenshots" ]; then
|
||||
mkdir -p "$dst/phoneScreenshots"
|
||||
cp "$locdir"images/phoneScreenshots/* "$dst/phoneScreenshots/"
|
||||
fi
|
||||
for img in "$locdir"images/{icon,featureGraphic,promoGraphic,tvBanner}.*; do
|
||||
cp "$img" "$dst/"
|
||||
done
|
||||
for shots in "$locdir"images/*Screenshots/; do
|
||||
t="$(basename "$shots")"
|
||||
mkdir -p "$dst/$t"
|
||||
cp "$shots"* "$dst/$t/"
|
||||
done
|
||||
# Per-version changelogs live in the same fastlane tree (see
|
||||
# scripts/sync_changelog_to_fastlane.sh) and map straight across.
|
||||
if [ -d "$locdir/changelogs" ]; then
|
||||
|
||||
Executable
+96
@@ -0,0 +1,96 @@
|
||||
#!/usr/bin/env bash
|
||||
# Publish TAG on Codeberg, which is canonical for tags and releases, with the
|
||||
# signed APK and its SHA-256 checksum attached: the direct-download channel
|
||||
# that Obtainium follows. Shared by .gitea/workflows/release.yaml (stable) and
|
||||
# beta.yaml (pre-release). Run from the repo checkout: it pushes the tag.
|
||||
#
|
||||
# Codeberg push-mirrors branches and tags to Gitea, but releases aren't git
|
||||
# objects and don't sync in either direction, so this pushes the tag straight
|
||||
# to Codeberg and creates the release over the API. Skips cleanly when TOKEN is
|
||||
# unset; fails loudly on anything else (see release.yaml for why).
|
||||
#
|
||||
# Env:
|
||||
# TOKEN CODEBERG_RELEASE_TOKEN (write:repository); empty = skip
|
||||
# API https://codeberg.org/api/v1/repos/<owner>/<repo>
|
||||
# TAG, SHA vX.Y.Z[-beta.N] and the commit it marks
|
||||
# PRERELEASE true | false
|
||||
# NOTES_FILE release notes (scripts/release_notes.sh)
|
||||
# APK the signed release APK
|
||||
set -euo pipefail
|
||||
if [ -z "${TOKEN:-}" ]; then
|
||||
echo "CODEBERG_RELEASE_TOKEN not set — skipping Codeberg publish."
|
||||
exit 0
|
||||
fi
|
||||
: "${API:?}" "${TAG:?}" "${SHA:?}" "${PRERELEASE:?}" "${NOTES_FILE:?}" "${APK:?}"
|
||||
if [ ! -f "$APK" ]; then echo "No release APK at $APK." >&2; exit 1; fi
|
||||
|
||||
WORK=$(mktemp -d)
|
||||
trap 'rm -rf "$WORK"' EXIT
|
||||
|
||||
ASSET_APK="clockula_${TAG}.apk"
|
||||
ASSET_SUM="${ASSET_APK}.sha256"
|
||||
cp "$APK" "$WORK/$ASSET_APK"
|
||||
( cd "$WORK" && sha256sum "$ASSET_APK" > "$ASSET_SUM" )
|
||||
|
||||
# Push the tag to Codeberg ourselves. Under Codeberg-canonical the mirror runs
|
||||
# Codeberg -> Gitea, so waiting for a tag to arrive from Gitea (what 0.3.2 did)
|
||||
# would wait forever. The tag minted on Gitea is in fact *deleted* by the next
|
||||
# mirror sync until Codeberg has it, so pushing it here is what makes it
|
||||
# durable on both forges.
|
||||
#
|
||||
# Pushing the ref first and creating the release with NO target_commitish is
|
||||
# deliberate: a release POST carrying a target_commitish for a commit or tag
|
||||
# Codeberg hasn't received yet is what produced the empty-bodied 500s.
|
||||
# Attaching to a ref that already exists doesn't need the API to write one.
|
||||
HOST=${API#https://}; HOST=${HOST%%/*}
|
||||
REPO=${API#*/repos/}
|
||||
git tag -f "$TAG" "$SHA"
|
||||
git push -f "https://${REPO%%/*}:${TOKEN}@${HOST}/${REPO}.git" "refs/tags/$TAG"
|
||||
|
||||
python3 - "$TAG" "$PRERELEASE" "$NOTES_FILE" <<'PY' > "$WORK/payload.json"
|
||||
import json, sys
|
||||
tag, pre, notes = sys.argv[1:4]
|
||||
print(json.dumps({
|
||||
"tag_name": tag,
|
||||
"name": tag,
|
||||
"body": open(notes).read(),
|
||||
"draft": False,
|
||||
"prerelease": pre == "true",
|
||||
}))
|
||||
PY
|
||||
|
||||
# Create (or update) the release. Codeberg 500s on a POST/GET against a tag it
|
||||
# has only just received (the release request outruns the indexing of the ref
|
||||
# pushed a moment ago), so a single attempt can fail even though the very same
|
||||
# call succeeds seconds later. Retry with backoff, and PATCH in place if a
|
||||
# release already exists (re-run safe). A 5xx body still exits curl 0, so the
|
||||
# loop, not `set -e`, controls the flow.
|
||||
ID=""
|
||||
for attempt in 1 2 3 4 5 6; do
|
||||
EXIST=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty' 2>/dev/null || true)
|
||||
if [ -n "$EXIST" ]; then
|
||||
curl -s -o /dev/null -w "release PATCH HTTP %{http_code}\n" -X PATCH \
|
||||
-H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
|
||||
-d @"$WORK/payload.json" "$API/releases/$EXIST"
|
||||
ID="$EXIST"; break
|
||||
fi
|
||||
CODE=$(curl -s -o "$WORK/response.json" -w "%{http_code}" -X POST \
|
||||
-H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
|
||||
-d @"$WORK/payload.json" "$API/releases")
|
||||
echo "release POST attempt $attempt HTTP $CODE"
|
||||
ID=$(jq -r '.id // empty' "$WORK/response.json" 2>/dev/null || true)
|
||||
[ -n "$ID" ] && break
|
||||
sleep $((attempt * 10))
|
||||
done
|
||||
if [ -z "$ID" ]; then echo "Could not resolve Codeberg release id after retries." >&2; exit 1; fi
|
||||
|
||||
# Attach APK + checksum, replacing any prior asset of the same name.
|
||||
for A in "$ASSET_APK" "$ASSET_SUM"; do
|
||||
OLD=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" \
|
||||
| jq -r --arg n "$A" '.[] | select(.name==$n) | .id')
|
||||
[ -n "$OLD" ] && curl -s -X DELETE -H "Authorization: token $TOKEN" "$API/releases/$ID/assets/$OLD" >/dev/null || true
|
||||
curl -s -X POST -H "Authorization: token $TOKEN" \
|
||||
-F "attachment=@$WORK/$A" \
|
||||
"$API/releases/$ID/assets?name=$A" -o /dev/null -w "asset $A HTTP %{http_code}\n"
|
||||
done
|
||||
echo "Published $TAG to Codeberg."
|
||||
Executable
+76
@@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env bash
|
||||
# Create (or update) the release for TAG on the Gitea build instance, the
|
||||
# changelog of record there, and attach the R8 mapping. Shared by
|
||||
# .gitea/workflows/release.yaml and beta.yaml.
|
||||
#
|
||||
# Creating it with target_commitish makes Gitea create the tag at SHA, so the
|
||||
# tag only ever marks a fully-shipped version. Upsert, so re-runs are safe.
|
||||
#
|
||||
# Env:
|
||||
# TOKEN, API Gitea token and .../api/v1/repos/<owner>/<repo>
|
||||
# TAG, SHA vX.Y.Z[-beta.N] and the commit it marks
|
||||
# PRERELEASE true | false
|
||||
# NOTES_FILE release notes (scripts/release_notes.sh)
|
||||
# MAPPING optional path to R8's mapping.txt
|
||||
set -euo pipefail
|
||||
: "${TOKEN:?}" "${API:?}" "${TAG:?}" "${SHA:?}" "${PRERELEASE:?}" "${NOTES_FILE:?}"
|
||||
|
||||
WORK=$(mktemp -d)
|
||||
trap 'rm -rf "$WORK"' EXIT
|
||||
|
||||
python3 - "$TAG" "$SHA" "$PRERELEASE" "$NOTES_FILE" <<'PY' > "$WORK/payload.json"
|
||||
import json, sys
|
||||
tag, sha, pre, notes = sys.argv[1:5]
|
||||
print(json.dumps({
|
||||
"tag_name": tag,
|
||||
"target_commitish": sha,
|
||||
"name": tag,
|
||||
"body": open(notes).read(),
|
||||
"draft": False,
|
||||
"prerelease": pre == "true",
|
||||
}))
|
||||
PY
|
||||
|
||||
# PATCH if a release for the tag already exists, else POST a new one (which
|
||||
# also creates the tag at target_commitish).
|
||||
ID=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty' 2>/dev/null || true)
|
||||
if [ -n "$ID" ]; then
|
||||
CODE=$(curl -s -o "$WORK/response.json" -w '%{http_code}' -X PATCH \
|
||||
-H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
|
||||
-d @"$WORK/payload.json" "$API/releases/$ID")
|
||||
OK=200
|
||||
else
|
||||
CODE=$(curl -s -o "$WORK/response.json" -w '%{http_code}' -X POST \
|
||||
-H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
|
||||
-d @"$WORK/payload.json" "$API/releases")
|
||||
OK=201
|
||||
fi
|
||||
cat "$WORK/response.json"; echo
|
||||
if [ "$CODE" != "$OK" ]; then
|
||||
echo "Gitea release upsert failed with HTTP $CODE (expected $OK)" >&2
|
||||
exit 1
|
||||
fi
|
||||
ID=$(jq -r '.id' "$WORK/response.json")
|
||||
echo "Created/updated Gitea release $TAG at $SHA"
|
||||
|
||||
# The R8 mapping keeps user crash stacktraces deobfuscatable. It's not an APK,
|
||||
# so it fits the no-binaries rule for this release. Best-effort: never fail a
|
||||
# release over it.
|
||||
attach_mapping() {
|
||||
local asset="mapping-${TAG#v}.txt.gz" old
|
||||
gzip -c "$MAPPING" > "$WORK/$asset"
|
||||
# Replace any prior asset of the same name (re-run safe).
|
||||
old=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" \
|
||||
| jq -r --arg n "$asset" '.[] | select(.name==$n) | .id')
|
||||
if [ -n "$old" ]; then
|
||||
curl -s -X DELETE -H "Authorization: token $TOKEN" "$API/releases/$ID/assets/$old" >/dev/null
|
||||
fi
|
||||
curl -s -X POST -H "Authorization: token $TOKEN" \
|
||||
-F "attachment=@$WORK/$asset" \
|
||||
"$API/releases/$ID/assets?name=$asset" -o /dev/null -w "asset $asset HTTP %{http_code}\n"
|
||||
}
|
||||
if [ -z "${MAPPING:-}" ] || [ ! -f "$MAPPING" ]; then
|
||||
echo "No mapping.txt (R8 off?) — skipping."
|
||||
else
|
||||
attach_mapping || echo "warning: could not attach the R8 mapping to $TAG" >&2
|
||||
fi
|
||||
Executable
+29
@@ -0,0 +1,29 @@
|
||||
#!/usr/bin/env bash
|
||||
# Print the forge release notes for VERSION: its `## [VERSION]` section of
|
||||
# CHANGELOG.md. A beta (X.Y.Z-beta.N) normally has no section of its own, so it
|
||||
# falls back to `## [Unreleased]`, i.e. what the release branch carries so far,
|
||||
# under a line saying what a beta is.
|
||||
#
|
||||
# scripts/release_notes.sh 1.1.0 > release-notes.md
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.." # repo root
|
||||
|
||||
VERSION=${1:?usage: release_notes.sh VERSION}
|
||||
|
||||
section() {
|
||||
awk -v ver="$1" '
|
||||
$0 ~ "^## \\[" ver "\\]" { flag = 1; next }
|
||||
/^## \[/ { flag = 0 }
|
||||
flag' CHANGELOG.md | sed -e '/./,$!d'
|
||||
}
|
||||
|
||||
NOTES=$(section "$VERSION")
|
||||
if [[ "$VERSION" == *-beta.* ]]; then
|
||||
[ -n "$NOTES" ] || NOTES=$(section Unreleased)
|
||||
printf '%s\n\n' "**Beta of ${VERSION%%-*}, for testing.** It updates in place to later betas and to the stable release. Obtainium only offers betas with *Include prereleases* switched on; F-Droid and Play never get them."
|
||||
fi
|
||||
if [ -n "$NOTES" ]; then
|
||||
printf '%s\n' "$NOTES"
|
||||
else
|
||||
echo "_No changelog entry for ${VERSION} — see CHANGELOG.md._"
|
||||
fi
|
||||
@@ -1,41 +1,58 @@
|
||||
#!/usr/bin/env bash
|
||||
# Write the current version's CHANGELOG.md section into the fastlane changelog
|
||||
# file that F-Droid harvests: fastlane/metadata/android/en-US/changelogs/<code>.txt
|
||||
# (en-US is F-Droid's fallback locale, so it covers every language).
|
||||
# Ensure the current version's "What's New" exists at
|
||||
# fastlane/metadata/android/en-US/changelogs/<code>.txt, which both F-Droid and
|
||||
# Google Play publish.
|
||||
#
|
||||
# Run this when cutting a release (after editing CHANGELOG.md and bumping
|
||||
# versionName in app/build.gradle.kts) and COMMIT the result, so the OFFICIAL
|
||||
# F-Droid repo — which reads the changelog from the tagged source tree — shows
|
||||
# this version's "What's New". The self-hosted release pipeline also runs it so
|
||||
# its changelog never depends on the file having been committed. Idempotent.
|
||||
#
|
||||
# Extraction matches the awk used for the Gitea release notes so all three
|
||||
# (release notes, self-hosted changelog, official changelog) stay in sync.
|
||||
# A COMMITTED file wins and is never rewritten: it is a hand-written summary
|
||||
# under 500 characters (Play's cap), not a copy of the CHANGELOG.md section.
|
||||
# Only when the file is missing is it generated from that section, so the
|
||||
# self-hosted release pipeline always has something to publish. The other
|
||||
# locales' changelogs are written by hand and never touched here.
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.." # repo root
|
||||
|
||||
VERSION=$(grep -oP 'versionName\s*=\s*"\K[^"]+' app/build.gradle.kts)
|
||||
[ -n "$VERSION" ] || { echo "No versionName in app/build.gradle.kts" >&2; exit 1; }
|
||||
MAJOR=${VERSION%%.*}; rest=${VERSION#*.}; MINOR=${rest%%.*}; PATCH=${rest##*.}
|
||||
MAJOR=${MAJOR:-0}; MINOR=${MINOR:-0}; PATCH=${PATCH:-0}
|
||||
VERSION_CODE=$(( MAJOR * 10000 + MINOR * 100 + PATCH ))
|
||||
VERSION=$(bash scripts/version_info.sh version)
|
||||
VERSION_CODE=$(bash scripts/version_info.sh version_code)
|
||||
|
||||
# Betas only ship to Codeberg, whose notes come from CHANGELOG.md. A What's New
|
||||
# file for one would sit in the tree F-Droid and Play read, so none is wanted.
|
||||
if [ "$(bash scripts/version_info.sh channel)" = beta ]; then
|
||||
echo "Beta $VERSION: no store What's New (betas only ship to Codeberg)."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Play rejects a longer "What's New" and F-Droid truncates it in-client.
|
||||
MAX_CHARS=${MAX_CHARS:-500}
|
||||
|
||||
CL_DIR="fastlane/metadata/android/en-US/changelogs"
|
||||
mkdir -p "$CL_DIR"
|
||||
OUT="$CL_DIR/${VERSION_CODE}.txt"
|
||||
|
||||
awk -v ver="$VERSION" '
|
||||
$0 ~ "^## \\[" ver "\\]" { flag = 1; next }
|
||||
/^## \[/ { flag = 0 }
|
||||
flag' CHANGELOG.md > "$OUT"
|
||||
# Trim leading blank lines (same as the pipeline did).
|
||||
sed -i -e '/./,$!d' "$OUT"
|
||||
if [ ! -s "$OUT" ]; then
|
||||
echo "See CHANGELOG.md for $VERSION." > "$OUT"
|
||||
if [ -s "$OUT" ]; then
|
||||
ACTION="Kept"
|
||||
else
|
||||
ACTION="Generated"
|
||||
awk -v ver="$VERSION" '
|
||||
$0 ~ "^## \\[" ver "\\]" { flag = 1; next }
|
||||
/^## \[/ { flag = 0 }
|
||||
flag' CHANGELOG.md > "$OUT"
|
||||
# Trim leading blank lines (same as the pipeline did).
|
||||
sed -i -e '/./,$!d' "$OUT"
|
||||
[ -s "$OUT" ] || echo "See CHANGELOG.md for $VERSION." > "$OUT"
|
||||
fi
|
||||
|
||||
CHARS=$(wc -m < "$OUT" | tr -d ' ')
|
||||
echo "Wrote $OUT (version $VERSION, code $VERSION_CODE, ${CHARS} chars)"
|
||||
if [ "$CHARS" -gt 500 ]; then
|
||||
echo " note: >500 chars — F-Droid may truncate this changelog in-client." >&2
|
||||
# Counted like check_store_listing.py: surrounding whitespace doesn't count.
|
||||
CHARS=$(python3 -c 'import sys; print(len(open(sys.argv[1], encoding="utf-8").read().strip()))' "$OUT")
|
||||
echo "$ACTION $OUT (version $VERSION, code $VERSION_CODE, ${CHARS} chars)"
|
||||
|
||||
# Hard limit, enforced in CI (.forgejo/workflows/ci.yaml) and before a release.
|
||||
if [ "$CHARS" -gt "$MAX_CHARS" ]; then
|
||||
cat >&2 <<MSG
|
||||
ERROR: $OUT is $CHARS characters, over the $MAX_CHARS-character limit.
|
||||
|
||||
F-Droid truncates the in-client changelog, so this one would be cut off
|
||||
mid-sentence and Play would reject the upload. Replace it with a hand-written
|
||||
summary under $MAX_CHARS characters and commit it.
|
||||
MSG
|
||||
exit 1
|
||||
fi
|
||||
Executable
+77
@@ -0,0 +1,77 @@
|
||||
#!/usr/bin/env bash
|
||||
# The one place that turns the committed versionName into a versionCode and a
|
||||
# release channel. The release and beta pipelines, the changelog sync and the
|
||||
# store-listing check all read it from here, so the scheme can't drift between
|
||||
# them.
|
||||
#
|
||||
# versionName channel versionCode
|
||||
# X.Y.Z-beta.N beta X*1000000 + Y*10000 + Z*100 + N (N = 1..98)
|
||||
# X.Y.Z stable X*1000000 + Y*10000 + Z*100 + 99
|
||||
#
|
||||
# A beta's code sits below its own stable release and above everything before
|
||||
# it, so a beta install updates in place to the next beta and then to the
|
||||
# stable version: 1.0.0-beta.1 -> 1000001, 1.0.0 -> 1000099.
|
||||
#
|
||||
# scripts/version_info.sh print version, version_code, base_version,
|
||||
# channel and prerelease as key=value lines
|
||||
# (ready for $GITHUB_OUTPUT)
|
||||
# scripts/version_info.sh <key> print just that value
|
||||
# scripts/version_info.sh --check also fail unless the committed versionCode
|
||||
# matches; the official F-Droid repo builds
|
||||
# the tag as committed, so it must
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.." # repo root
|
||||
|
||||
GRADLE="app/build.gradle.kts"
|
||||
NAME=$(grep -oP 'versionName\s*=\s*"\K[^"]+' "$GRADLE" || true)
|
||||
COMMITTED=$(grep -oP 'versionCode\s*=\s*\K[0-9]+' "$GRADLE" || true)
|
||||
[ -n "$NAME" ] || { echo "No versionName in $GRADLE" >&2; exit 1; }
|
||||
|
||||
if [[ ! "$NAME" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)(-beta\.([0-9]+))?$ ]]; then
|
||||
echo "versionName '$NAME' is neither X.Y.Z nor X.Y.Z-beta.N" >&2
|
||||
exit 1
|
||||
fi
|
||||
MAJOR=$((10#${BASH_REMATCH[1]})); MINOR=$((10#${BASH_REMATCH[2]})); PATCH=$((10#${BASH_REMATCH[3]}))
|
||||
BETA=${BASH_REMATCH[5]:+$((10#${BASH_REMATCH[5]}))}
|
||||
BASE="$MAJOR.$MINOR.$PATCH"
|
||||
|
||||
if [ "$MINOR" -gt 99 ] || [ "$PATCH" -gt 99 ]; then
|
||||
echo "versionName '$NAME': MINOR and PATCH each have room for 0-99" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ -n "$BETA" ]; then
|
||||
if [ "$BETA" -lt 1 ] || [ "$BETA" -gt 98 ]; then
|
||||
echo "versionName '$NAME': beta number must be 1-98 (99 is the stable release)" >&2
|
||||
exit 1
|
||||
fi
|
||||
CHANNEL=beta
|
||||
CODE=$(( MAJOR * 1000000 + MINOR * 10000 + PATCH * 100 + BETA ))
|
||||
else
|
||||
CHANNEL=stable
|
||||
CODE=$(( MAJOR * 1000000 + MINOR * 10000 + PATCH * 100 + 99 ))
|
||||
fi
|
||||
|
||||
# Betas are always pre-releases; so was everything before 1.0.0.
|
||||
if [ "$CHANNEL" = beta ] || [ "$MAJOR" = 0 ]; then PRERELEASE=true; else PRERELEASE=false; fi
|
||||
|
||||
case "${1:-}" in
|
||||
"")
|
||||
printf 'version=%s\nversion_code=%s\nbase_version=%s\nchannel=%s\nprerelease=%s\n' \
|
||||
"$NAME" "$CODE" "$BASE" "$CHANNEL" "$PRERELEASE"
|
||||
;;
|
||||
--check)
|
||||
if [ "$COMMITTED" != "$CODE" ]; then
|
||||
echo "ERROR: $GRADLE has versionCode = ${COMMITTED:-<none>}, but versionName '$NAME' needs $CODE." >&2
|
||||
echo "Set versionCode = $CODE (see docs/RELEASING.md for the scheme)." >&2
|
||||
exit 1
|
||||
fi
|
||||
echo "OK: versionName $NAME -> versionCode $CODE ($CHANNEL)."
|
||||
;;
|
||||
version) echo "$NAME" ;;
|
||||
version_code) echo "$CODE" ;;
|
||||
base_version) echo "$BASE" ;;
|
||||
channel) echo "$CHANNEL" ;;
|
||||
prerelease) echo "$PRERELEASE" ;;
|
||||
*) echo "Unknown key '$1'" >&2; exit 2 ;;
|
||||
esac
|
||||
Reference in new issue
Block a user