improvements: add scheduler and verify no running workflows

1)Add scheduler to mimic previous one running each 8 hours
2)Add modal window with verification that github not running
already workflows, so we dont interfere with them.

Signed-off-by: Denys Fedoryshchenko <denys.f@collabora.com>

Author: nuclearcat

CHANGELOG.md

@@ -2,7 +2,16 @@
 
 All notable changes to the KernelCI Staging Control application will be documented in this file.
 
-## [Unreleased]
+## [0.2.0]
+
+### Added
+
+- **Scheduler**: Added staging scheduler that will run staging at 0:00UTC 8:00UTC,16:00UTC
+  - Will be run using fastapi-crons
+  - Condition: If staging has run less than 1 hour ago - skip run
+  - Appears dashboard as user run, under "virtual" user "scheduler"
+
+## [0.1.0]
 
 ### Added
 - **Staging Run Cancellation**: Added ability to cancel running staging runs

database.py

@@ -12,6 +12,7 @@
     DEFAULT_ADMIN_EMAIL,
     SETTINGS_KEYS,
 )
+from scheduler_user import ensure_scheduler_user
 
 SQLALCHEMY_DATABASE_URL = DATABASE_URL
 
@@ -66,6 +67,13 @@ def run_migrations():
 
     print("Database migration check completed")
 
+    # Ensure scheduler user exists for legacy databases migrated without init_db
+    db = SessionLocal()
+    try:
+        ensure_scheduler_user(db)
+    finally:
+        db.close()
+
 
 def init_db():
     """Initialize database and create default admin user"""
@@ -94,6 +102,8 @@ def init_db():
             db.commit()
             print("Default admin user created")
 
+        ensure_scheduler_user(db)
+
         # Create default settings
         for setting_name, setting_key in SETTINGS_KEYS.items():
             setting = db.query(Settings).filter(Settings.key == setting_key).first()

main.py

@@ -24,6 +24,7 @@
 from sqlalchemy.orm import Session
 from pydantic import BaseModel
 import uvicorn
+from fastapi_crons import Crons
 
 from config import (
     APP_TITLE,
@@ -63,6 +64,7 @@
     validate_single_running_staging,
     enforce_single_running_staging,
 )
+from scheduler import register_cron_jobs
 
 
 # Pydantic models for API requests
@@ -115,6 +117,8 @@ async def lifespan(app: FastAPI):
 
 # Create app with lifespan
 app = FastAPI(title=APP_TITLE, lifespan=lifespan)
+crons = Crons(app)
+register_cron_jobs(crons)
 
 # Mount static files
 app.mount("/static", StaticFiles(directory="templates"), name="static")
@@ -974,5 +978,63 @@ async def get_staging_status(
     }
 
 
