refactor: 重构为可部署到服务器的模块化结构(v5.0.0)

- 拆包 fengxiang/:config/client/store/notify/monitor/admin/tts,统一入口 order_monitor.py
- 服务器形态:Docker 常驻,Cookie 由本机登录后 POST 上传并热加载,不再依赖桌面弹窗
- 修复:首次启动重推历史订单、speak() 阻塞主循环、夜间 sleep 10h 不可中断
- 修复:test_push.py 残留 miservice 依赖(小爱已移除)、run_monitor.bat 写死盘符
- 配置化:webhook/shopId 移出源码(环境变量 > config.yaml > 默认值)
- 可观测:滚动文件日志 + /healthz + Docker HEALTHCHECK + 告警冷却
- 飞书通道保留配置位,默认关闭(原 token 已失效 code=19001)
- 新增 22 项单元测试(不联网)
This commit is contained in:
houhuan committed 2026-11-16 12:45:23 +08:00
1 parent ab6a2bb7ea
commit 4ee30399bf
30 files changed
+2410 -825

No files matched your search

+14
View File
@@ -0,0 +1,14 @@
"""丰享订单监控核心包。
模块划分:
- config : 配置加载(config.yaml + 环境变量覆盖)
- logger : 日志初始化(控制台 + 滚动文件)
- client : 丰享商家端 API 客户端(连接复用、重试、异常分类)
- store : 运行状态持久化(最新订单号 + 已推送去重集合)
- notify : 通知通道(企业微信 / 飞书,可插拔)
- tts : 本地语音播报(仅 Windows 本地模式,进程内队列不阻塞主循环)
- monitor : 监控主循环(轮询调度、夜间暂停、Cookie 热重载与失效等待)
- admin : 内置管理/健康检查 HTTP 接口(接收本地推送的 Cookie)
"""
__version__ = "5.0.0"
+152
View File
@@ -0,0 +1,152 @@
"""内置管理接口(HTTP)。
存在的唯一目的是解决「服务器没有桌面,丰享登录必须人工过验证码」这个矛盾:
本机登录后把 Cookie POST 过来,容器内立刻热生效,不用重启、不用 SSH 拷文件。
接口:
GET /healthz 健康检查(Docker HEALTHCHECK 用,免鉴权,只返回运行指标)
GET /api/status 运行状态(同上,别名)
POST /api/cookies 更新 Cookie(需鉴权)
POST /api/test-push 发一条测试消息(需鉴权)
鉴权:请求头 X-Auth-Token 或 Authorization: Bearer <token>,也支持 ?token=。
安全默认:未配置 token 时只接受来自 127.0.0.1 的写请求。
"""
from __future__ import annotations
import json
import logging
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any, Dict
from urllib.parse import parse_qs, urlparse
from .config import Config
log = logging.getLogger("fengxiang.admin")
MAX_BODY = 64 * 1024
class _Handler(BaseHTTPRequestHandler):
server_version = "fengxiang-admin/1.0"
monitor = None # 由 AdminServer 注入
cfg = None
# -------- 工具方法 --------
def log_message(self, fmt: str, *args: Any) -> None:
log.debug("%s - %s", self.address_string(), fmt % args)
def _json(self, code: int, payload: Dict[str, Any]) -> None:
body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
self.send_response(code)
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 _auth_ok(self, query: Dict[str, list]) -> bool:
token = self.cfg.admin.token
if not token:
# 未配置 token:仅允许本机回环写入
return self.client_address[0] in ("127.0.0.1", "::1")
supplied = (
self.headers.get("X-Auth-Token")
or (self.headers.get("Authorization") or "").replace("Bearer ", "").strip()
or (query.get("token") or [""])[0]
)
return supplied == token
def _read_json(self) -> Dict[str, Any]:
length = int(self.headers.get("Content-Length") or 0)
if length <= 0 or length > MAX_BODY:
raise ValueError("请求体为空或过大")
raw = self.rfile.read(length)
data = json.loads(raw.decode("utf-8"))
if not isinstance(data, dict):
raise ValueError("请求体必须是 JSON 对象")
return data
# -------- 路由 --------
def do_GET(self) -> None: # noqa: N802
path = urlparse(self.path).path
if path in ("/healthz", "/api/status", "/api/health"):
self._json(200, self.monitor.status())
return
if path == "/":
self._json(200, {
"service": "fengxiang-monitor admin",
"endpoints": ["GET /healthz", "GET /api/status",
"POST /api/cookies", "POST /api/test-push"],
})
return
self._json(404, {"error": "not found"})
def do_POST(self) -> None: # noqa: N802
parsed = urlparse(self.path)
path = parsed.path
query = parse_qs(parsed.query)
if not self._auth_ok(query):
self._json(401, {"error": "unauthorized"})
return
if path == "/api/cookies":
try:
payload = self._read_json()
except (ValueError, json.JSONDecodeError) as exc:
self._json(400, {"error": f"参数错误: {exc}"})
return
cookies = payload.get("cookies", payload)
if not isinstance(cookies, dict) or not cookies:
self._json(400, {"error": "cookies 必须是非空对象"})
return
try:
ok = self.monitor.update_cookies({str(k): str(v) for k, v in cookies.items()})
except Exception as exc: # noqa: BLE001
log.exception("写入 Cookie 失败")
self._json(500, {"error": str(exc)})
return
if ok:
self._json(200, {"ok": True, "count": len(cookies), "status": self.monitor.status()})
else:
self._json(422, {"ok": False, "error": "Cookie 校验未通过,可能已失效"})
return
if path == "/api/test-push":
try:
payload = self._read_json()
except (ValueError, json.JSONDecodeError):
payload = {}
text = payload.get("text") or "【丰享监控】测试消息,请忽略。"
result = self.monitor.dispatcher.notify(text)
self._json(200, {"result": result})
return
self._json(404, {"error": "not found"})
class AdminServer:
def __init__(self, cfg: Config, monitor) -> None:
self.cfg = cfg
self.monitor = monitor
handler = type("BoundHandler", (_Handler,), {"monitor": monitor, "cfg": cfg})
self.httpd = ThreadingHTTPServer((cfg.admin.host, cfg.admin.port), handler)
self.httpd.daemon_threads = True
self._thread = threading.Thread(target=self.httpd.serve_forever,
name="admin-http", daemon=True)
def start(self) -> None:
self._thread.start()
log.info("管理接口已启动 http://%s:%d (健康检查 /healthz)",
self.cfg.admin.host, self.cfg.admin.port)
if not self.cfg.admin.token:
log.warning("未设置 admin.token,写接口仅允许本机回环访问")
def stop(self) -> None:
try:
self.httpd.shutdown()
self.httpd.server_close()
except Exception: # noqa: BLE001
pass
+124
View File
@@ -0,0 +1,124 @@
"""丰享商家端 API 客户端。
相比原实现的关键改动:
1. 复用 requests.Session(原代码每 5 秒新建 TLS 连接,纯浪费)
2. 只对「网络层故障」做有限重试,业务错误码不重试
3. 用异常区分三种状态,替代原来返回 "SESSION_EXPIRED" 魔法字符串
"""
from __future__ import annotations
import logging
from typing import Any, Dict, List, Optional
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from .config import Config
log = logging.getLogger("fengxiang.client")
# 丰享返回的「会话失效」错误码
SESSION_EXPIRED_CODES = {110003, 10009}
class FengxiangError(Exception):
"""所有客户端异常的基类。"""
class SessionExpired(FengxiangError):
"""Cookie/会话失效,需要重新登录。"""
class ApiError(FengxiangError):
"""接口返回了非 0 的业务错误码。"""
def __init__(self, errno: Any, errmsg: str = ""):
self.errno = errno
self.errmsg = errmsg
super().__init__(f"errno={errno} errmsg={errmsg}")
class NetworkError(FengxiangError):
"""网络/超时/非 JSON 响应,可稍后重试。"""
class FengxiangClient:
def __init__(self, cfg: Config, session: Optional[requests.Session] = None):
self.cfg = cfg
self.session = session or self._build_session()
self.cookies: Dict[str, str] = {}
def _build_session(self) -> requests.Session:
s = requests.Session()
retry = Retry(
total=self.cfg.api.max_retries,
connect=self.cfg.api.max_retries,
read=self.cfg.api.max_retries,
backoff_factor=0.5,
status_forcelist=(429, 500, 502, 503, 504),
allowed_methods=frozenset(["POST"]),
raise_on_status=False,
)
adapter = HTTPAdapter(max_retries=retry, pool_connections=2, pool_maxsize=4)
s.mount("https://", adapter)
s.mount("http://", adapter)
s.headers.update({
"Content-Type": "application/json",
"User-Agent": ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36"),
"Referer": self.cfg.api.base_url.rstrip("/") + "/MMS",
"Origin": self.cfg.api.base_url.rstrip("/"),
})
return s
def set_cookies(self, cookies: Dict[str, str]) -> None:
self.cookies = dict(cookies or {})
def list_orders(self, page_size: int = 5, page: int = 1) -> List[Dict[str, Any]]:
"""拉取订单列表。
返回订单列表;会话失效抛 SessionExpired;业务错误抛 ApiError;
网络问题抛 NetworkError。
"""
payload = {"shopId": self.cfg.shop_id, "page": page, "pageSize": page_size}
try:
resp = self.session.post(
self.cfg.api.order_url,
json=payload,
cookies=self.cookies,
timeout=self.cfg.api.timeout,
)
except requests.RequestException as exc:
raise NetworkError(f"请求失败: {exc}") from exc
if resp.status_code >= 500:
raise NetworkError(f"服务端 {resp.status_code}")
if resp.status_code >= 400:
raise NetworkError(f"HTTP {resp.status_code}")
try:
data = resp.json()
except ValueError as exc:
raise NetworkError(f"响应非 JSON: {resp.text[:120]}") from exc
errno = data.get("errno")
if errno == 0:
orders = (data.get("data") or {}).get("list") or []
return [o for o in orders if isinstance(o, dict)]
if errno in SESSION_EXPIRED_CODES:
raise SessionExpired(f"errno={errno} {data.get('errmsg', '')}".strip())
raise ApiError(errno, str(data.get("errmsg", "")))
def check_cookie(self, cookies: Dict[str, str]) -> bool:
"""校验 Cookie 是否可用(不抛异常)。"""
self.set_cookies(cookies)
try:
self.list_orders(page_size=1)
return True
except SessionExpired:
return False
except FengxiangError as exc:
log.warning("Cookie 校验时出现非会话类错误: %s", exc)
return False
+293
View File
@@ -0,0 +1,293 @@
"""配置加载。
优先级:环境变量 > config.yaml > 内置默认值。
之所以做三级覆盖,是为了让同一个镜像在本地、测试、生产三种环境复用,
而密钥(企业微信 webhook、管理接口 token)永远不进代码库。
"""
from __future__ import annotations
import os
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any, Dict, List, Tuple
import yaml
# ---------------------------------------------------------------------------
# 默认值:一份可直接跑起来的基线配置
# ---------------------------------------------------------------------------
DEFAULT_LOGIN_URL = (
"https://fspass.szfx.com/ucenter/userlogin"
"?platform=saas&redirect_url=https%3A%2F%2Ffs.szfx.com%2FMMS%23%2F"
"&return_url=https%3A%2F%2Ffs.szfx.com%2Fsaasmerchant%2Fsetstoken"
)
DEFAULTS: Dict[str, Any] = {
"shop_id": "20434543575189",
"timezone": "Asia/Shanghai",
"api": {
"base_url": "https://fs.szfx.com",
"order_path": "/saasmerchant/pcweb/order/quickpayorder/list",
"login_url": DEFAULT_LOGIN_URL,
"timeout": 20,
"max_retries": 2,
},
"notify": {
# 服务器上只开企业微信;feishu 保留配置位,默认关闭
"channels": ["wecom"],
"alert_cooldown_sec": 1800,
"wecom": {"webhook": ""},
"feishu": {"webhook": "", "enabled": False},
},
"polling": {
"peak_hours": [[11, 13], [17, 19]],
"interval_min": 5,
"interval_max": 10,
"peak_page_size": 20,
"idle_page_size": 5,
"night_start": "21:00",
"night_end": "07:40",
"night_check_sec": 60,
"keepalive_sec": 300,
# 一次补推超过该条数就不再逐条推送,改发汇总,防止恢复后刷屏
"bulk_summary_threshold": 5,
},
"paths": {
"cookies": "data/cookies.json",
"state": "data/state.json",
"logs": "data/logs",
},
"admin": {
"enabled": True,
"host": "0.0.0.0",
"port": 8089,
"token": "",
},
"log": {"level": "INFO", "max_bytes": 5242880, "backup_count": 5},
"tts": {"enabled": False, "voice_prompt": ""},
}
def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
"""递归合并字典,override 覆盖 base。"""
out = dict(base)
for key, value in (override or {}).items():
if isinstance(value, dict) and isinstance(out.get(key), dict):
out[key] = _deep_merge(out[key], value)
else:
out[key] = value
return out
def _as_bool(value: Any) -> bool:
if isinstance(value, bool):
return value
return str(value).strip().lower() in ("1", "true", "yes", "on", "y")
def parse_hhmm(text: str) -> int:
"""'21:00' -> 1260(当天分钟数)。"""
hh, mm = str(text).split(":")[:2]
return int(hh) * 60 + int(mm)
# ---------------------------------------------------------------------------
# 强类型配置对象
# ---------------------------------------------------------------------------
@dataclass
class ApiCfg:
base_url: str
order_path: str
login_url: str
timeout: int
max_retries: int
@property
def order_url(self) -> str:
return self.base_url.rstrip("/") + self.order_path
@dataclass
class NotifyCfg:
channels: List[str]
alert_cooldown_sec: int
wecom_webhook: str
feishu_webhook: str
feishu_enabled: bool
@dataclass
class PollingCfg:
peak_hours: List[Tuple[int, int]]
interval_min: int
interval_max: int
peak_page_size: int
idle_page_size: int
night_start_min: int
night_end_min: int
night_check_sec: int
keepalive_sec: int
bulk_summary_threshold: int
@dataclass
class PathsCfg:
cookies: Path
state: Path
logs: Path
@dataclass
class AdminCfg:
enabled: bool
host: str
port: int
token: str
@dataclass
class LogCfg:
level: str
max_bytes: int
backup_count: int
@dataclass
class TtsCfg:
enabled: bool
voice_prompt: str
@dataclass
class Config:
shop_id: str
timezone: str
api: ApiCfg
notify: NotifyCfg
polling: PollingCfg
paths: PathsCfg
admin: AdminCfg
log: LogCfg
tts: TtsCfg
raw: Dict[str, Any] = field(default_factory=dict, repr=False)
def ensure_dirs(self) -> None:
self.paths.cookies.parent.mkdir(parents=True, exist_ok=True)
self.paths.state.parent.mkdir(parents=True, exist_ok=True)
self.paths.logs.mkdir(parents=True, exist_ok=True)
def _apply_env(data: Dict[str, Any]) -> Dict[str, Any]:
"""环境变量覆盖。命名约定:FX_<段>_<键>。"""
env = os.environ
if env.get("FX_SHOP_ID"):
data["shop_id"] = env["FX_SHOP_ID"]
if env.get("FX_WECOM_WEBHOOK"):
data["notify"]["wecom"]["webhook"] = env["FX_WECOM_WEBHOOK"]
if env.get("FX_FEISHU_WEBHOOK"):
data["notify"]["feishu"]["webhook"] = env["FX_FEISHU_WEBHOOK"]
if env.get("FX_FEISHU_ENABLED"):
data["notify"]["feishu"]["enabled"] = _as_bool(env["FX_FEISHU_ENABLED"])
if env.get("FX_CHANNELS"):
data["notify"]["channels"] = [
c.strip() for c in env["FX_CHANNELS"].split(",") if c.strip()
]
if env.get("FX_ADMIN_TOKEN"):
data["admin"]["token"] = env["FX_ADMIN_TOKEN"]
if env.get("FX_ADMIN_PORT"):
data["admin"]["port"] = int(env["FX_ADMIN_PORT"])
if env.get("FX_ADMIN_ENABLED"):
data["admin"]["enabled"] = _as_bool(env["FX_ADMIN_ENABLED"])
if env.get("FX_DATA_DIR"):
base = Path(env["FX_DATA_DIR"])
data["paths"]["cookies"] = str(base / "cookies.json")
data["paths"]["state"] = str(base / "state.json")
data["paths"]["logs"] = str(base / "logs")
if env.get("FX_LOG_LEVEL"):
data["log"]["level"] = env["FX_LOG_LEVEL"]
if env.get("FX_TTS_ENABLED"):
data["tts"]["enabled"] = _as_bool(env["FX_TTS_ENABLED"])
return data
def load_config(path: str | os.PathLike | None = None) -> Config:
"""加载配置。path 为 None 时按 FX_CONFIG -> ./config.yaml 顺序查找。"""
cfg_path = path or os.environ.get("FX_CONFIG") or "config.yaml"
data = dict(DEFAULTS)
p = Path(cfg_path)
if p.exists():
with open(p, "r", encoding="utf-8") as f:
loaded = yaml.safe_load(f) or {}
if not isinstance(loaded, dict):
raise ValueError(f"配置文件格式错误(应为 YAML 映射): {p}")
data = _deep_merge(data, loaded)
data = _apply_env(data)
notify = data["notify"]
feishu_on = bool(notify["feishu"].get("enabled")) and bool(notify["feishu"]["webhook"])
channels = []
for name in notify.get("channels") or []:
if name == "feishu" and not feishu_on:
continue
if name == "wecom" and not notify["wecom"]["webhook"]:
continue
channels.append(name)
polling = data["polling"]
cfg = Config(
shop_id=str(data["shop_id"]),
timezone=str(data.get("timezone") or "Asia/Shanghai"),
api=ApiCfg(
base_url=data["api"]["base_url"],
order_path=data["api"]["order_path"],
login_url=data["api"]["login_url"],
timeout=int(data["api"]["timeout"]),
max_retries=int(data["api"]["max_retries"]),
),
notify=NotifyCfg(
channels=channels,
alert_cooldown_sec=int(notify["alert_cooldown_sec"]),
wecom_webhook=notify["wecom"]["webhook"],
feishu_webhook=notify["feishu"]["webhook"],
feishu_enabled=feishu_on,
),
polling=PollingCfg(
peak_hours=[tuple(h) for h in polling["peak_hours"]],
interval_min=int(polling["interval_min"]),
interval_max=int(polling["interval_max"]),
peak_page_size=int(polling["peak_page_size"]),
idle_page_size=int(polling["idle_page_size"]),
night_start_min=parse_hhmm(polling["night_start"]),
night_end_min=parse_hhmm(polling["night_end"]),
night_check_sec=int(polling["night_check_sec"]),
keepalive_sec=int(polling["keepalive_sec"]),
bulk_summary_threshold=int(polling["bulk_summary_threshold"]),
),
paths=PathsCfg(
cookies=Path(data["paths"]["cookies"]),
state=Path(data["paths"]["state"]),
logs=Path(data["paths"]["logs"]),
),
admin=AdminCfg(
enabled=_as_bool(data["admin"]["enabled"]),
host=data["admin"]["host"],
port=int(data["admin"]["port"]),
token=data["admin"]["token"],
),
log=LogCfg(
level=str(data["log"]["level"]).upper(),
max_bytes=int(data["log"]["max_bytes"]),
backup_count=int(data["log"]["backup_count"]),
),
tts=TtsCfg(
enabled=_as_bool(data["tts"]["enabled"]),
voice_prompt=data["tts"].get("voice_prompt") or "",
),
raw=data,
)
cfg.ensure_dirs()
return cfg
+45
View File
@@ -0,0 +1,45 @@
"""日志初始化:控制台 + 按大小滚动的文件。
原项目全程 print,容器里 detached 运行就查不到历史,出问题无法回溯。
这里统一收口到 logging,容器 stdout 由 docker json-file 限制大小,文件另有 5MB 滚动。
"""
from __future__ import annotations
import logging
import sys
from logging.handlers import RotatingFileHandler
from pathlib import Path
def setup_logging(log_dir: Path, level: str = "INFO",
max_bytes: int = 5 * 1024 * 1024, backup_count: int = 5) -> logging.Logger:
log_dir.mkdir(parents=True, exist_ok=True)
root = logging.getLogger()
root.setLevel(getattr(logging, level.upper(), logging.INFO))
# 避免重复初始化(测试中多次调用)
for h in list(root.handlers):
root.removeHandler(h)
fmt = logging.Formatter(
"%(asctime)s %(levelname)-7s [%(name)s] %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
console = logging.StreamHandler(stream=sys.stdout)
console.setFormatter(fmt)
root.addHandler(console)
file_handler = RotatingFileHandler(
log_dir / "monitor.log",
maxBytes=max_bytes,
backupCount=backup_count,
encoding="utf-8",
)
file_handler.setFormatter(fmt)
root.addHandler(file_handler)
# requests/urllib3 的连接细节太吵,只留警告
logging.getLogger("urllib3").setLevel(logging.WARNING)
return root
+429
View File
@@ -0,0 +1,429 @@
"""监控主循环。
与原实现的行为差异(都是有意的):
1. 首次启动只建立基线,不推送历史订单(原来初始拉单失败会把 20 单全推一遍)
2. 夜间暂停改为分片休眠:每 60 秒醒一次,可感知 Cookie 更新与停止信号(原来 sleep 10 小时)
3. Cookie 失效不再弹浏览器(服务器没桌面),改为告警 + 轮询等待新 Cookie,收到即自动恢复
4. Cookie 文件变化自动热重载,无需重启容器
5. 网络抖动走指数退避,连续失败才升级告警
6. 恢复后积压订单超过阈值改发汇总,避免刷屏
"""
from __future__ import annotations
import datetime
import json
import logging
import os
import random
import signal
import threading
import time
from pathlib import Path
from typing import Any, Dict, List, Optional
from .client import ApiError, FengxiangClient, FengxiangError, NetworkError, SessionExpired
from .config import Config
from .notify import Dispatcher, build_channels
from .store import State
from .tts import Speaker
log = logging.getLogger("fengxiang.monitor")
COOKIE_WAIT_POLL_SEC = 15 # 等待新 Cookie 时的轮询间隔
COOKIE_RECHECK_SEC = 300 # 即使文件没变,也每 5 分钟再验一次
STATE_SAVE_SEC = 600 # 无事件时的状态落盘间隔
def fmt_money(cents: Any) -> str:
try:
return f"{int(cents) / 100:.2f}元"
except (TypeError, ValueError):
return "0.00元"
def format_order_message(order: Dict[str, Any]) -> str:
return f"【丰享丰食】订单收款成功,收款{fmt_money(order.get('amountPayable'))}"
class Monitor:
def __init__(self, cfg: Config, client: Optional[FengxiangClient] = None,
dispatcher: Optional[Dispatcher] = None,
speaker: Optional[Speaker] = None):
self.cfg = cfg
self.client = client or FengxiangClient(cfg)
self.dispatcher = dispatcher or Dispatcher(
build_channels(cfg), cfg.notify.alert_cooldown_sec
)
self.speaker = speaker or Speaker(cfg.tts.voice_prompt, cfg.tts.enabled)
self.state = State.load(cfg.paths.state)
self.stop_event = threading.Event()
self._cookie_sig: Optional[tuple] = None
self._last_state_save = 0.0
self._net_failures = 0
self._started_at = time.time()
self._admin = None
self._last_cookie_check = 0.0
self._now_impl = self._default_now
# ------------------------------------------------------------------ 时间
def now(self) -> datetime.datetime:
"""当前时间。测试可通过替换 _now_impl 注入固定时间。"""
return self._now_impl()
def _default_now(self) -> datetime.datetime:
try:
import zoneinfo
return datetime.datetime.now(zoneinfo.ZoneInfo(self.cfg.timezone))
except Exception: # noqa: BLE001 - 无 tzdata 时退回本机时区
return datetime.datetime.now()
def is_peak(self) -> bool:
hour = self.now().hour
return any(start <= hour < end for start, end in self.cfg.polling.peak_hours)
def is_night(self) -> bool:
n = self.now()
minutes = n.hour * 60 + n.minute
p = self.cfg.polling
return minutes >= p.night_start_min or minutes < p.night_end_min
def seconds_until_morning(self) -> int:
n = self.now()
target = n.replace(hour=0, minute=0, second=0, microsecond=0) + datetime.timedelta(
minutes=self.cfg.polling.night_end_min
)
if target <= n:
target += datetime.timedelta(days=1)
return max(1, int((target - n).total_seconds()))
def poll_page_size(self) -> int:
p = self.cfg.polling
return p.peak_page_size if self.is_peak() else p.idle_page_size
# ------------------------------------------------------------------ Cookie
def _cookie_sig_of_file(self) -> Optional[tuple]:
path = Path(self.cfg.paths.cookies)
if not path.exists():
return None
st = path.stat()
return (st.st_mtime_ns, st.st_size)
def read_cookies(self) -> Optional[Dict[str, str]]:
path = Path(self.cfg.paths.cookies)
if not path.exists():
return None
try:
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
if isinstance(data, dict) and data:
return {str(k): str(v) for k, v in data.items()}
log.warning("cookie 文件内容不是非空字典,忽略")
return None
except (OSError, ValueError) as exc:
log.error("读取 cookie 文件失败: %s", exc)
return None
def apply_cookies(self, cookies: Dict[str, str], source: str = "file") -> bool:
"""校验并应用 Cookie(供主循环与管理接口共用)。"""
if not cookies:
return False
if not self.client.check_cookie(cookies):
log.warning("来自 %s 的 Cookie 校验未通过", source)
return False
self.client.set_cookies(cookies)
old = self.state.cookie_updated_ts
self.state.cookie_updated_ts = time.time()
self.state.cookie_valid = True
self.state.save()
log.info("Cookie 已生效(来源=%s,共 %d 项,距上次更新 %.0f 秒)",
source, len(cookies), self.state.cookie_updated_ts - old if old else 0)
if old and self.state.gap_since_ts:
gap_min = (time.time() - self.state.gap_since_ts) / 60
self.dispatcher.notify(f"【丰享监控】已重新登录,监控恢复(中断约 {gap_min:.0f} 分钟)")
self.state.gap_since_ts = 0.0
self.state.save()
return True
def _load_cookie_if_changed(self, force: bool = False) -> bool:
sig = self._cookie_sig_of_file()
if sig is None:
if force:
log.warning("未找到 Cookie 文件: %s", self.cfg.paths.cookies)
return False
if not force and sig == self._cookie_sig:
return True
cookies = self.read_cookies()
ok = self.apply_cookies(cookies or {}, source="file")
if ok:
self._cookie_sig = sig
else:
# 记录签名,避免同一份坏 Cookie 反复校验
self._cookie_sig = sig
return ok
def update_cookies(self, cookies: Dict[str, str]) -> bool:
"""管理接口收到新 Cookie:落盘后立即校验生效。"""
from .store import atomic_write_json
atomic_write_json(Path(self.cfg.paths.cookies), cookies)
self._cookie_sig = self._cookie_sig_of_file()
return self.apply_cookies(cookies, source="admin-api")
# ------------------------------------------------------------------ 状态
def status(self) -> Dict[str, Any]:
now = time.time()
return {
"app": "fengxiang-monitor",
"mode": ("night" if self.is_night() else ("peak" if self.is_peak() else "idle")),
"cookie_valid": bool(self.state.cookie_valid),
"cookie_age_sec": int(now - self.state.cookie_updated_ts) if self.state.cookie_updated_ts else None,
"last_order_id": self.state.last_order_id,
"last_poll_age_sec": int(now - self.state.last_poll_ts) if self.state.last_poll_ts else None,
"total_pushed": self.state.total_pushed,
"uptime_sec": int(now - self._started_at),
"net_failures": self._net_failures,
}
def _save_state(self, force: bool = False) -> None:
now = time.time()
if force or now - self._last_state_save > STATE_SAVE_SEC:
self.state.save()
self._last_state_save = now
# ------------------------------------------------------------------ 主流程
def stop(self, *_args) -> None:
log.info("收到停止信号,准备退出")
self.stop_event.set()
def _install_signals(self) -> None:
for sig in (signal.SIGTERM, signal.SIGINT):
try:
signal.signal(sig, self.stop)
except (ValueError, OSError): # 非主线程/平台不支持
pass
def run(self) -> None:
self._install_signals()
self.speaker.start()
log.info("丰享订单监控启动 v%s | shop=%s | 通道=%s",
__import__("fengxiang").__version__, self.cfg.shop_id,
",".join(c.name for c in self.dispatcher.channels) or "无")
if self.cfg.admin.enabled:
from .admin import AdminServer
self._admin = AdminServer(self.cfg, self)
self._admin.start()
# 1) 确保有可用 Cookie
if not self._ensure_cookie():
log.error("启动阶段未获得可用 Cookie,进入等待模式")
if self.stop_event.is_set():
self._shutdown()
return
# 2) 建立基线(不推送历史订单)
if self.state.cookie_valid:
self._bootstrap()
# 3) 主循环
while not self.stop_event.is_set():
try:
if self.is_night():
self._night_wait()
continue
self._load_cookie_if_changed(force=False)
page_size = self.poll_page_size()
try:
orders = self.client.list_orders(page_size=page_size)
except SessionExpired as exc:
self._on_session_expired(str(exc))
continue
except (NetworkError, ApiError) as exc:
self._on_soft_error(exc)
continue
self._net_failures = 0
self.state.touch_poll()
self._process(orders, page_size)
self._save_state()
self._wait(self._next_interval())
except Exception as exc: # noqa: BLE001 - 主循环绝不能被单次异常打死
log.exception("主循环异常(已忽略并继续): %s", exc)
self._wait(10)
self._shutdown()
def _shutdown(self) -> None:
self.speaker.stop()
if self._admin:
self._admin.stop()
self._save_state(force=True)
log.info("监控已停止")
def _ensure_cookie(self) -> bool:
"""启动时确保 Cookie 可用;不可用则等待(不弹浏览器)。"""
if self._load_cookie_if_changed(force=True):
log.info("启动校验通过,复用已有 Cookie")
return True
cookies = self.read_cookies()
if cookies and self.client.check_cookie(cookies):
return self.apply_cookies(cookies, source="file")
self.state.cookie_valid = False
self.state.gap_since_ts = self.state.gap_since_ts or time.time()
self.state.save()
self.dispatcher.alert(
"cookie_need_login",
"【丰享监控】需要登录:Cookie 缺失或已失效。请在本机运行 fengxiang_scraper.py 完成登录,"
"脚本会自动上传 Cookie,服务器收到后自动恢复监控。",
)
return self._wait_for_new_cookie()
def _wait_for_new_cookie(self) -> bool:
"""等待新 Cookie 落地。返回是否拿到可用 Cookie。"""
baseline = self._cookie_sig_of_file()
log.warning("进入 Cookie 等待模式(等待 %s 更新)", self.cfg.paths.cookies)
last_log = 0.0
last_recheck = 0.0
while not self.stop_event.is_set():
self.stop_event.wait(COOKIE_WAIT_POLL_SEC)
if self.stop_event.is_set():
return False
sig = self._cookie_sig_of_file()
if sig and sig != baseline:
cookies = self.read_cookies()
if cookies and self.apply_cookies(cookies, source="file"):
self._cookie_sig = sig
return True
baseline = sig
log.warning("新 Cookie 仍不可用,继续等待")
# 兜底:文件没变化但可能是同一份 Cookie 恢复了(服务端续期)
now = time.time()
if now - last_recheck > COOKIE_RECHECK_SEC:
last_recheck = now
cookies = self.read_cookies()
if cookies and self.client.check_cookie(cookies):
if self.apply_cookies(cookies, source="recheck"):
return True
if now - last_log > 300:
last_log = now
log.warning("仍在等待 Cookie(已等待 %.0f 分钟)", (now - (self.state.gap_since_ts or now)) / 60)
return False
def _on_session_expired(self, reason: str) -> None:
log.error("会话失效: %s", reason)
self.state.cookie_valid = False
self.state.gap_since_ts = self.state.gap_since_ts or time.time()
self.state.save()
self.dispatcher.alert(
"cookie_expired",
"【丰享监控】登录已失效(Cookie 过期),监控暂停。"
"请在本机运行 fengxiang_scraper.py 重新登录,上传后自动恢复。",
)
self._wait_for_new_cookie()
def _on_soft_error(self, exc: FengxiangError) -> None:
self._net_failures += 1
backoff = min(60, 5 * (2 ** min(self._net_failures - 1, 4))) + random.uniform(0, 3)
log.warning("拉取订单失败(第 %d 次): %s,%.1f 秒后重试",
self._net_failures, exc, backoff)
if self._net_failures in (5, 20, 60):
self.dispatcher.alert(
f"net_fail_{self._net_failures}",
f"【丰享监控】连续 {self._net_failures} 次拉单失败,最近错误:{exc}",
)
self._wait(backoff)
def _bootstrap(self) -> None:
"""建立订单基线:取最新一单作为参考点,不推送。"""
if self.state.last_order_id:
return
try:
orders = self.client.list_orders(page_size=1)
except FengxiangError as exc:
log.warning("建立基线失败(下次轮询再试): %s", exc)
return
if orders:
self.state.last_order_id = str(orders[0].get("orderId"))
self.state.mark_pushed([self.state.last_order_id])
self.state.save()
log.info("已建立基线,当前最新订单 %s(不推送历史订单)", self.state.last_order_id)
def _process(self, orders: List[Dict[str, Any]], page_size: int) -> None:
if not orders:
log.debug("本次拉取为空")
return
new_orders: List[Dict[str, Any]] = []
for order in orders:
oid = str(order.get("orderId") or "")
if not oid:
continue
if self.state.last_order_id and oid == self.state.last_order_id:
break
if self.state.has_pushed(oid):
continue
new_orders.append(order)
if not new_orders:
log.debug("暂无新订单(最新=%s)", self.state.last_order_id)
return
if len(new_orders) >= page_size:
log.warning("本次新订单数达到页大小 %d,可能仍有更早订单未拉取,建议临时调大 page_size",
page_size)
newest_id = str(new_orders[0].get("orderId"))
threshold = self.cfg.polling.bulk_summary_threshold
if len(new_orders) > threshold:
total = sum(int(o.get("amountPayable") or 0) for o in new_orders)
msg = (f"【丰享丰食】监控恢复,期间新增 {len(new_orders)} 笔订单,"
f"合计 {fmt_money(total)}(已合并提醒)")
log.info("积压 %d 单,发送汇总消息", len(new_orders))
self.dispatcher.notify(msg)
else:
log.info("发现 %d 笔新订单", len(new_orders))
for order in reversed(new_orders): # 从旧到新
msg = format_order_message(order)
self.dispatcher.notify(msg)
self.speaker.say(msg)
time.sleep(0.3)
self.state.mark_pushed([str(o.get("orderId")) for o in new_orders])
self.state.last_order_id = newest_id
self.state.save()
def _next_interval(self) -> float:
p = self.cfg.polling
return random.uniform(p.interval_min, p.interval_max)
def _wait(self, seconds: float) -> None:
"""可中断等待。"""
if seconds > 0:
self.stop_event.wait(seconds)
def _night_wait(self) -> None:
remaining = self.seconds_until_morning()
step = min(remaining, self.cfg.polling.night_check_sec)
if remaining == step:
log.info("夜间暂停,%.0f 分钟后恢复", remaining / 60)
# 分片休眠:便于感知 Cookie 更新和停止信号
waited = 0.0
while waited < remaining and not self.stop_event.is_set():
chunk = min(self.cfg.polling.night_check_sec, remaining - waited)
self.stop_event.wait(chunk)
waited += chunk
self._load_cookie_if_changed(force=False)
if not self.stop_event.is_set():
log.info("夜间结束,恢复监控")
self._bootstrap()
def build_monitor(cfg: Config) -> Monitor:
return Monitor(cfg)
+103
View File
@@ -0,0 +1,103 @@
"""通知通道。
设计要点:
- 通道可插拔(企业微信 / 飞书),单个通道失败不影响其他通道,也不影响主循环
- 告警(Cookie 失效、登录提示)带冷却,避免每 5 秒往群里刷一条
- 所有 webhook 从配置读取,源码里不再出现密钥
"""
from __future__ import annotations
import logging
import time
from typing import Dict, List, Protocol, Tuple
import requests
from .config import Config
log = logging.getLogger("fengxiang.notify")
class Channel(Protocol):
name: str
def send(self, text: str) -> None: # pragma: no cover - 协议声明
...
class WecomChannel:
name = "wecom"
def __init__(self, webhook: str, timeout: int = 10):
self.webhook = webhook
self.timeout = timeout
def send(self, text: str) -> None:
payload = {"msgtype": "text", "text": {"content": text}}
resp = requests.post(self.webhook, json=payload, timeout=self.timeout)
data = resp.json()
if data.get("errcode") != 0:
raise RuntimeError(f"企业微信返回错误: {data}")
class FeishuChannel:
name = "feishu"
def __init__(self, webhook: str, timeout: int = 10):
self.webhook = webhook
self.timeout = timeout
def send(self, text: str) -> None:
payload = {"msg_type": "text", "content": {"text": text}}
resp = requests.post(self.webhook, json=payload, timeout=self.timeout)
data = resp.json()
# 飞书新老版本返回结构不同,统一取出成功标志
code = data.get("code", data.get("StatusCode"))
if code != 0:
raise RuntimeError(f"飞书返回错误: {data}")
def build_channels(cfg: Config) -> List[Channel]:
channels: List[Channel] = []
for name in cfg.notify.channels:
if name == "wecom" and cfg.notify.wecom_webhook:
channels.append(WecomChannel(cfg.notify.wecom_webhook))
elif name == "feishu" and cfg.notify.feishu_enabled and cfg.notify.feishu_webhook:
channels.append(FeishuChannel(cfg.notify.feishu_webhook))
else:
log.warning("通道 %s 已配置但缺少 webhook/token,跳过", name)
return channels
class Dispatcher:
def __init__(self, channels: List[Channel], alert_cooldown_sec: int = 1800):
self.channels = channels
self.alert_cooldown_sec = alert_cooldown_sec
self._last_alert: Dict[str, float] = {}
def notify(self, text: str) -> Dict[str, bool]:
"""广播一条消息,返回各通道成功与否。异常不外抛。"""
result: Dict[str, bool] = {}
for ch in self.channels:
try:
ch.send(text)
result[ch.name] = True
log.info("推送成功 [%s] %s", ch.name, text.replace("\n", " ")[:80])
except Exception as exc: # noqa: BLE001 - 推送失败绝不能让监控挂掉
result[ch.name] = False
log.error("推送失败 [%s]: %s", ch.name, exc)
if not self.channels:
log.warning("未配置任何推送通道,消息未发出: %s", text)
return result
def alert(self, key: str, text: str) -> Tuple[bool, str]:
"""带冷却的告警。同一 key 在冷却期内不重复发送。"""
now = time.time()
last = self._last_alert.get(key, 0)
if now - last < self.alert_cooldown_sec:
log.debug("告警 %s 处于冷却期,跳过", key)
return False, "cooldown"
self._last_alert[key] = now
self.notify(text)
return True, "sent"
+104
View File
@@ -0,0 +1,104 @@
"""运行状态持久化。
解决原项目两个真实问题:
1. 进程重启后 last_order_id 丢失 → 靠「取当前最新」兜底,但拉单失败时会重推历史订单
2. 一次拉取超过 page_size 时,仅靠 orderId 断点会漏单
因此这里同时保存 last_order_id 和最近推送过的订单号集合(去重兜底)。
写入采用 tmp + os.replace 原子替换,避免断电/被杀留下半个 JSON。
"""
from __future__ import annotations
import json
import logging
import os
import time
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional
log = logging.getLogger("fengxiang.store")
MAX_PUSHED_IDS = 500
@dataclass
class State:
last_order_id: Optional[str] = None
pushed_ids: List[str] = field(default_factory=list)
last_poll_ts: float = 0.0
cookie_updated_ts: float = 0.0
cookie_valid: bool = False
gap_since_ts: float = 0.0 # 最近一次进入「会话失效」的时刻
total_pushed: int = 0
# 运行时字段,不落盘
_path: Optional[Path] = field(default=None, repr=False, compare=False)
# ---------------- 持久化 ----------------
@classmethod
def load(cls, path: Path) -> "State":
state = cls(_path=Path(path))
if Path(path).exists():
try:
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
state.last_order_id = str(data["last_order_id"]) if data.get("last_order_id") else None
state.pushed_ids = [str(i) for i in data.get("pushed_ids", [])]
state.last_poll_ts = float(data.get("last_poll_ts") or 0)
state.cookie_updated_ts = float(data.get("cookie_updated_ts") or 0)
state.cookie_valid = bool(data.get("cookie_valid"))
state.gap_since_ts = float(data.get("gap_since_ts") or 0)
state.total_pushed = int(data.get("total_pushed") or 0)
log.info("已加载状态: last_order_id=%s 去重缓存=%d 条",
state.last_order_id, len(state.pushed_ids))
except (OSError, ValueError, KeyError, TypeError) as exc:
log.warning("状态文件损坏,按全新状态启动: %s", exc)
return state
def to_dict(self) -> Dict[str, Any]:
return {
"last_order_id": self.last_order_id,
"pushed_ids": self.pushed_ids[-MAX_PUSHED_IDS:],
"last_poll_ts": self.last_poll_ts,
"cookie_updated_ts": self.cookie_updated_ts,
"cookie_valid": self.cookie_valid,
"gap_since_ts": self.gap_since_ts,
"total_pushed": self.total_pushed,
}
def save(self, path: Optional[Path] = None) -> None:
target = Path(path or self._path or "state.json")
target.parent.mkdir(parents=True, exist_ok=True)
tmp = target.with_suffix(target.suffix + ".tmp")
with open(tmp, "w", encoding="utf-8") as f:
json.dump(self.to_dict(), f, ensure_ascii=False, indent=2)
f.flush()
os.fsync(f.fileno())
os.replace(tmp, target)
# ---------------- 业务方法 ----------------
def has_pushed(self, order_id: str) -> bool:
return str(order_id) in self.pushed_ids
def mark_pushed(self, order_ids: Iterable[str]) -> None:
ids = [str(i) for i in order_ids]
self.pushed_ids.extend(ids)
self.total_pushed += len(ids)
if len(self.pushed_ids) > MAX_PUSHED_IDS:
self.pushed_ids = self.pushed_ids[-MAX_PUSHED_IDS:]
def touch_poll(self) -> None:
self.last_poll_ts = time.time()
def atomic_write_json(path: Path, data: Any) -> None:
"""供管理接口写 cookies 复用。"""
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
tmp = path.with_suffix(path.suffix + ".tmp")
with open(tmp, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
f.flush()
os.fsync(f.fileno())
os.replace(tmp, path)
+65
View File
@@ -0,0 +1,65 @@
"""本地语音播报(仅本地 Windows 模式使用,容器内自动禁用)。
原来 speak() 是同步调用:IndexTTS2 首次加载模型要 1-2 分钟,合成每次几秒,
直接卡在轮询主循环里,导致监控间隔完全失真。这里改为后台线程 + 队列。
服务器(Linux/容器)没有声卡也不装 torch,所以此模块在非 Windows 上直接降级为 no-op。
"""
from __future__ import annotations
import logging
import queue
import sys
import threading
from typing import Optional
log = logging.getLogger("fengxiang.tts")
class Speaker:
def __init__(self, voice_prompt: str = "", enabled: bool = True):
self.enabled = bool(enabled) and sys.platform == "win32"
self.voice_prompt = voice_prompt or None
self._queue: "queue.Queue[Optional[str]]" = queue.Queue(maxsize=20)
self._thread: Optional[threading.Thread] = None
self._impl = None
if enabled and not self.enabled:
log.info("当前平台 %s 不支持本地播报,已自动禁用 TTS", sys.platform)
def start(self) -> None:
if not self.enabled or self._thread:
return
self._thread = threading.Thread(target=self._worker, name="tts", daemon=True)
self._thread.start()
def say(self, text: str) -> None:
"""非阻塞投递,队列满则丢弃并告警(绝不阻塞监控)。"""
if not self.enabled:
return
try:
self._queue.put_nowait(text)
except queue.Full:
log.warning("TTS 队列已满,丢弃本次播报")
def _worker(self) -> None:
while True:
text = self._queue.get()
if text is None:
return
try:
if self._impl is None:
from local_tts import speak as local_speak # 延迟导入,避免无依赖时启动失败
self._impl = local_speak
self._impl(text, voice_prompt=self.voice_prompt)
log.info("语音播报完成: %s", text)
except Exception as exc: # noqa: BLE001
log.error("语音播报失败: %s", exc)
def stop(self) -> None:
if not self.enabled:
return
try:
self._queue.put_nowait(None)
except queue.Full:
pass