feat: add configurable delayed password relogin

This commit is contained in:
AttilaNet
2026-11-11 11:48:52 +08:00
parent 4a1b06ee9d
commit 5b1ef25048
12 changed files with 1068 additions and 24 deletions
+229 -15
View File
@@ -71,6 +71,10 @@ class RevisionConflict(ValueError):
"""The browser edited a different applied configuration revision."""
class AutoReloginBlocked(ValueError):
"""Password login has no verified local credentials/target to use."""
def _private_field(field):
normalized = str(field).lower().replace("_", "").replace("-", "")
return normalized in SECRET_FIELDS or sensitive(field)
@@ -186,6 +190,16 @@ class AccountWorker:
self._last_game_error = None
self._game_failure_sequence = 0
self.schedule = AccountSchedule()
self._auto_relogin_suspended = False
self._auto_relogin_pending_config = None
self._auto_relogin_inflight = False
self._auto_relogin_target = None
self._auto_relogin_account = ""
self._auto_relogin_error = ""
self._auto_relogin_blocked = False
# Reuse the account's existing disconnected settings for login
# preferences. Role policies remain in their own role directories.
self._login_settings_root = manager.store.role_root(self.id)
self.state_root = self.state = manager.store.role_root(self.id, demo=self.demo)
self.config, self.revision = self._load_config(self.state_root)
self.trace = WebTrace(self)
@@ -199,7 +213,12 @@ class AccountWorker:
def _load_config(self, folder):
record = self.manager.store.load_config(folder)
return (validate_config(record["config"]), record["revision"]) if record else (default_config(), 0)
value, revision = (validate_config(record["config"]), record["revision"]) if record else (default_config(), 0)
if folder != self._login_settings_root:
login = self.manager.store.load_config(self._login_settings_root)
if login:
value["auto_relogin"] = validate_config(login["config"])["auto_relogin"]
return value, revision
def _engine(self, client=None, *, state_root=None, config=None):
state_root = self.state_root if state_root is None else state_root
@@ -319,7 +338,59 @@ class AccountWorker:
"demo": self.demo, "running": self._running, "busy": False, "player": player,
"revision": self.revision, "error": self.error, "connection_state": self.connection_state,
"connection_message": self.connection_message, "last_game_success_at": self.last_game_success_at,
"next_retry_at": self.next_retry_at})
"next_retry_at": self.next_retry_at, "auto_relogin_status": self._auto_relogin_status()})
def _auto_relogin_status(self):
with self.lock:
preference = (self._auto_relogin_pending_config[1] if self._auto_relogin_pending_config
else self.config["auto_relogin"])
state, message, next_at = "idle", "自动重登已开启;等待游戏连接掉线", None
if not preference["enabled"]:
state, message = "disabled", "自动重登已关闭"
elif self._auto_relogin_suspended:
state, message = "suspended", "已暂停本次自动重登;手动登录或恢复成功后重新参与掉线监测"
elif self._auto_relogin_pending_config:
state, message = "suspended", "正在保存自动重登设置,旧登录计划已取消"
elif self.demo:
message = "离线演示不执行自动重登"
elif self._auto_relogin_inflight:
state, message = "authenticating", "正在使用服务器保存的密码重新登录原区服、原角色;策略保持停止"
elif not self.active_identity or self.schedule.disconnected_at is not None and not self._auto_relogin_target:
state, message = "blocked", "没有可确认的原区服和角色会话,请先手动登录并选择区服"
elif self.schedule.disconnected_at is not None:
if not self._has_saved_password:
state, message = "blocked", "未在服务器保存密码,无法自动重登;请手动登录并勾选记住密码"
elif self._auto_relogin_account != self._saved_account:
state, message = "blocked", "保存密码的账号与掉线角色所属账号不匹配,请手动登录确认"
elif self._auto_relogin_blocked:
state, message = "blocked", self._auto_relogin_error
else:
deadline = self.schedule.auto_relogin_deadline(self.config)
if deadline is not None:
next_at = datetime.fromtimestamp(self.schedule.disconnected_wall_at
+ deadline - self.schedule.disconnected_at, timezone.utc).isoformat(timespec="milliseconds")
state = "failed" if self._auto_relogin_error else "waiting"
message = (self._auto_relogin_error + ";将按配置分钟间隔再次尝试" if self._auto_relogin_error
else f"游戏已掉线,从首次掉线起等待 {preference['delay_minutes']} 分钟后重新登录原区服、原角色")
return {"state": state, "message": self.safe_text(message), "next_attempt_at": next_at}
def _mark_disconnected(self, session, identity):
if not self._auto_relogin_suspended and self.schedule.disconnected_at is None:
self.schedule.disconnected()
self._auto_relogin_target = identity
self._auto_relogin_account = session.account_name.strip()
self._auto_relogin_error = ""
self._auto_relogin_blocked = False
def suspend_auto_relogin(self):
# Called synchronously at submit/close, before any queued lifecycle job.
with self.lock:
self._auto_relogin_suspended = True
self.schedule.clear_disconnection()
self._auto_relogin_target = None
self._auto_relogin_account = ""
self._auto_relogin_error = ""
self._auto_relogin_blocked = False
def _require_game(self):
if self.connection_state != "online" and not (self._retry_probe and self.connection_state == "retrying"):
@@ -349,6 +420,8 @@ class AccountWorker:
self.log(self.error)
return
self.engine.heartbeat_enabled = False
if client is not None:
self._mark_disconnected(client.session, self.active_identity)
delay = self.schedule.game_failed(retry=temporary and not expired and client is not None)
with self.lock:
self.next_retry_at = None
@@ -370,7 +443,7 @@ class AccountWorker:
self._last_game_error_message = self.error
self.log(self.connection_message)
def _game_succeeded(self):
def _game_succeeded(self, *, activated=False):
previous = self.connection_state
with self.lock:
self.connection_state = "online"
@@ -378,6 +451,12 @@ class AccountWorker:
self.last_game_success_at = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
self.next_retry_at = None
self.error = ""
if activated:
self._auto_relogin_suspended = False
self._auto_relogin_target = None
self._auto_relogin_account = ""
self._auto_relogin_error = ""
self._auto_relogin_blocked = False
self.schedule.game_resumed()
self.engine.heartbeat_enabled = True
if previous != "online":
@@ -387,6 +466,7 @@ class AccountWorker:
with self.lock:
result = deepcopy(self._summary)
result.update(running=self._running, busy=bool(self._active or self._pending))
result["auto_relogin_status"] = self._auto_relogin_status()
return result
@property
@@ -411,7 +491,7 @@ class AccountWorker:
def check_intent(self, *, check_persistence=False):
with self.lock:
job = self._execution
if job and job.consuming and (self._closing or job.generation != self._generation):
if job and job.consuming and (self._closing or self.manager._closing or job.generation != self._generation):
raise CancelledBeforeDispatch()
if check_persistence and getattr(self, "_session_write_error", ""):
raise OSError(self._session_write_error)
@@ -523,6 +603,8 @@ class AccountWorker:
final_status, final_error = "failed", self.error
self.log(self.error)
with self.condition:
if self._auto_relogin_pending_config and self._auto_relogin_pending_config[0] == job.id:
self._auto_relogin_pending_config = None
self._summary = summary
# A terminal job means its counters and status are both
# visible. Publish them atomically for HTTP polling.
@@ -547,12 +629,17 @@ class AccountWorker:
saved = self.securestore.active()
if saved is not None and not self.demo:
# Restore settings without issuing an unsolicited game request.
self.securestore.load(saved)
session = self.securestore.load(saved)
self.state_root = self.state = self.manager.store.role_root(self.id, saved)
self.config, self.revision = self._load_config(self.state_root)
self.active_identity = saved
self.engine = self._engine()
self.connection_message = "服务已启动或重启;已保留保存的会话,请手动恢复会话或重新登录,策略保持停止"
# Opt-in only: retain the known startup offline origin even
# while disabled, so enabling later can reuse that timestamp.
self._mark_disconnected(session, saved)
if self.config["auto_relogin"]["enabled"]:
self.connection_message = "服务已启动或重启;将等待配置分钟后使用保存的密码重新登录原区服、原角色,策略保持停止"
self.log(self.connection_message)
if self.demo:
self.result(*self.engine.poll())
@@ -610,9 +697,19 @@ class AccountWorker:
raise RuntimeError("策略保存必须在账号队列中执行")
if revision is not None and revision != self.revision:
raise RevisionConflict("策略已在其他页面更新,请刷新后重试")
value = validate_config(self.config if config is None else config)
source = deepcopy(self.config if config is None else config)
if self._execution and self._execution.operation == "import_config":
# Legacy portable documents contain strategy rules, not local
# login authorization. Never erase or enable this preference.
source["auto_relogin"] = deepcopy(self.config["auto_relogin"])
value = validate_config(source)
new_revision = self.revision + 1
self.manager.store.save_config(self.state_root, value, new_revision)
if self.state_root != self._login_settings_root:
login = self.manager.store.load_config(self._login_settings_root)
local = validate_config(login["config"]) if login else default_config()
local["auto_relogin"] = deepcopy(value["auto_relogin"])
self.manager.store.save_config(self._login_settings_root, local, new_revision)
apply_config(self.engine, value)
with self.lock:
self.config, self.revision = value, new_revision
@@ -678,11 +775,28 @@ class AccountWorker:
return active
def _tick(self, job):
if not self.demo and self.engine.client is None:
return None
kind = self.schedule.due(self.engine, self.config, self._running)
if kind is None:
return None
if kind == "auto_relogin":
with self.lock:
if self._auto_relogin_status()["state"] not in {"waiting", "failed"}:
# A blocked password login must not starve existing
# read-only timeout probes that could restore the client.
kind = self.schedule.due(self.engine, dict(self.config, auto_relogin={"enabled": False}), self._running)
else:
# Automation is already stopped on disconnect. This tick
# still consumes authentication intent and must be revocable.
job.consuming = True
self.check_intent()
self._running = self.engine.auto = False
self.schedule.stop()
if kind == "auto_relogin":
return self._auto_relogin()
if kind is None:
return None
if not self.demo and self.engine.client is None:
return None
auto = False
try:
if kind == "retry":
@@ -735,6 +849,100 @@ class AccountWorker:
self.schedule.poll_finished(self.config)
raise
def _password_login_flow(self):
flow = self.manager.login_factory(self.catalog, self.securestore.device(), trace=self.trace)
# Preserve the factory's existing constructor convention. The real
# SDK flow checks this optional guard at its own HTTP send boundary.
if isinstance(flow, PasswordLogin):
flow.cancel_guard = self.check_intent
return flow
def _auto_relogin(self):
client = None
self._auto_relogin_inflight = True
try:
self.check_intent()
identity = self._auto_relogin_target
if not identity or identity != self.active_identity:
raise AutoReloginBlocked("无法确认掉线前的原区服和角色,请手动登录确认")
try:
target = self.securestore.load(identity)
except (OSError, ValueError, KeyError):
raise AutoReloginBlocked("掉线前保存的角色会话不存在或无法读取,请手动登录确认") from None
if not target.account_id or not target.account_name or not target.server_id or not target.role_id:
raise AutoReloginBlocked("保存的会话缺少可确认的账号、原区服或角色,请手动登录确认")
saved, account, password = self.securestore.load_credentials()
self.remember({"password": password})
if not saved or not account or not password:
raise AutoReloginBlocked("未在服务器保存密码,无法自动重登;请手动登录并勾选记住密码")
if account.strip() != target.account_name.strip():
raise AutoReloginBlocked("保存密码的账号与掉线角色所属账号不匹配,请手动登录确认")
self.manager._claim_identity(self, identity)
self.check_intent()
self._session_write_error = ""
client, response, context = self._password_login_flow().authenticate(account, password)
self.check_intent()
# account_name is the input username; account_id is the SDK uid.
# Neither can substitute for the other when choosing the target.
if (client.session.account_name.strip() != target.account_name.strip()
or str(context.get("uid", "")) != target.account_id
or client.session.account_id != target.account_id
or client.session.channel != target.channel
or client.session.platform != target.platform
or context.get("channel") != target.channel):
raise ValueError("密码登录返回的账号与原角色会话不匹配,已拒绝进入区服")
servers = server_entries(response, target.platform)
server = next((row for row in servers if row["id"] == target.server_id), None)
if server is None:
raise ValueError("官方登录列表中没有掉线前的原区服,已拒绝切换其他区服")
roles = [row for row in response.get("masterInfos") or [] if isinstance(row, dict)
and str(row.get("serverId")) == str(target.server_id)]
if not roles or {str(row.get("id")) for row in roles} != {str(target.role_id)}:
raise ValueError("官方登录列表中无法确认原区服的原角色,已拒绝进入或创建其他角色")
self._bind_client(client)
self.check_intent()
client.enter_server(context["center_url"], server, context["uid"], self.catalog,
context["channel"], target.platform, context["device_id"])
self.check_intent()
if client.session.server_id != target.server_id or client.session.account_id != target.account_id:
raise ValueError("进入区服返回的账号或区服与掉线前不匹配,已停止自动重登")
# Client.snapshot must reject a different character before saving
# it; enter_server normally resets role_id to zero for manual use.
client.session.role_id = target.role_id
snapshot = client.snapshot()
self.check_intent()
if session_identity(client.session) != identity or int(snapshot.raw.get("master", {}).get("id") or 0) != target.role_id:
raise ValueError("进服后的角色与掉线前不匹配,已停止自动重登")
result = self._activate_client(client, snapshot)
client = None # The worker now owns this client.
self.log("自动重登成功,已恢复原区服和原角色的监控;策略保持停止")
return result
except Exception as error:
with self.lock:
# One cancellation path handles both a guard exception and a
# revoked SDK call that eventually returns a transport error.
try:
self.check_intent()
if isinstance(error, CancelledBeforeDispatch):
raise error
except CancelledBeforeDispatch:
preference = (self._auto_relogin_pending_config[1] if self._auto_relogin_pending_config
else self.config["auto_relogin"])
if (not self._auto_relogin_suspended and preference["enabled"]
and self.schedule.disconnected_at is not None):
self.schedule.auto_relogin_failed()
self._auto_relogin_error = "自动重登已被新的操作取消"
raise
self.schedule.auto_relogin_failed()
self._auto_relogin_blocked = isinstance(error, AutoReloginBlocked)
self._auto_relogin_error = "自动重登未完成:" + self.safe_text(str(error))
self.log(self._auto_relogin_error)
return {"connected": False, "running": False, "message": self._auto_relogin_error}
finally:
self._auto_relogin_inflight = False
if client is not None:
client.close()
def _bind_client(self, client):
if not isinstance(client.session, Session):
raise ValueError("登录客户端未提供受支持的会话")
@@ -873,9 +1081,10 @@ class AccountWorker:
self.config, self.revision = value, revision
self.engine, self.active_identity, self.demo = engine, identity, False
self._running = False
self.schedule.monitor(True)
self.schedule.poll_finished(self.config)
self._invalidate_views(clear=True)
self.schedule.monitor(True)
self.schedule.poll_finished(self.config)
self._game_succeeded(activated=True)
self._invalidate_views(clear=True)
except Exception:
with self.lock:
self.engine, self.active_identity, self.demo = old_engine, previous_identity, old_demo
@@ -895,7 +1104,6 @@ class AccountWorker:
self.manager._release_identity(self, previous_identity)
if old_client is not None and old_client is not client:
old_client.close()
self._game_succeeded()
return {"connected": True, "running": False, "has_saved_password": self._has_saved_password}
def _login(self, payload):
@@ -920,7 +1128,7 @@ class AccountWorker:
self.schedule.monitor(False)
self.securestore.save_credentials(account, password, remember)
self._refresh_login_metadata()
flow = self.manager.login_factory(self.catalog, self.securestore.device(), trace=self.trace)
flow = self._password_login_flow()
client, response, context = flow.authenticate(account, password)
try:
self.check_intent()
@@ -1054,8 +1262,9 @@ class AccountWorker:
return {"running": False}
def close(self, timeout=30):
self.stop()
with self.condition:
self.suspend_auto_relogin()
self.stop()
self._closing = True
for job in self._pending:
job.status, job.error, job.payload = "cancelled", "账号正在关闭,操作已取消", {}
@@ -1174,10 +1383,13 @@ class WebManager:
if revision is not None and revision != worker.revision:
raise RevisionConflict("策略已在其他页面更新,请刷新后重试")
changed = any(value.get(section) != worker.config.get(section) for section in
("policy", "quest_policy", "daily_policy", "sweep_policy", "explore_policy", "progression_policy", "overrides"))
("policy", "quest_policy", "daily_policy", "sweep_policy", "explore_policy", "progression_policy", "overrides", "auto_relogin"))
login_changed = value["auto_relogin"] != worker.config["auto_relogin"]
if changed:
worker.stop(keep_running=True)
job = worker.enqueue("__config", {"config": value, "revision": revision})
if login_changed:
worker._auto_relogin_pending_config = (job["id"], deepcopy(value["auto_relogin"]))
return {"config": deepcopy(worker.config), "revision": worker.revision,
"pending": True, "job_id": job["id"], "job": job}
@@ -1198,6 +1410,8 @@ class WebManager:
worker._jobs[job.id] = job
return job.public()
if operation in STOP_ACTIONS or operation in {"login", "enter_server", "restore_session", "logout", "forget_login"}:
if operation in {"login", "enter_server", "restore_session", "logout", "forget_login"}:
worker.suspend_auto_relogin()
worker.stop()
consuming = operation not in READ_ACTIONS and operation not in LOCAL_ACTIONS and operation not in {"logout", "forget_login"}
return worker.enqueue(operation, payload, consuming=consuming)