Your Name
1567 lines
53 KiB
Python
1567 lines
53 KiB
Python
"""Nexus — Sync Engine v2 API Routes (Step 4)
|
||
|
||
S1: POST /api/sync/files — rsync file sync
|
||
P1: POST /api/sync/preview — rsync dry-run (方案D: 智能提示预览)
|
||
"""
|
||
|
||
import logging
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||
|
||
from server.api.schemas import (
|
||
SyncFiles,
|
||
SyncBrowse,
|
||
SyncBrowseLocal,
|
||
SyncPreview,
|
||
FileOperation,
|
||
FileClipboardApply,
|
||
LocalFileOperation,
|
||
LocalFilePreview,
|
||
SyncVerify,
|
||
SyncCancel,
|
||
ValidateSourcePath,
|
||
SyncDiagnose,
|
||
FileSyncDiff,
|
||
FileDownload,
|
||
FileRead,
|
||
FileWrite,
|
||
FileChmod,
|
||
FileCompress,
|
||
FileDecompress,
|
||
)
|
||
from server.api.remote_path_validation import RemotePathError, assert_clipboard_transfer_safe
|
||
from server.utils.posix_paths import (
|
||
PosixPathError,
|
||
assert_zip_member_safe,
|
||
ensure_under_nexus_upload,
|
||
is_path_under_prefix,
|
||
normalize_remote_abs_path,
|
||
posix_basename,
|
||
posix_dirname,
|
||
posix_join,
|
||
normalize_remote_dest,
|
||
remote_join,
|
||
resolve_nexus_host_path,
|
||
to_posix,
|
||
)
|
||
from server.application.services.sync_engine_v2 import SyncEngineV2
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.database.sync_log_repo import SyncLogRepositoryImpl
|
||
from server.infrastructure.database.audit_log_repo import AuditLogRepositoryImpl
|
||
from server.infrastructure.database.push_schedule_repo import PushRetryJobRepositoryImpl
|
||
from server.api.auth_jwt import get_current_admin
|
||
from server.domain.models import Admin, AuditLog
|
||
|
||
router = APIRouter(prefix="/api/sync", tags=["sync"])
|
||
|
||
logger = logging.getLogger("nexus.sync_v2")
|
||
|
||
|
||
async def _get_sync_engine(request: Request) -> SyncEngineV2:
|
||
"""DI factory for SyncEngineV2"""
|
||
session = request.state.db
|
||
return SyncEngineV2(
|
||
server_repo=ServerRepositoryImpl(session),
|
||
sync_log_repo=SyncLogRepositoryImpl(session),
|
||
audit_repo=AuditLogRepositoryImpl(session),
|
||
retry_repo=PushRetryJobRepositoryImpl(session),
|
||
)
|
||
|
||
|
||
@router.post("/files")
|
||
async def sync_files(
|
||
payload: SyncFiles,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""S1: File sync via rsync over SSH (with parallel execution)"""
|
||
engine = await _get_sync_engine(request)
|
||
return await engine.sync_files(
|
||
server_ids=payload.server_ids,
|
||
source_path=payload.source_path,
|
||
target_path=payload.target_path,
|
||
sync_mode=payload.sync_mode,
|
||
operator=admin.username,
|
||
batch_size=payload.batch_size,
|
||
concurrency=payload.concurrency,
|
||
)
|
||
|
||
|
||
@router.post("/preview")
|
||
async def preview_sync(
|
||
payload: SyncPreview,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""P1: Dry-run rsync --stats against one representative server.
|
||
|
||
No data is transferred. Returns file-change statistics and optional
|
||
per-file list (verbose=true, capped at 200 lines).
|
||
|
||
Full-sync mode (--delete) shows files_deleted — use this to confirm
|
||
before running a destructive full sync.
|
||
"""
|
||
engine = await _get_sync_engine(request)
|
||
result = await engine.preview_sync(
|
||
server_id=payload.server_id,
|
||
source_path=payload.source_path,
|
||
target_path=payload.target_path,
|
||
sync_mode=payload.sync_mode,
|
||
verbose=payload.verbose,
|
||
)
|
||
if "error" in result:
|
||
raise HTTPException(status_code=400, detail=result["error"])
|
||
|
||
await _audit_sync(
|
||
"sync_preview", "server", payload.server_id,
|
||
f"Dry-run preview: {payload.source_path} → server #{payload.server_id} ({payload.sync_mode})",
|
||
admin.username, request,
|
||
)
|
||
return result
|
||
|
||
|
||
@router.post("/file-ops")
|
||
async def file_operation(
|
||
payload: FileOperation,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Remote file operation (delete / rename / mkdir) via SSH exec.
|
||
|
||
All paths are shlex-quoted server-side. Dirs use rm -rf; confirm
|
||
client-side before sending delete on a directory. Audit-logged.
|
||
"""
|
||
import shlex
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.remote_shell import exec_ssh_command_with_fallback
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="Server not found")
|
||
|
||
op = payload.operation
|
||
try:
|
||
p = normalize_remote_abs_path(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
if op == "delete":
|
||
# rm -rf covers both files and directories
|
||
cmd = f"rm -rf {shlex.quote(p)}"
|
||
audit_detail = f"删除: {p}"
|
||
elif op == "rename":
|
||
if not payload.new_path:
|
||
raise HTTPException(status_code=400, detail="new_path required for rename")
|
||
try:
|
||
np = normalize_remote_abs_path(payload.new_path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
cmd = f"mv {shlex.quote(p)} {shlex.quote(np)}"
|
||
audit_detail = f"重命名: {p} → {np}"
|
||
elif op == "mkdir":
|
||
cmd = f"mkdir -p {shlex.quote(p)}"
|
||
audit_detail = f"新建目录: {p}"
|
||
else:
|
||
raise HTTPException(status_code=400, detail="Invalid operation")
|
||
|
||
result = await exec_ssh_command_with_fallback(server, cmd, timeout=30)
|
||
if result["exit_code"] != 0:
|
||
err = (result.get("stderr") or result.get("stdout") or "")[:300]
|
||
raise HTTPException(
|
||
status_code=403 if "permission denied" in err.lower() else 400,
|
||
detail=err or f"Command failed (exit {result['exit_code']})",
|
||
)
|
||
|
||
await _audit_sync(
|
||
f"file_{op}", "server", payload.server_id,
|
||
f"{audit_detail} 于 {server.name}", admin.username, request,
|
||
)
|
||
return {"success": True, "operation": op, "path": p}
|
||
|
||
|
||
@router.post("/file-clipboard")
|
||
async def apply_file_clipboard(
|
||
payload: FileClipboardApply,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Batch copy (cp -r) or move/cut (mv -t) remote paths into dest_dir."""
|
||
import shlex
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.asyncssh_pool import exec_ssh_command
|
||
from server.infrastructure.ssh.remote_shell import exec_ssh_command_with_fallback
|
||
|
||
try:
|
||
sources, dest_dir = assert_clipboard_transfer_safe(payload.sources, payload.dest_dir)
|
||
except RemotePathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
dest_q = shlex.quote(dest_dir)
|
||
check = await exec_ssh_command(server, f"test -d {dest_q}", timeout=15)
|
||
if check["exit_code"] != 0:
|
||
raise HTTPException(status_code=400, detail="目标目录不存在")
|
||
|
||
quoted_sources = " ".join(shlex.quote(s) for s in sources)
|
||
if payload.mode == "copy":
|
||
cmd = f"cp -r {quoted_sources} {dest_q}"
|
||
audit_action = "file_copy"
|
||
audit_detail = f"复制 {len(sources)} 项 → {dest_dir}"
|
||
else:
|
||
cmd = f"mv -t {dest_q} {quoted_sources}"
|
||
audit_action = "file_move"
|
||
audit_detail = f"移动 {len(sources)} 项 → {dest_dir}"
|
||
|
||
result = await exec_ssh_command_with_fallback(server, cmd, timeout=120)
|
||
if result["exit_code"] != 0:
|
||
raise HTTPException(
|
||
status_code=502,
|
||
detail=(result["stderr"] or result["stdout"] or "传输失败")[:300],
|
||
)
|
||
|
||
await _audit_sync(
|
||
audit_action,
|
||
"server",
|
||
payload.server_id,
|
||
f"{audit_detail} 于 {server.name}",
|
||
admin.username,
|
||
request,
|
||
)
|
||
return {
|
||
"success": True,
|
||
"mode": payload.mode,
|
||
"dest_dir": dest_dir,
|
||
"count": len(sources),
|
||
}
|
||
|
||
|
||
@router.post("/browse")
|
||
async def browse_directory(
|
||
payload: SyncBrowse,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Browse remote directory listing via SSH"""
|
||
from server.infrastructure.ssh.asyncssh_pool import exec_ssh_command
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
|
||
session = request.state.db
|
||
server_id = payload.server_id
|
||
path = payload.path
|
||
|
||
if not server_id:
|
||
raise HTTPException(status_code=400, detail="server_id required")
|
||
|
||
repo = ServerRepositoryImpl(session)
|
||
server = await repo.get_by_id(server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="Server not found")
|
||
|
||
try:
|
||
path = normalize_remote_abs_path(path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
import shlex
|
||
from server.utils.unix_ls import parse_ls_la_line, perms_to_mode_octal
|
||
|
||
path_q = shlex.quote(path)
|
||
result = await exec_ssh_command(
|
||
server,
|
||
f"ls -la --time-style=long-iso {path_q}",
|
||
timeout=10,
|
||
)
|
||
if result["exit_code"] != 0:
|
||
result = await exec_ssh_command(server, f"ls -la {path_q}", timeout=10)
|
||
|
||
await _audit_sync("browse_directory", "server", server_id, f"Browse {server.name}:{path}", admin.username, request)
|
||
|
||
if result["exit_code"] != 0:
|
||
return {"path": path, "items": [], "error": result["stderr"][:500]}
|
||
|
||
raw_entries = []
|
||
for line in result["stdout"].split("\n"):
|
||
parsed = parse_ls_la_line(line)
|
||
if parsed:
|
||
raw_entries.append(parsed)
|
||
|
||
items = []
|
||
for e in raw_entries:
|
||
is_dir = bool(e["is_dir"])
|
||
is_link = bool(e["is_link"])
|
||
try:
|
||
size = int(e["size"]) if not is_dir and not is_link else 0
|
||
except (TypeError, ValueError):
|
||
size = 0
|
||
if is_dir:
|
||
ftype = "directory"
|
||
elif is_link:
|
||
ftype = "symlink"
|
||
else:
|
||
ftype = "file"
|
||
mode_octal = perms_to_mode_octal(e["perms"]) or ""
|
||
items.append({
|
||
"name": e["name"],
|
||
"type": ftype,
|
||
"size": size,
|
||
"modified": e["modified"],
|
||
"permissions": e["perms"],
|
||
"owner": e.get("owner") or "",
|
||
"group": e.get("group") or "",
|
||
"mode_octal": mode_octal,
|
||
"link_target": e.get("link_target"),
|
||
})
|
||
|
||
return {"path": path, "items": items}
|
||
|
||
|
||
@router.post("/browse-local")
|
||
async def browse_local_directory(
|
||
payload: SyncBrowseLocal,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Browse a local directory on the Nexus server (for upload file manager).
|
||
|
||
Only allows browsing under /tmp/nexus_upload_* directories.
|
||
Returns entries with name, is_dir, size.
|
||
"""
|
||
import os
|
||
|
||
try:
|
||
real_path = ensure_under_nexus_upload(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=403, detail=str(exc)) from exc
|
||
|
||
if not os.path.isdir(real_path):
|
||
raise HTTPException(status_code=404, detail="目录不存在")
|
||
|
||
entries = []
|
||
try:
|
||
for entry in sorted(os.scandir(real_path), key=lambda e: (not e.is_dir(), e.name.lower())):
|
||
try:
|
||
stat = entry.stat()
|
||
entries.append({
|
||
"name": entry.name,
|
||
"is_dir": entry.is_dir(),
|
||
"size": stat.st_size if not entry.is_dir() else 0,
|
||
})
|
||
except OSError:
|
||
continue
|
||
except PermissionError:
|
||
raise HTTPException(status_code=403, detail="无权限访问该目录") from None
|
||
|
||
return {"path": real_path, "entries": entries}
|
||
|
||
|
||
@router.post("/local-file-ops")
|
||
async def local_file_operation(
|
||
payload: LocalFileOperation,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Delete or rename a file/directory in the local upload staging area.
|
||
|
||
Only allows operations under /tmp/nexus_upload_* directories.
|
||
"""
|
||
import os
|
||
import shutil
|
||
|
||
try:
|
||
real_path = ensure_under_nexus_upload(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=403, detail=str(exc)) from exc
|
||
|
||
path = to_posix(real_path)
|
||
|
||
if payload.operation == "delete":
|
||
if not os.path.exists(real_path):
|
||
raise HTTPException(status_code=404, detail="文件或目录不存在")
|
||
try:
|
||
if os.path.isdir(real_path):
|
||
shutil.rmtree(real_path)
|
||
else:
|
||
os.unlink(real_path)
|
||
except OSError as e:
|
||
raise HTTPException(status_code=500, detail=f"删除失败: {e}") from e
|
||
|
||
await _audit_sync(
|
||
"local_file_delete", "sync", 0,
|
||
f"删除: {path}", admin.username, request,
|
||
)
|
||
return {"success": True, "operation": "delete", "path": path}
|
||
|
||
elif payload.operation == "rename":
|
||
if not payload.new_name:
|
||
raise HTTPException(status_code=400, detail="new_name 必填")
|
||
# Sanitize: strip slashes and path traversal
|
||
safe_name = payload.new_name.replace("/", "_").replace("\\", "_").strip()
|
||
if not safe_name or safe_name == "." or safe_name == "..":
|
||
raise HTTPException(status_code=400, detail="无效的新名称")
|
||
|
||
if not os.path.exists(real_path):
|
||
raise HTTPException(status_code=404, detail="文件或目录不存在")
|
||
|
||
new_path = posix_join(posix_dirname(real_path), safe_name)
|
||
|
||
try:
|
||
ensure_under_nexus_upload(new_path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=403, detail=str(exc)) from exc
|
||
new_path = resolve_nexus_host_path(new_path)
|
||
|
||
if os.path.exists(new_path):
|
||
raise HTTPException(status_code=400, detail="目标名称已存在")
|
||
|
||
try:
|
||
os.rename(real_path, new_path)
|
||
except OSError as e:
|
||
raise HTTPException(status_code=500, detail=f"重命名失败: {e}") from e
|
||
|
||
await _audit_sync(
|
||
"local_file_rename", "sync", 0,
|
||
f"重命名: {path} → {safe_name}", admin.username, request,
|
||
)
|
||
return {"success": True, "operation": "rename", "path": path, "new_name": safe_name}
|
||
|
||
|
||
@router.post("/local-file-preview")
|
||
async def local_file_preview(
|
||
payload: LocalFilePreview,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Preview file content in the local upload staging area.
|
||
|
||
Only allows files under /tmp/nexus_upload_* directories.
|
||
Returns up to 4KB of file content, base64-encoded.
|
||
"""
|
||
import os
|
||
import base64
|
||
|
||
try:
|
||
real_path = ensure_under_nexus_upload(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=403, detail=str(exc)) from exc
|
||
|
||
path = to_posix(real_path)
|
||
|
||
if not os.path.isfile(real_path):
|
||
raise HTTPException(status_code=404, detail="文件不存在或不是普通文件")
|
||
|
||
# Size check: skip files over 1MB
|
||
file_size = os.path.getsize(real_path)
|
||
if file_size > 1_048_576:
|
||
raise HTTPException(status_code=400, detail="文件过大，不支持预览（>1MB）")
|
||
|
||
# Read up to 4KB
|
||
max_read = 4096
|
||
try:
|
||
with open(real_path, "rb") as f:
|
||
raw = f.read(max_read)
|
||
except OSError as e:
|
||
raise HTTPException(status_code=500, detail=f"读取失败: {e}") from None
|
||
|
||
truncated = file_size > max_read
|
||
|
||
# Detect encoding: try UTF-8 decode
|
||
encoding_hint = "binary"
|
||
try:
|
||
raw.decode("utf-8")
|
||
encoding_hint = "text"
|
||
except (UnicodeDecodeError, ValueError):
|
||
pass
|
||
|
||
name = posix_basename(real_path)
|
||
|
||
await _audit_sync(
|
||
"local_file_preview", "sync", 0,
|
||
f"预览: {path}", admin.username, request,
|
||
)
|
||
|
||
return {
|
||
"name": name,
|
||
"size": file_size,
|
||
"content_base64": base64.b64encode(raw).decode("ascii"),
|
||
"truncated": truncated,
|
||
"encoding_hint": encoding_hint,
|
||
}
|
||
|
||
|
||
async def _audit_sync(action: str, target_type: str, target_id: int, detail: str, operator: str, request: Request):
|
||
"""Create audit log entry for sync operations"""
|
||
try:
|
||
session = request.state.db
|
||
audit_repo = AuditLogRepositoryImpl(session)
|
||
await audit_repo.create(AuditLog(
|
||
admin_username=operator,
|
||
action=action,
|
||
target_type=target_type,
|
||
target_id=target_id,
|
||
detail=detail,
|
||
ip_address=request.client.host if request.client else "",
|
||
))
|
||
except Exception:
|
||
logger.warning(f"Audit log write failed for {action} on {target_type}/{target_id}", exc_info=True)
|
||
|
||
|
||
@router.post("/cancel")
|
||
async def cancel_sync(
|
||
payload: SyncCancel,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Cancel an in-progress push by setting a Redis flag.
|
||
|
||
The sync engine checks this flag before each rsync execution.
|
||
Already-completed servers retain their results; pending ones are skipped.
|
||
"""
|
||
try:
|
||
from server.infrastructure.redis.client import get_redis
|
||
redis = get_redis()
|
||
await redis.set(f"sync:cancel:{payload.batch_id}", "1", ex=3600)
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"取消操作失败: {e}") from e
|
||
|
||
await _audit_sync(
|
||
"sync_cancel", "sync", 0,
|
||
f"取消推送: batch_id={payload.batch_id}", admin.username, request,
|
||
)
|
||
|
||
return {"cancelled": True, "batch_id": payload.batch_id}
|
||
|
||
|
||
# ── H5: Validate Source Path ──
|
||
|
||
_FORBIDDEN_PATH_PREFIXES = ("/etc", "/root", "/home", "/var", "/boot", "/dev", "/proc", "/sys", "/run", "/srv")
|
||
|
||
|
||
@router.post("/validate-source-path")
|
||
async def validate_source_path(
|
||
payload: ValidateSourcePath,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Validate a local directory path on the Nexus server as a push source.
|
||
|
||
Security: rejects sensitive system paths (/etc, /root, /home, etc.)
|
||
and paths with traversal components.
|
||
"""
|
||
import os
|
||
|
||
path = payload.path.strip()
|
||
|
||
try:
|
||
real_path = resolve_nexus_host_path(path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
if ".." in to_posix(path).split("/"):
|
||
raise HTTPException(status_code=400, detail="路径不允许包含 '..'")
|
||
|
||
# Reject sensitive paths
|
||
for prefix in _FORBIDDEN_PATH_PREFIXES:
|
||
if real_path == prefix or real_path.startswith(prefix + "/"):
|
||
raise HTTPException(status_code=403, detail=f"不允许使用系统路径: {prefix}")
|
||
|
||
if not os.path.exists(real_path):
|
||
raise HTTPException(status_code=404, detail="路径不存在")
|
||
|
||
if not os.path.isdir(real_path):
|
||
raise HTTPException(status_code=400, detail="路径不是目录")
|
||
|
||
# Count files and total size
|
||
file_count = 0
|
||
total_size = 0
|
||
for root, _dirs, fnames in os.walk(real_path):
|
||
for fn in fnames:
|
||
file_count += 1
|
||
try:
|
||
total_size += os.path.getsize(posix_join(root, fn))
|
||
except OSError:
|
||
pass
|
||
if file_count >= 10000:
|
||
break
|
||
if file_count >= 10000:
|
||
break
|
||
|
||
await _audit_sync(
|
||
"validate_source_path", "sync", 0,
|
||
f"验证源路径: {path} ({file_count} 文件)",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {
|
||
"valid": True,
|
||
"is_dir": True,
|
||
"path": real_path,
|
||
"file_count": file_count,
|
||
"size_bytes": total_size,
|
||
"file_count_truncated": file_count >= 10000,
|
||
}
|
||
|
||
|
||
# ── H4: Diagnose Push Failure ──
|
||
|
||
@router.post("/diagnose")
|
||
async def diagnose_push(
|
||
payload: SyncDiagnose,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Diagnose why a push failed for a specific server.
|
||
|
||
Checks SSH connectivity, disk space, target path permissions, and write access.
|
||
"""
|
||
import shlex
|
||
from server.infrastructure.ssh.asyncssh_pool import exec_ssh_command
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
result = {
|
||
"server_id": payload.server_id,
|
||
"server_name": server.name,
|
||
"ssh_ok": False,
|
||
"disk_avail": None,
|
||
"disk_used_pct": None,
|
||
"path_exists": None,
|
||
"path_perms": None,
|
||
"path_writable": None,
|
||
"errors": [],
|
||
}
|
||
|
||
# 1. SSH connectivity
|
||
try:
|
||
r = await exec_ssh_command(server, "echo ok", timeout=10)
|
||
if r["exit_code"] == 0 and "ok" in r["stdout"]:
|
||
result["ssh_ok"] = True
|
||
else:
|
||
result["errors"].append(f"SSH 连接异常: {r['stderr'][:200] or 'exit code ' + str(r['exit_code'])}")
|
||
# Cannot continue if SSH fails
|
||
await _audit_sync("diagnose", "server", payload.server_id, "诊断: SSH不通", admin.username, request)
|
||
return result
|
||
except Exception as e:
|
||
result["errors"].append(f"SSH 连接失败: {e}")
|
||
await _audit_sync("diagnose", "server", payload.server_id, "诊断: SSH失败", admin.username, request)
|
||
return result
|
||
|
||
try:
|
||
dest = normalize_remote_dest(payload.target_path or server.target_path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
safe_dest = shlex.quote(dest)
|
||
|
||
# 2. Disk space
|
||
try:
|
||
r = await exec_ssh_command(server, f"df -h {safe_dest} | tail -1", timeout=10)
|
||
if r["exit_code"] == 0:
|
||
parts = r["stdout"].strip().split()
|
||
if len(parts) >= 6:
|
||
result["disk_avail"] = parts[3] # e.g. "50G"
|
||
try:
|
||
result["disk_used_pct"] = int(parts[4].replace("%", "")) # e.g. 72
|
||
except ValueError:
|
||
pass
|
||
except Exception as e:
|
||
logger.debug(f"Diagnose disk check failed for server {payload.server_id}: {e}")
|
||
try:
|
||
r = await exec_ssh_command(server, f"ls -ld {safe_dest} 2>&1", timeout=10)
|
||
if r["exit_code"] == 0:
|
||
result["path_exists"] = True
|
||
parts = r["stdout"].strip().split()
|
||
if parts:
|
||
result["path_perms"] = parts[0] # e.g. "drwxr-xr-x"
|
||
else:
|
||
result["path_exists"] = False
|
||
result["errors"].append(f"目标路径不存在: {dest}")
|
||
except Exception as e:
|
||
logger.debug(f"Diagnose path check failed for server {payload.server_id}: {e}")
|
||
|
||
# 4. Write test
|
||
if result["path_exists"]:
|
||
try:
|
||
test_file = remote_join(dest, ".nexus_diag_test_$$")
|
||
r = await exec_ssh_command(
|
||
server,
|
||
f"touch {shlex.quote(test_file)} && rm -f {shlex.quote(test_file)}",
|
||
timeout=10,
|
||
)
|
||
result["path_writable"] = r["exit_code"] == 0
|
||
if r["exit_code"] != 0:
|
||
result["errors"].append(f"目标路径不可写: {r['stderr'][:200]}")
|
||
except Exception as e:
|
||
result["errors"].append(f"写入测试失败: {e}")
|
||
result["path_writable"] = False
|
||
else:
|
||
result["path_writable"] = False
|
||
|
||
await _audit_sync(
|
||
"diagnose", "server", payload.server_id,
|
||
f"诊断: SSH={'✓' if result['ssh_ok'] else '✗'} 路径={'✓' if result['path_exists'] else '✗'} 写入={'✓' if result['path_writable'] else '✗'}",
|
||
admin.username, request,
|
||
)
|
||
|
||
return result
|
||
|
||
|
||
# ── H3: File Diff View ──
|
||
|
||
_MAX_DIFF_SIZE = 102_400 # 100 KB
|
||
|
||
|
||
@router.post("/file-diff")
|
||
async def file_diff(
|
||
payload: FileSyncDiff,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Compare a local file with its remote counterpart to show push diff.
|
||
|
||
Security: only allows diffing files under /tmp/nexus_upload_* source paths.
|
||
Reads up to 100KB from each side. Returns unified diff lines.
|
||
"""
|
||
import os
|
||
import difflib
|
||
import shlex
|
||
from server.infrastructure.ssh.asyncssh_pool import exec_ssh_command
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
|
||
try:
|
||
real_source = ensure_under_nexus_upload(payload.source_path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=403, detail=str(exc)) from exc
|
||
|
||
rel = to_posix(payload.relative_path).lstrip("/")
|
||
if not rel or ".." in rel.split("/"):
|
||
raise HTTPException(status_code=400, detail="相对路径无效")
|
||
|
||
local_file = resolve_nexus_host_path(posix_join(real_source, rel))
|
||
if not is_path_under_prefix(local_file, real_source):
|
||
raise HTTPException(status_code=403, detail="文件路径越界")
|
||
|
||
if not os.path.isfile(local_file):
|
||
return {
|
||
"file_name": posix_basename(rel),
|
||
"local_exists": False,
|
||
"remote_exists": None,
|
||
"local_size": 0,
|
||
"remote_size": None,
|
||
"diff_lines": [],
|
||
"truncated": False,
|
||
"error": "本地文件不存在",
|
||
}
|
||
|
||
# Read local file
|
||
local_size = os.path.getsize(local_file)
|
||
try:
|
||
with open(local_file, "r", encoding="utf-8", errors="replace") as f:
|
||
local_text = f.read(_MAX_DIFF_SIZE)
|
||
except OSError as e:
|
||
raise HTTPException(status_code=500, detail=f"读取本地文件失败: {e}") from None
|
||
|
||
local_lines = local_text.splitlines(keepends=True)
|
||
local_truncated = local_size > _MAX_DIFF_SIZE
|
||
|
||
# Get server + target path
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
dest = normalize_remote_dest(payload.target_path or server.target_path)
|
||
remote_file = remote_join(dest, rel)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
# Read remote file
|
||
remote_exists = False
|
||
remote_size = None
|
||
remote_lines = []
|
||
remote_truncated = False
|
||
|
||
try:
|
||
r = await exec_ssh_command(
|
||
server,
|
||
f"wc -c {shlex.quote(remote_file)} 2>/dev/null && cat {shlex.quote(remote_file)}",
|
||
timeout=15,
|
||
)
|
||
if r["exit_code"] == 0:
|
||
remote_exists = True
|
||
output = r["stdout"]
|
||
# First line is wc -c output: " 12345 /path/file"
|
||
first_newline = output.index("\n") if "\n" in output else 0
|
||
wc_line = output[:first_newline].strip()
|
||
try:
|
||
remote_size = int(wc_line.split()[0])
|
||
except (ValueError, IndexError):
|
||
remote_size = None
|
||
remote_text = output[first_newline + 1:]
|
||
if remote_size is not None and remote_size > _MAX_DIFF_SIZE:
|
||
remote_truncated = True
|
||
remote_lines = remote_text.splitlines(keepends=True)
|
||
else:
|
||
# File doesn't exist on remote — treat as empty (all local lines are additions)
|
||
remote_exists = False
|
||
except Exception as e:
|
||
# SSH failed — report error
|
||
logger.warning(f"File diff remote read failed for server {payload.server_id}: {e}")
|
||
remote_exists = None
|
||
|
||
# Compute unified diff
|
||
diff_lines = []
|
||
for line in difflib.unified_diff(
|
||
remote_lines, local_lines,
|
||
fromfile=f"remote/{payload.relative_path}",
|
||
tofile=f"local/{payload.relative_path}",
|
||
lineterm="",
|
||
):
|
||
if line.startswith("+") and not line.startswith("+++"):
|
||
diff_lines.append({"type": "add", "content": line[1:]})
|
||
elif line.startswith("-") and not line.startswith("---"):
|
||
diff_lines.append({"type": "del", "content": line[1:]})
|
||
elif line.startswith("@@"):
|
||
diff_lines.append({"type": "header", "content": line})
|
||
elif line.startswith(" "):
|
||
diff_lines.append({"type": "ctx", "content": line[1:]})
|
||
|
||
await _audit_sync(
|
||
"file_diff", "server", payload.server_id,
|
||
f"文件对比: {payload.relative_path}",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {
|
||
"file_name": posix_basename(rel),
|
||
"local_exists": True,
|
||
"remote_exists": remote_exists,
|
||
"local_size": local_size,
|
||
"remote_size": remote_size,
|
||
"diff_lines": diff_lines,
|
||
"truncated": local_truncated or remote_truncated,
|
||
}
|
||
|
||
|
||
# ── File Upload via SFTP ──
|
||
|
||
MAX_UPLOAD_FILE_SIZE = 104_857_600 # 100 MB
|
||
|
||
|
||
@router.post("/upload")
|
||
async def upload_file(
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Upload a file to a remote server via SFTP.
|
||
|
||
Multipart form fields:
|
||
- server_id: int (required)
|
||
- remote_path: str (target directory, required)
|
||
- file: UploadFile (required)
|
||
|
||
The file is uploaded to {remote_path}/{filename} on the target server.
|
||
If the file already exists, it will be overwritten.
|
||
"""
|
||
import asyncssh
|
||
from server.infrastructure.ssh.asyncssh_pool import remote_write_bytes, ssh_pool
|
||
|
||
form = await request.form()
|
||
server_id_raw = form.get("server_id")
|
||
remote_path_raw = form.get("remote_path", "/tmp")
|
||
file = form.get("file")
|
||
|
||
if not server_id_raw:
|
||
raise HTTPException(status_code=400, detail="server_id 必填")
|
||
try:
|
||
server_id = int(server_id_raw)
|
||
except (ValueError, TypeError):
|
||
raise HTTPException(status_code=400, detail="server_id 必须为数字") from None
|
||
|
||
if not file or not hasattr(file, "filename") or not file.filename:
|
||
raise HTTPException(status_code=400, detail="请选择要上传的文件")
|
||
|
||
# Read file content with size check
|
||
content = await file.read()
|
||
if len(content) > MAX_UPLOAD_FILE_SIZE:
|
||
raise HTTPException(status_code=400, detail=f"文件大小超过限制 ({MAX_UPLOAD_FILE_SIZE // (1024*1024)}MB)")
|
||
|
||
remote_path = str(remote_path_raw).strip()
|
||
filename = file.filename
|
||
|
||
try:
|
||
remote_dir = normalize_remote_abs_path(remote_path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
# Sanitize filename — strip slashes to prevent path injection
|
||
safe_filename = filename.replace("/", "_").replace("\\", "_").strip()
|
||
if not safe_filename:
|
||
raise HTTPException(status_code=400, detail="文件名无效")
|
||
|
||
# Get server from DB
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
full_remote_path = remote_join(remote_dir, safe_filename)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
from server.utils.files_elevation import get_files_elevation
|
||
|
||
try:
|
||
conn = await ssh_pool.acquire(server)
|
||
try:
|
||
await remote_write_bytes(
|
||
conn,
|
||
full_remote_path,
|
||
content,
|
||
elevation=get_files_elevation(server),
|
||
)
|
||
finally:
|
||
await ssh_pool.release(server.id)
|
||
except asyncssh.PermissionDenied:
|
||
raise HTTPException(status_code=403, detail=f"SSH 权限不足，无法写入 {full_remote_path}") from None
|
||
except asyncssh.SFTPError as e:
|
||
raise HTTPException(status_code=400, detail=f"SFTP 上传失败: {e}") from e
|
||
except Exception as e:
|
||
raise HTTPException(status_code=502, detail=f"SSH 连接失败: {e}") from e
|
||
|
||
# Audit
|
||
await _audit_sync(
|
||
"file_upload", "server", server_id,
|
||
f"上传 {safe_filename} ({len(content)} bytes) → {server.name}:{full_remote_path}",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {
|
||
"success": True,
|
||
"server_id": server_id,
|
||
"remote_path": full_remote_path,
|
||
"filename": safe_filename,
|
||
"size": len(content),
|
||
}
|
||
|
||
|
||
# ── ZIP Upload & Extract (for push workflow) ──
|
||
|
||
MAX_ZIP_FILE_SIZE = 524_288_000 # 500 MB
|
||
|
||
|
||
@router.post("/upload-zip")
|
||
async def upload_zip(
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Upload a ZIP file to Nexus, extract it, return the source path for rsync push.
|
||
|
||
Multipart form fields:
|
||
- file: UploadFile (required, must be .zip)
|
||
|
||
Returns {"source_path": "/tmp/nexus_upload_xxx/", "file_count": N}
|
||
"""
|
||
import os
|
||
import posixpath
|
||
import uuid
|
||
import zipfile
|
||
import shutil
|
||
|
||
form = await request.form()
|
||
file = form.get("file")
|
||
|
||
if not file or not hasattr(file, "filename") or not file.filename:
|
||
raise HTTPException(status_code=400, detail="请选择 ZIP 文件")
|
||
|
||
filename = file.filename
|
||
if not filename.lower().endswith(".zip"):
|
||
raise HTTPException(status_code=400, detail="仅支持 .zip 格式")
|
||
|
||
# Read with size check
|
||
content = await file.read()
|
||
if len(content) > MAX_ZIP_FILE_SIZE:
|
||
raise HTTPException(status_code=400, detail=f"文件大小超过限制 ({MAX_ZIP_FILE_SIZE // (1024*1024)}MB)")
|
||
if len(content) == 0:
|
||
raise HTTPException(status_code=400, detail="文件为空")
|
||
|
||
# Create temp directory
|
||
upload_id = uuid.uuid4().hex[:12]
|
||
extract_dir = f"/tmp/nexus_upload_{upload_id}"
|
||
zip_path = f"{extract_dir}.zip"
|
||
|
||
try:
|
||
os.makedirs(extract_dir, exist_ok=True)
|
||
|
||
# Save ZIP
|
||
with open(zip_path, "wb") as f:
|
||
f.write(content)
|
||
|
||
# Validate and extract with zip slip protection
|
||
file_count = 0
|
||
with zipfile.ZipFile(zip_path, "r") as zf:
|
||
extract_base = resolve_nexus_host_path(extract_dir)
|
||
for info in zf.infolist():
|
||
try:
|
||
member_path = assert_zip_member_safe(extract_dir, info.filename)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
real_path = resolve_nexus_host_path(member_path)
|
||
if not is_path_under_prefix(real_path, extract_base):
|
||
raise HTTPException(status_code=400, detail=f"ZIP 包含非法路径: {info.filename}")
|
||
if info.is_dir():
|
||
continue
|
||
file_count += 1
|
||
|
||
zf.extractall(extract_dir)
|
||
|
||
# Clean up ZIP file
|
||
os.unlink(zip_path)
|
||
|
||
if file_count == 0:
|
||
shutil.rmtree(extract_dir, ignore_errors=True)
|
||
raise HTTPException(status_code=400, detail="ZIP 文件为空（无文件）")
|
||
|
||
# Build file listing (relative paths, capped at 500)
|
||
files = []
|
||
for root, _dirs, fnames in os.walk(extract_dir):
|
||
for fn in fnames:
|
||
rel = posixpath.relpath(posix_join(root, fn), extract_dir)
|
||
files.append(rel)
|
||
if len(files) >= 500:
|
||
break
|
||
if len(files) >= 500:
|
||
break
|
||
files_truncated = file_count > len(files)
|
||
|
||
# Audit
|
||
await _audit_sync(
|
||
"upload_zip", "sync", 0,
|
||
f"上传 ZIP: {filename} ({len(content)} bytes) → {extract_dir} ({file_count} 个文件)",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {
|
||
"success": True,
|
||
"source_path": extract_dir,
|
||
"file_count": file_count,
|
||
"files": files,
|
||
"files_truncated": files_truncated,
|
||
"filename": filename,
|
||
"size": len(content),
|
||
}
|
||
|
||
except HTTPException:
|
||
shutil.rmtree(extract_dir, ignore_errors=True)
|
||
try:
|
||
os.unlink(zip_path)
|
||
except OSError:
|
||
pass
|
||
raise
|
||
except zipfile.BadZipFile:
|
||
shutil.rmtree(extract_dir, ignore_errors=True)
|
||
try:
|
||
os.unlink(zip_path)
|
||
except OSError:
|
||
pass
|
||
raise HTTPException(status_code=400, detail="无效的 ZIP 文件") from None
|
||
except Exception as e:
|
||
shutil.rmtree(extract_dir, ignore_errors=True)
|
||
try:
|
||
os.unlink(zip_path)
|
||
except OSError:
|
||
pass
|
||
raise HTTPException(status_code=500, detail=f"解压失败: {e}") from e
|
||
|
||
|
||
# ── Post-Push Verification (sha256sum comparison) ──
|
||
|
||
@router.post("/verify")
|
||
async def verify_sync(
|
||
payload: SyncVerify,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Verify pushed files by comparing sha256sums between source and target servers.
|
||
|
||
Walks the local source directory and computes sha256 for each file,
|
||
then runs sha256sum on each target server via SSH and compares.
|
||
Returns per-server results: matched / missing / mismatched file lists.
|
||
"""
|
||
import asyncio
|
||
import hashlib
|
||
import os
|
||
import posixpath
|
||
import shlex
|
||
from server.infrastructure.ssh.asyncssh_pool import exec_ssh_command
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
|
||
session = request.state.db
|
||
|
||
if not os.path.isdir(payload.source_path):
|
||
raise HTTPException(status_code=400, detail=f"源路径不存在: {payload.source_path}")
|
||
|
||
# Build local file manifest: {relative_path: sha256hex}
|
||
local_files = {}
|
||
for root, _dirs, fnames in os.walk(payload.source_path):
|
||
for fn in fnames:
|
||
full = posix_join(root, fn)
|
||
rel = posixpath.relpath(full, to_posix(payload.source_path))
|
||
if len(local_files) >= payload.max_files:
|
||
break
|
||
try:
|
||
h = hashlib.sha256()
|
||
with open(full, "rb") as f:
|
||
for chunk in iter(lambda: f.read(8192), b""):
|
||
h.update(chunk)
|
||
local_files[rel] = h.hexdigest()
|
||
except OSError:
|
||
continue
|
||
if len(local_files) >= payload.max_files:
|
||
break
|
||
|
||
if not local_files:
|
||
raise HTTPException(status_code=400, detail="源目录无文件可校验")
|
||
|
||
# Verify against each server concurrently
|
||
sem = asyncio.Semaphore(5)
|
||
results = {}
|
||
|
||
async def _verify_one(sid: int):
|
||
async with sem:
|
||
server = await ServerRepositoryImpl(session).get_by_id(sid)
|
||
if not server:
|
||
results[sid] = {"server_id": sid, "server_name": "", "error": "服务器不存在"}
|
||
return
|
||
|
||
try:
|
||
dest = normalize_remote_dest(payload.target_path or server.target_path)
|
||
except PosixPathError as exc:
|
||
results[sid] = {
|
||
"server_id": sid,
|
||
"server_name": server.name,
|
||
"error": str(exc),
|
||
}
|
||
return
|
||
# Run sha256sum on remote server for the same relative paths
|
||
# Build a file list for sha256sum to check
|
||
file_list = " ".join(shlex.quote(f) for f in local_files.keys())
|
||
cmd = f"cd {shlex.quote(dest)} && sha256sum {file_list} 2>/dev/null"
|
||
|
||
try:
|
||
r = await exec_ssh_command(server, cmd, timeout=60)
|
||
except Exception as e:
|
||
results[sid] = {
|
||
"server_id": sid, "server_name": server.name,
|
||
"error": f"SSH 连接失败: {e}",
|
||
}
|
||
return
|
||
|
||
# Parse sha256sum output: "hash filename"
|
||
remote_files = {}
|
||
if r["exit_code"] == 0:
|
||
for line in r["stdout"].strip().split("\n"):
|
||
parts = line.split(None, 1)
|
||
if len(parts) == 2:
|
||
remote_files[parts[1]] = parts[0]
|
||
|
||
matched = []
|
||
missing = []
|
||
mismatched = []
|
||
for rel, local_hash in local_files.items():
|
||
if rel not in remote_files:
|
||
missing.append(rel)
|
||
elif remote_files[rel] != local_hash:
|
||
mismatched.append(rel)
|
||
else:
|
||
matched.append(rel)
|
||
|
||
results[sid] = {
|
||
"server_id": sid,
|
||
"server_name": server.name,
|
||
"matched": len(matched),
|
||
"missing": len(missing),
|
||
"mismatched": len(mismatched),
|
||
"missing_files": missing[:50],
|
||
"mismatched_files": mismatched[:50],
|
||
}
|
||
|
||
await asyncio.gather(*[_verify_one(sid) for sid in payload.server_ids])
|
||
|
||
# Audit
|
||
await _audit_sync(
|
||
"sync_verify", "sync", 0,
|
||
f"推送校验: {payload.source_path} → {len(payload.server_ids)} 台服务器",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {"results": results, "total_local_files": len(local_files)}
|
||
|
||
|
||
# ── File Download / Read / Write ──
|
||
|
||
MAX_READ_FILE_SIZE = 1_000_000 # 1MB
|
||
|
||
|
||
@router.post("/download")
|
||
async def download_file(
|
||
payload: FileDownload,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""P2-7: Download a file from a remote server via SFTP."""
|
||
from fastapi.responses import StreamingResponse
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.asyncssh_pool import sftp_session, ssh_pool
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
remote_path = normalize_remote_abs_path(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
conn = await ssh_pool.acquire(server)
|
||
try:
|
||
async with sftp_session(conn) as sftp:
|
||
# Check file exists and size
|
||
try:
|
||
stat = await sftp.stat(remote_path)
|
||
except FileNotFoundError:
|
||
raise HTTPException(status_code=404, detail="文件不存在") from None
|
||
except Exception as e:
|
||
raise HTTPException(status_code=502, detail=f"无法访问文件: {e}") from e
|
||
|
||
if stat.type not in ("regular file", "unknown"):
|
||
raise HTTPException(status_code=400, detail="只能下载文件，不能下载目录")
|
||
|
||
# H-15: Download file size limit (100MB)
|
||
MAX_DOWNLOAD_SIZE = 100 * 1024 * 1024
|
||
if hasattr(stat, "size") and stat.size and stat.size > MAX_DOWNLOAD_SIZE:
|
||
raise HTTPException(status_code=413, detail=f"文件大小 {stat.size} 字节超过下载限制 100MB")
|
||
|
||
# H-02: Sanitize filename for Content-Disposition (RFC 6266)
|
||
import re as _re
|
||
filename = _re.sub(r'[^\w.\-]', '_', posix_basename(remote_path)) or "download"
|
||
|
||
async def file_generator():
|
||
async with sftp.open(remote_path, "rb") as f:
|
||
while chunk := await f.read(65536):
|
||
yield chunk
|
||
|
||
await _audit_sync(
|
||
"file_download", "server", payload.server_id,
|
||
f"下载文件: {remote_path}",
|
||
admin.username, request,
|
||
)
|
||
|
||
return StreamingResponse(
|
||
file_generator(),
|
||
media_type="application/octet-stream",
|
||
headers={"Content-Disposition": f'attachment; filename="{filename}"'},
|
||
)
|
||
finally:
|
||
await ssh_pool.release(server.id)
|
||
|
||
|
||
@router.post("/read-file")
|
||
async def read_file(
|
||
payload: FileRead,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""P2-8: Read text file content from a remote server."""
|
||
import shlex
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.remote_shell import exec_ssh_command_with_fallback
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
remote_path = normalize_remote_abs_path(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
path_q = shlex.quote(remote_path)
|
||
size_result = await exec_ssh_command_with_fallback(
|
||
server, f"stat -c%s {path_q}", timeout=5,
|
||
)
|
||
if size_result["exit_code"] != 0:
|
||
raise HTTPException(status_code=404, detail="文件不存在或无法访问")
|
||
|
||
try:
|
||
file_size = int(size_result["stdout"].strip())
|
||
except ValueError:
|
||
raise HTTPException(status_code=502, detail="无法获取文件大小") from None
|
||
|
||
if file_size > payload.max_size:
|
||
raise HTTPException(
|
||
status_code=413,
|
||
detail=f"文件大小 {file_size} 字节超过限制 {payload.max_size} 字节",
|
||
)
|
||
|
||
result = await exec_ssh_command_with_fallback(server, f"cat {path_q}", timeout=15)
|
||
if result["exit_code"] != 0:
|
||
err = ((result.get("stderr") or "") + (result.get("stdout") or ""))[:200]
|
||
raise HTTPException(status_code=502, detail=f"读取失败: {err}")
|
||
|
||
await _audit_sync(
|
||
"file_read", "server", payload.server_id,
|
||
f"读取文件: {remote_path} ({file_size} bytes)",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {"content": result["stdout"], "size": file_size, "path": remote_path}
|
||
|
||
|
||
@router.post("/write-file")
|
||
async def write_file(
|
||
payload: FileWrite,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Write text file content to a remote server (SFTP + SSH tee/mv/sudo fallback)."""
|
||
import asyncssh
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.asyncssh_pool import remote_write_bytes, ssh_pool
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
remote_path = normalize_remote_abs_path(payload.path)
|
||
except PosixPathError as e:
|
||
raise HTTPException(status_code=400, detail=str(e)) from e
|
||
|
||
from server.utils.files_elevation import get_files_elevation
|
||
|
||
content_bytes = payload.content.encode("utf-8")
|
||
if len(content_bytes) > 5_000_000:
|
||
raise HTTPException(status_code=413, detail="文件内容超过 5MB 限制")
|
||
|
||
try:
|
||
conn = await ssh_pool.acquire(server)
|
||
try:
|
||
await remote_write_bytes(
|
||
conn,
|
||
remote_path,
|
||
content_bytes,
|
||
elevation=get_files_elevation(server),
|
||
)
|
||
finally:
|
||
await ssh_pool.release(server.id)
|
||
except asyncssh.PermissionDenied:
|
||
raise HTTPException(
|
||
status_code=403,
|
||
detail=(
|
||
f"无写入权限: {remote_path}。"
|
||
"请确认 SSH 用户对目录有写权限，或已配置免密 sudo（tee/mv）。"
|
||
),
|
||
) from None
|
||
except FileNotFoundError:
|
||
raise HTTPException(status_code=404, detail="目标路径不存在") from None
|
||
except asyncssh.SFTPError as e:
|
||
raise HTTPException(
|
||
status_code=403,
|
||
detail=(
|
||
f"写入失败: {e}。"
|
||
f"路径 {remote_path} — 若文件属主为 root，请为 SSH 用户配置免密 sudo 或修改文件权限。"
|
||
),
|
||
) from e
|
||
except Exception as e:
|
||
raise HTTPException(status_code=502, detail=f"SSH 连接失败: {e}") from e
|
||
|
||
await _audit_sync(
|
||
"file_write", "server", payload.server_id,
|
||
f"写入文件: {remote_path} ({len(content_bytes)} bytes)",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {"success": True, "path": remote_path, "size": len(content_bytes)}
|
||
|
||
|
||
@router.post("/chmod")
|
||
async def chmod_file(
|
||
payload: FileChmod,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Change file permissions (and optional owner) on a remote server."""
|
||
import shlex
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.remote_shell import exec_ssh_command_with_fallback
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
remote_path = normalize_remote_abs_path(payload.path)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
from server.infrastructure.ssh.asyncssh_pool import exec_ssh_command
|
||
from server.utils.files_chmod_policy import (
|
||
RECURSIVE_CHMOD_TIMEOUT_SEC,
|
||
SINGLE_CHMOD_TIMEOUT_SEC,
|
||
assert_recursive_chmod_allowed,
|
||
)
|
||
|
||
path_q = shlex.quote(remote_path)
|
||
recursive = bool(payload.recursive)
|
||
if recursive:
|
||
try:
|
||
assert_recursive_chmod_allowed(remote_path)
|
||
except ValueError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
dir_check = await exec_ssh_command(server, f"test -d {path_q}", timeout=10)
|
||
if dir_check.get("exit_code") != 0:
|
||
raise HTTPException(status_code=400, detail="递归 chmod 仅适用于目录")
|
||
|
||
chmod_prefix = "chmod -R " if recursive else "chmod "
|
||
chown_prefix = "chown -R " if recursive else "chown "
|
||
cmd_parts = [f"{chmod_prefix}{shlex.quote(payload.mode)} {path_q}"]
|
||
if payload.owner:
|
||
group = (payload.group or payload.owner).strip()
|
||
owner_spec = shlex.quote(f"{payload.owner}:{group}")
|
||
cmd_parts.append(f"{chown_prefix}{owner_spec} {path_q}")
|
||
|
||
timeout = RECURSIVE_CHMOD_TIMEOUT_SEC if recursive else SINGLE_CHMOD_TIMEOUT_SEC
|
||
result = await exec_ssh_command_with_fallback(server, " && ".join(cmd_parts), timeout=timeout)
|
||
if result["exit_code"] != 0:
|
||
err = ((result.get("stderr") or "") + (result.get("stdout") or ""))[:300]
|
||
raise HTTPException(
|
||
status_code=403 if "permission denied" in err.lower() else 502,
|
||
detail=err or "chmod 失败",
|
||
)
|
||
|
||
audit_bits = [f"chmod {'-R ' if recursive else ''}{payload.mode}"]
|
||
if payload.owner:
|
||
audit_bits.append(
|
||
f"chown {'-R ' if recursive else ''}{payload.owner}:{payload.group or payload.owner}"
|
||
)
|
||
await _audit_sync(
|
||
"file_permission_change",
|
||
"server",
|
||
payload.server_id,
|
||
f"{' '.join(audit_bits)} {remote_path}",
|
||
admin.username,
|
||
request,
|
||
)
|
||
|
||
return {
|
||
"success": True,
|
||
"path": remote_path,
|
||
"mode": payload.mode,
|
||
"owner": payload.owner,
|
||
"group": payload.group,
|
||
"recursive": recursive,
|
||
"elevated": bool(result.get("elevated")),
|
||
}
|
||
|
||
|
||
@router.post("/compress")
|
||
async def compress_files(
|
||
payload: FileCompress,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Compress files into tar.gz or zip archive."""
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.remote_archive import run_remote_compress
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
dest = normalize_remote_abs_path(payload.dest)
|
||
paths = [normalize_remote_abs_path(p) for p in payload.paths]
|
||
except PosixPathError as e:
|
||
raise HTTPException(status_code=400, detail=str(e)) from e
|
||
|
||
result = await run_remote_compress(
|
||
server, paths, dest, payload.format, timeout=120,
|
||
)
|
||
if result["exit_code"] != 0:
|
||
err = ((result.get("stderr") or "") + (result.get("stdout") or ""))[:400]
|
||
raise HTTPException(
|
||
status_code=403 if "permission denied" in err.lower() else 502,
|
||
detail=(
|
||
f"压缩失败: {err}"
|
||
if err.strip()
|
||
else "压缩失败。请确认对目标目录有写权限，或配置免密 sudo。"
|
||
),
|
||
)
|
||
|
||
await _audit_sync(
|
||
"file_compress", "server", payload.server_id,
|
||
f"压缩 {len(payload.paths)} 个文件 → {dest}",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {"success": True, "dest": dest, "format": payload.format}
|
||
|
||
|
||
@router.post("/decompress")
|
||
async def decompress_file(
|
||
payload: FileDecompress,
|
||
request: Request,
|
||
admin: Admin = Depends(get_current_admin),
|
||
):
|
||
"""Decompress a tar.gz or zip archive."""
|
||
import shlex
|
||
from server.infrastructure.database.server_repo import ServerRepositoryImpl
|
||
from server.infrastructure.ssh.remote_shell import exec_ssh_command_with_fallback
|
||
|
||
session = request.state.db
|
||
server = await ServerRepositoryImpl(session).get_by_id(payload.server_id)
|
||
if not server:
|
||
raise HTTPException(status_code=404, detail="服务器不存在")
|
||
|
||
try:
|
||
archive_path = normalize_remote_abs_path(payload.path)
|
||
dest_dir = normalize_remote_abs_path(payload.dest)
|
||
except PosixPathError as exc:
|
||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||
|
||
path = shlex.quote(archive_path)
|
||
dest = shlex.quote(dest_dir)
|
||
|
||
if archive_path.endswith(".tar.gz") or archive_path.endswith(".tgz"):
|
||
cmd = f"tar xzf {path} -C {dest}"
|
||
elif archive_path.endswith(".zip"):
|
||
cmd = f"unzip -o {path} -d {dest}"
|
||
else:
|
||
raise HTTPException(status_code=400, detail="仅支持 .tar.gz/.tgz 和 .zip 格式")
|
||
|
||
result = await exec_ssh_command_with_fallback(server, cmd, timeout=120)
|
||
if result["exit_code"] != 0:
|
||
raise HTTPException(status_code=502, detail=f"解压失败: {result['stderr'][:300]}")
|
||
|
||
await _audit_sync(
|
||
"file_decompress", "server", payload.server_id,
|
||
f"解压 {archive_path} → {dest_dir}",
|
||
admin.username, request,
|
||
)
|
||
|
||
return {"success": True, "path": archive_path, "dest": dest_dir}
|