#!/usr/bin/env python3 """Small local HTTP worker for the YYB admin integration. The worker owns per-job sessions and invokes the already verified protocol scripts. It intentionally exposes QR images and state only; cookies and raw payment links never leave the worker API. """ from __future__ import annotations import argparse import base64 import importlib.util import json import os import re import shutil import subprocess import sys import threading import time import uuid from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from urllib.parse import urlparse ROOT = Path(__file__).resolve().parent.parent sys.path.insert(0, str(ROOT)) DEFAULT_DATA = ROOT / "config" / "worker-jobs" DEFAULT_EVIDENCE_TTL_HOURS = 72 WORKER_KEY = os.environ.get("YYB_WORKER_KEY", "") _jobs: dict[str, dict] = {} _lock = threading.Lock() from pyvm.payment_errors import describe_payment_failure # noqa: E402 def _payment_failure_message(job: dict, phase: str, fallback: str) -> str: """从阶段日志提取业务码，向管理端返回准确且可操作的失败信息。""" detail = "\n".join(job.get("logs", [])) message = describe_payment_failure(str(job.get("provider", "")), phase, detail) return message if message else fallback def _load_selector(): path = ROOT / "scripts" / "select-peace-elite.py" spec = importlib.util.spec_from_file_location("yyb_worker_selector", path) if not spec or not spec.loader: raise RuntimeError("无法加载和平精英选择器") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module def _job_dir(job_id: str) -> Path: return Path(_jobs[job_id]["directory"]) def _cleanup_expired_jobs(data_dir: Path, ttl_hours: int) -> int: """清理超过保留期的任务证据；只处理 data_dir 的一级任务目录。""" if ttl_hours <= 0 or not data_dir.exists(): return 0 deadline = time.time() - ttl_hours * 3600 removed = 0 for directory in data_dir.iterdir(): if not directory.is_dir() or directory.is_symlink(): continue try: if directory.stat().st_mtime >= deadline: continue shutil.rmtree(directory) removed += 1 except OSError as exc: print(f"无法清理过期任务证据 {directory.name}: {exc}", flush=True) return removed def _safe_log(job: dict, line: str) -> None: # Do not persist cookies, payment URI, or long opaque tokens in the worker API. clean = re.sub(r"weixin://\S+", "[付款链接已隐藏]", line) clean = re.sub(r"HOLD_[A-Za-z0-9_-]+", "[订单已隐藏]", clean) clean = re.sub(r"(订单\s*[:：]\s*)\S+", r"\1[订单已隐藏]", clean) clean = re.sub(r"(?:token|openid|openkey|cookie)=\S+", "[敏感字段已隐藏]", clean, flags=re.I) clean = re.sub(r"(?:pay_token|web_token|anti_token|session_id|sessionid)\s*[:= ]\s*\S+", "[敏感字段已隐藏]", clean, flags=re.I) timestamp = time.strftime("%H:%M:%S") with _lock: job["logs"] = (job.get("logs", []) + [f"[{timestamp}] {clean.strip()}"])[-100:] def _run_process(job_id: str, command: list[str], phase: str, mark_success: bool = True) -> int: """Run one stage process and return its exit code. When ``mark_success`` is False the caller owns the post-success state transition (used by the staged payment flow). """ job = _jobs[job_id] environment = os.environ.copy() environment.pop("NODE_OPTIONS", None) # 子进程输出经管道实时转存日志；关闭块缓冲避免日志滞后。 environment["PYTHONUNBUFFERED"] = "1" with _lock: job["phase"] = phase job["status"] = "running" stage_started = time.monotonic() _safe_log(job, f"[{phase}] 开始执行") try: process = subprocess.Popen(command, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1, env=environment) with _lock: job["process_pid"] = process.pid assert process.stdout is not None for line in process.stdout: _safe_log(job, line) code = process.wait() _safe_log(job, f"[{phase}] 执行结束，耗时 {time.monotonic() - stage_started:.1f} 秒") with _lock: job["process_pid"] = None if code != 0: if job.get("status") == "stopped": # 停止请求已 kill 本进程：保留停止语义，不被阶段失败覆盖。 job["message"] = "任务已停止" else: job["status"] = "failed" job["phase"] = phase job["message"] = f"{phase}失败（退出码 {code}）" elif phase == "login": job["status"] = "ready" job["phase"] = "selection" job["message"] = "登录成功，请选择平台、点券、区服和角色" elif mark_success: job["status"] = "success" job["phase"] = "completed" job["message"] = "付款流程已完成" return code except Exception as exc: # noqa: BLE001 _safe_log(job, f"[{phase}] 执行异常，耗时 {time.monotonic() - stage_started:.1f} 秒") with _lock: job["status"] = "failed" job["message"] = str(exc) return 1 def _start_login(job_id: str, provider: str, timeout: int) -> None: job = _jobs[job_id] directory = _job_dir(job_id) session = directory / "mall-session.json" qr = directory / ("qq-login.jpg" if provider == "qq" else "wechat-login.jpg") command = [sys.executable, f"scripts/login-{provider}.py", "--session", str(session), "--qr", str(qr), "--timeout", str(timeout)] with _lock: job["provider"] = provider job["qr_path"] = str(qr) job["session_path"] = str(session) job["status"] = "waiting_login" job["phase"] = "login" threading.Thread(target=_run_process, args=(job_id, command, "login"), daemon=True).start() def _selection_options(job_id: str, platform: str, points: int | None, zone_id: str | None = None) -> dict: if job_id not in _jobs: raise ValueError("任务不存在") selector = _load_selector() session = json.loads((_job_dir(job_id) / "mall-session.json").read_text(encoding="utf-8")) cookies = session.get("cookies", {}) products = selector.product_options(cookies, platform) if points is not None and not any(int(item["points"]) == points for item in products): raise ValueError("当前登录态不支持该点券档位") product = next((item for item in products if int(item["points"]) == points), None) if points else None if product is None: product = products[0] cmall = selector.Cmall(cookies, str(product["offer_id"]), platform) zones = cmall.zones() selected_zone = next((zone for zone in zones if str(zone["zone_id"]) == str(zone_id)), None) if zone_id and selected_zone is None: raise ValueError("区服不存在") selected_zone = selected_zone or (zones[0] if zones else None) roles = cmall.roles(selected_zone["zone_id"]) if selected_zone else [] return {"products": products, "zones": zones, "roles": roles, "default_product": product, "default_zone": selected_zone} def _payment_stage(job_id: str, command: list[str], phase: str, running_message: str, failed_message: str) -> bool: """Run one payment stage; return True on success without touching final state.""" job = _jobs[job_id] with _lock: if job.get("status") == "stopped": return False job["status"] = "running" job["phase"] = phase job["message"] = running_message code = _run_process(job_id, command, phase, mark_success=False) if code != 0: with _lock: if job.get("status") == "stopped": return False job["status"] = "failed" job["phase"] = phase job["message"] = _payment_failure_message(job, phase, failed_message) return False return True PAYMENT_CHECK_INTERVAL = 3 PAYMENT_CHECK_TIMEOUT = 300 def _check_payment_once(job_id: str) -> int: """Read-only completion check; returns 0=confirmed, 1=not yet, 2=check failed.""" job = _jobs[job_id] directory = _job_dir(job_id) command = [sys.executable, "scripts/jsdom-pay.py", "--check-only", "--session", str(directory / "mall-session.json"), "--out-dir", str(directory / "jsdom-order")] environment = os.environ.copy() environment.pop("NODE_OPTIONS", None) check_started = time.monotonic() _safe_log(job, "[到账检测] 开始执行") try: result = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, env=environment, timeout=90) except subprocess.TimeoutExpired: _safe_log(job, f"[到账检测] 执行超时，耗时 {time.monotonic() - check_started:.1f} 秒") with _lock: job["payment_last_checked_at"] = int(time.time()) return 2 for line in (result.stdout or "").splitlines(): _safe_log(job, line) for line in (result.stderr or "").splitlines(): _safe_log(job, line) _safe_log(job, f"[到账检测] 执行结束，耗时 {time.monotonic() - check_started:.1f} 秒") with _lock: job["payment_last_checked_at"] = int(time.time()) return result.returncode def _monitor_payment(job_id: str) -> None: """Background loop that re-checks completion until timeout or confirmation.""" job = _jobs[job_id] deadline = time.monotonic() + PAYMENT_CHECK_TIMEOUT while time.monotonic() < deadline: time.sleep(PAYMENT_CHECK_INTERVAL) with _lock: if job.get("status") in {"stopped", "success"}: return code = _check_payment_once(job_id) if code == 0: with _lock: job["status"] = "success" job["phase"] = "completed" job["message"] = "已确认到账，充值完成" return if code == 2: with _lock: job["message"] = "到账检测暂时失败，将继续重试" with _lock: job["status"] = "payment_timeout" job["phase"] = "payment" job["message"] = "付款码已生成，但未在时限内确认到账，请人工核对" def _payment_flow(job_id: str, selection: dict) -> None: """Staged payment: create mall order -> create payment QR -> monitor arrival. The QR is generated before any waiting, so the UI switches to waiting_payment immediately; only a timeout moves to payment_timeout. """ job = _jobs[job_id] directory = _job_dir(job_id) session = directory / "mall-session.json" response = directory / "mall-order-response.json" output = directory / "jsdom-order" with _lock: job["status"] = "ordering" job["phase"] = "payment" job["message"] = "正在创建商城订单" order_cmd = [sys.executable, "main.py", "mall", "auto", "--session", str(session), "--order-template", str(ROOT / "config" / "mall-order-template.json"), "--quantity", "1", "--product-id", str(selection["product_id"]), "--offer-id", str(selection["offer_id"]), "--role-id", str(selection["role_id"]), "--role-name", str(selection["role_name"]), "--zone-id", str(selection["zone_id"]), "--zone-name", str(selection["zone_name"]), "--output", str(response)] if selection.get("area"): order_cmd.extend(["--area", str(selection["area"])]) if selection.get("partition"): order_cmd.extend(["--partition", str(selection["partition"])]) if selection.get("order_pf"): order_cmd.extend(["--pf", str(selection["order_pf"])]) if not _payment_stage(job_id, order_cmd, "order", "正在创建商城订单", "创建商城订单失败"): return pay_cmd = [sys.executable, "scripts/jsdom-pay.py", "--session", str(session), "--mall-response", str(response), "--out-dir", str(output), "--zone-id", str(selection["zone_id"]), "--pf", str(selection.get("order_pf", "")), "--amount-fen", str(selection["price_fen"]), "--skip-payment-check"] if not _payment_stage(job_id, pay_cmd, "payment", "正在生成微信付款码", "生成付款码失败"): return meta_path = output / "payment-meta.json" try: meta = json.loads(meta_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): meta = {} with _lock: job["status"] = "waiting_payment" job["phase"] = "payment" job["message"] = "付款码已生成，请扫码付款" job["payment_qr_created_at"] = meta.get("qr_created_at", int(time.time())) _monitor_payment(job_id) def _start_payment(job_id: str, selection: dict) -> None: with _lock: if _jobs[job_id].get("status") == "stopped": return _jobs[job_id]["status"] = "ordering" _jobs[job_id]["phase"] = "payment" _jobs[job_id]["message"] = "正在创建商城订单" threading.Thread(target=_payment_flow, args=(job_id, selection), daemon=True).start() def _stop_job(job_id: str) -> None: if job_id not in _jobs: raise ValueError("任务不存在") job = _jobs[job_id] pid = job.get("process_pid") if pid: try: os.kill(int(pid), 15) except ProcessLookupError: pass with _lock: if job.get("status") == "waiting_payment": job["status"] = "stopped" job["phase"] = "payment" job["message"] = "已放弃到账追踪；商城订单仍可能完成，请人工核对" else: job["status"] = "stopped" job["phase"] = "stopped" job["message"] = "任务已停止" def _public_job(job_id: str) -> dict: job = _jobs[job_id] result = {key: value for key, value in job.items() if key not in {"directory", "session_path", "process_pid"}} qr_path = job.get("qr_path", "") if qr_path and Path(qr_path).exists(): qr_bytes = Path(qr_path).read_bytes() result["qr_data"] = base64.b64encode(qr_bytes).decode("ascii") result["qr_mime_type"] = "image/jpeg" if qr_bytes.startswith(b"\xff\xd8\xff") else "image/png" output = Path(job["directory"]) / "jsdom-order" for name in ("wechat-pay.png", "payment-status.json"): path = None if output.exists(): direct = output / name path = direct if direct.exists() else next(output.glob(f"*/{name}"), None) if path and name.endswith(".png"): payment_qr_bytes = path.read_bytes() result["payment_qr_data"] = base64.b64encode(payment_qr_bytes).decode("ascii") result["payment_qr_mime_type"] = "image/jpeg" if payment_qr_bytes.startswith(b"\xff\xd8\xff") else "image/png" elif path: try: status = json.loads(path.read_text(encoding="utf-8")) matched = status.get("matched_completion") if isinstance(status, dict) else None result["payment_status"] = { "checked_at": status.get("checked_at") if isinstance(status, dict) else None, "matched_completion": { "is_finished": matched.get("is_finished"), "status": matched.get("status"), } if isinstance(matched, dict) else None, } except (OSError, json.JSONDecodeError): pass for key in ("payment_qr_created_at", "payment_last_checked_at"): if job.get(key) is not None: result[key] = job[key] return result class Handler(BaseHTTPRequestHandler): server_version = "YYBWorker/1" def _json(self, status: int, value: dict) -> None: body = json.dumps(value, ensure_ascii=False).encode("utf-8") self.send_response(status) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def _body(self) -> dict: length = int(self.headers.get("Content-Length", "0")) return json.loads(self.rfile.read(length) or b"{}") def _authorized(self) -> bool: if not WORKER_KEY: return True value = self.headers.get("Authorization", "") return value == f"Bearer {WORKER_KEY}" def do_POST(self) -> None: # noqa: N802 if not self._authorized(): return self._json(401, {"detail": "未授权"}) path = urlparse(self.path).path.strip("/").split("/") try: if path == ["v1", "jobs"]: job_id = uuid.uuid4().hex[:16] directory = DEFAULT_DATA / job_id directory.mkdir(parents=True, exist_ok=True) os.chmod(directory, 0o700) _jobs[job_id] = {"job_id": job_id, "status": "created", "phase": "login", "logs": [], "directory": str(directory), "created_at": int(time.time())} return self._json(201, _public_job(job_id)) if len(path) == 4 and path[:2] == ["v1", "jobs"] and path[3] == "login": job_id = path[2] body = self._body() if job_id not in _jobs or body.get("provider") not in {"qq", "wechat"}: return self._json(400, {"detail": "无效任务或登录方式"}) _start_login(job_id, body["provider"], int(body.get("timeout", 600))) return self._json(202, _public_job(job_id)) if len(path) == 4 and path[:2] == ["v1", "jobs"] and path[3] == "selection-options": job_id = path[2] body = self._body() options = _selection_options(job_id, str(body.get("platform", "android")), body.get("points"), body.get("zone_id")) _jobs[job_id]["selection_options"] = options return self._json(200, options) if len(path) == 4 and path[:2] == ["v1", "jobs"] and path[3] == "selection": job_id = path[2] body = self._body() required = ("platform", "points", "product_id", "role_id", "role_name", "zone_id") if job_id not in _jobs or any(not body.get(key) for key in required): return self._json(400, {"detail": "选择参数不完整"}) selector = _load_selector() if body["platform"] not in selector.PLATFORMS: return self._json(400, {"detail": "不支持的平台"}) session_path = _job_dir(job_id) / "mall-session.json" cookies = json.loads(session_path.read_text(encoding="utf-8")).get("cookies", {}) product = next((item for item in selector.product_options(cookies, body["platform"]) if str(item["product_id"]) == str(body["product_id"]) and int(item["points"]) == int(body["points"])), None) if product is None: return self._json(400, {"detail": "商品已失效，请重新选择"}) cmall = selector.Cmall(cookies, str(product["offer_id"]), body["platform"]) zone = next((item for item in cmall.zones() if str(item["zone_id"]) == str(body["zone_id"])), None) if zone is None: return self._json(400, {"detail": "区服已失效，请重新选择"}) role = next((item for item in cmall.roles(zone["zone_id"]) if str(item["role_id"]) == str(body["role_id"])), None) if role is None or role.get("ban_status") == "1": return self._json(400, {"detail": "角色不可充值，请重新选择"}) _jobs[job_id]["selection"] = { "platform": body["platform"], "points": product["points"], "price_fen": product["price_fen"], "product_id": product["product_id"], "offer_id": product["offer_id"], "zone_id": zone["zone_id"], "zone_name": zone["name"], "role_id": role["role_id"], "role_name": role["name"], "area": role.get("area", ""), "partition": role.get("partition", ""), "order_pf": selector.PLATFORMS[body["platform"]]["order_pf"], } _jobs[job_id]["phase"] = "payment" result = _public_job(job_id) result["selection"] = _jobs[job_id]["selection"] return self._json(200, result) if len(path) == 4 and path[:2] == ["v1", "jobs"] and path[3] == "payment": job_id = path[2] if job_id not in _jobs: return self._json(400, {"detail": "任务不存在"}) job = _jobs[job_id] with _lock: if job.get("status") == "stopped": return self._json(400, {"detail": "任务已停止，不能生成付款码"}) if job.get("status") in {"ordering", "waiting_payment", "payment_timeout"} \ or job.get("process_pid"): return self._json(400, {"detail": "已有进行中的支付流程，请勿重复操作"}) if not job.get("selection"): return self._json(400, {"detail": "请先完成角色选择"}) _start_payment(job_id, job["selection"]) return self._json(202, _public_job(job_id)) if len(path) == 5 and path[:2] == ["v1", "jobs"] and path[3:5] == ["payment", "check"]: job_id = path[2] if job_id not in _jobs: return self._json(400, {"detail": "任务不存在"}) job = _jobs[job_id] with _lock: if job.get("status") not in {"waiting_payment", "payment_timeout"}: return self._json(400, {"detail": "当前任务状态不支持检测到账"}) code = _check_payment_once(job_id) with _lock: if code == 0: job["status"] = "success" job["phase"] = "completed" job["message"] = "已确认到账，充值完成" elif code == 1: # 保持 payment_timeout：检测由人工反复触发，避免无人监控的 waiting_payment。 job["message"] = "仍未确认到账，请继续人工核对" else: job["message"] = "到账检测暂时失败，请稍后重试" return self._json(200, _public_job(job_id)) if len(path) == 4 and path[:2] == ["v1", "jobs"] and path[3] == "stop": _stop_job(path[2]) return self._json(200, _public_job(path[2])) return self._json(404, {"detail": "接口不存在"}) except Exception as exc: # noqa: BLE001 return self._json(500, {"detail": str(exc)}) def do_GET(self) -> None: # noqa: N802 if urlparse(self.path).path == "/health": return self._json(200, {"status": "ok"}) if not self._authorized(): return self._json(401, {"detail": "未授权"}) path = urlparse(self.path).path.strip("/").split("/") if len(path) == 3 and path[:2] == ["v1", "jobs"] and path[2] in _jobs: return self._json(200, _public_job(path[2])) return self._json(404, {"detail": "接口不存在"}) def log_message(self, fmt: str, *args) -> None: return def _restore_jobs(data_dir: Path) -> int: """Rebuild in-memory jobs from task directories after a restart. Only payment-phase jobs with a persisted QR baseline are restored so that the payment QR stays visible and the read-only check can be re-run. """ restored = 0 for directory in data_dir.iterdir(): if not directory.is_dir(): continue job_id = directory.name if job_id in _jobs: continue session = directory / "mall-session.json" output = directory / "jsdom-order" meta_path = output / "payment-meta.json" if not session.exists(): continue if not meta_path.exists(): _jobs[job_id] = { "job_id": job_id, "status": "ready", "phase": "selection", "logs": ["服务重启，已从任务目录恢复登录会话"], "directory": str(directory), "created_at": int(time.time()), "message": "已恢复：登录会话有效，请选择充值信息", } restored += 1 continue try: meta = json.loads(meta_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): continue status = "waiting_payment" phase = "payment" message = "已恢复：付款码已生成，可重新检测到账" last_checked = None status_path = output / "payment-status.json" if status_path.exists(): try: record = json.loads(status_path.read_text(encoding="utf-8")) last_checked = record.get("checked_at") if record.get("matched_completion"): status = "success" phase = "completed" message = "已恢复：已确认到账" except (OSError, json.JSONDecodeError): pass _jobs[job_id] = { "job_id": job_id, "status": status, "phase": phase, "logs": ["服务重启，已从任务目录恢复本任务"], "directory": str(directory), "created_at": int(time.time()), "message": message, "payment_qr_created_at": meta.get("qr_created_at"), "payment_last_checked_at": last_checked, } restored += 1 return restored def main() -> int: global DEFAULT_DATA, WORKER_KEY parser = argparse.ArgumentParser(description="YYB admin worker") parser.add_argument("--host", default="127.0.0.1") parser.add_argument("--port", type=int, default=8810) parser.add_argument("--data-dir", type=Path, default=DEFAULT_DATA) parser.add_argument("--evidence-ttl-hours", type=int, default=DEFAULT_EVIDENCE_TTL_HOURS, help="任务原始证据保留时长；0 表示不自动清理") parser.add_argument("--key", default=None, help="HTTP Bearer 鉴权密钥；默认读取 YYB_WORKER_KEY") args = parser.parse_args() # 强制绝对路径：子进程以 ROOT 为 cwd，相对路径会让任务文件写到错误位置。 DEFAULT_DATA = Path(args.data_dir).resolve() if args.key is not None: WORKER_KEY = args.key if args.host not in {"127.0.0.1", "localhost", "::1"} and not WORKER_KEY: parser.error("监听非本机地址时必须设置 --key 或 YYB_WORKER_KEY") if args.evidence_ttl_hours < 0: parser.error("--evidence-ttl-hours 不能小于 0") DEFAULT_DATA.mkdir(parents=True, exist_ok=True) os.chmod(DEFAULT_DATA, 0o700) removed = _cleanup_expired_jobs(DEFAULT_DATA, args.evidence_ttl_hours) if removed: print(f"已清理 {removed} 个过期任务证据（保留期 {args.evidence_ttl_hours} 小时）", flush=True) restored = _restore_jobs(DEFAULT_DATA) if restored: print(f"已从任务目录恢复 {restored} 个支付任务", flush=True) server = ThreadingHTTPServer((args.host, args.port), Handler) print(f"YYB worker listening on {args.host}:{args.port}", flush=True) server.serve_forever() return 0 if __name__ == "__main__": raise SystemExit(main())