supervisor/examples/mock_runner.rs

//! Mock Runner Binary for Testing OpenRPC Examples
//!
//! This is a simple mock runner that simulates an actor binary for testing
//! the Hero Supervisor OpenRPC integration. It connects to Redis, listens for
//! jobs using the proper Hero job queue system, and echoes the job payload.
//!
//! Usage:
//! ```bash
//! cargo run --example mock_runner -- --actor-id test_actor --db-path /tmp/test_db --redis-url redis://localhost:6379
//! ```

use std::env;
use std::time::Duration;
use tokio::time::sleep;
use redis::AsyncCommands;
use hero_supervisor::{
    Job, JobStatus, JobError, client::{Client, ClientBuilder}
};

#[derive(Debug, Clone)]
pub struct MockRunnerConfig {
    pub actor_id: String,
    pub db_path: String,
    pub redis_url: String,
}

impl MockRunnerConfig {
    pub fn from_args() -> Result<Self, Box<dyn std::error::Error>> {
        let args: Vec<String> = env::args().collect();
        
        let mut actor_id = None;
        let mut db_path = None;
        let mut redis_url = None;
        
        let mut i = 1;
        while i < args.len() {
            match args[i].as_str() {
                "--actor-id" => {
                    if i + 1 < args.len() {
                        actor_id = Some(args[i + 1].clone());
                        i += 2;
                    } else {
                        return Err("Missing value for --actor-id".into());
                    }
                }
                "--db-path" => {
                    if i + 1 < args.len() {
                        db_path = Some(args[i + 1].clone());
                        i += 2;
                    } else {
                        return Err("Missing value for --db-path".into());
                    }
                }
                "--redis-url" => {
                    if i + 1 < args.len() {
                        redis_url = Some(args[i + 1].clone());
                        i += 2;
                    } else {
                        return Err("Missing value for --redis-url".into());
                    }
                }
                _ => i += 1,
            }
        }
        
        Ok(MockRunnerConfig {
            actor_id: actor_id.ok_or("Missing required --actor-id argument")?,
            db_path: db_path.ok_or("Missing required --db-path argument")?,
            redis_url: redis_url.unwrap_or_else(|| "redis://localhost:6379".to_string()),
        })
    }
}

pub struct MockRunner {
    config: MockRunnerConfig,
    client: Client,
}

impl MockRunner {
    pub async fn new(config: MockRunnerConfig) -> Result<Self, Box<dyn std::error::Error>> {
        let client = ClientBuilder::new()
            .redis_url(&config.redis_url)
            .build()
            .await?;
        
        Ok(MockRunner {
            config,
            client,
        })
    }
    
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
        println!("🤖 Mock Runner '{}' starting...", self.config.actor_id);
        println!("📂 DB Path: {}", self.config.db_path);
        println!("🔗 Redis URL: {}", self.config.redis_url);
        
        // Use the proper Hero job queue key for this actor instance
        // Format: hero:q:work:type:{job_type}:group:{group}:inst:{instance}
        let work_queue_key = format!("hero:q:work:type:osis:group:default:inst:{}", self.config.actor_id);
        
        println!("👂 Listening for jobs on queue: {}", work_queue_key);
        
        loop {
            // Try to pop a job ID from the work queue using the Hero protocol
            let job_id = self.client.get_job_id(&work_queue_key).await?;
            
            match job_id {
                Some(job_id) => {
                    println!("📨 Received job ID: {}", job_id);
                    if let Err(e) = self.process_job(&job_id).await {
                        eprintln!("❌ Error processing job {}: {}", job_id, e);
                        // Mark job as error
                        if let Err(e2) = self.client.set_job_status(&job_id, JobStatus::Error).await {
                            eprintln!("❌ Failed to set job error status: {}", e2);
                        }
                    }
                }
                None => {
                    // No jobs available, wait a bit
                    sleep(Duration::from_millis(100)).await;
                }
            }
        }
    }
    
    async fn process_job(&self, job_id: &str) -> Result<(), JobError> {
        // Load the job from Redis using the Hero job system
        let job = self.client.get_job(job_id).await?;
        
        self.process_job_internal(&self.client, job_id, &job).await
    }

    async fn process_job_internal(
        &self,
        client: &Client,
        job_id: &str,
        job: &Job,
    ) -> Result<(), JobError> {
        println!("🔄 Processing job {} with payload: {}", job_id, job.payload);
        
        // Mark job as started
        client.set_job_status(job_id, JobStatus::Started).await?;
        println!("🚀 Job {} marked as Started", job_id);
        
        // Simulate processing time
        sleep(Duration::from_millis(500)).await;
        
        // Echo the payload (simulate job execution)
        let output = format!("echo: {}", job.payload);
        println!("📤 Output: {}", output);
        
        // Set the job result
        client.set_result(job_id, &output).await?;
        
        println!("✅ Job {} completed successfully", job_id);
        
        Ok(())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse command line arguments
    let config = MockRunnerConfig::from_args()?;
    
    // Create and run the mock runner
    let runner = MockRunner::new(config).await?;
    runner.run().await?;
    
    Ok(())
}