656 lines
24 KiB
Python
656 lines
24 KiB
Python
from __future__ import annotations
|
|
|
|
from fastapi import APIRouter
|
|
|
|
from app.schemas.common import ApiResponse
|
|
from app.services.ops_agent_service import (
|
|
build_managed_node_handover_bootstrap_plan,
|
|
execute_managed_node_onboarding_bootstrap,
|
|
execute_managed_node_onboarding_acceptance,
|
|
execute_managed_node_onboarding_recovery,
|
|
get_managed_node_delivery_queue,
|
|
get_managed_node_handover,
|
|
get_managed_node_onboarding,
|
|
list_managed_node_delivery_queue_records,
|
|
list_managed_nodes_with_agent_state,
|
|
list_ops_job_events,
|
|
preview_managed_node_onboarding_bootstrap,
|
|
preview_managed_node_onboarding_acceptance,
|
|
preview_managed_node_onboarding_recovery,
|
|
request_managed_node_delivery_queue_action,
|
|
summarize_ops_job_events,
|
|
)
|
|
from app.services.ops_job_service import (
|
|
approve_ops_job,
|
|
cancel_ops_job,
|
|
create_ops_job,
|
|
create_ops_job_batch,
|
|
dispatch_ops_job,
|
|
get_ops_job,
|
|
list_ops_jobs,
|
|
sync_managed_nodes_from_cluster,
|
|
upsert_managed_node,
|
|
)
|
|
from app.services.ops_migration_service import (
|
|
execute_ops_migration,
|
|
get_ops_migration_source_profile,
|
|
preview_ops_migration,
|
|
)
|
|
from app.services.ops_playbook_service import (
|
|
cancel_ops_playbook_run,
|
|
execute_ops_playbook,
|
|
get_ops_playbook_run,
|
|
get_ops_playbooks,
|
|
get_recent_ops_playbook_runs,
|
|
list_ops_playbook_run_events,
|
|
preview_ops_playbook,
|
|
rerun_ops_playbook_run,
|
|
)
|
|
from app.services.ops_policy_service import preview_ops_job_policy
|
|
from app.services.ops_service import (
|
|
execute_codex_action,
|
|
execute_resolved_driver_action,
|
|
get_ops_activity_stream,
|
|
get_ops_codex_brief,
|
|
get_ops_contract_detail,
|
|
get_ops_contract_registry,
|
|
get_ops_doctor_decision,
|
|
get_ops_driver_feed,
|
|
get_ops_go_live_summary,
|
|
get_ops_go_live_signoff,
|
|
get_ops_go_live_bundle,
|
|
get_ops_go_live_review,
|
|
get_ops_link_snapshot,
|
|
get_ops_node_scene_log,
|
|
get_ops_stack_diagnosis,
|
|
execute_driver_action,
|
|
preview_driver_action,
|
|
resolve_codex_action,
|
|
resolve_driver_action_request,
|
|
resolve_ops_runbook_sequence,
|
|
execute_ops_runbook_sequence,
|
|
get_ops_blueprint,
|
|
get_ops_capabilities,
|
|
get_ops_inspection_overview,
|
|
get_ops_overview,
|
|
get_ops_runbook,
|
|
)
|
|
from app.services.ops_template_service import get_ops_action_templates
|
|
|
|
router = APIRouter(tags=["ops"])
|
|
|
|
|
|
@router.get("/ops/overview", response_model=ApiResponse)
|
|
def ops_overview() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_overview())
|
|
|
|
|
|
@router.get("/ops/migration/source-profile", response_model=ApiResponse)
|
|
def ops_migration_source_profile() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_migration_source_profile())
|
|
|
|
|
|
@router.post("/ops/migration/preview", response_model=ApiResponse)
|
|
def ops_migration_preview(payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = preview_ops_migration(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/migration/execute", response_model=ApiResponse)
|
|
def ops_migration_execute(payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = execute_ops_migration(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.get("/ops/link-snapshot", response_model=ApiResponse)
|
|
def ops_link_snapshot() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_link_snapshot())
|
|
|
|
|
|
@router.get("/ops/stack-diagnosis", response_model=ApiResponse)
|
|
def ops_stack_diagnosis(base_url: str = "") -> ApiResponse:
|
|
return ApiResponse(data=get_ops_stack_diagnosis(base_url=base_url))
|
|
|
|
|
|
@router.get("/ops/go-live-summary", response_model=ApiResponse)
|
|
def ops_go_live_summary(base_url: str = "") -> ApiResponse:
|
|
return ApiResponse(data=get_ops_go_live_summary(base_url=base_url))
|
|
|
|
|
|
@router.get("/ops/doctor-decision", response_model=ApiResponse)
|
|
def ops_doctor_decision(base_url: str = "", report_dir: str = "") -> ApiResponse:
|
|
return ApiResponse(data=get_ops_doctor_decision(base_url=base_url, report_dir=report_dir))
|
|
|
|
|
|
@router.get("/ops/go-live-signoff", response_model=ApiResponse)
|
|
def ops_go_live_signoff(base_url: str = "", report_dir: str = "") -> ApiResponse:
|
|
return ApiResponse(data=get_ops_go_live_signoff(base_url=base_url, report_dir=report_dir))
|
|
|
|
|
|
@router.get("/ops/go-live-bundle", response_model=ApiResponse)
|
|
def ops_go_live_bundle(base_url: str = "", report_dir: str = "") -> ApiResponse:
|
|
return ApiResponse(data=get_ops_go_live_bundle(base_url=base_url, report_dir=report_dir))
|
|
|
|
|
|
@router.get("/ops/go-live-review", response_model=ApiResponse)
|
|
def ops_go_live_review(base_url: str = "", report_dir: str = "") -> ApiResponse:
|
|
return ApiResponse(data=get_ops_go_live_review(base_url=base_url, report_dir=report_dir))
|
|
|
|
|
|
@router.get("/ops/inspection-overview", response_model=ApiResponse)
|
|
def ops_inspection_overview(
|
|
limit: int = 80,
|
|
status: str = "",
|
|
problem_kind: str = "",
|
|
query: str = "",
|
|
only_problem: bool = False,
|
|
only_participating: bool = False,
|
|
) -> ApiResponse:
|
|
return ApiResponse(
|
|
data=get_ops_inspection_overview(
|
|
fetch_limit=limit,
|
|
status=status,
|
|
problem_kind=problem_kind,
|
|
query=query,
|
|
only_problem=only_problem,
|
|
only_participating=only_participating,
|
|
)
|
|
)
|
|
|
|
|
|
@router.get("/ops/activity-stream", response_model=ApiResponse)
|
|
def ops_activity_stream(
|
|
limit: int = 18,
|
|
kind: str = "",
|
|
status: str = "",
|
|
execution_mode: str = "",
|
|
query: str = "",
|
|
) -> ApiResponse:
|
|
return ApiResponse(
|
|
data=get_ops_activity_stream(
|
|
limit=limit,
|
|
kind=kind,
|
|
status=status,
|
|
execution_mode=execution_mode,
|
|
query=query,
|
|
)
|
|
)
|
|
|
|
|
|
@router.get("/ops/driver-feed", response_model=ApiResponse)
|
|
def ops_driver_feed() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_driver_feed())
|
|
|
|
|
|
@router.get("/ops/codex-brief", response_model=ApiResponse)
|
|
def ops_codex_brief() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_codex_brief())
|
|
|
|
|
|
@router.get("/ops/capabilities", response_model=ApiResponse)
|
|
def ops_capabilities() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_capabilities())
|
|
|
|
|
|
@router.get("/ops/contracts", response_model=ApiResponse)
|
|
def ops_contracts() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_contract_registry())
|
|
|
|
|
|
@router.get("/ops/contracts/{contract_key}", response_model=ApiResponse)
|
|
def ops_contract_detail(contract_key: str) -> ApiResponse:
|
|
data = get_ops_contract_detail(contract_key)
|
|
if not data:
|
|
return ApiResponse(code=1, message="contract 不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.get("/ops/action-templates", response_model=ApiResponse)
|
|
def ops_action_templates() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_action_templates())
|
|
|
|
|
|
@router.get("/ops/playbooks", response_model=ApiResponse)
|
|
def ops_playbooks() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_playbooks())
|
|
|
|
|
|
@router.get("/ops/playbook-runs", response_model=ApiResponse)
|
|
def ops_playbook_runs(
|
|
limit: int = 12,
|
|
status: str = "",
|
|
group_key: str = "",
|
|
query: str = "",
|
|
) -> ApiResponse:
|
|
return ApiResponse(
|
|
data=get_recent_ops_playbook_runs(
|
|
limit=limit,
|
|
status=status,
|
|
group_key=group_key,
|
|
query=query,
|
|
)
|
|
)
|
|
|
|
|
|
@router.get("/ops/playbook-runs/{run_code}", response_model=ApiResponse)
|
|
def ops_playbook_run_detail(run_code: str) -> ApiResponse:
|
|
data = get_ops_playbook_run(run_code)
|
|
if not data:
|
|
return ApiResponse(code=1, message="playbook run 不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.get("/ops/playbook-runs/{run_code}/events", response_model=ApiResponse)
|
|
def ops_playbook_run_events(
|
|
run_code: str,
|
|
limit: int = 80,
|
|
step_key: str = "",
|
|
node_code: str = "",
|
|
) -> ApiResponse:
|
|
data = list_ops_playbook_run_events(
|
|
run_code,
|
|
limit=limit,
|
|
step_key=step_key,
|
|
node_code=node_code,
|
|
)
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.post("/ops/playbook-runs/{run_code}/rerun", response_model=ApiResponse)
|
|
def ops_playbook_run_rerun(run_code: str, payload: dict | None = None) -> ApiResponse:
|
|
payload = payload or {}
|
|
ok, message, data = rerun_ops_playbook_run(
|
|
run_code,
|
|
requested_by=str(payload.get("requested_by") or "api").strip() or "api",
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/playbook-runs/{run_code}/cancel", response_model=ApiResponse)
|
|
def ops_playbook_run_cancel(run_code: str, payload: dict | None = None) -> ApiResponse:
|
|
payload = payload or {}
|
|
ok, message, data = cancel_ops_playbook_run(
|
|
run_code,
|
|
cancelled_by=str(payload.get("cancelled_by") or "api").strip() or "api",
|
|
reason=str(payload.get("reason") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/playbooks/preview", response_model=ApiResponse)
|
|
def ops_playbook_preview(payload: dict) -> ApiResponse:
|
|
ok, message, data = preview_ops_playbook(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/playbooks/execute", response_model=ApiResponse)
|
|
def ops_playbook_execute(payload: dict) -> ApiResponse:
|
|
ok, message, data = execute_ops_playbook(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.get("/ops/blueprint", response_model=ApiResponse)
|
|
def ops_blueprint() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_blueprint())
|
|
|
|
|
|
@router.get("/ops/runbook", response_model=ApiResponse)
|
|
def ops_runbook() -> ApiResponse:
|
|
return ApiResponse(data=get_ops_runbook())
|
|
|
|
|
|
@router.post("/ops/runbook/sequences/{sequence_key}/resolve", response_model=ApiResponse)
|
|
def ops_runbook_sequence_resolve(sequence_key: str, payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = resolve_ops_runbook_sequence(sequence_key, payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/runbook/sequences/{sequence_key}/execute", response_model=ApiResponse)
|
|
def ops_runbook_sequence_execute(sequence_key: str, payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = execute_ops_runbook_sequence(sequence_key, payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.get("/ops/nodes", response_model=ApiResponse)
|
|
def ops_nodes() -> ApiResponse:
|
|
return ApiResponse(data=list_managed_nodes_with_agent_state())
|
|
|
|
|
|
@router.get("/ops/nodes/{node_code}/handover", response_model=ApiResponse)
|
|
def ops_node_handover(
|
|
node_code: str,
|
|
control_plane_base_url: str = "",
|
|
root_dir: str = "",
|
|
) -> ApiResponse:
|
|
data = get_managed_node_handover(
|
|
node_code,
|
|
control_plane_base_url=control_plane_base_url,
|
|
root_dir=root_dir,
|
|
)
|
|
if not data:
|
|
return ApiResponse(code=1, message="节点不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.get("/ops/nodes/{node_code}/onboarding", response_model=ApiResponse)
|
|
def ops_node_onboarding(
|
|
node_code: str,
|
|
control_plane_base_url: str = "",
|
|
root_dir: str = "",
|
|
) -> ApiResponse:
|
|
data = get_managed_node_onboarding(
|
|
node_code,
|
|
control_plane_base_url=control_plane_base_url,
|
|
root_dir=root_dir,
|
|
)
|
|
if not data:
|
|
return ApiResponse(code=1, message="节点不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/onboarding/acceptance/preview", response_model=ApiResponse)
|
|
def ops_node_onboarding_acceptance_preview(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = preview_managed_node_onboarding_acceptance(
|
|
node_code=node_code,
|
|
requested_by=str(normalized_payload.get("requested_by") or "api").strip() or "api",
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/onboarding/bootstrap/preview", response_model=ApiResponse)
|
|
def ops_node_onboarding_bootstrap_preview(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = preview_managed_node_onboarding_bootstrap(
|
|
node_code=node_code,
|
|
requested_by=str(normalized_payload.get("requested_by") or "api").strip() or "api",
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/onboarding/bootstrap/execute", response_model=ApiResponse)
|
|
def ops_node_onboarding_bootstrap_execute(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = execute_managed_node_onboarding_bootstrap(
|
|
node_code=node_code,
|
|
requested_by=str(normalized_payload.get("requested_by") or "api").strip() or "api",
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/onboarding/acceptance/execute", response_model=ApiResponse)
|
|
def ops_node_onboarding_acceptance_execute(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = execute_managed_node_onboarding_acceptance(
|
|
node_code=node_code,
|
|
requested_by=str(normalized_payload.get("requested_by") or "api").strip() or "api",
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/onboarding/recovery/preview", response_model=ApiResponse)
|
|
def ops_node_onboarding_recovery_preview(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = preview_managed_node_onboarding_recovery(
|
|
node_code=node_code,
|
|
requested_by=str(normalized_payload.get("requested_by") or "api").strip() or "api",
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/onboarding/recovery/execute", response_model=ApiResponse)
|
|
def ops_node_onboarding_recovery_execute(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = execute_managed_node_onboarding_recovery(
|
|
node_code=node_code,
|
|
requested_by=str(normalized_payload.get("requested_by") or "api").strip() or "api",
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.get("/ops/nodes/{node_code}/scene-log", response_model=ApiResponse)
|
|
def ops_node_scene_log(
|
|
node_code: str,
|
|
limit: int = 80,
|
|
mode: str = "",
|
|
) -> ApiResponse:
|
|
data = get_ops_node_scene_log(node_code, limit=limit, mode=mode)
|
|
if not data:
|
|
return ApiResponse(code=1, message="节点不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/handover/bootstrap-plan", response_model=ApiResponse)
|
|
def ops_node_handover_bootstrap_plan(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
normalized_payload = payload or {}
|
|
ok, message, data = build_managed_node_handover_bootstrap_plan(
|
|
node_code=node_code,
|
|
issued_by=str(normalized_payload.get("issued_by") or "api").strip() or "api",
|
|
expires_in_hours=int(normalized_payload.get("expires_in_hours") or 72),
|
|
control_plane_base_url=str(normalized_payload.get("control_plane_base_url") or "").strip(),
|
|
root_dir=str(normalized_payload.get("root_dir") or "").strip(),
|
|
metadata=normalized_payload.get("metadata") or {},
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.get("/ops/nodes/{node_code}/delivery-queue", response_model=ApiResponse)
|
|
def ops_node_delivery_queue(node_code: str) -> ApiResponse:
|
|
data = get_managed_node_delivery_queue(node_code)
|
|
if not data:
|
|
return ApiResponse(code=1, message="节点不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.get("/ops/nodes/{node_code}/delivery-queue/records", response_model=ApiResponse)
|
|
def ops_node_delivery_queue_records(
|
|
node_code: str,
|
|
state: str = "",
|
|
limit: int = 50,
|
|
) -> ApiResponse:
|
|
data = list_managed_node_delivery_queue_records(
|
|
node_code,
|
|
state=state,
|
|
limit=limit,
|
|
)
|
|
if not data:
|
|
return ApiResponse(code=1, message="节点不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/delivery-queue/flush", response_model=ApiResponse)
|
|
def ops_node_delivery_queue_flush(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = request_managed_node_delivery_queue_action(
|
|
node_code,
|
|
"delivery.queue.flush",
|
|
payload=payload or {},
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/delivery-queue/replay", response_model=ApiResponse)
|
|
def ops_node_delivery_queue_replay(node_code: str, payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = request_managed_node_delivery_queue_action(
|
|
node_code,
|
|
"delivery.queue.replay",
|
|
payload=payload or {},
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/delivery-queue/records/{record_id}/replay", response_model=ApiResponse)
|
|
def ops_node_delivery_queue_record_replay(
|
|
node_code: str,
|
|
record_id: str,
|
|
payload: dict | None = None,
|
|
) -> ApiResponse:
|
|
ok, message, data = request_managed_node_delivery_queue_action(
|
|
node_code,
|
|
"delivery.queue.replay",
|
|
payload=payload or {},
|
|
record_id=record_id,
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/{node_code}/delivery-queue/records/{record_id}/discard", response_model=ApiResponse)
|
|
def ops_node_delivery_queue_record_discard(
|
|
node_code: str,
|
|
record_id: str,
|
|
payload: dict | None = None,
|
|
) -> ApiResponse:
|
|
ok, message, data = request_managed_node_delivery_queue_action(
|
|
node_code,
|
|
"delivery.queue.discard",
|
|
payload=payload or {},
|
|
record_id=record_id,
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes", response_model=ApiResponse)
|
|
def ops_nodes_upsert(payload: dict) -> ApiResponse:
|
|
ok, message, data = upsert_managed_node(payload)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/nodes/sync-from-cluster", response_model=ApiResponse)
|
|
def ops_nodes_sync_from_cluster(dry_run: bool = False) -> ApiResponse:
|
|
return ApiResponse(data=sync_managed_nodes_from_cluster(dry_run=dry_run))
|
|
|
|
|
|
@router.get("/ops/jobs", response_model=ApiResponse)
|
|
def ops_jobs(limit: int = 20, compact: bool = True, rollout_id: int = 0) -> ApiResponse:
|
|
normalized_rollout_id = int(rollout_id or 0)
|
|
jobs = list_ops_jobs(
|
|
limit=limit,
|
|
compact=compact,
|
|
rollout_id=normalized_rollout_id if normalized_rollout_id > 0 else None,
|
|
)
|
|
page_status_counts: dict[str, int] = {}
|
|
for item in jobs:
|
|
item_status = str(item.get("status") or "").strip() or "unknown"
|
|
page_status_counts[item_status] = int(page_status_counts.get(item_status, 0) or 0) + 1
|
|
return ApiResponse(
|
|
data={
|
|
"jobs": jobs,
|
|
"filters": {
|
|
"limit": int(limit or 20),
|
|
"compact": bool(compact),
|
|
"rollout_id": normalized_rollout_id,
|
|
},
|
|
"page_summary": {
|
|
"jobs_total": len(jobs),
|
|
"status_counts": page_status_counts,
|
|
},
|
|
}
|
|
)
|
|
|
|
|
|
@router.get("/ops/jobs/{job_id}", response_model=ApiResponse)
|
|
def ops_job_detail(job_id: int) -> ApiResponse:
|
|
data = get_ops_job(job_id)
|
|
if not data:
|
|
return ApiResponse(code=1, message="任务不存在", data={})
|
|
return ApiResponse(data=data)
|
|
|
|
|
|
@router.get("/ops/jobs/{job_id}/events", response_model=ApiResponse)
|
|
def ops_job_events(job_id: int, limit: int = 50) -> ApiResponse:
|
|
events = list_ops_job_events(job_id, limit=limit)
|
|
return ApiResponse(
|
|
data={
|
|
"events": events,
|
|
"summary": summarize_ops_job_events(events, job_id=job_id, limit=limit),
|
|
}
|
|
)
|
|
|
|
|
|
@router.post("/ops/driver-actions/execute", response_model=ApiResponse)
|
|
def ops_driver_action_execute(payload: dict) -> ApiResponse:
|
|
ok, message, data = execute_driver_action(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/driver-actions/preview", response_model=ApiResponse)
|
|
def ops_driver_action_preview(payload: dict) -> ApiResponse:
|
|
ok, message, data = preview_driver_action(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/driver-actions/resolve", response_model=ApiResponse)
|
|
def ops_driver_action_resolve(payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = resolve_driver_action_request(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/driver-actions/execute-resolved", response_model=ApiResponse)
|
|
def ops_driver_action_execute_resolved(payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = execute_resolved_driver_action(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/codex-actions/resolve", response_model=ApiResponse)
|
|
def ops_codex_action_resolve(payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = resolve_codex_action(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/codex-actions/execute", response_model=ApiResponse)
|
|
def ops_codex_action_execute(payload: dict | None = None) -> ApiResponse:
|
|
ok, message, data = execute_codex_action(payload or {})
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/jobs", response_model=ApiResponse)
|
|
def ops_jobs_create(payload: dict) -> ApiResponse:
|
|
ok, message, data = create_ops_job(payload)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/jobs/batch", response_model=ApiResponse)
|
|
def ops_jobs_create_batch(payload: dict) -> ApiResponse:
|
|
ok, message, data = create_ops_job_batch(payload)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/policy/preview", response_model=ApiResponse)
|
|
def ops_policy_preview(payload: dict) -> ApiResponse:
|
|
return ApiResponse(data=preview_ops_job_policy(payload))
|
|
|
|
|
|
@router.post("/ops/jobs/{job_id}/approve", response_model=ApiResponse)
|
|
def ops_job_approve(job_id: int, payload: dict | None = None) -> ApiResponse:
|
|
payload = payload or {}
|
|
ok, message, data = approve_ops_job(job_id, approved_by=str(payload.get("approved_by") or "api").strip() or "api")
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/jobs/{job_id}/cancel", response_model=ApiResponse)
|
|
def ops_job_cancel(job_id: int, payload: dict | None = None) -> ApiResponse:
|
|
payload = payload or {}
|
|
ok, message, data = cancel_ops_job(
|
|
job_id,
|
|
cancelled_by=str(payload.get("cancelled_by") or "api").strip() or "api",
|
|
reason=str(payload.get("reason") or "").strip(),
|
|
)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|
|
|
|
|
|
@router.post("/ops/jobs/{job_id}/dispatch", response_model=ApiResponse)
|
|
def ops_job_dispatch(job_id: int) -> ApiResponse:
|
|
ok, message, data = dispatch_ops_job(job_id)
|
|
return ApiResponse(code=0 if ok else 1, message=message, data=data)
|