logan
2cfd45c9d1
1. run.sh: start/stop/restart/status/logs/build/test - PID file management in .pids/ - Colored output, health check wait, log files - Auto alembic migrate on start 2. DB Connector (replaces mock aiomysql): - MySQL: aiomysql (connect/query/dml/test) - PostgreSQL: asyncpg (connect/query/dml/test) - SQLite: sqlite3 via executor (connect/query/dml/test) - Unified interface: DBConnector.test_connection/execute_query/execute_dml - Connection test returns version + latency 3. GitLab CI/CD pipeline: - test: backend pytest + frontend build - build: Docker images (manual trigger) - deploy: SSH deploy (manual trigger) - Cache: pip + node_modules Tests: 128 passing, frontend build: OK
289 lines
11 KiB
Python
289 lines
11 KiB
Python
"""Database connector — unified interface for MySQL/PostgreSQL/SQLite.
|
|
|
|
Provides real database connections for query execution and connection testing.
|
|
Replaces mock aiomysql calls with actual driver connections.
|
|
"""
|
|
import asyncio
|
|
import time
|
|
import sqlite3
|
|
from typing import Optional, List, Dict, Any, Tuple
|
|
|
|
from app.models.instance import Instance
|
|
from app.services.sql_analyzer import SQLAnalyzer
|
|
|
|
MAX_ROWS = 10000
|
|
QUERY_TIMEOUT = 30
|
|
DML_TIMEOUT = 60
|
|
|
|
|
|
class ConnectionResult:
|
|
"""Result of a connection test."""
|
|
def __init__(self, success: bool, message: str, version: str = None, latency_ms: int = 0):
|
|
self.success = success
|
|
self.message = message
|
|
self.version = version
|
|
self.latency_ms = latency_ms
|
|
|
|
def to_dict(self):
|
|
return {
|
|
"success": self.success,
|
|
"message": self.message,
|
|
"version": self.version,
|
|
"latency_ms": self.latency_ms,
|
|
}
|
|
|
|
|
|
class QueryResult:
|
|
"""Result of a SQL query execution."""
|
|
def __init__(self, columns: List[str], rows: List[Dict[str, Any]],
|
|
total: int, elapsed_ms: int, truncated: bool = False):
|
|
self.columns = columns
|
|
self.rows = rows
|
|
self.total = total
|
|
self.elapsed_ms = elapsed_ms
|
|
self.truncated = truncated
|
|
|
|
|
|
class DBConnector:
|
|
"""Unified database connector supporting MySQL, PostgreSQL, SQLite."""
|
|
|
|
_analyzer = SQLAnalyzer()
|
|
|
|
@staticmethod
|
|
async def test_connection(instance: Instance) -> ConnectionResult:
|
|
"""Test database connectivity and return version info."""
|
|
start = time.time()
|
|
|
|
try:
|
|
if instance.db_type == "mysql":
|
|
return await DBConnector._test_mysql(instance, start)
|
|
elif instance.db_type in ("postgres", "postgresql"):
|
|
return await DBConnector._test_postgres(instance, start)
|
|
elif instance.db_type == "sqlite":
|
|
return await DBConnector._test_sqlite(instance, start)
|
|
else:
|
|
return ConnectionResult(False, f"暂不支持 {instance.db_type} 类型数据源")
|
|
except Exception as e:
|
|
elapsed = int((time.time() - start) * 1000)
|
|
return ConnectionResult(False, f"连接失败: {str(e)}", latency_ms=elapsed)
|
|
|
|
@staticmethod
|
|
async def execute_query(
|
|
instance: Instance, database: Optional[str], sql: str, user_id: int
|
|
) -> 'QueryResult':
|
|
"""Execute a read-only SQL query on the target database."""
|
|
# Validate SQL is read-only
|
|
is_safe, error_msg = DBConnector._analyzer.validate_readonly(sql)
|
|
if not is_safe:
|
|
raise ValueError(error_msg)
|
|
|
|
# Auto-add LIMIT
|
|
upper_sql = sql.strip().upper()
|
|
import re
|
|
if not re.search(r"LIMIT\s+\d+", upper_sql, re.IGNORECASE):
|
|
sql = sql.rstrip(";") + f" LIMIT {MAX_ROWS};"
|
|
|
|
start = time.time()
|
|
|
|
if instance.db_type == "mysql":
|
|
rows, columns = await DBConnector._query_mysql(instance, database, sql)
|
|
elif instance.db_type in ("postgres", "postgresql"):
|
|
rows, columns = await DBConnector._query_postgres(instance, database, sql)
|
|
elif instance.db_type == "sqlite":
|
|
rows, columns = await DBConnector._query_sqlite(instance, sql)
|
|
else:
|
|
raise ValueError(f"暂不支持 {instance.db_type} 查询")
|
|
|
|
elapsed = int((time.time() - start) * 1000)
|
|
return QueryResult(
|
|
columns=columns,
|
|
rows=rows,
|
|
total=len(rows),
|
|
elapsed_ms=elapsed,
|
|
truncated=len(rows) >= MAX_ROWS,
|
|
)
|
|
|
|
@staticmethod
|
|
async def execute_dml(instance: Instance, database: str, sql: str) -> str:
|
|
"""Execute a DML statement (INSERT/UPDATE/DELETE)."""
|
|
if instance.db_type == "mysql":
|
|
return await DBConnector._dml_mysql(instance, database, sql)
|
|
elif instance.db_type in ("postgres", "postgresql"):
|
|
return await DBConnector._dml_postgres(instance, database, sql)
|
|
elif instance.db_type == "sqlite":
|
|
return await DBConnector._dml_sqlite(instance, sql)
|
|
else:
|
|
raise ValueError(f"暂不支持 {instance.db_type} 执行")
|
|
|
|
# ===== MySQL =====
|
|
|
|
@staticmethod
|
|
async def _test_mysql(instance: Instance, start: float) -> ConnectionResult:
|
|
import aiomysql
|
|
conn = await asyncio.wait_for(
|
|
aiomysql.connect(
|
|
host=instance.host, port=instance.port,
|
|
user=instance.username, password=instance.password,
|
|
db=instance.database,
|
|
),
|
|
timeout=10,
|
|
)
|
|
try:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute("SELECT VERSION()")
|
|
version = (await cur.fetchone())[0]
|
|
elapsed = int((time.time() - start) * 1000)
|
|
return ConnectionResult(True, "连接成功", version=version, latency_ms=elapsed)
|
|
finally:
|
|
conn.close()
|
|
|
|
@staticmethod
|
|
async def _query_mysql(instance: Instance, database: Optional[str], sql: str) -> Tuple[List[Dict], List[str]]:
|
|
import aiomysql
|
|
conn = await aiomysql.connect(
|
|
host=instance.host, port=instance.port,
|
|
user=instance.username, password=instance.password,
|
|
db=database or instance.database,
|
|
)
|
|
try:
|
|
async with conn.cursor(aiomysql.DictCursor) as cur:
|
|
await asyncio.wait_for(cur.execute(sql), timeout=QUERY_TIMEOUT)
|
|
rows = await cur.fetchall()
|
|
columns = [desc[0] for desc in cur.description] if cur.description else []
|
|
return rows, columns
|
|
except asyncio.TimeoutError:
|
|
raise ValueError("查询超时（30秒）")
|
|
finally:
|
|
conn.close()
|
|
|
|
@staticmethod
|
|
async def _dml_mysql(instance: Instance, database: str, sql: str) -> str:
|
|
import aiomysql
|
|
conn = await aiomysql.connect(
|
|
host=instance.host, port=instance.port,
|
|
user=instance.username, password=instance.password,
|
|
db=database, autocommit=True,
|
|
)
|
|
try:
|
|
async with conn.cursor() as cur:
|
|
await asyncio.wait_for(cur.execute(sql), timeout=DML_TIMEOUT)
|
|
affected = cur.rowcount
|
|
return f"执行成功，影响 {affected} 行"
|
|
except asyncio.TimeoutError:
|
|
raise ValueError("执行超时（60秒）")
|
|
finally:
|
|
conn.close()
|
|
|
|
# ===== PostgreSQL =====
|
|
|
|
@staticmethod
|
|
async def _test_postgres(instance: Instance, start: float) -> ConnectionResult:
|
|
import asyncpg
|
|
dsn = f"postgresql://{instance.username}:{instance.password}@{instance.host}:{instance.port}/{instance.database or 'postgres'}"
|
|
conn = await asyncio.wait_for(asyncpg.connect(dsn), timeout=10)
|
|
try:
|
|
version = await conn.fetchval("SELECT version()")
|
|
elapsed = int((time.time() - start) * 1000)
|
|
# version string is long, take first part
|
|
ver_short = version.split(",")[0] if version else "unknown"
|
|
return ConnectionResult(True, "连接成功", version=ver_short, latency_ms=elapsed)
|
|
finally:
|
|
await conn.close()
|
|
|
|
@staticmethod
|
|
async def _query_postgres(instance: Instance, database: Optional[str], sql: str) -> Tuple[List[Dict], List[str]]:
|
|
import asyncpg
|
|
dsn = f"postgresql://{instance.username}:{instance.password}@{instance.host}:{instance.port}/{database or instance.database or 'postgres'}"
|
|
conn = await asyncpg.connect(dsn)
|
|
try:
|
|
# asyncpg returns Records, convert to dicts
|
|
stmt = await asyncio.wait_for(conn.fetch(sql), timeout=QUERY_TIMEOUT)
|
|
rows = [dict(r) for r in stmt]
|
|
columns = list(stmt[0].keys()) if stmt else []
|
|
return rows, columns
|
|
except asyncio.TimeoutError:
|
|
raise ValueError("查询超时（30秒）")
|
|
finally:
|
|
await conn.close()
|
|
|
|
@staticmethod
|
|
async def _dml_postgres(instance: Instance, database: str, sql: str) -> str:
|
|
import asyncpg
|
|
dsn = f"postgresql://{instance.username}:{instance.password}@{instance.host}:{instance.port}/{database}"
|
|
conn = await asyncpg.connect(dsn)
|
|
try:
|
|
status = await asyncio.wait_for(conn.execute(sql), timeout=DML_TIMEOUT)
|
|
# status like "UPDATE 3"
|
|
parts = status.split()
|
|
affected = int(parts[1]) if len(parts) >= 2 else 0
|
|
return f"执行成功，影响 {affected} 行"
|
|
except asyncio.TimeoutError:
|
|
raise ValueError("执行超时（60秒）")
|
|
finally:
|
|
await conn.close()
|
|
|
|
# ===== SQLite (remote instance) =====
|
|
|
|
@staticmethod
|
|
async def _test_sqlite(instance: Instance, start: float) -> ConnectionResult:
|
|
# SQLite uses host as file path
|
|
db_path = instance.host
|
|
loop = asyncio.get_event_loop()
|
|
try:
|
|
def _connect():
|
|
conn = sqlite3.connect(db_path)
|
|
cur = conn.execute("SELECT sqlite_version()")
|
|
ver = cur.fetchone()[0]
|
|
conn.close()
|
|
return ver
|
|
version = await loop.run_in_executor(None, _connect)
|
|
elapsed = int((time.time() - start) * 1000)
|
|
return ConnectionResult(True, "连接成功", version=f"SQLite {version}", latency_ms=elapsed)
|
|
except Exception as e:
|
|
elapsed = int((time.time() - start) * 1000)
|
|
return ConnectionResult(False, f"连接失败: {e}", latency_ms=elapsed)
|
|
|
|
@staticmethod
|
|
async def _query_sqlite(instance: Instance, sql: str) -> Tuple[List[Dict], List[str]]:
|
|
db_path = instance.host
|
|
loop = asyncio.get_event_loop()
|
|
|
|
def _query():
|
|
conn = sqlite3.connect(db_path)
|
|
conn.row_factory = sqlite3.Row
|
|
cur = conn.execute(sql)
|
|
rows = [dict(r) for r in cur.fetchall()]
|
|
columns = [desc[0] for desc in cur.description] if cur.description else []
|
|
conn.close()
|
|
return rows, columns
|
|
|
|
try:
|
|
return await asyncio.wait_for(
|
|
loop.run_in_executor(None, _query),
|
|
timeout=QUERY_TIMEOUT,
|
|
)
|
|
except asyncio.TimeoutError:
|
|
raise ValueError("查询超时（30秒）")
|
|
|
|
@staticmethod
|
|
async def _dml_sqlite(instance: Instance, sql: str) -> str:
|
|
db_path = instance.host
|
|
loop = asyncio.get_event_loop()
|
|
|
|
def _execute():
|
|
conn = sqlite3.connect(db_path)
|
|
cur = conn.execute(sql)
|
|
affected = cur.rowcount
|
|
conn.commit()
|
|
conn.close()
|
|
return affected
|
|
|
|
try:
|
|
affected = await asyncio.wait_for(
|
|
loop.run_in_executor(None, _execute),
|
|
timeout=DML_TIMEOUT,
|
|
)
|
|
return f"执行成功，影响 {affected} 行"
|
|
except asyncio.TimeoutError:
|
|
raise ValueError("执行超时（60秒）")
|