Files
myrzx_bot/ranch_web/updates.py
T

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()