+@app.get("/api/staging/check-workflow")
+async def check_workflow_status(
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Check if GitHub workflow is already running"""
+    # Only allow admin/maintainer to check workflow status
+    if current_user.role not in [UserRole.ADMIN, UserRole.MAINTAINER]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="Not enough permissions"
+        )
+
+    # Check if GitHub token is configured
+    github_token = get_setting(GITHUB_TOKEN)
+    if not github_token:
+        return {
+            "can_trigger": False,
+            "reason": "GitHub token not configured",
+            "running_workflows": [],
+        }
+
+    try:
+        from github_integration import GitHubWorkflowManager
+
+        github_manager = GitHubWorkflowManager(github_token)
+        running_workflows = await github_manager.get_running_workflows()
+
+        if running_workflows:
+            return {
+                "can_trigger": False,
+                "reason": f"GitHub workflow is already running ({len(running_workflows)} active)",
+                "running_workflows": running_workflows,
+            }
+
+        # Also check if there's a running staging in database
+        running_staging = validate_single_running_staging(db)
+        if running_staging:
+            return {
+                "can_trigger": False,
+                "reason": f"Staging run #{running_staging.id} is already running",
+                "running_workflows": [],
+            }
+
+        return {
+            "can_trigger": True,
+            "reason": "Ready to trigger new staging run",
+            "running_workflows": [],
+        }
+
+    except Exception as e:
+        print(f"Error checking workflow status: {e}")
+        return {
+            "can_trigger": False,
+            "reason": f"Error checking workflow status: {str(e)}",
+            "running_workflows": [],
+        }
+
+
 if __name__ == "__main__":
     uvicorn.run(app, host=HOST, port=PORT)

requirements.txt

@@ -8,3 +8,4 @@ passlib[bcrypt]==1.7.4
 aiofiles==23.2.1
 httpx==0.25.2
 toml
+fastapi-crons==2.0.1

scheduler.py

@@ -0,0 +1,116 @@
+"""Background scheduler setup for automatic staging runs."""
+
+import logging
+from datetime import datetime, timedelta
+
+from fastapi_crons import Crons
+
+from database import SessionLocal
+from db_constraints import (
+    validate_single_running_staging,
+    enforce_single_running_staging,
+)
+from discord_webhook import discord_webhook
+from models import (
+    InitiatedVia,
+    StagingRun,
+    StagingRunStatus,
+)
+from scheduler_config import (
+    SCHEDULER_AUTO_KERNEL_TREE,
+    SCHEDULER_SKIP_WINDOW_SECONDS,
+    SCHEDULER_USERNAME,
+)
+from scheduler_user import ensure_scheduler_user
+
+logger = logging.getLogger(__name__)
+
+CRON_EXPRESSION = "0 0,8,16 * * *"  # 00:00, 08:00, 16:00 UTC
+
+
+async def _run_scheduled_staging() -> None:
+    """Execute a staging run if cooldown and concurrency constraints allow it."""
+    db = SessionLocal()
+    try:
+        scheduler_user = ensure_scheduler_user(db)
+
+        now = datetime.utcnow()
+        cooldown_start = now - timedelta(seconds=SCHEDULER_SKIP_WINDOW_SECONDS)
+
+        # Skip if another user triggered a run recently
+        recent_manual_run = (
+            db.query(StagingRun)
+            .filter(StagingRun.start_time >= cooldown_start)
+            .filter(StagingRun.user_id != scheduler_user.id)
+            .order_by(StagingRun.start_time.desc())
+            .first()
+        )
+        if recent_manual_run:
+            logger.info(
+                "Skipping scheduled staging: recent run #%s by %s at %s",
+                recent_manual_run.id,
+                recent_manual_run.user.username,
+                recent_manual_run.start_time,
+            )
+            return
+
+        # Skip if a run is in progress
+        running_staging = validate_single_running_staging(db)
+        if running_staging:
+            logger.info(
+                "Skipping scheduled staging: run #%s is currently %s",
+                running_staging.id,
+                running_staging.status.value,
+            )
+            return
+
+        staging_run = StagingRun(
+            user_id=scheduler_user.id,
+            status=StagingRunStatus.RUNNING,
+            initiated_via=InitiatedVia.CRON,
+            kernel_tree=SCHEDULER_AUTO_KERNEL_TREE,
+        )
+        db.add(staging_run)
+        db.flush()
+
+        if not enforce_single_running_staging(db, staging_run.id):
+            logger.warning(
+                "Scheduled staging run #%s cancelled due to concurrency enforcement",
+                staging_run.id,
+            )
+            db.rollback()
+            return
+
+        db.commit()
+        db.refresh(staging_run)
+        logger.info("Scheduled staging run #%s started", staging_run.id)
+
+        logger.info("Using virtual scheduler user '%s'", SCHEDULER_USERNAME)
+
+        if discord_webhook:
+            try:
+                await discord_webhook.send_staging_start(
+                    SCHEDULER_USERNAME, staging_run.id
+                )
+            except Exception as exc:
+                logger.warning(
+                    "Discord notification failed for scheduler run #%s: %s",
+                    staging_run.id,
+                    exc,
+                )
+
+    except Exception as exc:
+        logger.error("Scheduler job failed: %s", exc)
+        db.rollback()
+    finally:
+        db.close()
+
+
+def register_cron_jobs(crons: Crons) -> None:
+    """Attach scheduled staging jobs to the provided cron scheduler."""
+
+    @crons.cron(CRON_EXPRESSION, name="staging_scheduler")
+    async def scheduled_staging_job():
+        await _run_scheduled_staging()
+
+    logger.info("Registered scheduled staging job for expression '%s'", CRON_EXPRESSION)

scheduler_config.py

@@ -0,0 +1,5 @@
+"""Configuration constants for the built-in staging scheduler."""
+
+SCHEDULER_USERNAME = "scheduler"
+SCHEDULER_AUTO_KERNEL_TREE = "auto"
+SCHEDULER_SKIP_WINDOW_SECONDS = 3600  # 1 hour cool-down window

scheduler_user.py

@@ -0,0 +1,28 @@
+"""Helpers for managing the virtual scheduler user account."""
+
+import secrets
+from sqlalchemy.orm import Session
+
+from models import User, UserRole
+from scheduler_config import SCHEDULER_USERNAME
+
+
+def ensure_scheduler_user(db: Session) -> User:
+    """Return the scheduler user, creating it with a strong random password if missing."""
+    user = db.query(User).filter(User.username == SCHEDULER_USERNAME).first()
+    if user:
+        return user
+
+    from auth import get_password_hash  # Imported lazily to avoid circular dependency
+
+    random_secret = secrets.token_urlsafe(64)
+    user = User(
+        username=SCHEDULER_USERNAME,
+        password_hash=get_password_hash(random_secret),
+        role=UserRole.MAINTAINER,
+        email=None,
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return user