318 lines
14 KiB
Python
318 lines
14 KiB
Python
"""Official stable Web 2 releases and a file-only host updater handshake.
|
|
|
|
This module is also used by the Linux host, so it imports no application, Qt,
|
|
HTTP framework, or third-party library. It never executes an update itself.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from datetime import datetime, timedelta, timezone
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import stat
|
|
import tempfile
|
|
import threading
|
|
from urllib.error import HTTPError
|
|
from urllib.request import HTTPRedirectHandler, Request, build_opener
|
|
import uuid
|
|
|
|
REPOSITORY = "attilanet/myrzx_bot"
|
|
IMAGE = "ghcr.io/attilanet/myrzx_bot-web"
|
|
RELEASES_API = f"https://api.github.com/repos/{REPOSITORY}/releases"
|
|
PROTOCOL = 1
|
|
_TAG = re.compile(r"v2\.(0|[1-9][0-9]{0,8})\.(0|[1-9][0-9]{0,8})", re.ASCII)
|
|
_CURRENT = re.compile(r"v?2\.(0|[1-9][0-9]{0,8})\.(0|[1-9][0-9]{0,8})(\.dev[0-9]+)?", re.ASCII)
|
|
_ID = re.compile(r"[0-9a-f]{32}", re.ASCII)
|
|
HOST_STATES = frozenset({"pending", "applying", "succeeded", "rolled_back", "failed"})
|
|
_MESSAGES = {
|
|
"unchecked": "尚未检查官方 Web 2 正式版本。",
|
|
"no_release": "官方尚无稳定 Web 2 正式版;不会安装旧版桌面程序。",
|
|
"up_to_date": "当前已是最新稳定 Web 2 版本。",
|
|
"available": "发现稳定 Web 2 更新。",
|
|
"check_failed": "GitHub 发布检查失败,请稍后重试。",
|
|
"unavailable": "未启用有效的 Linux 宿主机执行器;当前仅可检查更新。",
|
|
"pending": "更新请求已提交,等待宿主机处理。",
|
|
"applying": "宿主机正在备份、更新并检查服务健康。",
|
|
"succeeded": "宿主机已确认更新后服务健康。",
|
|
"rolled_back": "更新未通过健康检查,宿主机已恢复旧镜像及更新前数据。",
|
|
"failed": "宿主机更新失败,请操作者检查部署状态。",
|
|
}
|
|
|
|
|
|
def utc_now():
|
|
return datetime.now(timezone.utc)
|
|
|
|
|
|
def timestamp(value=None):
|
|
return (value or utc_now()).isoformat(timespec="seconds").replace("+00:00", "Z")
|
|
|
|
|
|
def parse_time(value):
|
|
if not isinstance(value, str) or len(value) > 40:
|
|
return None
|
|
try:
|
|
result = datetime.fromisoformat(value.replace("Z", "+00:00"))
|
|
except ValueError:
|
|
return None
|
|
return result.astimezone(timezone.utc) if result.tzinfo is not None else None
|
|
|
|
|
|
def stable_version(tag):
|
|
"""Accept only canonical official image tags in the stable 2.x channel."""
|
|
match = _TAG.fullmatch(tag) if isinstance(tag, str) else None
|
|
if match is None:
|
|
raise ValueError("更新版本必须是稳定的 v2.x.y,且数字不含前导零。")
|
|
return 2, int(match[1]), int(match[2]), 1
|
|
|
|
|
|
def current_version_key(version):
|
|
match = _CURRENT.fullmatch(version) if isinstance(version, str) else None
|
|
if match is None:
|
|
raise ValueError("当前 Web 版本必须是 2.x.y 或 2.x.y.devN。")
|
|
return 2, int(match[1]), int(match[2]), int(match[3] is None)
|
|
|
|
|
|
def validate_image_release(repository, tag, source_version):
|
|
"""Gate publishing on the official repository and the actual source version."""
|
|
if not isinstance(repository, str) or repository.lower() != REPOSITORY:
|
|
raise ValueError("只有官方仓库可发布此镜像。")
|
|
stable_version(tag)
|
|
if source_version != tag[1:]:
|
|
raise ValueError("源码版本必须与稳定发布标签完全一致。")
|
|
return tag
|
|
|
|
|
|
def valid_id(value):
|
|
return isinstance(value, str) and _ID.fullmatch(value) is not None
|
|
|
|
|
|
def read_json(path, *, limit=65536):
|
|
"""Read a small regular control file without following Linux symlinks."""
|
|
flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
|
|
try:
|
|
if Path(path).is_symlink():
|
|
return None
|
|
descriptor = os.open(path, flags)
|
|
with os.fdopen(descriptor, "rb") as stream:
|
|
info = os.fstat(stream.fileno())
|
|
if not stat.S_ISREG(info.st_mode) or info.st_size > limit:
|
|
return None
|
|
payload = stream.read(limit + 1)
|
|
if len(payload) > limit:
|
|
return None
|
|
return json.loads(payload)
|
|
except (OSError, ValueError, UnicodeError):
|
|
return None
|
|
|
|
|
|
def atomic_json(path, value, *, mode=0o644):
|
|
"""Replace a complete control file; never write through a destination link."""
|
|
path = Path(path)
|
|
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
|
|
descriptor, temporary = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
|
|
try:
|
|
with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as stream:
|
|
os.chmod(temporary, mode)
|
|
json.dump(value, stream, ensure_ascii=False, indent=2)
|
|
stream.write("\n")
|
|
stream.flush()
|
|
os.fsync(stream.fileno())
|
|
os.replace(temporary, path)
|
|
finally:
|
|
if os.path.exists(temporary):
|
|
os.unlink(temporary)
|
|
|
|
|
|
class _NoRedirect(HTTPRedirectHandler):
|
|
def redirect_request(self, req, fp, code, msg, headers, newurl):
|
|
return None
|
|
|
|
|
|
def github_releases():
|
|
"""Fetch only the fixed public repository. No tokens or asset downloads."""
|
|
opener = build_opener(_NoRedirect())
|
|
releases = []
|
|
for page in range(1, 11):
|
|
request = Request(f"{RELEASES_API}?per_page=100&page={page}", headers={
|
|
"Accept": "application/vnd.github+json",
|
|
"User-Agent": "ranch-web-release-checker/2",
|
|
"X-GitHub-Api-Version": "2022-11-28",
|
|
})
|
|
try:
|
|
with opener.open(request, timeout=8) as response:
|
|
payload = response.read(2 * 1024 * 1024 + 1)
|
|
except HTTPError as error:
|
|
if error.code == 404: # A repository without public releases.
|
|
return []
|
|
raise
|
|
if len(payload) > 2 * 1024 * 1024:
|
|
raise ValueError("发布列表超出大小限制。")
|
|
items = json.loads(payload)
|
|
if not isinstance(items, list) or len(items) > 100:
|
|
raise ValueError("发布列表格式无效。")
|
|
releases.extend(items)
|
|
if len(items) < 100:
|
|
return releases
|
|
raise ValueError("发布列表超出页数限制,请稍后重试。")
|
|
|
|
|
|
def official_tags(releases):
|
|
tags = set()
|
|
for release in releases:
|
|
if not isinstance(release, dict):
|
|
continue
|
|
if release.get("draft") is not False or release.get("prerelease") is not False:
|
|
continue
|
|
tag = release.get("tag_name")
|
|
try:
|
|
stable_version(tag)
|
|
except ValueError:
|
|
continue
|
|
tags.add(tag)
|
|
return tags
|
|
|
|
|
|
class UpdateService:
|
|
def __init__(self, root, current_version):
|
|
self.root = Path(root)
|
|
self.current_version = current_version
|
|
self._current = current_version_key(current_version)
|
|
self._lock = threading.RLock()
|
|
|
|
def _executor(self):
|
|
directory = os.environ.get("RANCH_WEB_UPDATER_DIR", "")
|
|
result = {"configured": False, "enabled": False, "auto_apply": False,
|
|
"state": "unconfigured", "heartbeat_at": None}
|
|
if not directory:
|
|
return result, None
|
|
value = read_json(Path(directory) / "capability.json")
|
|
if not isinstance(value, dict) or value.get("protocol") != PROTOCOL:
|
|
return result, None
|
|
if not valid_id(value.get("executor_id")):
|
|
return result, None
|
|
seen, expiry = parse_time(value.get("heartbeat_at")), parse_time(value.get("expires_at"))
|
|
if seen is None or expiry is None:
|
|
return result, None
|
|
now = utc_now()
|
|
result.update(configured=True, heartbeat_at=timestamp(seen),
|
|
auto_apply=value.get("auto_apply") is True)
|
|
if seen > now + timedelta(seconds=60) or expiry <= now or expiry > seen + timedelta(minutes=16):
|
|
result["state"] = "expired"
|
|
return result, None
|
|
result["enabled"] = value.get("enabled") is True
|
|
result["state"] = "ready" if result["enabled"] else "disabled"
|
|
return result, value["executor_id"] if result["enabled"] else None
|
|
|
|
def _request(self):
|
|
value = read_json(self.root / "update-request.json")
|
|
if not isinstance(value, dict) or value.get("protocol") != PROTOCOL:
|
|
return None
|
|
if not valid_id(value.get("request_id")) or parse_time(value.get("requested_at")) is None:
|
|
return None
|
|
try:
|
|
stable_version(value.get("version"))
|
|
except ValueError:
|
|
return None
|
|
return {key: value[key] for key in ("request_id", "version", "requested_at")}
|
|
|
|
def _host_status(self):
|
|
value = read_json(self.root / "updater-status.json")
|
|
if not isinstance(value, dict) or value.get("protocol") != PROTOCOL:
|
|
return None
|
|
if value.get("status") not in HOST_STATES or not valid_id(value.get("request_id")):
|
|
return None
|
|
if parse_time(value.get("updated_at")) is None:
|
|
return None
|
|
try:
|
|
stable_version(value.get("version"))
|
|
except ValueError:
|
|
return None
|
|
# Advisory files in /data are not trusted to supply public free text.
|
|
result = {key: value[key] for key in ("request_id", "status", "version", "updated_at")}
|
|
result["error"] = _MESSAGES[value["status"]] if value["status"] in {"failed", "rolled_back"} else None
|
|
return result
|
|
|
|
def status(self):
|
|
with self._lock:
|
|
cache = read_json(self.root / "update-check.json")
|
|
cache = cache if isinstance(cache, dict) else {}
|
|
state = cache.get("status", "unchecked")
|
|
if state not in {"unchecked", "no_release", "up_to_date", "available", "check_failed"}:
|
|
state = "unchecked"
|
|
checked = parse_time(cache.get("checked_at"))
|
|
latest = cache.get("latest_version")
|
|
try:
|
|
key = stable_version(latest)
|
|
except ValueError:
|
|
latest, key = None, None
|
|
available = key is not None and key > self._current and state != "check_failed"
|
|
if latest and state != "check_failed":
|
|
state = "available" if available else "up_to_date"
|
|
elif state in {"available", "up_to_date"}:
|
|
state = "unchecked"
|
|
executor, _ = self._executor()
|
|
request, host = self._request(), self._host_status()
|
|
if request:
|
|
request["status"] = "pending"
|
|
if host and host["request_id"] == request["request_id"]:
|
|
request["status"] = host["status"]
|
|
state = request["status"]
|
|
elif host:
|
|
state = host["status"]
|
|
result = {
|
|
"current_version": self.current_version, "latest_version": latest,
|
|
"available": available, "checked_at": timestamp(checked) if checked else None,
|
|
"release_url": f"https://github.com/{REPOSITORY}/releases/tag/{latest}" if latest else None,
|
|
"channel": "stable-2.x", "repository": REPOSITORY,
|
|
"status": state, "message": _MESSAGES[state],
|
|
"error": _MESSAGES[state] if state in {"check_failed", "failed", "rolled_back"} else None,
|
|
"can_apply": available and executor["enabled"] and state not in {"pending", "applying"},
|
|
"executor": executor, "request": request, "host_status": host,
|
|
}
|
|
return result
|
|
|
|
def check(self):
|
|
with self._lock:
|
|
try:
|
|
tags = official_tags(github_releases())
|
|
latest = max(tags, key=stable_version) if tags else None
|
|
state = "no_release" if latest is None else "available" if stable_version(latest) > self._current else "up_to_date"
|
|
cache = {"status": state, "latest_version": latest, "checked_at": timestamp()}
|
|
except Exception:
|
|
# Never expose response bodies, proxy addresses, tokens, or paths.
|
|
cache = {"status": "check_failed", "latest_version": None, "checked_at": timestamp()}
|
|
atomic_json(self.root / "update-check.json", cache)
|
|
return self.status()
|
|
|
|
def request_update(self, version=None):
|
|
with self._lock:
|
|
if version is not None:
|
|
stable_version(version)
|
|
executor, executor_id = self._executor()
|
|
if not executor["enabled"]:
|
|
result = self.status()
|
|
result.update(status="unavailable", message=_MESSAGES["unavailable"], can_apply=False)
|
|
return result
|
|
state = self.status()
|
|
if state["status"] in {"pending", "applying"}:
|
|
return state
|
|
# Revalidate against live official releases, never just a local cache.
|
|
try:
|
|
tags = official_tags(github_releases())
|
|
except Exception:
|
|
raise ValueError(_MESSAGES["check_failed"]) from None
|
|
target = version or (max(tags, key=stable_version) if tags else None)
|
|
if target is None or target not in tags:
|
|
raise ValueError("指定版本不是官方已发布的稳定 Web 2 正式版。")
|
|
if stable_version(target) <= self._current:
|
|
raise ValueError("仅允许升级到比当前版本更新的稳定 Web 2 正式版。")
|
|
atomic_json(self.root / "update-check.json", {
|
|
"status": "available", "latest_version": max(tags, key=stable_version), "checked_at": timestamp(),
|
|
})
|
|
atomic_json(self.root / "update-request.json", {
|
|
"protocol": PROTOCOL, "request_id": uuid.uuid4().hex, "executor_id": executor_id,
|
|
"version": target, "requested_at": timestamp(),
|
|
}, mode=0o600)
|
|
return self.status()
|