254 lines
7.9 KiB
Python
254 lines
7.9 KiB
Python
"""
|
|
Demo Operations API - Business operations for demo session management
|
|
"""
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Path
|
|
import structlog
|
|
import jwt
|
|
from datetime import datetime, timezone
|
|
|
|
from app.api.schemas import DemoSessionResponse, DemoSessionStats
|
|
from app.services import DemoSessionManager, DemoCleanupService
|
|
from app.core import get_db, get_redis, DemoRedisWrapper
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from shared.routing import RouteBuilder
|
|
|
|
router = APIRouter(tags=["demo-operations"])
|
|
logger = structlog.get_logger()
|
|
|
|
route_builder = RouteBuilder('demo')
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_resource_action_route("sessions", "session_id", "extend", include_tenant_prefix=False),
|
|
response_model=DemoSessionResponse
|
|
)
|
|
async def extend_demo_session(
|
|
session_id: str = Path(...),
|
|
db: AsyncSession = Depends(get_db),
|
|
redis: DemoRedisWrapper = Depends(get_redis)
|
|
):
|
|
"""Extend demo session expiration (BUSINESS OPERATION)"""
|
|
try:
|
|
session_manager = DemoSessionManager(db, redis)
|
|
session = await session_manager.extend_session(session_id)
|
|
|
|
session_token = jwt.encode(
|
|
{
|
|
"session_id": session.session_id,
|
|
"virtual_tenant_id": str(session.virtual_tenant_id),
|
|
"demo_account_type": session.demo_account_type,
|
|
"exp": session.expires_at.timestamp()
|
|
},
|
|
"demo-secret-key",
|
|
algorithm="HS256"
|
|
)
|
|
|
|
return {
|
|
"session_id": session.session_id,
|
|
"virtual_tenant_id": str(session.virtual_tenant_id),
|
|
"demo_account_type": session.demo_account_type,
|
|
"status": session.status.value,
|
|
"created_at": session.created_at,
|
|
"expires_at": session.expires_at,
|
|
"demo_config": session.session_metadata.get("demo_config", {}),
|
|
"session_token": session_token
|
|
}
|
|
|
|
except ValueError as e:
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
except Exception as e:
|
|
logger.error("Failed to extend session", error=str(e))
|
|
raise HTTPException(status_code=500, detail=str(e))
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_base_route("stats", include_tenant_prefix=False),
|
|
response_model=DemoSessionStats
|
|
)
|
|
async def get_demo_stats(
|
|
db: AsyncSession = Depends(get_db),
|
|
redis: DemoRedisWrapper = Depends(get_redis)
|
|
):
|
|
"""Get demo session statistics (BUSINESS OPERATION)"""
|
|
session_manager = DemoSessionManager(db, redis)
|
|
stats = await session_manager.get_session_stats()
|
|
return stats
|
|
|
|
|
|
@router.post(
|
|
route_builder.build_operations_route("cleanup", include_tenant_prefix=False),
|
|
response_model=dict
|
|
)
|
|
async def run_cleanup(
|
|
db: AsyncSession = Depends(get_db),
|
|
redis: DemoRedisWrapper = Depends(get_redis)
|
|
):
|
|
"""
|
|
Trigger session cleanup via background worker (async via Redis queue)
|
|
|
|
Returns immediately after enqueuing work - does not block
|
|
"""
|
|
from datetime import timedelta
|
|
from sqlalchemy import select
|
|
from app.models.demo_session import DemoSession, DemoSessionStatus
|
|
import uuid
|
|
import json
|
|
|
|
logger.info("Starting demo session cleanup enqueue")
|
|
|
|
now = datetime.now(timezone.utc)
|
|
stuck_threshold = now - timedelta(minutes=5)
|
|
|
|
# Find expired sessions
|
|
result = await db.execute(
|
|
select(DemoSession).where(
|
|
DemoSession.status.in_([
|
|
DemoSessionStatus.PENDING,
|
|
DemoSessionStatus.READY,
|
|
DemoSessionStatus.PARTIAL,
|
|
DemoSessionStatus.FAILED,
|
|
DemoSessionStatus.ACTIVE
|
|
]),
|
|
DemoSession.expires_at < now
|
|
)
|
|
)
|
|
expired_sessions = result.scalars().all()
|
|
|
|
# Find stuck sessions
|
|
stuck_result = await db.execute(
|
|
select(DemoSession).where(
|
|
DemoSession.status == DemoSessionStatus.PENDING,
|
|
DemoSession.created_at < stuck_threshold
|
|
)
|
|
)
|
|
stuck_sessions = stuck_result.scalars().all()
|
|
|
|
all_sessions = list(expired_sessions) + list(stuck_sessions)
|
|
|
|
if not all_sessions:
|
|
return {
|
|
"status": "no_sessions",
|
|
"message": "No sessions to cleanup",
|
|
"total_expired": 0,
|
|
"total_stuck": 0
|
|
}
|
|
|
|
# Create cleanup job
|
|
job_id = str(uuid.uuid4())
|
|
session_ids = [s.session_id for s in all_sessions]
|
|
|
|
job_data = {
|
|
"job_id": job_id,
|
|
"session_ids": session_ids,
|
|
"created_at": now.isoformat(),
|
|
"retry_count": 0
|
|
}
|
|
|
|
# Enqueue job
|
|
client = await redis.get_client()
|
|
await client.lpush("cleanup:queue", json.dumps(job_data))
|
|
|
|
logger.info(
|
|
"Cleanup job enqueued",
|
|
job_id=job_id,
|
|
session_count=len(session_ids),
|
|
expired_count=len(expired_sessions),
|
|
stuck_count=len(stuck_sessions)
|
|
)
|
|
|
|
return {
|
|
"status": "enqueued",
|
|
"job_id": job_id,
|
|
"session_count": len(session_ids),
|
|
"total_expired": len(expired_sessions),
|
|
"total_stuck": len(stuck_sessions),
|
|
"message": f"Cleanup job enqueued for {len(session_ids)} sessions"
|
|
}
|
|
|
|
|
|
@router.get(
|
|
route_builder.build_operations_route("cleanup/{job_id}", include_tenant_prefix=False),
|
|
response_model=dict
|
|
)
|
|
async def get_cleanup_status(
|
|
job_id: str,
|
|
redis: DemoRedisWrapper = Depends(get_redis)
|
|
):
|
|
"""Get status of cleanup job"""
|
|
import json
|
|
|
|
client = await redis.get_client()
|
|
status_key = f"cleanup:job:{job_id}:status"
|
|
|
|
status_data = await client.get(status_key)
|
|
if not status_data:
|
|
return {
|
|
"status": "not_found",
|
|
"message": "Job not found or expired (jobs expire after 1 hour)"
|
|
}
|
|
|
|
return json.loads(status_data)
|
|
|
|
|
|
@router.post(
|
|
"/demo/sessions/{session_id}/seed-alerts",
|
|
response_model=dict
|
|
)
|
|
async def seed_demo_alerts(
|
|
session_id: str = Path(...),
|
|
db: AsyncSession = Depends(get_db),
|
|
redis: DemoRedisWrapper = Depends(get_redis)
|
|
):
|
|
"""Seed enriched demo alerts for a demo session (DEMO OPERATION)"""
|
|
try:
|
|
import subprocess
|
|
import os
|
|
|
|
# Get session to validate and get tenant_id
|
|
session_manager = DemoSessionManager(db, redis)
|
|
session = await session_manager.get_session(session_id)
|
|
|
|
if not session:
|
|
raise HTTPException(status_code=404, detail="Demo session not found")
|
|
|
|
# Set environment variables for seeding script
|
|
env = os.environ.copy()
|
|
env['DEMO_TENANT_ID'] = str(session.virtual_tenant_id)
|
|
|
|
# Determine script path based on environment
|
|
# In container: /app/scripts/seed_enriched_alert_demo.py
|
|
# In development: services/demo_session/scripts/seed_enriched_alert_demo.py
|
|
script_path = '/app/scripts/seed_enriched_alert_demo.py' if os.path.exists('/app/scripts') else 'services/demo_session/scripts/seed_enriched_alert_demo.py'
|
|
|
|
# Run the seeding script
|
|
result = subprocess.run(
|
|
['python3', script_path],
|
|
env=env,
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=30
|
|
)
|
|
|
|
if result.returncode != 0:
|
|
logger.error("Alert seeding failed",
|
|
stdout=result.stdout,
|
|
stderr=result.stderr)
|
|
raise HTTPException(status_code=500, detail=f"Alert seeding failed: {result.stderr}")
|
|
|
|
logger.info("Demo alerts seeded successfully", session_id=session_id)
|
|
|
|
return {
|
|
"status": "success",
|
|
"session_id": session_id,
|
|
"tenant_id": str(session.virtual_tenant_id),
|
|
"alerts_seeded": 5,
|
|
"message": "Demo alerts published and will be enriched automatically"
|
|
}
|
|
|
|
except subprocess.TimeoutExpired:
|
|
raise HTTPException(status_code=504, detail="Alert seeding timeout")
|
|
except Exception as e:
|
|
logger.error("Failed to seed alerts", error=str(e), session_id=session_id)
|
|
raise HTTPException(status_code=500, detail=str(e))
|