Files
GitMa/backend/app/api/status.py
panw 44921c5646 feat: complete Git Repo Manager MVP implementation
Backend (Phase 1-6):
- Pydantic schemas for request/response validation
- Service layer (SSH Key, Server, Repo, Sync)
- API routes with authentication
- FastAPI main application with lifespan management
- ORM models (SshKey, Server, Repo, SyncLog)

Frontend (Phase 7):
- Vue 3 + Element Plus + Pinia + Vue Router
- API client with Axios and interceptors
- State management stores
- All page components (Dashboard, Servers, Repos, SyncLogs, SshKeys, Settings)

Deployment (Phase 8):
- README with quick start guide
- Startup script (start.sh)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-30 16:30:13 +08:00

139 lines
3.9 KiB
Python

"""
Status API routes.
Provides system status and health check endpoints:
- GET /api/status - Get system status and health information
"""
from typing import Dict, Any
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from sqlalchemy import text
from app.api.deps import get_db_session, require_auth_optional
from app.schemas.common import SuccessResponse
from app.config import get_settings
from app.models.server import Server
from app.models.ssh_key import SshKey
from app.models.repo import Repo
router = APIRouter(prefix="/api/status", tags=["Status"])
@router.get("", response_model=SuccessResponse[Dict[str, Any]])
def get_status(
db: Session = Depends(get_db_session),
_authenticated: bool = Depends(require_auth_optional)
):
"""
Get system status and health information.
This endpoint provides information about:
- Application status and version
- Database connectivity and statistics
- Counts of servers, SSH keys, and repositories
- Storage paths
Authentication is optional for this endpoint.
Authenticated users may receive additional information.
Args:
db: Database session (injected)
_authenticated: Whether request is authenticated (injected)
Returns:
SuccessResponse containing system status information
Example response:
{
"code": 0,
"data": {
"status": "healthy",
"version": "1.0.0",
"database": {
"status": "connected",
"servers_count": 2,
"ssh_keys_count": 3,
"repos_count": 15
},
"storage": {
"data_dir": "/path/to/data",
"repos_dir": "/path/to/data/repos",
"ssh_keys_dir": "/path/to/data/ssh_keys"
},
"authenticated": true
},
"message": "System status retrieved successfully"
}
"""
settings = get_settings()
status_info: Dict[str, Any] = {
"status": "healthy",
"version": "1.0.0",
"authenticated": _authenticated
}
# Check database connectivity
try:
# Execute a simple query to verify database connection
db.execute(text("SELECT 1"))
# Get counts for each model
servers_count = db.query(Server).count()
ssh_keys_count = db.query(SshKey).count()
repos_count = db.query(Repo).count()
status_info["database"] = {
"status": "connected",
"servers_count": servers_count,
"ssh_keys_count": ssh_keys_count,
"repos_count": repos_count
}
except Exception as e:
status_info["database"] = {
"status": "error",
"error": str(e)
}
status_info["status"] = "degraded"
# Storage paths (only show to authenticated users)
if _authenticated:
status_info["storage"] = {
"data_dir": str(settings.data_dir),
"repos_dir": str(settings.repos_dir),
"ssh_keys_dir": str(settings.ssh_keys_dir),
"db_path": str(settings.db_path)
}
return SuccessResponse(
code=0,
data=status_info,
message="System status retrieved successfully"
)
@router.get("/health", response_model=SuccessResponse[Dict[str, str]])
def health_check():
"""
Simple health check endpoint.
This is a lightweight endpoint for load balancers and monitoring systems.
It always returns 200 OK when the service is running.
Returns:
SuccessResponse indicating healthy status
Example response:
{
"code": 0,
"data": {"status": "ok"},
"message": "Service is healthy"
}
"""
return SuccessResponse(
code=0,
data={"status": "ok"},
message="Service is healthy"
)