397 lines
17 KiB
Python
397 lines
17 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.parse import urlsplit
|
|
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
|
|
TOKEN_FILE_NAME = "update-github-token"
|
|
TOKEN_FILE_ENV = "RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE"
|
|
_TOKEN_LIMIT = 4096
|
|
_RELEASE_FAILURES = {
|
|
"check_failed": "GitHub 发布检查失败,请稍后重试。",
|
|
"access_denied": "无法访问官方 GitHub 发布(401/403/404);请检查服务端 GitHub Token 文件及私有仓库的只读发布权限。",
|
|
"token_file_invalid": "GitHub Token 文件不可用;请检查服务端文件、0600 权限及数据目录 UID 10001 所有权。",
|
|
}
|
|
_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
|
|
|
|
|
|
class GitHubReleaseError(RuntimeError):
|
|
"""Fixed, public explanations; never retain credentials or HTTP bodies."""
|
|
|
|
def __init__(self, code="check_failed"):
|
|
self.code = code if code in _RELEASE_FAILURES else "check_failed"
|
|
super().__init__(_RELEASE_FAILURES[self.code])
|
|
|
|
|
|
def github_token_path(data_dir=None):
|
|
"""An explicit override is a server-side path, never a raw token."""
|
|
override = os.environ.get(TOKEN_FILE_ENV)
|
|
if override is not None:
|
|
if not override or not Path(override).is_absolute():
|
|
raise GitHubReleaseError("token_file_invalid")
|
|
return Path(override)
|
|
return Path(data_dir) / TOKEN_FILE_NAME if data_dir is not None else None
|
|
|
|
|
|
def _validate_token(payload):
|
|
try:
|
|
token = payload.decode("ascii").rstrip("\r\n")
|
|
if not 0 < len(payload) <= _TOKEN_LIMIT or re.fullmatch(r"[!-~]+", token) is None:
|
|
raise ValueError
|
|
except (UnicodeError, ValueError):
|
|
raise GitHubReleaseError("token_file_invalid") from None
|
|
return token
|
|
|
|
|
|
def _github_token(data_dir):
|
|
path = github_token_path(data_dir)
|
|
if path is None:
|
|
return None
|
|
flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
|
|
try:
|
|
if path.is_symlink():
|
|
raise GitHubReleaseError("token_file_invalid")
|
|
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_nlink != 1 or info.st_size > _TOKEN_LIMIT
|
|
or (os.name == "posix" and stat.S_IMODE(info.st_mode) != 0o600)):
|
|
raise GitHubReleaseError("token_file_invalid")
|
|
return _validate_token(stream.read(_TOKEN_LIMIT + 1))
|
|
except FileNotFoundError:
|
|
if TOKEN_FILE_ENV not in os.environ:
|
|
return None # Existing public deployments need no credential.
|
|
raise GitHubReleaseError("token_file_invalid") from None
|
|
except OSError:
|
|
raise GitHubReleaseError("token_file_invalid") from None
|
|
|
|
|
|
def github_releases(data_dir=None):
|
|
"""Fetch fixed official releases using only an optional server token file."""
|
|
# Validate before loading credentials, even if a caller monkey-patches the URL.
|
|
endpoint = urlsplit(RELEASES_API)
|
|
if (endpoint.scheme != "https" or endpoint.netloc != "api.github.com"
|
|
or endpoint.path != f"/repos/{REPOSITORY}/releases" or endpoint.query or endpoint.fragment):
|
|
raise GitHubReleaseError()
|
|
token = _github_token(data_dir)
|
|
opener = build_opener(_NoRedirect())
|
|
releases = []
|
|
for page in range(1, 11):
|
|
headers = {
|
|
"Accept": "application/vnd.github+json",
|
|
"User-Agent": "ranch-web-release-checker/2",
|
|
"X-GitHub-Api-Version": "2022-11-28",
|
|
}
|
|
if token is not None:
|
|
headers["Authorization"] = f"Bearer {token}"
|
|
request = Request(f"{RELEASES_API}?per_page=100&page={page}", headers=headers)
|
|
try:
|
|
with opener.open(request, timeout=8) as response:
|
|
payload = response.read(2 * 1024 * 1024 + 1)
|
|
if len(payload) > 2 * 1024 * 1024:
|
|
raise ValueError
|
|
items = json.loads(payload)
|
|
if not isinstance(items, list) or len(items) > 100:
|
|
raise ValueError
|
|
except HTTPError as error:
|
|
error.close()
|
|
raise GitHubReleaseError("access_denied" if error.code in {401, 403, 404} else "check_failed") from None
|
|
except Exception:
|
|
raise GitHubReleaseError() from None
|
|
releases.extend(items)
|
|
if len(items) < 100:
|
|
return releases
|
|
raise GitHubReleaseError()
|
|
|
|
|
|
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"]
|
|
failure = cache.get("failure")
|
|
failure = failure if isinstance(failure, str) else None
|
|
message = (_RELEASE_FAILURES.get(failure, _MESSAGES[state])
|
|
if state == "check_failed" else _MESSAGES[state])
|
|
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": message,
|
|
"error": message 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(self.root))
|
|
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 GitHubReleaseError as error:
|
|
cache = {"status": "check_failed", "failure": error.code,
|
|
"latest_version": None, "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(self.root))
|
|
except GitHubReleaseError as error:
|
|
raise ValueError(str(error)) from None
|
|
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()
|