PapaTramp
cd2f27792d
Add agent update settings, pending self-update via poll, desired config per host, and automatic or manual SSH/WinRM fallback when agents do not report agent.update events.
505 lines
17 KiB
Python
505 lines
17 KiB
Python
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from pydantic import BaseModel
|
|
from sqlalchemy import func, select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from datetime import datetime, timezone
|
|
|
|
from app.auth.jwt_auth import get_current_user, require_admin
|
|
from app.config import get_settings
|
|
from app.database import get_db
|
|
from app.models import Event, Host
|
|
from app.schemas.list_models import HostDetail, HostListResponse, HostSummary
|
|
from app.services.agent_version import latest_agent_versions_by_product
|
|
from app.services.agent_update import (
|
|
AgentUpdateNotAllowedError,
|
|
execute_agent_update_fallback,
|
|
host_version_status,
|
|
request_agent_update,
|
|
)
|
|
from app.services.agent_update_settings import get_effective_agent_update_config
|
|
from app.services.agent_host_config import get_host_agent_settings, update_host_agent_config
|
|
from app.services.host_delete import delete_host_and_related
|
|
from app.services.linux_admin_settings import get_effective_linux_admin_config
|
|
from app.services.win_admin_settings import get_effective_win_admin_config
|
|
from app.services.winrm_connect import (
|
|
HostNotWindowsError,
|
|
HostTargetMissingError,
|
|
WinAdminNotConfiguredError,
|
|
WinRmTestResult,
|
|
iter_winrm_targets,
|
|
test_winrm_connection,
|
|
)
|
|
from app.services.ssh_connect import (
|
|
HostNotLinuxError as SshHostNotLinuxError,
|
|
HostTargetMissingError as SshHostTargetMissingError,
|
|
LinuxAdminNotConfiguredError,
|
|
SshCommandResult,
|
|
iter_ssh_targets,
|
|
run_ssh_monitor_update,
|
|
test_ssh_connection,
|
|
)
|
|
from app.services.host_health import (
|
|
HEARTBEAT_TYPE,
|
|
agent_status as compute_agent_status,
|
|
apply_agent_status_host_filter,
|
|
max_daily_report_time_by_host,
|
|
max_event_time_by_host,
|
|
)
|
|
|
|
router = APIRouter(prefix="/hosts", tags=["hosts"])
|
|
|
|
|
|
@router.get("", response_model=HostListResponse)
|
|
def list_hosts(
|
|
page: int = Query(1, ge=1),
|
|
page_size: int = Query(50, ge=1, le=200),
|
|
product: str | None = None,
|
|
hostname: str | None = None,
|
|
agent_status: str | None = Query(None, pattern="^(online|stale|unknown)$"),
|
|
db: Session = Depends(get_db),
|
|
_user: str = Depends(get_current_user),
|
|
) -> HostListResponse:
|
|
stmt = select(Host)
|
|
count_stmt = select(func.count()).select_from(Host)
|
|
|
|
if product:
|
|
stmt = stmt.where(Host.product == product)
|
|
count_stmt = count_stmt.where(Host.product == product)
|
|
if hostname:
|
|
like = f"%{hostname}%"
|
|
host_match = Host.hostname.ilike(like) | Host.display_name.ilike(like)
|
|
stmt = stmt.where(host_match)
|
|
count_stmt = count_stmt.where(host_match)
|
|
|
|
settings = get_settings()
|
|
if agent_status:
|
|
stmt, count_stmt = apply_agent_status_host_filter(
|
|
stmt,
|
|
count_stmt,
|
|
agent_status,
|
|
stale_minutes=settings.sac_heartbeat_stale_minutes,
|
|
)
|
|
|
|
total = db.scalar(count_stmt) or 0
|
|
rows = db.scalars(
|
|
stmt.order_by(Host.last_seen_at.desc())
|
|
.offset((page - 1) * page_size)
|
|
.limit(page_size)
|
|
).all()
|
|
|
|
hb_map = max_event_time_by_host(db, HEARTBEAT_TYPE)
|
|
report_map = max_daily_report_time_by_host(db)
|
|
latest_map = latest_agent_versions_by_product(db)
|
|
update_cfg = get_effective_agent_update_config(db)
|
|
|
|
items: list[HostSummary] = []
|
|
for host in rows:
|
|
event_count = db.scalar(
|
|
select(func.count()).select_from(Event).where(Event.host_id == host.id)
|
|
)
|
|
last_hb = hb_map.get(host.id)
|
|
items.append(
|
|
HostSummary(
|
|
id=host.id,
|
|
hostname=host.hostname,
|
|
display_name=host.display_name,
|
|
os_family=host.os_family,
|
|
os_version=host.os_version,
|
|
product=host.product,
|
|
product_version=host.product_version,
|
|
ipv4=host.ipv4,
|
|
last_seen_at=host.last_seen_at,
|
|
event_count=int(event_count or 0),
|
|
last_heartbeat_at=last_hb,
|
|
last_daily_report_at=report_map.get(host.id),
|
|
last_inventory_at=host.inventory_updated_at,
|
|
agent_status=compute_agent_status(
|
|
last_hb, stale_minutes=settings.sac_heartbeat_stale_minutes
|
|
),
|
|
version_status=host_version_status(host, cfg=update_cfg, latest_map=latest_map),
|
|
pending_agent_update=bool(host.pending_agent_update),
|
|
)
|
|
)
|
|
|
|
return HostListResponse(
|
|
items=items,
|
|
total=total,
|
|
page=page,
|
|
page_size=page_size,
|
|
latest_agent_versions=latest_agent_versions_by_product(db),
|
|
)
|
|
|
|
|
|
def _host_detail_from_model(
|
|
host: Host,
|
|
*,
|
|
db: Session,
|
|
settings,
|
|
) -> HostDetail:
|
|
hb_map = max_event_time_by_host(db, HEARTBEAT_TYPE)
|
|
report_map = max_daily_report_time_by_host(db)
|
|
event_count = db.scalar(
|
|
select(func.count()).select_from(Event).where(Event.host_id == host.id)
|
|
)
|
|
last_hb = hb_map.get(host.id)
|
|
latest_map = latest_agent_versions_by_product(db)
|
|
update_cfg = get_effective_agent_update_config(db)
|
|
return HostDetail(
|
|
id=host.id,
|
|
hostname=host.hostname,
|
|
display_name=host.display_name,
|
|
os_family=host.os_family,
|
|
os_version=host.os_version,
|
|
product=host.product,
|
|
product_version=host.product_version,
|
|
ipv4=host.ipv4,
|
|
ipv6=host.ipv6,
|
|
last_seen_at=host.last_seen_at,
|
|
event_count=int(event_count or 0),
|
|
last_heartbeat_at=last_hb,
|
|
last_daily_report_at=report_map.get(host.id),
|
|
last_inventory_at=host.inventory_updated_at,
|
|
agent_status=compute_agent_status(last_hb, stale_minutes=settings.sac_heartbeat_stale_minutes),
|
|
version_status=host_version_status(host, cfg=update_cfg, latest_map=latest_map),
|
|
pending_agent_update=bool(host.pending_agent_update),
|
|
agent_instance_id=host.agent_instance_id,
|
|
tags=host.tags if isinstance(host.tags, list) else [],
|
|
use_sac_mode=host.use_sac_mode,
|
|
inventory=host.inventory if isinstance(host.inventory, dict) else None,
|
|
inventory_updated_at=host.inventory_updated_at,
|
|
created_at=host.created_at,
|
|
ssh_admin_ok=host.ssh_admin_ok,
|
|
ssh_admin_checked_at=host.ssh_admin_checked_at,
|
|
pending_update_requested_at=host.pending_update_requested_at,
|
|
pending_update_target_version=host.pending_update_target_version,
|
|
agent_config_revision=int(host.agent_config_revision or 0),
|
|
agent_config=get_host_agent_settings(host) or None,
|
|
agent_update_state=host.agent_update_state,
|
|
agent_update_last_at=host.agent_update_last_at,
|
|
agent_update_last_error=host.agent_update_last_error,
|
|
)
|
|
|
|
|
|
def _set_ssh_admin_status(host: Host, ok: bool) -> None:
|
|
host.ssh_admin_ok = ok
|
|
host.ssh_admin_checked_at = datetime.now(timezone.utc)
|
|
|
|
|
|
@router.get("/{host_id}", response_model=HostDetail)
|
|
def get_host(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user: str = Depends(get_current_user),
|
|
) -> HostDetail:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
settings = get_settings()
|
|
return _host_detail_from_model(host, db=db, settings=settings)
|
|
|
|
|
|
class HostDeleteResponse(BaseModel):
|
|
status: str
|
|
host_id: int
|
|
hostname: str
|
|
deleted_events: int
|
|
deleted_problems: int
|
|
|
|
|
|
class HostWinRmTestResponse(BaseModel):
|
|
ok: bool
|
|
message: str
|
|
target: str
|
|
hostname: str | None = None
|
|
|
|
|
|
class HostSshActionResponse(BaseModel):
|
|
ok: bool
|
|
message: str
|
|
target: str
|
|
stdout: str | None = None
|
|
stderr: str | None = None
|
|
exit_code: int | None = None
|
|
product_version: str | None = None
|
|
ssh_admin_ok: bool | None = None
|
|
|
|
|
|
class HostAgentUpdateRequestResponse(BaseModel):
|
|
status: str
|
|
pending_agent_update: bool
|
|
target_version: str | None = None
|
|
agent_update_state: str | None = None
|
|
|
|
|
|
class HostAgentConfigUpdate(BaseModel):
|
|
settings: dict[str, object] = {}
|
|
|
|
|
|
class HostAgentConfigResponse(BaseModel):
|
|
config_revision: int
|
|
settings: dict[str, object]
|
|
|
|
|
|
def _ssh_action_response(
|
|
result: SshCommandResult,
|
|
*,
|
|
attempts: list[str] | None = None,
|
|
ssh_admin_ok: bool | None = None,
|
|
) -> HostSshActionResponse:
|
|
message = result.message
|
|
if attempts:
|
|
message = f"{message} (пробовали: {', '.join(attempts)})"
|
|
return HostSshActionResponse(
|
|
ok=result.ok,
|
|
message=message,
|
|
target=result.target,
|
|
stdout=result.stdout or None,
|
|
stderr=result.stderr or None,
|
|
exit_code=result.exit_code,
|
|
product_version=result.agent_version,
|
|
ssh_admin_ok=ssh_admin_ok,
|
|
)
|
|
|
|
|
|
def _run_ssh_action_on_host(
|
|
host: Host,
|
|
cfg,
|
|
*,
|
|
action,
|
|
) -> HostSshActionResponse:
|
|
try:
|
|
targets = iter_ssh_targets(host)
|
|
except SshHostNotLinuxError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
except SshHostTargetMissingError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
|
|
last_result: SshCommandResult | None = None
|
|
attempts: list[str] = []
|
|
for target in targets:
|
|
try:
|
|
result = action(target=target, user=cfg.user, password=cfg.password)
|
|
except LinuxAdminNotConfiguredError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
except RuntimeError as exc:
|
|
raise HTTPException(status_code=503, detail=str(exc)) from exc
|
|
last_result = result
|
|
attempts.append(f"{target}={'OK' if result.ok else 'fail'}")
|
|
if result.ok:
|
|
return _ssh_action_response(result, attempts=attempts if len(attempts) > 1 else None)
|
|
|
|
assert last_result is not None
|
|
return _ssh_action_response(last_result, attempts=attempts if len(attempts) > 1 else None)
|
|
|
|
|
|
@router.post("/{host_id}/actions/winrm-test", response_model=HostWinRmTestResponse)
|
|
def test_host_winrm(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostWinRmTestResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
|
|
cfg = get_effective_win_admin_config(db)
|
|
if not cfg.configured:
|
|
raise HTTPException(status_code=400, detail="Windows domain admin is not configured")
|
|
|
|
try:
|
|
targets = iter_winrm_targets(host)
|
|
except HostNotWindowsError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
except HostTargetMissingError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
|
|
last_result = None
|
|
attempts: list[str] = []
|
|
for target in targets:
|
|
try:
|
|
result = test_winrm_connection(
|
|
target=target,
|
|
user=cfg.user,
|
|
password=cfg.password,
|
|
)
|
|
except WinAdminNotConfiguredError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
except RuntimeError as exc:
|
|
raise HTTPException(status_code=503, detail=str(exc)) from exc
|
|
last_result = result
|
|
attempts.append(f"{target}={'OK' if result.ok else 'fail'}")
|
|
if result.ok:
|
|
if len(targets) > 1:
|
|
result = WinRmTestResult(
|
|
ok=True,
|
|
message=f"{result.message} (пробовали: {', '.join(attempts)})",
|
|
target=result.target,
|
|
hostname=result.hostname,
|
|
)
|
|
return HostWinRmTestResponse(
|
|
ok=result.ok,
|
|
message=result.message,
|
|
target=result.target,
|
|
hostname=result.hostname,
|
|
)
|
|
|
|
assert last_result is not None
|
|
message = last_result.message
|
|
if len(attempts) > 1:
|
|
message = f"{message} (пробовали: {', '.join(attempts)})"
|
|
return HostWinRmTestResponse(
|
|
ok=False,
|
|
message=message,
|
|
target=last_result.target,
|
|
hostname=last_result.hostname,
|
|
)
|
|
|
|
|
|
@router.post("/{host_id}/actions/ssh-test", response_model=HostSshActionResponse)
|
|
def test_host_ssh(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostSshActionResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
|
|
cfg = get_effective_linux_admin_config(db)
|
|
if not cfg.configured:
|
|
raise HTTPException(status_code=400, detail="Linux SSH admin is not configured")
|
|
|
|
response = _run_ssh_action_on_host(host, cfg, action=test_ssh_connection)
|
|
_set_ssh_admin_status(host, response.ok)
|
|
db.commit()
|
|
return response.model_copy(update={"ssh_admin_ok": host.ssh_admin_ok})
|
|
|
|
|
|
@router.post("/{host_id}/actions/agent-update", response_model=HostSshActionResponse)
|
|
def update_host_agent_via_ssh(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostSshActionResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
|
|
cfg = get_effective_linux_admin_config(db)
|
|
if not cfg.configured:
|
|
raise HTTPException(status_code=400, detail="Linux SSH admin is not configured")
|
|
|
|
response = _run_ssh_action_on_host(host, cfg, action=run_ssh_monitor_update)
|
|
_set_ssh_admin_status(host, response.ok)
|
|
if response.ok and response.product_version:
|
|
host.product_version = response.product_version
|
|
db.commit()
|
|
return response.model_copy(
|
|
update={
|
|
"product_version": host.product_version if response.ok else response.product_version,
|
|
"ssh_admin_ok": host.ssh_admin_ok,
|
|
}
|
|
)
|
|
|
|
|
|
@router.post("/{host_id}/actions/request-agent-update", response_model=HostAgentUpdateRequestResponse)
|
|
def post_request_agent_update(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostAgentUpdateRequestResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
try:
|
|
request_agent_update(db, host)
|
|
except AgentUpdateNotAllowedError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
db.commit()
|
|
return HostAgentUpdateRequestResponse(
|
|
status="requested",
|
|
pending_agent_update=host.pending_agent_update,
|
|
target_version=host.pending_update_target_version,
|
|
agent_update_state=host.agent_update_state,
|
|
)
|
|
|
|
|
|
@router.post("/{host_id}/actions/agent-update-fallback", response_model=HostSshActionResponse)
|
|
def post_agent_update_fallback(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostSshActionResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
|
|
ok, message, version = execute_agent_update_fallback(db, host)
|
|
db.commit()
|
|
return HostSshActionResponse(
|
|
ok=ok,
|
|
message=message,
|
|
target=host.hostname,
|
|
product_version=version or (host.product_version if ok else None),
|
|
ssh_admin_ok=host.ssh_admin_ok,
|
|
)
|
|
|
|
|
|
@router.patch("/{host_id}/agent-config", response_model=HostAgentConfigResponse)
|
|
def patch_host_agent_config(
|
|
host_id: int,
|
|
body: HostAgentConfigUpdate,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostAgentConfigResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
try:
|
|
update_host_agent_config(db, host, body.settings)
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=422, detail=str(exc)) from exc
|
|
db.commit()
|
|
settings = get_host_agent_settings(host)
|
|
return HostAgentConfigResponse(
|
|
config_revision=int(host.agent_config_revision or 0),
|
|
settings=settings,
|
|
)
|
|
|
|
|
|
@router.get("/{host_id}/agent-config", response_model=HostAgentConfigResponse)
|
|
def get_host_agent_config(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostAgentConfigResponse:
|
|
host = db.get(Host, host_id)
|
|
if host is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
settings = get_host_agent_settings(host)
|
|
return HostAgentConfigResponse(
|
|
config_revision=int(host.agent_config_revision or 0),
|
|
settings=settings,
|
|
)
|
|
|
|
|
|
@router.delete("/{host_id}", response_model=HostDeleteResponse)
|
|
def delete_host(
|
|
host_id: int,
|
|
db: Session = Depends(get_db),
|
|
_user=Depends(require_admin),
|
|
) -> HostDeleteResponse:
|
|
result = delete_host_and_related(db, host_id)
|
|
if result is None:
|
|
raise HTTPException(status_code=404, detail="Host not found")
|
|
db.commit()
|
|
return HostDeleteResponse(
|
|
status="deleted",
|
|
host_id=result.host_id,
|
|
hostname=result.hostname,
|
|
deleted_events=result.deleted_events,
|
|
deleted_problems=result.deleted_problems,
|
|
)
|
|
|