Add Web 2 workspace and controlled deployment updates
This commit is contained in:
@@ -0,0 +1,669 @@
|
||||
"""FastAPI transport and administrator boundary for the headless workspace."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import OrderedDict
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import replace
|
||||
import hashlib
|
||||
import inspect
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path as FilePath
|
||||
import re
|
||||
import secrets
|
||||
import threading
|
||||
import time
|
||||
from typing import Annotated, Any
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from fastapi import FastAPI, HTTPException, Path, Query, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
from starlette.responses import FileResponse, JSONResponse, Response
|
||||
from starlette.staticfiles import StaticFiles
|
||||
|
||||
from . import GAME_VERSION, __version__
|
||||
from .config import COOKIE_NAME, WebConfig, is_loopback, normalize_host, normalize_origin, verify_password
|
||||
|
||||
|
||||
PAGES = tuple("login incubator bag ranch daily hatching mainline battles gifts commissions exploration maps statistics plans yields".split())
|
||||
ACTIONS = frozenset("refresh refresh_maps refresh_tasks claim_daily lock unlock sell feed quote_expansion expand export_config import_config import_yields reset_map_pending login enter_server restore_session logout forget_login start stop".split())
|
||||
Identifier = Annotated[str, Path(pattern=r"^[A-Za-z0-9_-]{1,80}$")]
|
||||
_PUBLIC_PATHS = frozenset({"/api/health", "/api/meta", "/api/auth/status", "/api/auth/login", "/api/auth/logout"})
|
||||
_WRITES = frozenset({"POST", "PUT", "PATCH", "DELETE"})
|
||||
_JOB_STATUSES = frozenset({"queued", "running", "succeeded", "failed", "cancelled"})
|
||||
_PRIVATE_KEYS = frozenset({"key", "reqid", "reqsid", "requestid", "password", "passwordhash", "passwd", "pwd", "userpwd", "newpass", "secret", "credentials", "protected", "authorization", "cookie", "setcookie", "raw", "snapshot", "rawsnapshot", "profileroot", "stateroot", "dataroot", "datadir", "filepath", "budgetpath", "private", "headers", "body", "request", "response"})
|
||||
_METADATA_CONTEXTS = frozenset({"columns", "fields", "filters", "form", "pages", "options", "tabs"})
|
||||
_FILE_KEYS = frozenset({"path", "filepath", "fileroot", "root", "profileroot", "stateroot", "datadir", "budgetpath"})
|
||||
_YIELDS_IMPORT_PATH = re.compile(r"/api/accounts/[A-Za-z0-9_-]{1,80}/actions/import_yields")
|
||||
_YIELDS_IMPORT_BODY_BYTES = 12 * 1024 * 1024
|
||||
|
||||
|
||||
def _error(status: int, code: str, message: str) -> JSONResponse:
|
||||
return JSONResponse({"error": {"code": code, "message": message}, "detail": message}, status_code=status)
|
||||
|
||||
|
||||
class _Redactor:
|
||||
def __init__(self, settings: WebConfig):
|
||||
self.lock = threading.Lock()
|
||||
self.secrets: set[str] = set()
|
||||
self.paths = {str(settings.data_dir), settings.data_dir.as_posix()}
|
||||
|
||||
def remember(self, value: Any) -> None:
|
||||
if isinstance(value, dict):
|
||||
for key, item in value.items():
|
||||
name = str(key).lower().replace("_", "").replace("-", "")
|
||||
if name in _PRIVATE_KEYS or "token" in name or "password" in name or name.endswith(("key", "secret")):
|
||||
if isinstance(item, str) and item:
|
||||
with self.lock:
|
||||
if len(self.secrets) < 4096:
|
||||
self.secrets.add(item)
|
||||
elif isinstance(item, (list, dict)):
|
||||
self.remember(item)
|
||||
elif isinstance(value, list):
|
||||
for item in value:
|
||||
self.remember(item)
|
||||
|
||||
def text(self, value: str) -> str:
|
||||
with self.lock:
|
||||
known = sorted(self.secrets, key=len, reverse=True)
|
||||
for secret in known:
|
||||
value = value.replace(secret, "<隐藏>")
|
||||
for path in sorted(self.paths, key=len, reverse=True):
|
||||
value = value.replace(path, "<本地目录>")
|
||||
value = re.sub(
|
||||
r'''(?i)(["']?(?:password|passwd|pwd|[\w-]*token|secret|authorization|cookie|reqsid|reqid|key)["']?\s*[:=]\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;&}\r\n]+)''',
|
||||
lambda m: m[1] + "<隐藏>", value,
|
||||
)
|
||||
value = re.sub(r"(?i)\b(?:Bearer|Basic)\s+[A-Za-z0-9+/=_\-.]+", "<隐藏>", value)
|
||||
value = re.sub(r"[A-Za-z]:[\\/][^\s\"'<>]*", "<本地路径>", value)
|
||||
value = re.sub(r"(?<![\w:/])/[^/\s\"'<>][^\s\"'<>]*", "<本地路径>", value)
|
||||
value = re.sub(r"\\\\[^\s\"'<>]+", "<本地路径>", value)
|
||||
return value[:32_000]
|
||||
|
||||
def public(self, value: Any, *, context: str = "", trace: bool = False, depth: int = 0) -> Any:
|
||||
if depth > 32:
|
||||
return None
|
||||
if value is None or type(value) in (bool, int):
|
||||
return value
|
||||
if type(value) is float:
|
||||
return value if math.isfinite(value) else None
|
||||
if isinstance(value, str):
|
||||
return self.text(value)
|
||||
if isinstance(value, (list, tuple)):
|
||||
return [self.public(item, context=context, trace=trace, depth=depth + 1) for item in value]
|
||||
if isinstance(value, dict):
|
||||
result = {}
|
||||
for field, item in value.items():
|
||||
if not isinstance(field, str):
|
||||
field = str(field)
|
||||
name = field.lower().replace("_", "").replace("-", "")
|
||||
if name == "hassavedpassword":
|
||||
if type(item) is bool:
|
||||
result[field] = item
|
||||
continue
|
||||
metadata_key = name == "key" and context in _METADATA_CONTEXTS and not trace
|
||||
envelope = trace and name in {"headers", "body", "request", "response"}
|
||||
private = name in _PRIVATE_KEYS or "token" in name or "password" in name or name.endswith(("key", "secret"))
|
||||
if private and not (metadata_key or envelope):
|
||||
if trace:
|
||||
result[field] = "<隐藏>"
|
||||
continue
|
||||
result[field] = self.public(item, context=field, trace=trace, depth=depth + 1)
|
||||
return result
|
||||
# Never serialize arbitrary Engine / Session / Snapshot / Path objects.
|
||||
return None
|
||||
|
||||
|
||||
class _Sessions:
|
||||
def __init__(self, settings: WebConfig):
|
||||
self.settings = settings
|
||||
self.lock = threading.Lock()
|
||||
self.sessions: OrderedDict[str, float] = OrderedDict()
|
||||
self.failures: OrderedDict[str, list[tuple[float, object]]] = OrderedDict()
|
||||
|
||||
def authenticated(self, request: Request) -> bool:
|
||||
if not self.settings.credential:
|
||||
return bool(request.client and is_loopback(request.client.host))
|
||||
token = request.cookies.get(COOKIE_NAME, "")
|
||||
if not re.fullmatch(r"[A-Za-z0-9_-]{43}", token):
|
||||
return False
|
||||
digest = hashlib.sha256(token.encode()).hexdigest()
|
||||
with self.lock:
|
||||
expiry = self.sessions.get(digest)
|
||||
if expiry is not None and expiry > time.monotonic():
|
||||
return True
|
||||
self.sessions.pop(digest, None)
|
||||
return False
|
||||
|
||||
def login(self, request: Request, password: str) -> str:
|
||||
peer = request.client.host if request.client else "unknown"
|
||||
now = time.monotonic()
|
||||
reservation = object()
|
||||
with self.lock:
|
||||
failures = [entry for entry in self.failures.get(peer, []) if entry[0] > now - 60]
|
||||
if len(failures) >= 10:
|
||||
raise HTTPException(429, "尝试过于频繁,请稍后再试")
|
||||
# Pending verifications count against the same bounded per-peer budget.
|
||||
self.failures[peer] = failures + [(now, reservation)]
|
||||
self.failures.move_to_end(peer)
|
||||
while len(self.failures) > 1024:
|
||||
self.failures.popitem(last=False)
|
||||
# PBKDF work runs outside the session lock, independently for each request.
|
||||
if not verify_password(password, self.settings.credential):
|
||||
raise HTTPException(401, "管理密码错误")
|
||||
token = secrets.token_urlsafe(32)
|
||||
digest = hashlib.sha256(token.encode()).hexdigest()
|
||||
now = time.monotonic()
|
||||
with self.lock:
|
||||
failures = [entry for entry in self.failures.get(peer, [])
|
||||
if entry[1] is not reservation and entry[0] > now - 60]
|
||||
if failures:
|
||||
self.failures[peer] = failures
|
||||
else:
|
||||
self.failures.pop(peer, None)
|
||||
expired = [key for key, expiry in self.sessions.items() if expiry <= now]
|
||||
for key in expired:
|
||||
del self.sessions[key]
|
||||
while len(self.sessions) >= 256:
|
||||
self.sessions.popitem(last=False)
|
||||
self.sessions[digest] = now + self.settings.session_ttl
|
||||
self.logout(request)
|
||||
return token
|
||||
|
||||
def logout(self, request: Request) -> None:
|
||||
token = request.cookies.get(COOKIE_NAME, "")
|
||||
with self.lock:
|
||||
self.sessions.pop(hashlib.sha256(token.encode()).hexdigest(), None)
|
||||
|
||||
|
||||
class _Boundary:
|
||||
"""Bounded ASGI body buffering and checks before any API handler runs."""
|
||||
|
||||
def __init__(self, app, *, settings: WebConfig, sessions: _Sessions):
|
||||
self.app, self.settings, self.sessions = app, settings, sessions
|
||||
|
||||
async def __call__(self, scope, receive, send):
|
||||
if scope["type"] != "http":
|
||||
await self.app(scope, receive, send)
|
||||
return
|
||||
request = Request(scope)
|
||||
|
||||
async def deny(status, code, message):
|
||||
await _error(status, code, message)(scope, receive, secure_send)
|
||||
|
||||
async def secure_send(message):
|
||||
if message["type"] == "http.response.start":
|
||||
headers = list(message.get("headers", []))
|
||||
headers.extend([
|
||||
(b"x-content-type-options", b"nosniff"),
|
||||
(b"referrer-policy", b"same-origin"),
|
||||
(b"x-frame-options", b"DENY"),
|
||||
(b"content-security-policy", b"default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; object-src 'none'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'"),
|
||||
])
|
||||
if scope["path"].startswith("/api/"):
|
||||
headers.append((b"cache-control", b"no-store"))
|
||||
message = {**message, "headers": headers}
|
||||
await send(message)
|
||||
|
||||
hosts = request.headers.getlist("host")
|
||||
try:
|
||||
if len(hosts) != 1 or any(c in hosts[0] for c in "@/\\?# \t\r\n,"):
|
||||
raise ValueError
|
||||
parsed = urlsplit("http://" + hosts[0])
|
||||
host = normalize_host(parsed.hostname or "")
|
||||
if parsed.port is not None and not 1 <= parsed.port <= 65535:
|
||||
raise ValueError
|
||||
if host not in self.settings.trusted_hosts:
|
||||
raise ValueError
|
||||
except ValueError:
|
||||
await deny(400, "invalid_host", "请求主机不受信任")
|
||||
return
|
||||
|
||||
is_api = scope["path"] == "/api" or scope["path"].startswith("/api/")
|
||||
if is_api and request.method in _WRITES:
|
||||
origins = request.headers.getlist("origin")
|
||||
fetch_site = request.headers.get("sec-fetch-site", "")
|
||||
try:
|
||||
if fetch_site == "cross-site" or len(origins) > 1:
|
||||
raise ValueError
|
||||
if origins:
|
||||
origin = normalize_origin(origins[0])
|
||||
same_origin = normalize_origin(f"{scope['scheme']}://{hosts[0]}")
|
||||
if origin not in {same_origin, *self.settings.allowed_origins}:
|
||||
raise ValueError
|
||||
elif fetch_site not in {"", "none", "same-origin"}:
|
||||
raise ValueError
|
||||
except ValueError:
|
||||
await deny(403, "invalid_origin", "禁止跨站操作,请从当前工作台发起请求")
|
||||
return
|
||||
if is_api and scope["path"] not in _PUBLIC_PATHS and not self.sessions.authenticated(request):
|
||||
status = 401 if self.settings.credential else 403
|
||||
await deny(status, "authentication_required", "请先登录管理工作台" if status == 401 else "本机免密模式只允许本机访问")
|
||||
return
|
||||
if not is_api:
|
||||
await self.app(scope, receive, secure_send)
|
||||
return
|
||||
if len(scope.get("query_string", b"")) > 16_384:
|
||||
await deny(414, "query_too_large", "查询条件过长")
|
||||
return
|
||||
body_limit = self.settings.max_body_bytes
|
||||
if request.method == "POST" and _YIELDS_IMPORT_PATH.fullmatch(scope["path"]):
|
||||
# An 8 MiB file expands to about 10.7 MiB in base64, plus JSON metadata.
|
||||
body_limit = _YIELDS_IMPORT_BODY_BYTES
|
||||
lengths = request.headers.getlist("content-length")
|
||||
try:
|
||||
if len(lengths) > 1 or (lengths and (not lengths[0].isascii() or not lengths[0].isdecimal())):
|
||||
raise ValueError
|
||||
declared = int(lengths[0]) if lengths else None
|
||||
except ValueError:
|
||||
await deny(400, "invalid_length", "请求正文长度无效")
|
||||
return
|
||||
if declared is not None and declared > body_limit:
|
||||
await deny(413, "body_too_large", "请求正文超过允许大小")
|
||||
return
|
||||
if request.headers.get("content-encoding", "identity").lower() != "identity":
|
||||
await deny(415, "unsupported_encoding", "请求正文不支持压缩编码")
|
||||
return
|
||||
chunks, size = [], 0
|
||||
while True:
|
||||
part = await receive()
|
||||
if part["type"] == "http.disconnect":
|
||||
return
|
||||
chunk = part.get("body", b"")
|
||||
size += len(chunk)
|
||||
if size > body_limit:
|
||||
await deny(413, "body_too_large", "请求正文超过允许大小")
|
||||
return
|
||||
chunks.append(chunk)
|
||||
if not part.get("more_body", False):
|
||||
break
|
||||
if declared is not None and size != declared:
|
||||
await deny(400, "invalid_length", "请求正文长度与声明不符")
|
||||
return
|
||||
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
|
||||
if size and request.method in _WRITES and content_type != "application/json":
|
||||
await deny(415, "unsupported_media_type", "请使用 application/json 提交请求")
|
||||
return
|
||||
buffered = b"".join(chunks)
|
||||
delivered = False
|
||||
|
||||
async def replay():
|
||||
nonlocal delivered
|
||||
if not delivered:
|
||||
delivered = True
|
||||
return {"type": "http.request", "body": buffered, "more_body": False}
|
||||
return await receive()
|
||||
|
||||
await self.app(scope, replay, secure_send)
|
||||
|
||||
|
||||
class _Input(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
|
||||
class AccountInput(_Input):
|
||||
label: Annotated[StrictStr, Field(max_length=200)] = ""
|
||||
demo: StrictBool = True
|
||||
|
||||
|
||||
class ConfigInput(_Input):
|
||||
config: dict[str, Any]
|
||||
revision: Annotated[StrictInt, Field(ge=0)] | None = None
|
||||
|
||||
|
||||
class LoginInput(_Input):
|
||||
password: Annotated[StrictStr, Field(min_length=1, max_length=1024)]
|
||||
|
||||
|
||||
class UpdateInput(_Input):
|
||||
version: Annotated[StrictStr, Field(max_length=64)] | None = None
|
||||
|
||||
|
||||
def _no_file_paths(value: Any, depth: int = 0) -> None:
|
||||
if depth > 32:
|
||||
raise HTTPException(400, "请求内容嵌套过深")
|
||||
if isinstance(value, dict):
|
||||
for field, item in value.items():
|
||||
name = str(field).lower().replace("_", "").replace("-", "")
|
||||
if name in _FILE_KEYS:
|
||||
raise HTTPException(400, "不允许通过 API 指定服务器文件路径")
|
||||
if name == "filename" and (not isinstance(item, str) or re.search(r"[\\/:\x00]", item) or item.startswith(".")):
|
||||
raise HTTPException(400, "导入文件名必须是不含路径的名称")
|
||||
_no_file_paths(item, depth + 1)
|
||||
elif isinstance(value, list):
|
||||
for item in value:
|
||||
_no_file_paths(item, depth + 1)
|
||||
|
||||
|
||||
class _Assets(StaticFiles):
|
||||
async def get_response(self, path, scope):
|
||||
allowed = {".html", ".js", ".mjs", ".css", ".svg", ".png", ".jpg", ".jpeg", ".webp", ".ico", ".woff", ".woff2"}
|
||||
parts = path.replace("\\", "/").split("/")
|
||||
if any(part.startswith(".") for part in parts) or FilePath(path).suffix.lower() not in allowed:
|
||||
raise HTTPException(404, "静态资源不存在")
|
||||
return await super().get_response(path, scope)
|
||||
|
||||
|
||||
def create_app(data_dir=None, manager=None, config=None, updates=None) -> FastAPI:
|
||||
"""Create an application; injected collaborators retain their ownership."""
|
||||
if config is None:
|
||||
settings = WebConfig.from_env(**({"data_dir": data_dir} if data_dir is not None else {}))
|
||||
elif isinstance(config, WebConfig):
|
||||
settings = replace(config, data_dir=data_dir) if data_dir is not None else config
|
||||
elif isinstance(config, dict):
|
||||
values = dict(config)
|
||||
if data_dir is not None:
|
||||
values["data_dir"] = data_dir
|
||||
settings = WebConfig.from_env(**values)
|
||||
else:
|
||||
raise TypeError("config 必须是 WebConfig 或字典")
|
||||
sessions, redactor = _Sessions(settings), _Redactor(settings)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
owned = []
|
||||
try:
|
||||
if app.state.manager is None:
|
||||
from .service import WebManager
|
||||
settings.data_dir.mkdir(parents=True, exist_ok=True)
|
||||
app.state.manager = await run_in_threadpool(WebManager, settings.data_dir)
|
||||
owned.append(app.state.manager)
|
||||
if app.state.updates is None:
|
||||
from .updates import UpdateService
|
||||
app.state.updates = await run_in_threadpool(UpdateService, settings.data_dir, __version__)
|
||||
owned.append(app.state.updates)
|
||||
yield
|
||||
finally:
|
||||
failures = []
|
||||
try:
|
||||
for item in reversed(owned):
|
||||
close = getattr(item, "close", None)
|
||||
if close:
|
||||
try:
|
||||
if inspect.iscoroutinefunction(close):
|
||||
await close()
|
||||
else:
|
||||
await run_in_threadpool(close)
|
||||
except Exception:
|
||||
failures.append(True)
|
||||
finally:
|
||||
if manager is None:
|
||||
app.state.manager = None
|
||||
if updates is None:
|
||||
app.state.updates = None
|
||||
with sessions.lock:
|
||||
sessions.sessions.clear()
|
||||
sessions.failures.clear()
|
||||
with redactor.lock:
|
||||
redactor.secrets.clear()
|
||||
if failures:
|
||||
raise RuntimeError("Web 服务关闭未完成,请查看已脱敏日志") from None
|
||||
|
||||
app = FastAPI(title="牧羊人之心 Web 工作台", version=__version__, lifespan=lifespan,
|
||||
docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app.state.manager, app.state.updates, app.state.config = manager, updates, settings
|
||||
app.add_middleware(_Boundary, settings=settings, sessions=sessions)
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_error(request, exc):
|
||||
return _error(422, "invalid_request", "请求字段或格式不正确,请检查输入")
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_error(request, exc):
|
||||
messages = {404: "请求的资源不存在", 405: "不支持此请求方法"}
|
||||
message = messages.get(exc.status_code, redactor.text(str(exc.detail)))
|
||||
return _error(exc.status_code, "request_rejected", message)
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def internal_error(request, exc):
|
||||
return _error(500, "internal_error", "操作未完成,请查看已脱敏日志后重试")
|
||||
|
||||
def invoke(target, method, *args, **kwargs):
|
||||
if target is None:
|
||||
raise HTTPException(503, "服务尚未启动")
|
||||
try:
|
||||
return getattr(target, method)(*args, **kwargs)
|
||||
except HTTPException:
|
||||
raise
|
||||
except KeyError:
|
||||
raise HTTPException(404, "账号、任务或记录不存在") from None
|
||||
except NotImplementedError:
|
||||
raise HTTPException(501, "当前部署尚未支持此操作") from None
|
||||
except ValueError as exc:
|
||||
status = 409 if type(exc).__name__ == "RevisionConflict" else 400
|
||||
text = redactor.text(str(exc))
|
||||
message = text if re.search(r"[\u3400-\u9fff]", text) else "请求参数无效,请检查后重试"
|
||||
raise HTTPException(status, message) from None
|
||||
except RuntimeError as exc:
|
||||
text = redactor.text(str(exc))
|
||||
message = text if re.search(r"[\u3400-\u9fff]", text) else "当前状态无法执行此操作"
|
||||
raise HTTPException(409, message) from None
|
||||
except Exception:
|
||||
# Catch at the transport boundary so server access/error logs do not print secrets.
|
||||
raise HTTPException(500, "操作未完成,请查看已脱敏日志后重试") from None
|
||||
|
||||
def public(value, **kwargs):
|
||||
return redactor.public(value, **kwargs)
|
||||
|
||||
def public_error(value):
|
||||
if not value:
|
||||
return value
|
||||
if not isinstance(value, str) or "Traceback" in value or re.search(r"\n\s*File\s+[\"']", value):
|
||||
return "操作未完成,请查看已脱敏日志后重试"
|
||||
text = redactor.text(value)
|
||||
return text if re.search(r"[\u3400-\u9fff]", text) else "操作未完成,请查看已脱敏日志后重试"
|
||||
|
||||
def public_updates(value):
|
||||
from .updates import HOST_STATES, current_version_key, stable_version, valid_id
|
||||
if not isinstance(value, dict):
|
||||
raise HTTPException(500, "更新服务返回格式不正确")
|
||||
fields = ("current_version", "latest_version", "available", "checked_at", "release_url", "channel",
|
||||
"repository", "status", "message", "error", "can_apply")
|
||||
result = public({field: value[field] for field in fields if field in value})
|
||||
states = {"unchecked", "no_release", "up_to_date", "available", "check_failed", "unavailable", *HOST_STATES}
|
||||
if value.get("status") in states:
|
||||
result["status"] = value["status"]
|
||||
for field, validator in (("current_version", current_version_key), ("latest_version", stable_version)):
|
||||
if field in value:
|
||||
try:
|
||||
validator(value[field])
|
||||
except (ValueError, TypeError):
|
||||
result[field] = None
|
||||
else:
|
||||
result[field] = value[field]
|
||||
executor = value.get("executor")
|
||||
result["executor"] = public({field: executor[field] for field in
|
||||
("configured", "enabled", "auto_apply", "state", "heartbeat_at") if field in executor}) if isinstance(executor, dict) else None
|
||||
for field, allowed in (("request", ("version", "requested_at", "status")),
|
||||
("host_status", ("version", "status", "updated_at", "error"))):
|
||||
record = value.get(field)
|
||||
result[field] = None
|
||||
if not isinstance(record, dict) or not valid_id(record.get("request_id")) or record.get("status") not in HOST_STATES:
|
||||
continue
|
||||
try:
|
||||
stable_version(record.get("version"))
|
||||
except (ValueError, TypeError):
|
||||
continue
|
||||
mapped = public({key: record[key] for key in allowed if key in record})
|
||||
# These validated control-plane fields are public updater metadata.
|
||||
mapped.update(request_id=record["request_id"], version=record["version"], status=record["status"])
|
||||
result[field] = mapped
|
||||
return result
|
||||
|
||||
def submit(account_id, operation, payload):
|
||||
if operation not in ACTIONS:
|
||||
raise HTTPException(404, "不支持此操作")
|
||||
_no_file_paths(payload)
|
||||
redactor.remember(payload)
|
||||
value = invoke(app.state.manager, "submit", account_id, operation, payload)
|
||||
return public_job(value)
|
||||
|
||||
def public_job(value):
|
||||
if not isinstance(value, dict) or value.get("status") not in _JOB_STATUSES:
|
||||
raise HTTPException(500, "后台任务返回格式不正确")
|
||||
result = {field: value.get(field) for field in ("id", "status", "operation", "result", "error")}
|
||||
result["error"] = public_error(result["error"])
|
||||
return public(result)
|
||||
|
||||
def public_summary(value):
|
||||
if not isinstance(value, dict):
|
||||
raise HTTPException(500, "账号状态返回格式不正确")
|
||||
result = {field: value.get(field) for field in ("id", "label", "connected", "demo", "running", "busy", "revision", "error")}
|
||||
result["error"] = public_error(result["error"])
|
||||
player = value.get("player")
|
||||
result["player"] = {field: player.get(field) for field in ("name", "level", "exp", "next_exp", "money", "ke", "ti")} if isinstance(player, dict) else None
|
||||
return public(result)
|
||||
|
||||
@app.get("/api/health")
|
||||
def health():
|
||||
return {"status": "ok", "version": __version__}
|
||||
|
||||
@app.get("/api/meta")
|
||||
def meta():
|
||||
update_status = invoke(app.state.updates, "status")
|
||||
result = public({"version": __version__, "gameVersion": GAME_VERSION,
|
||||
"access": {"mode": settings.access_mode, "password_required": bool(settings.credential)},
|
||||
"features": [*PAGES, "multi_account", "jobs", "config_autosave", "updates"]})
|
||||
result["updates"] = public_updates(update_status)
|
||||
return result
|
||||
|
||||
@app.get("/api/auth/status")
|
||||
def auth_status(request: Request):
|
||||
return {"required": bool(settings.credential), "authenticated": sessions.authenticated(request), "access_mode": settings.access_mode}
|
||||
|
||||
@app.post("/api/auth/login")
|
||||
def admin_login(request: Request, body: LoginInput):
|
||||
if not settings.credential:
|
||||
if not sessions.authenticated(request):
|
||||
raise HTTPException(403, "本机免密模式只允许本机访问")
|
||||
return {"required": False, "authenticated": True, "access_mode": "local"}
|
||||
token = sessions.login(request, body.password)
|
||||
response = JSONResponse({"required": True, "authenticated": True, "access_mode": "password"})
|
||||
response.set_cookie(COOKIE_NAME, token, max_age=settings.session_ttl, httponly=True,
|
||||
secure=settings.secure_cookie, samesite="strict", path="/api")
|
||||
return response
|
||||
|
||||
@app.post("/api/auth/logout")
|
||||
def admin_logout(request: Request):
|
||||
sessions.logout(request)
|
||||
response = JSONResponse({"authenticated": False})
|
||||
response.delete_cookie(COOKIE_NAME, path="/api", httponly=True, secure=settings.secure_cookie, samesite="strict")
|
||||
return response
|
||||
|
||||
@app.get("/api/schema")
|
||||
def get_schema():
|
||||
from .views import schema
|
||||
catalog = getattr(app.state.manager, "catalog", None)
|
||||
if catalog is None:
|
||||
from ranch_assistant.model import Catalog
|
||||
catalog = Catalog()
|
||||
return public(schema(catalog))
|
||||
|
||||
@app.get("/api/accounts")
|
||||
def list_accounts():
|
||||
return [public_summary(item) for item in invoke(app.state.manager, "list_accounts")]
|
||||
|
||||
@app.post("/api/accounts", status_code=201)
|
||||
def create_account(body: AccountInput):
|
||||
return public_summary(invoke(app.state.manager, "create_account", label=body.label, demo=body.demo))
|
||||
|
||||
@app.delete("/api/accounts/{account_id}", status_code=204)
|
||||
def remove_account(account_id: Identifier):
|
||||
invoke(app.state.manager, "remove_account", account_id)
|
||||
return Response(status_code=204)
|
||||
|
||||
@app.get("/api/accounts/{account_id}/status")
|
||||
def status(account_id: Identifier):
|
||||
return public_summary(invoke(app.state.manager, "status", account_id))
|
||||
|
||||
@app.get("/api/accounts/{account_id}/config")
|
||||
def get_config(account_id: Identifier):
|
||||
return public(invoke(app.state.manager, "get_config", account_id))
|
||||
|
||||
@app.put("/api/accounts/{account_id}/config")
|
||||
def set_config(account_id: Identifier, body: ConfigInput, response: Response):
|
||||
_no_file_paths(body.config)
|
||||
result = invoke(app.state.manager, "set_config", account_id, body.config, revision=body.revision)
|
||||
if isinstance(result, dict) and result.get("pending"):
|
||||
response.status_code = 202
|
||||
return public(result)
|
||||
|
||||
@app.get("/api/accounts/{account_id}/views/{page}")
|
||||
def view(account_id: Identifier, page: str, request: Request):
|
||||
if page not in PAGES:
|
||||
raise HTTPException(404, "页面不存在")
|
||||
params = dict(request.query_params)
|
||||
if "query" in params:
|
||||
if len(params) > 1:
|
||||
raise HTTPException(400, "JSON 查询条件不能与简单参数混用")
|
||||
try:
|
||||
query = json.loads(params["query"])
|
||||
except (ValueError, RecursionError):
|
||||
raise HTTPException(400, "页面查询条件不是有效 JSON") from None
|
||||
if not isinstance(query, dict):
|
||||
raise HTTPException(400, "页面查询条件必须是对象")
|
||||
else:
|
||||
query = params or None
|
||||
_no_file_paths(query)
|
||||
return public(invoke(app.state.manager, "view", account_id, page, query=query))
|
||||
|
||||
@app.post("/api/accounts/{account_id}/actions/{operation}", status_code=202)
|
||||
def action(account_id: Identifier, operation: str, payload: dict[str, Any] | None = None):
|
||||
return submit(account_id, operation, payload or {})
|
||||
|
||||
@app.get("/api/accounts/{account_id}/jobs/{job_id}")
|
||||
def job(account_id: Identifier, job_id: Identifier):
|
||||
return public_job(invoke(app.state.manager, "job", account_id, job_id))
|
||||
|
||||
@app.get("/api/accounts/{account_id}/logs")
|
||||
def logs(account_id: Identifier, after: Annotated[int, Query(ge=0)] = 0, debug: bool = False):
|
||||
return public(invoke(app.state.manager, "logs", account_id, after=after, debug=debug))
|
||||
|
||||
@app.get("/api/accounts/{account_id}/logs/{entry_id}")
|
||||
@app.get("/api/accounts/{account_id}/debug/{entry_id}")
|
||||
def log_detail(account_id: Identifier, entry_id: Annotated[int, Path(ge=1)]):
|
||||
method = "log_detail" if hasattr(app.state.manager, "log_detail") else "debug_entry"
|
||||
if not hasattr(app.state.manager, method):
|
||||
raise HTTPException(501, "当前运行时尚未提供单条调试详情")
|
||||
return public(invoke(app.state.manager, method, account_id, entry_id), trace=True)
|
||||
|
||||
@app.get("/api/accounts/{account_id}/config/export", status_code=202)
|
||||
def config_export(account_id: Identifier):
|
||||
return submit(account_id, "export_config", {})
|
||||
|
||||
@app.post("/api/accounts/{account_id}/config/import", status_code=202)
|
||||
def config_import(account_id: Identifier, payload: dict[str, Any]):
|
||||
# The REST upload accepts a portable document; the action layer uses {config: document}.
|
||||
wrapped = payload if "config" in payload else {"config": payload}
|
||||
return submit(account_id, "import_config", wrapped)
|
||||
|
||||
@app.get("/api/system/updates")
|
||||
def update_status():
|
||||
return public_updates(invoke(app.state.updates, "status"))
|
||||
|
||||
@app.post("/api/system/updates/check")
|
||||
def update_check():
|
||||
return public_updates(invoke(app.state.updates, "check"))
|
||||
|
||||
@app.post("/api/system/updates/apply", status_code=202)
|
||||
def update_apply(body: UpdateInput | None = None):
|
||||
version = body.version if body else None
|
||||
if version is not None and not re.fullmatch(r"v2\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)", version):
|
||||
raise HTTPException(400, "更新版本必须是正式的 v2.x.y 版本号,例如 v2.0.1")
|
||||
return public_updates(invoke(app.state.updates, "request_update", version))
|
||||
|
||||
static_dir = FilePath(__file__).resolve().parent / "static"
|
||||
|
||||
@app.get("/", include_in_schema=False)
|
||||
def index():
|
||||
index_path = static_dir / "index.html"
|
||||
if not index_path.is_file():
|
||||
raise HTTPException(503, "前端资源尚未准备完成")
|
||||
return FileResponse(index_path, media_type="text/html", headers={"Cache-Control": "no-cache"})
|
||||
|
||||
app.mount("/static", _Assets(directory=static_dir, check_dir=False, follow_symlink=False), name="static")
|
||||
return app
|
||||
Reference in New Issue
Block a user