chore: initial commit for phase07

apps/daemon/src/scheduler/mod.rs

@@ -0,0 +1,165 @@
+use std::sync::Arc;
+use anyhow::Result;
+use tokio::time::{interval, Duration};
+use tracing::{info, error, warn};
+use serde::Deserialize;
+
+use crate::server::ServerManager;
+
+/// A scheduled task received from the panel API.
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScheduledTask {
+    pub id: String,
+    pub server_uuid: String,
+    pub action: String,   // "command", "power", "backup"
+    pub payload: String,   // command string, power action, or "backup"
+    pub schedule_type: String,
+    pub is_active: bool,
+    pub next_run_at: Option<String>, // ISO 8601
+}
+
+/// Scheduler that polls the panel API for due tasks and executes them.
+pub struct Scheduler {
+    server_manager: Arc<ServerManager>,
+    api_url: String,
+    node_token: String,
+    poll_interval_secs: u64,
+}
+
+impl Scheduler {
+    pub fn new(
+        server_manager: Arc<ServerManager>,
+        api_url: String,
+        node_token: String,
+    ) -> Self {
+        Self {
+            server_manager,
+            api_url,
+            node_token,
+            poll_interval_secs: 15,
+        }
+    }
+
+    /// Run the scheduler loop. This should be spawned as a tokio task.
+    pub async fn run(self: Arc<Self>) {
+        info!("Scheduler started (poll interval: {}s)", self.poll_interval_secs);
+        let mut tick = interval(Duration::from_secs(self.poll_interval_secs));
+
+        loop {
+            tick.tick().await;
+            if let Err(e) = self.poll_and_execute().await {
+                error!(error = %e, "Scheduler poll failed");
+            }
+        }
+    }
+
+    /// Poll the API for due tasks and execute them.
+    async fn poll_and_execute(&self) -> Result<()> {
+        let client = reqwest::Client::new();
+        let url = format!("{}/api/internal/schedules/due", self.api_url);
+
+        let resp = client
+            .get(&url)
+            .bearer_auth(&self.node_token)
+            .send()
+            .await?;
+
+        if !resp.status().is_success() {
+            warn!(status = %resp.status(), "Failed to fetch due tasks");
+            return Ok(());
+        }
+
+        #[derive(Deserialize)]
+        struct DueResponse {
+            tasks: Vec<ScheduledTask>,
+        }
+
+        let due: DueResponse = resp.json().await?;
+        if due.tasks.is_empty() {
+            return Ok(());
+        }
+
+        info!(count = due.tasks.len(), "Processing due scheduled tasks");
+
+        for task in &due.tasks {
+            if let Err(e) = self.execute_task(task).await {
+                error!(
+                    task_id = %task.id,
+                    server = %task.server_uuid,
+                    error = %e,
+                    "Failed to execute scheduled task"
+                );
+            }
+
+            // Notify API that task was executed
+            let ack_url = format!(
+                "{}/api/internal/schedules/{}/ack",
+                self.api_url, task.id
+            );
+            let _ = client
+                .post(&ack_url)
+                .bearer_auth(&self.node_token)
+                .send()
+                .await;
+        }
+
+        Ok(())
+    }
+
+    /// Execute a single scheduled task.
+    async fn execute_task(&self, task: &ScheduledTask) -> Result<()> {
+        info!(
+            task_id = %task.id,
+            action = %task.action,
+            server = %task.server_uuid,
+            "Executing scheduled task"
+        );
+
+        match task.action.as_str() {
+            "command" => {
+                // Send command to server's stdin via Docker exec
+                let docker = self.server_manager.docker();
+                docker
+                    .send_command(&task.server_uuid, &task.payload)
+                    .await?;
+            }
+            "power" => {
+                match task.payload.as_str() {
+                    "start" => self.server_manager.start_server(&task.server_uuid).await?,
+                    "stop" => self.server_manager.stop_server(&task.server_uuid).await?,
+                    "restart" => {
+                        let _ = self.server_manager.stop_server(&task.server_uuid).await;
+                        tokio::time::sleep(Duration::from_secs(3)).await;
+                        self.server_manager.start_server(&task.server_uuid).await?;
+                    }
+                    "kill" => self.server_manager.kill_server(&task.server_uuid).await?,
+                    _ => warn!(payload = %task.payload, "Unknown power action"),
+                }
+            }
+            "backup" => {
+                // Trigger backup via the backup module
+                info!(
+                    server = %task.server_uuid,
+                    "Backup scheduled task — delegating to backup module"
+                );
+                // Backup is handled by sending callback to API
+                let client = reqwest::Client::new();
+                let url = format!(
+                    "{}/api/internal/servers/{}/backup",
+                    self.api_url, task.server_uuid
+                );
+                let _ = client
+                    .post(&url)
+                    .bearer_auth(&self.node_token)
+                    .json(&serde_json::json!({ "name": format!("auto-{}", task.id) }))
+                    .send()
+                    .await;
+            }
+            _ => {
+                warn!(action = %task.action, "Unknown scheduled action");
+            }
+        }
+
+        Ok(())
+    }
+}