from __future__ import annotations import base64 import hashlib import json import logging import threading import time from collections.abc import Callable from dataclasses import asdict from dataclasses import dataclass, field from pathlib import Path from typing import Any import requests from pixiv_app.core.paths import runtime_path logger = logging.getLogger(__name__) def file_sha256(path: str | Path) -> str: digest = hashlib.sha256() with Path(path).open("rb") as fp: for chunk in iter(lambda: fp.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def persist_cloud_session_tokens(access_token: str, refresh_token: str = "") -> None: """将刷新后的 Token 写回桌面会话文件,供 GUI 与 Gallery API 共用。""" from pixiv_app.core.auth import SessionStore from pixiv_app.core.paths import app_session_file store = SessionStore(app_session_file()) payload = store.load() cloud = payload.get("cloud_sync") if isinstance(payload.get("cloud_sync"), dict) else {} cloud["access_token"] = access_token if refresh_token: cloud["refresh_token"] = refresh_token payload["cloud_sync"] = cloud store.save(payload) def _decode_jwt_exp(token: str) -> float: """解码 JWT 的 exp 字段,返回 Unix 时间戳;解码失败返回 0。""" if not token or "." not in token: return 0.0 try: payload = token.split(".")[1] payload += "=" * (4 - len(payload) % 4) decoded = json.loads(base64.urlsafe_b64decode(payload)) return float(decoded.get("exp", 0)) except Exception: return 0.0 class CloudSession: """全局单例,统一管理云同步 Token 的读写、刷新与持久化。 所有需要访问 Sakura Cloud API 的模块(GUI、Gallery、FollowSync、XMedia) 都通过此单例获取配置和创建客户端,确保 token 刷新互不冲突、变更全局可见。 """ _instance: CloudSession | None = None _instance_lock = threading.Lock() def __new__(cls) -> CloudSession: if cls._instance is None: with cls._instance_lock: if cls._instance is None: instance = super().__new__(cls) instance._base_url = "" instance._access_token = "" instance._refresh_token = "" instance._enabled = False instance._refresh_lock = threading.Lock() instance._listeners: list[Callable[[str, str], None]] = [] instance._last_refresh_time = 0.0 cls._instance = instance return cls._instance # ------------------------------------------------------------------ # 配置入口 # ------------------------------------------------------------------ def configure( self, *, base_url: str = "", access_token: str = "", refresh_token: str = "", enabled: bool = False, ) -> None: """GUI 启动 / 登录 / 保存会话时调用,同步最新 token 到全局单例。""" self._base_url = (base_url or "").strip() self._access_token = (access_token or "").strip() self._refresh_token = (refresh_token or "").strip() self._enabled = bool(enabled) def load_from_disk(self) -> dict[str, Any]: """从磁盘会话文件读取云端配置并应用到单例,返回原始 payload。""" from pixiv_app.core.auth import SessionStore from pixiv_app.core.paths import app_session_file store = SessionStore(app_session_file()) payload = store.load() cloud = payload.get("cloud_sync") if isinstance(payload.get("cloud_sync"), dict) else {} self.configure( base_url=str(cloud.get("base_url") or ""), access_token=str(cloud.get("access_token") or ""), refresh_token=str(cloud.get("refresh_token") or ""), enabled=bool(cloud.get("enabled", False)), ) return payload @property def enabled(self) -> bool: return self._enabled and bool(self._base_url) and bool(self._access_token) # ------------------------------------------------------------------ # Config 快照 # ------------------------------------------------------------------ def get_config(self) -> CloudSyncConfig: """返回当前 token 的 CloudSyncConfig 快照。 调用时机:每次创建 SakuraCloudClient 前。 若 access_token 即将过期(< 5 分钟),主动触发一次刷新。 """ if self._access_token and self._is_expired_or_near(threshold_seconds=300): self.try_refresh() return CloudSyncConfig( base_url=self._base_url, access_token=self._access_token, refresh_token=self._refresh_token, ) # ------------------------------------------------------------------ # 监听者管理 # ------------------------------------------------------------------ def add_listener(self, callback: Callable[[str, str], None]) -> None: """注册 token 刷新回调(如 GUI 的 _on_cloud_token_refreshed)。""" if callback not in self._listeners: self._listeners.append(callback) def remove_listener(self, callback: Callable[[str, str], None]) -> None: try: self._listeners.remove(callback) except ValueError: pass def notify_listeners(self, access_token: str, refresh_token: str) -> None: """通知所有监听者 token 已更新(成功时为新的 token 对,失败时为空字符串)。""" for callback in self._listeners: try: callback(access_token, refresh_token) except Exception: logger.exception("CloudSession listener %s failed", getattr(callback, "__name__", callback)) # ------------------------------------------------------------------ # Token 刷新(核心) # ------------------------------------------------------------------ def try_refresh(self) -> bool: """统一刷新入口。使用全局锁防止并发重复刷新。 Returns: True: 刷新成功,access_token 已更新 False: 刷新失败,token 已被清空,监听者已收到空 token 通知 """ refresh = self._refresh_token if not refresh: return False with self._refresh_lock: # 二次检查:可能其他线程已刷新 refresh = self._refresh_token if not refresh: return False # 距上次刷新不足 5 秒,跳过(防抖) elapsed = time.time() - self._last_refresh_time if elapsed < 5.0 and self._access_token: return True try: resp = requests.post( f"{self._base_url}/api/v1/auth/refresh", json={"refresh_token": refresh}, timeout=30.0, ) if resp.status_code != 200: logger.warning( "CloudSession refresh failed HTTP %s: %s", resp.status_code, resp.text[:200], ) return False body = resp.json() data = body.get("data", body) if isinstance(body, dict) else {} if not isinstance(data, dict): self._on_refresh_failed() return False new_access = (data.get("access_token") or "").strip() new_refresh = (data.get("refresh_token") or "").strip() if not new_access: self._on_refresh_failed() return False # 更新内存 self._access_token = new_access if new_refresh: self._refresh_token = new_refresh self._last_refresh_time = time.time() # 写盘 self._persist() # 通知监听者 self.notify_listeners(self._access_token, self._refresh_token) logger.info("CloudSession token refreshed successfully") return True except Exception: logger.exception("CloudSession refresh error") self._on_refresh_failed() return False def _on_refresh_failed(self) -> None: """刷新失败:清空 token + 写盘 + 通知监听者。""" self._access_token = "" self._refresh_token = "" self._last_refresh_time = time.time() self._persist() self.notify_listeners("", "") def _persist(self) -> None: """将当前 token 写入磁盘会话文件。异常记录日志但不抛出。""" try: persist_cloud_session_tokens(self._access_token, self._refresh_token) except Exception: logger.exception("CloudSession persist to disk failed") # ------------------------------------------------------------------ # JWT 辅助 # ------------------------------------------------------------------ def _is_expired_or_near(self, threshold_seconds: int = 300) -> bool: exp = _decode_jwt_exp(self._access_token) if exp <= 0: return False return (exp - threshold_seconds) <= time.time() @dataclass class CloudSyncConfig: base_url: str access_token: str refresh_token: str = "" chunk_size: int = 5 * 1024 * 1024 timeout: float = 60.0 @dataclass class SyncMetadata: resource_type: str = "artwork" source_platform: str = "pixiv" source_id: str | None = None content_type: str | None = None title: str = "" author: str | None = None author_id: str | None = None tags: list[str] = field(default_factory=list) metadata: dict[str, Any] = field(default_factory=dict) page_count: int = 1 thumbnail_url: str | None = None description: str | None = None word_count: int = 0 series_id: str | None = None series_title: str | None = None chapter_title: str | None = None chapter_order: int = 0 class SyncFailureQueue: def __init__(self, path: str | Path | None = None) -> None: self.path = Path(path) if path else runtime_path("cloud_sync_failures.json") def load(self) -> list[dict[str, Any]]: if not self.path.is_file(): return [] try: data = json.loads(self.path.read_text(encoding="utf-8")) return data if isinstance(data, list) else [] except Exception: return [] def save(self, items: list[dict[str, Any]]) -> None: self.path.parent.mkdir(parents=True, exist_ok=True) self.path.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8") def add(self, file_path: str | Path, metadata: SyncMetadata, mime_type: str | None, error: str) -> None: now = time.time() file_path = str(Path(file_path)) items = self.load() key = (file_path, metadata.source_platform, metadata.source_id) for item in items: item_key = ( str(item.get("file_path") or ""), str(item.get("metadata", {}).get("source_platform") or ""), item.get("metadata", {}).get("source_id"), ) if item_key == key: attempts = int(item.get("attempts") or 0) item.update( { "metadata": asdict(metadata), "mime_type": mime_type, "attempts": attempts, "last_error": error, "updated_at": now, "next_retry_at": now + min(3600, 60 * (2 ** min(attempts, 5))), } ) self.save(items) return items.append( { "file_path": file_path, "metadata": asdict(metadata), "mime_type": mime_type, "attempts": 0, "last_error": error, "created_at": now, "updated_at": now, "next_retry_at": now + 60, } ) self.save(items) class SakuraCloudClient: def __init__( self, config: CloudSyncConfig, *, on_token_refreshed: Callable[[str, str], None] | None = None, cloud_session: CloudSession | None = None, ) -> None: self.config = config self.base_url = config.base_url.rstrip("/") self.session = requests.Session() self.session.headers.update({"Authorization": f"Bearer {config.access_token}"}) self._cloud_session = cloud_session # 全局单例引用 # 仅在没有 cloud_session 时使用独立锁和回调(兼容旧路径) if cloud_session is None: self._on_token_refreshed = on_token_refreshed or persist_cloud_session_tokens self._refresh_lock = threading.Lock() else: self._on_token_refreshed = None self._refresh_lock = None def check_file(self, sha256: str, file_size: int) -> dict[str, Any]: return self._post("/api/v1/sync/check", {"sha256": sha256, "file_size": file_size}) def init_upload( self, *, sha256: str, file_name: str, file_size: int, mime_type: str | None, resource_type: str, ) -> dict[str, Any]: return self._post( "/api/v1/upload/init", { "sha256": sha256, "file_name": file_name, "file_size": file_size, "mime_type": mime_type, "resource_type": resource_type, }, ) def upload_chunk(self, upload_id: str, chunk: bytes) -> dict[str, Any]: response = self._request( "POST", "/api/v1/upload/chunk", data={"upload_id": upload_id}, files={"chunk": ("chunk.bin", chunk)}, ) return self._unwrap(response) def complete_upload(self, upload_id: str) -> dict[str, Any]: return self._post("/api/v1/upload/complete", {"upload_id": upload_id}) def sync_metadata(self, file_id: str, metadata: SyncMetadata) -> dict[str, Any]: payload = { "file_id": file_id, "resource_type": metadata.resource_type, "source_platform": metadata.source_platform, "source_id": metadata.source_id, "content_type": metadata.content_type, "title": metadata.title, "author": metadata.author, "author_id": metadata.author_id, "tags": metadata.tags, "metadata": metadata.metadata, "page_count": metadata.page_count, "thumbnail_url": metadata.thumbnail_url, "description": metadata.description, "word_count": metadata.word_count, "series_id": metadata.series_id, "series_title": metadata.series_title, "chapter_title": metadata.chapter_title, "chapter_order": metadata.chapter_order, } return self._post("/api/v1/sync/metadata", payload) def upsert_follow(self, payload: dict[str, Any]) -> dict[str, Any]: return self._post("/api/v1/follows", payload) def bulk_upsert_follows(self, items: list[dict[str, Any]]) -> dict[str, Any]: return self._post("/api/v1/follows/bulk-upsert", {"items": items}) def create_alert(self, payload: dict[str, Any]) -> dict[str, Any]: return self._post("/api/v1/follows/alerts", payload) def _request( self, method: str, path: str, *, json: dict[str, Any] | None = None, data: dict[str, Any] | None = None, files: dict[str, Any] | None = None, _retry_on_401: bool = True, ) -> requests.Response: url = f"{self.base_url}{path}" response = self.session.request( method, url, json=json, data=data, files=files, timeout=self.config.timeout, ) if response.status_code == 401 and _retry_on_401 and self._try_refresh_token(): response = self.session.request( method, url, json=json, data=data, files=files, timeout=self.config.timeout, ) return response def _post(self, path: str, payload: dict[str, Any], *, _retry_on_401: bool = True) -> dict[str, Any]: response = self._request("POST", path, json=payload, _retry_on_401=_retry_on_401) return self._unwrap(response) def _try_refresh_token(self) -> bool: # --- 新路径:委托给全局 CloudSession --- if self._cloud_session is not None: ok = self._cloud_session.try_refresh() if ok: # 刷新成功后同步更新本地 config 和 session headers new_config = self._cloud_session.get_config() self.config.access_token = new_config.access_token self.config.refresh_token = new_config.refresh_token self.session.headers.update({"Authorization": f"Bearer {new_config.access_token}"}) return ok # --- 旧路径(向后兼容,无 cloud_session 时使用) --- refresh = self.config.refresh_token.strip() if not refresh: return False with self._refresh_lock: refresh = self.config.refresh_token.strip() if not refresh: return False try: resp = requests.post( f"{self.base_url}/api/v1/auth/refresh", json={"refresh_token": refresh}, timeout=self.config.timeout, ) if resp.status_code != 200: return False body = resp.json() data = body.get("data", body) if isinstance(body, dict) else {} if not isinstance(data, dict): return False new_access = (data.get("access_token") or "").strip() new_refresh = (data.get("refresh_token") or "").strip() if not new_access: return False self.config.access_token = new_access self.session.headers.update({"Authorization": f"Bearer {new_access}"}) if new_refresh: self.config.refresh_token = new_refresh try: self._on_token_refreshed(self.config.access_token, self.config.refresh_token) except Exception: logger.exception("SakuraCloudClient._on_token_refreshed failed") return True except Exception: logger.exception("SakuraCloudClient._try_refresh_token error") return False @staticmethod def _unwrap(response: requests.Response) -> dict[str, Any]: response.raise_for_status() body = response.json() if isinstance(body, dict) and "data" in body: return body["data"] return body class SyncManager: def __init__(self, client: SakuraCloudClient, failure_queue: SyncFailureQueue | None = None) -> None: self.client = client self.failure_queue = failure_queue or SyncFailureQueue() def sync_file(self, file_path: str | Path, metadata: SyncMetadata, *, mime_type: str | None = None) -> dict[str, Any]: try: return self._sync_file_once(file_path, metadata, mime_type=mime_type) except Exception as exc: self.failure_queue.add(file_path, metadata, mime_type, str(exc)) raise def _sync_file_once(self, file_path: str | Path, metadata: SyncMetadata, *, mime_type: str | None = None) -> dict[str, Any]: path = Path(file_path) sha256 = file_sha256(path) file_size = path.stat().st_size checked = self.client.check_file(sha256, file_size) file_id = checked.get("file_id") if checked.get("owned_by_user") else None if not file_id: init = self.client.init_upload( sha256=sha256, file_name=path.name, file_size=file_size, mime_type=mime_type, resource_type=self._upload_resource_type(metadata, mime_type), ) if init.get("exists") and init.get("file_id"): file_id = str(init["file_id"]) else: upload_id = str(init["upload_id"]) with path.open("rb") as fp: for chunk in iter(lambda: fp.read(self.client.config.chunk_size), b""): self.client.upload_chunk(upload_id, chunk) completed = self.client.complete_upload(upload_id) file_id = str(completed["file_id"]) return self.client.sync_metadata(str(file_id), metadata) @staticmethod def _upload_resource_type(metadata: SyncMetadata, mime_type: str | None) -> str: if metadata.resource_type == "novel": return "novel" if (mime_type or "").lower().startswith("video/") or (metadata.content_type or "").lower() == "video": return "video" return "image" def retry_failed(self, *, limit: int = 5) -> dict[str, int]: now = time.time() items = self.failure_queue.load() kept: list[dict[str, Any]] = [] retried = 0 succeeded = 0 failed = 0 for item in items: if retried >= limit or float(item.get("next_retry_at") or 0) > now: kept.append(item) continue path = Path(str(item.get("file_path") or "")) if not path.is_file(): failed += 1 continue try: metadata = SyncMetadata(**dict(item.get("metadata") or {})) self._sync_file_once(path, metadata, mime_type=item.get("mime_type")) succeeded += 1 except Exception as exc: attempts = int(item.get("attempts") or 0) + 1 item["attempts"] = attempts item["last_error"] = str(exc) item["updated_at"] = now item["next_retry_at"] = now + min(3600, 60 * (2 ** min(attempts, 5))) kept.append(item) failed += 1 retried += 1 self.failure_queue.save(kept) return {"retried": retried, "succeeded": succeeded, "failed": failed, "remaining": len(kept)}