209a744d94
后端重构： - 新增分层架构：API Routes -> Services -> Repositories -> Infrastructure - 彻底移除全局单例，全面采用 FastAPI 依赖注入 - 新增 api/ 目录拆分路由（proxies, plugins, scheduler, settings, stats） - 新增 services/ 业务逻辑层：ProxyService, PluginService, SchedulerService, ValidatorService, SettingsService - 新增 repositories/ 数据访问层：ProxyRepository, SettingsRepository, PluginSettingsRepository - 新增 models/ 层：Pydantic Schemas + Domain Models - 重写 core/config.py：采用 Pydantic Settings 管理配置 - 新增 core/db.py：基于 asynccontextmanager 的连接管理，支持数据库迁移 - 新增 core/exceptions.py：统一业务异常体系 插件系统重构（核心）： - 新增 core/plugin_system/：BaseCrawlerPlugin + PluginRegistry - 采用显式注册模式（装饰器 + plugins/__init__.py），类型安全、测试友好 - 新增 plugins/base.py：BaseHTTPPlugin 通用 HTTP 爬虫基类 - 迁移全部 7 个插件到新架构（fate0, proxylist_download, ip3366, ip89, kuaidaili, speedx, yundaili） - 插件状态持久化到 plugin_settings 表 任务调度重构： - 新增 core/tasks/queue.py：ValidationQueue + WorkerPool - 解耦爬取与验证：爬虫只负责爬取，代理提交队列后由 Worker 异步验证 - 调度器定时从数据库拉取存量代理并分批投入验证队列 前端调整： - 新增 frontend/src/services/ 层拆分 API 调用逻辑 - 调整 stores/ 和 views/ 使用 Service 层 - 保持 API 兼容性，页面无需大幅修改 其他： - 新增 main.py 作为新入口 - 新增 DESIGN.md 架构设计文档 - 更新 requirements.txt 增加 pydantic-settings
304 lines
10 KiB
Python
304 lines
10 KiB
Python
"""代理数据访问层 - 所有 SQL 操作收敛于此"""
|
|
import aiosqlite
|
|
from datetime import datetime, timedelta
|
|
from typing import List, Optional, Tuple, Union
|
|
from models.domain import Proxy
|
|
from core.log import logger
|
|
|
|
|
|
VALID_PROTOCOLS = ("http", "https", "socks4", "socks5")
|
|
|
|
|
|
def _to_datetime(value: Union[str, datetime, None]) -> Optional[datetime]:
|
|
if value is None:
|
|
return None
|
|
if isinstance(value, datetime):
|
|
return value
|
|
if isinstance(value, str):
|
|
for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%dT%H:%M:%S.%f"):
|
|
try:
|
|
return datetime.strptime(value, fmt)
|
|
except ValueError:
|
|
continue
|
|
return None
|
|
|
|
|
|
class ProxyRepository:
|
|
"""代理 Repository"""
|
|
|
|
@staticmethod
|
|
async def insert_or_update(
|
|
db: aiosqlite.Connection,
|
|
ip: str,
|
|
port: int,
|
|
protocol: str = "http",
|
|
score: int = 10,
|
|
) -> bool:
|
|
if protocol not in VALID_PROTOCOLS:
|
|
protocol = "http"
|
|
try:
|
|
await db.execute(
|
|
"""
|
|
INSERT INTO proxies (ip, port, protocol, score, last_check, created_at)
|
|
VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
|
|
ON CONFLICT(ip, port) DO UPDATE SET
|
|
protocol = excluded.protocol,
|
|
score = excluded.score,
|
|
last_check = CURRENT_TIMESTAMP
|
|
""",
|
|
(ip, port, protocol, score),
|
|
)
|
|
await db.commit()
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"insert_or_update proxy failed: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def update_score(
|
|
db: aiosqlite.Connection,
|
|
ip: str,
|
|
port: int,
|
|
delta: int,
|
|
min_score: int = 0,
|
|
max_score: int = 100,
|
|
) -> bool:
|
|
try:
|
|
async with db.execute(
|
|
"SELECT score FROM proxies WHERE ip = ? AND port = ?", (ip, port)
|
|
) as cursor:
|
|
row = await cursor.fetchone()
|
|
if not row:
|
|
return False
|
|
current_score = row[0]
|
|
new_score = max(min_score, min(max_score, current_score + delta))
|
|
await db.execute(
|
|
"UPDATE proxies SET score = ?, last_check = CURRENT_TIMESTAMP WHERE ip = ? AND port = ?",
|
|
(new_score, ip, port),
|
|
)
|
|
if new_score <= 0:
|
|
await db.execute("DELETE FROM proxies WHERE score <= 0")
|
|
await db.commit()
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"update_score failed: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def update_response_time(
|
|
db: aiosqlite.Connection,
|
|
ip: str,
|
|
port: int,
|
|
response_time_ms: float,
|
|
) -> bool:
|
|
try:
|
|
await db.execute(
|
|
"UPDATE proxies SET response_time_ms = ? WHERE ip = ? AND port = ?",
|
|
(response_time_ms, ip, port),
|
|
)
|
|
await db.commit()
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"update_response_time failed: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def delete(db: aiosqlite.Connection, ip: str, port: int) -> None:
|
|
await db.execute("DELETE FROM proxies WHERE ip = ? AND port = ?", (ip, port))
|
|
await db.commit()
|
|
|
|
@staticmethod
|
|
async def batch_delete(db: aiosqlite.Connection, proxies: List[Tuple[str, int]]) -> int:
|
|
if not proxies:
|
|
return 0
|
|
await db.executemany("DELETE FROM proxies WHERE ip = ? AND port = ?", proxies)
|
|
await db.commit()
|
|
return len(proxies)
|
|
|
|
@staticmethod
|
|
async def get_by_ip_port(
|
|
db: aiosqlite.Connection, ip: str, port: int
|
|
) -> Optional[Proxy]:
|
|
async with db.execute(
|
|
"SELECT ip, port, protocol, score, response_time_ms, last_check, created_at FROM proxies WHERE ip = ? AND port = ?",
|
|
(ip, port),
|
|
) as cursor:
|
|
row = await cursor.fetchone()
|
|
if row:
|
|
return Proxy(
|
|
ip=row[0],
|
|
port=row[1],
|
|
protocol=row[2],
|
|
score=row[3],
|
|
response_time_ms=row[4],
|
|
last_check=_to_datetime(row[5]),
|
|
created_at=_to_datetime(row[6]),
|
|
)
|
|
return None
|
|
|
|
@staticmethod
|
|
async def get_random(db: aiosqlite.Connection) -> Optional[Proxy]:
|
|
async with db.execute(
|
|
"SELECT ip, port, protocol, score, response_time_ms, last_check, created_at FROM proxies WHERE score > 0 ORDER BY RANDOM() LIMIT 1"
|
|
) as cursor:
|
|
row = await cursor.fetchone()
|
|
if row:
|
|
return Proxy(
|
|
ip=row[0],
|
|
port=row[1],
|
|
protocol=row[2],
|
|
score=row[3],
|
|
response_time_ms=row[4],
|
|
last_check=_to_datetime(row[5]),
|
|
created_at=_to_datetime(row[6]),
|
|
)
|
|
return None
|
|
|
|
@staticmethod
|
|
async def list_all(
|
|
db: aiosqlite.Connection,
|
|
protocol: Optional[str] = None,
|
|
limit: int = 100000,
|
|
) -> List[Proxy]:
|
|
query = "SELECT ip, port, protocol, score, response_time_ms, last_check, created_at FROM proxies"
|
|
params: List = []
|
|
if protocol:
|
|
query += " WHERE protocol = ?"
|
|
params.append(protocol.lower())
|
|
query += " LIMIT ?"
|
|
params.append(limit)
|
|
|
|
async with db.execute(query, params) as cursor:
|
|
rows = await cursor.fetchall()
|
|
return [
|
|
Proxy(
|
|
ip=row[0],
|
|
port=row[1],
|
|
protocol=row[2],
|
|
score=row[3],
|
|
response_time_ms=row[4],
|
|
last_check=_to_datetime(row[5]),
|
|
created_at=_to_datetime(row[6]),
|
|
)
|
|
for row in rows
|
|
]
|
|
|
|
@staticmethod
|
|
async def list_paginated(
|
|
db: aiosqlite.Connection,
|
|
page: int = 1,
|
|
page_size: int = 20,
|
|
protocol: Optional[str] = None,
|
|
min_score: int = 0,
|
|
max_score: Optional[int] = None,
|
|
sort_by: str = "last_check",
|
|
sort_order: str = "DESC",
|
|
) -> Tuple[List[Proxy], int]:
|
|
conditions = ["score >= ?"]
|
|
params: List = [min_score]
|
|
|
|
if protocol:
|
|
conditions.append("protocol = ?")
|
|
params.append(protocol)
|
|
if max_score is not None:
|
|
conditions.append("score <= ?")
|
|
params.append(max_score)
|
|
|
|
where_clause = " AND ".join(conditions)
|
|
order_clause = f"{sort_by} {sort_order}"
|
|
offset = (page - 1) * page_size
|
|
|
|
count_query = f"SELECT COUNT(*) FROM proxies WHERE {where_clause}"
|
|
async with db.execute(count_query, list(params)) as cursor:
|
|
row = await cursor.fetchone()
|
|
total = row[0] if row else 0
|
|
|
|
data_query = f"""
|
|
SELECT ip, port, protocol, score, response_time_ms, last_check, created_at
|
|
FROM proxies
|
|
WHERE {where_clause}
|
|
ORDER BY {order_clause}
|
|
LIMIT ? OFFSET ?
|
|
"""
|
|
params.extend([page_size, offset])
|
|
async with db.execute(data_query, params) as cursor:
|
|
rows = await cursor.fetchall()
|
|
proxies = [
|
|
Proxy(
|
|
ip=row[0],
|
|
port=row[1],
|
|
protocol=row[2],
|
|
score=row[3],
|
|
response_time_ms=row[4],
|
|
last_check=_to_datetime(row[5]),
|
|
created_at=_to_datetime(row[6]),
|
|
)
|
|
for row in rows
|
|
]
|
|
return proxies, total
|
|
|
|
@staticmethod
|
|
async def get_stats(db: aiosqlite.Connection) -> dict:
|
|
query = """
|
|
SELECT
|
|
COUNT(*) as total,
|
|
COUNT(CASE WHEN score > 0 THEN 1 END) as available,
|
|
AVG(score) as avg_score,
|
|
COUNT(CASE WHEN protocol = 'http' THEN 1 END) as http_count,
|
|
COUNT(CASE WHEN protocol = 'https' THEN 1 END) as https_count,
|
|
COUNT(CASE WHEN protocol = 'socks4' THEN 1 END) as socks4_count,
|
|
COUNT(CASE WHEN protocol = 'socks5' THEN 1 END) as socks5_count
|
|
FROM proxies
|
|
"""
|
|
async with db.execute(query) as cursor:
|
|
row = await cursor.fetchone()
|
|
if row:
|
|
return {
|
|
"total": row[0] or 0,
|
|
"available": row[1] or 0,
|
|
"avg_score": round(row[2], 2) if row[2] else 0,
|
|
"http_count": row[3] or 0,
|
|
"https_count": row[4] or 0,
|
|
"socks4_count": row[5] or 0,
|
|
"socks5_count": row[6] or 0,
|
|
}
|
|
return {
|
|
"total": 0,
|
|
"available": 0,
|
|
"avg_score": 0,
|
|
"http_count": 0,
|
|
"https_count": 0,
|
|
"socks4_count": 0,
|
|
"socks5_count": 0,
|
|
}
|
|
|
|
@staticmethod
|
|
async def get_today_new_count(db: aiosqlite.Connection) -> int:
|
|
try:
|
|
async with db.execute(
|
|
"SELECT COUNT(*) FROM proxies WHERE DATE(last_check) = DATE('now', 'localtime')"
|
|
) as cursor:
|
|
row = await cursor.fetchone()
|
|
return row[0] if row else 0
|
|
except Exception as e:
|
|
logger.error(f"get_today_new_count failed: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def clean_invalid(db: aiosqlite.Connection) -> int:
|
|
await db.execute("DELETE FROM proxies WHERE score <= 0")
|
|
await db.commit()
|
|
return db.total_changes
|
|
|
|
@staticmethod
|
|
async def clean_expired(db: aiosqlite.Connection, days: int) -> int:
|
|
try:
|
|
await db.execute(
|
|
"DELETE FROM proxies WHERE last_check < datetime('now', '-{} days')".format(days)
|
|
)
|
|
await db.commit()
|
|
return db.total_changes
|
|
except Exception as e:
|
|
logger.error(f"clean_expired failed: {e}")
|
|
return 0
|