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