377 lines
13 KiB
Python
377 lines
13 KiB
Python
"""虎牙自动注册批次执行器。"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
import uuid
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime, timezone
|
|
from typing import Optional
|
|
|
|
from core.douyu.proxy_fetcher import ProxyFetcher
|
|
from core.huya.auto_register import HuyaAutoRegisterResult, register_huya_with_sms_line
|
|
from core.huya.cookie_utils import normalize_huya_cookie
|
|
from core.sms_provider import SmsLine
|
|
|
|
from ..database import SessionLocal
|
|
from ..models import ProxyConfig as ProxyConfigModel
|
|
from .huya_service import upsert_huya_cookie
|
|
|
|
|
|
def _now() -> datetime:
|
|
return datetime.now(timezone.utc)
|
|
|
|
|
|
def _cookie_preview(cookie: str) -> str:
|
|
normalized = normalize_huya_cookie(cookie or "")
|
|
if not normalized:
|
|
return ""
|
|
return normalized[:50] + "..." if len(normalized) > 50 else normalized
|
|
|
|
|
|
@dataclass
|
|
class HuyaRegisterItemState:
|
|
"""单个手机号在批次中的状态。"""
|
|
|
|
line: int
|
|
phone: str
|
|
provider: str
|
|
sms_url: str = ""
|
|
status: str = "pending"
|
|
message: str = "等待开始"
|
|
code: str = ""
|
|
change_code: str = ""
|
|
attempts: int = 0
|
|
change_attempts: int = 0
|
|
account_id: int | None = None
|
|
username: str = ""
|
|
uid: str = ""
|
|
password: str = ""
|
|
password_changed: bool = False
|
|
cookie: str = ""
|
|
cookie_preview: str = ""
|
|
started_at: datetime | None = None
|
|
finished_at: datetime | None = None
|
|
|
|
def to_dict(self) -> dict:
|
|
return {
|
|
"line": self.line,
|
|
"phone": self.phone,
|
|
"provider": self.provider,
|
|
"sms_url": self.sms_url,
|
|
"status": self.status,
|
|
"message": self.message,
|
|
"code": self.code,
|
|
"change_code": self.change_code,
|
|
"attempts": self.attempts,
|
|
"change_attempts": self.change_attempts,
|
|
"account_id": self.account_id,
|
|
"username": self.username,
|
|
"uid": self.uid,
|
|
"password": self.password,
|
|
"password_changed": self.password_changed,
|
|
"cookie": self.cookie,
|
|
"cookie_preview": self.cookie_preview,
|
|
"started_at": self.started_at,
|
|
"finished_at": self.finished_at,
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class HuyaRegisterBatch:
|
|
"""自动注册批次内存快照。"""
|
|
|
|
batch_id: str
|
|
tag: str
|
|
created_by: int
|
|
concurrency: int
|
|
wait_seconds: float
|
|
poll_interval: float
|
|
items: list[HuyaRegisterItemState]
|
|
password_prefix: str = "hy"
|
|
fixed_password: str = ""
|
|
use_proxy: bool = False
|
|
status: str = "pending"
|
|
message: str = "等待开始"
|
|
created_at: datetime = field(default_factory=_now)
|
|
started_at: datetime | None = None
|
|
finished_at: datetime | None = None
|
|
|
|
|
|
class HuyaRegisterRunner:
|
|
"""在后台线程中批量执行虎牙手机号自动注册。"""
|
|
|
|
def __init__(
|
|
self,
|
|
batch: HuyaRegisterBatch,
|
|
sms_lines: list[SmsLine],
|
|
proxy_config: Optional[ProxyConfigModel] = None,
|
|
):
|
|
self.batch = batch
|
|
self.sms_lines = sms_lines
|
|
self.proxy_config = proxy_config
|
|
self._lock = threading.Lock()
|
|
self._stop = threading.Event()
|
|
self._shared_proxy_fetcher = self._create_proxy_fetcher()
|
|
|
|
def _create_proxy_fetcher(self) -> ProxyFetcher | None:
|
|
"""按需创建 API 代理获取器。"""
|
|
if not self.batch.use_proxy or not self.proxy_config or not self.proxy_config.enabled:
|
|
return None
|
|
if not self.proxy_config.api_url:
|
|
return None
|
|
|
|
wl_platform = "xiequ"
|
|
wl_credentials = None
|
|
if self.proxy_config.whitelist_enabled:
|
|
wl_platform = getattr(self.proxy_config, "whitelist_platform", None) or "xiequ"
|
|
wl_credentials = getattr(self.proxy_config, "whitelist_credentials", None)
|
|
if not wl_credentials and self.proxy_config.whitelist_uid and self.proxy_config.whitelist_ukey:
|
|
wl_credentials = {
|
|
"uid": self.proxy_config.whitelist_uid,
|
|
"ukey": self.proxy_config.whitelist_ukey,
|
|
}
|
|
|
|
return ProxyFetcher(
|
|
api_url=self.proxy_config.api_url,
|
|
whitelist_platform=wl_platform,
|
|
whitelist_credentials=wl_credentials,
|
|
stop_event=self._stop,
|
|
)
|
|
|
|
def stop(self):
|
|
self._stop.set()
|
|
with self._lock:
|
|
if self.batch.status == "running":
|
|
self.batch.message = "正在停止"
|
|
|
|
def snapshot(self) -> dict:
|
|
with self._lock:
|
|
total = len(self.batch.items)
|
|
success = sum(1 for item in self.batch.items if item.status == "success")
|
|
failed = sum(1 for item in self.batch.items if item.status == "error")
|
|
stopped = sum(1 for item in self.batch.items if item.status == "stopped")
|
|
running = sum(1 for item in self.batch.items if item.status in {"sending", "waiting", "changing", "logging"})
|
|
return {
|
|
"batch_id": self.batch.batch_id,
|
|
"status": self.batch.status,
|
|
"message": self.batch.message,
|
|
"tag": self.batch.tag,
|
|
"created_by": self.batch.created_by,
|
|
"concurrency": self.batch.concurrency,
|
|
"wait_seconds": self.batch.wait_seconds,
|
|
"poll_interval": self.batch.poll_interval,
|
|
"password_prefix": self.batch.password_prefix,
|
|
"use_proxy": self.batch.use_proxy,
|
|
"total": total,
|
|
"success_count": success,
|
|
"failed_count": failed,
|
|
"stopped_count": stopped,
|
|
"running_count": running,
|
|
"created_at": self.batch.created_at,
|
|
"started_at": self.batch.started_at,
|
|
"finished_at": self.batch.finished_at,
|
|
"items": [item.to_dict() for item in self.batch.items],
|
|
}
|
|
|
|
def _set_item(self, index: int, **updates):
|
|
with self._lock:
|
|
item = self.batch.items[index]
|
|
for key, value in updates.items():
|
|
setattr(item, key, value)
|
|
|
|
def _save_cookie(self, result: HuyaAutoRegisterResult) -> tuple[int | None, str, str]:
|
|
db = SessionLocal()
|
|
try:
|
|
account = upsert_huya_cookie(db, result.cookie, tag=self.batch.tag, username_hint="")
|
|
account.game_phone = result.phone
|
|
if result.username:
|
|
account.username = result.username
|
|
if result.password:
|
|
account.account_password = result.password
|
|
if result.password_changed:
|
|
account.status = "password_changed"
|
|
account.updated_at = _now()
|
|
db.commit()
|
|
db.refresh(account)
|
|
return account.id, account.username or "", account.uid or account.yyuid or ""
|
|
finally:
|
|
db.close()
|
|
|
|
def _resolve_proxy(self) -> tuple[dict[str, str] | None, str]:
|
|
"""为单个手机号解析代理；返回代理字典和错误消息。"""
|
|
if not self.batch.use_proxy:
|
|
return None, ""
|
|
if not self.proxy_config or not self.proxy_config.enabled:
|
|
return None, "已开启代理，但代理配置未启用"
|
|
|
|
if self.proxy_config.http or self.proxy_config.https:
|
|
proxy_url = self.proxy_config.http or self.proxy_config.https
|
|
return {"http": proxy_url, "https": proxy_url}, ""
|
|
|
|
if self._shared_proxy_fetcher:
|
|
proxy_url = self._shared_proxy_fetcher.fetch_new_proxy(max_attempts=3)
|
|
if proxy_url:
|
|
return {"http": proxy_url, "https": proxy_url}, ""
|
|
return None, "获取代理失败"
|
|
|
|
return None, "已开启代理，但未配置静态代理或代理 API"
|
|
|
|
def _run_one(self, index: int, item: SmsLine):
|
|
if self._stop.is_set():
|
|
self._set_item(index, status="stopped", message="已停止", finished_at=_now())
|
|
return
|
|
|
|
proxies, proxy_error = self._resolve_proxy()
|
|
if proxy_error:
|
|
self._set_item(index, status="error", message=proxy_error, finished_at=_now())
|
|
return
|
|
|
|
self._set_item(index, status="sending", message="注册并改密", started_at=_now(), finished_at=None)
|
|
result = register_huya_with_sms_line(
|
|
item,
|
|
wait_seconds=self.batch.wait_seconds,
|
|
poll_interval=self.batch.poll_interval,
|
|
password_prefix=self.batch.password_prefix,
|
|
fixed_password=self.batch.fixed_password,
|
|
proxies=proxies,
|
|
stop_event=self._stop,
|
|
)
|
|
|
|
account_id = None
|
|
username = result.username
|
|
uid = result.uid
|
|
message = result.message
|
|
status = result.status
|
|
cookie = result.cookie if result.success else ""
|
|
if result.success:
|
|
self._set_item(
|
|
index,
|
|
status="logging",
|
|
message="保存账号密码",
|
|
code=result.code,
|
|
change_code=result.change_code,
|
|
attempts=result.attempts,
|
|
change_attempts=result.change_attempts,
|
|
username=result.username,
|
|
uid=result.uid,
|
|
password=result.password,
|
|
password_changed=result.password_changed,
|
|
)
|
|
try:
|
|
account_id, username, uid = self._save_cookie(result)
|
|
except Exception as exc:
|
|
status = "error"
|
|
cookie = ""
|
|
message = f"账号保存失败: {exc}"
|
|
|
|
exposed_cookie = "" if result.password_changed else cookie
|
|
|
|
self._set_item(
|
|
index,
|
|
status=status,
|
|
message=message,
|
|
code=result.code,
|
|
change_code=result.change_code,
|
|
attempts=result.attempts,
|
|
change_attempts=result.change_attempts,
|
|
account_id=account_id,
|
|
username=username,
|
|
uid=uid,
|
|
password=result.password,
|
|
password_changed=result.password_changed,
|
|
cookie=normalize_huya_cookie(exposed_cookie),
|
|
cookie_preview=_cookie_preview(exposed_cookie),
|
|
finished_at=_now(),
|
|
)
|
|
|
|
def run(self):
|
|
"""线程入口。"""
|
|
with self._lock:
|
|
self.batch.status = "running"
|
|
self.batch.message = "批次运行中"
|
|
self.batch.started_at = _now()
|
|
|
|
try:
|
|
if self._shared_proxy_fetcher:
|
|
ok, msg = self._shared_proxy_fetcher.warmup_whitelist()
|
|
if not ok:
|
|
with self._lock:
|
|
self.batch.message = f"代理白名单预热失败: {msg}"
|
|
|
|
with ThreadPoolExecutor(max_workers=self.batch.concurrency) as executor:
|
|
futures = []
|
|
for index, item in enumerate(self.sms_lines):
|
|
if self._stop.is_set():
|
|
self._set_item(index, status="stopped", message="已停止", finished_at=_now())
|
|
continue
|
|
futures.append(executor.submit(self._run_one, index, item))
|
|
|
|
for future in as_completed(futures):
|
|
future.result()
|
|
except Exception as exc:
|
|
with self._lock:
|
|
self.batch.status = "error"
|
|
self.batch.message = f"批次执行异常: {exc}"
|
|
self.batch.finished_at = _now()
|
|
return
|
|
|
|
with self._lock:
|
|
if self._stop.is_set():
|
|
self.batch.status = "stopped"
|
|
self.batch.message = "批次已停止"
|
|
else:
|
|
self.batch.status = "finished"
|
|
self.batch.message = "批次已完成"
|
|
self.batch.finished_at = _now()
|
|
|
|
|
|
class HuyaRegisterRegistry:
|
|
"""管理自动注册批次。"""
|
|
|
|
def __init__(self):
|
|
self._lock = threading.Lock()
|
|
self._runners: dict[str, HuyaRegisterRunner] = {}
|
|
|
|
def create(
|
|
self,
|
|
sms_lines: list[SmsLine],
|
|
tag: str,
|
|
created_by: int,
|
|
concurrency: int,
|
|
wait_seconds: float,
|
|
poll_interval: float,
|
|
password_prefix: str = "hy",
|
|
fixed_password: str = "",
|
|
use_proxy: bool = False,
|
|
proxy_config: Optional[ProxyConfigModel] = None,
|
|
) -> HuyaRegisterRunner:
|
|
batch_id = uuid.uuid4().hex[:12]
|
|
batch = HuyaRegisterBatch(
|
|
batch_id=batch_id,
|
|
tag=tag,
|
|
created_by=created_by,
|
|
concurrency=max(1, min(int(concurrency or 1), 5)),
|
|
wait_seconds=max(15.0, float(wait_seconds or 180)),
|
|
poll_interval=max(1.0, float(poll_interval or 5)),
|
|
password_prefix=(password_prefix or "hy").strip()[:8] or "hy",
|
|
fixed_password=(fixed_password or "").strip(),
|
|
use_proxy=bool(use_proxy),
|
|
items=[
|
|
HuyaRegisterItemState(line=index + 1, phone=item.phone, provider=item.provider, sms_url=item.url)
|
|
for index, item in enumerate(sms_lines)
|
|
],
|
|
)
|
|
runner = HuyaRegisterRunner(batch=batch, sms_lines=sms_lines, proxy_config=proxy_config)
|
|
with self._lock:
|
|
self._runners[batch_id] = runner
|
|
return runner
|
|
|
|
def get(self, batch_id: str) -> HuyaRegisterRunner | None:
|
|
with self._lock:
|
|
return self._runners.get(batch_id)
|
|
|
|
|
|
huya_register_registry = HuyaRegisterRegistry()
|