move repos into monorepo

lib/runner/sync_runner.rs

@@ -0,0 +1,175 @@
+use crate::Job;
+use crate::runner_trait::Runner;
+use log::{debug, error, info};
+use rhai::{Engine, Dynamic};
+use std::sync::Arc;
+use tracing::subscriber::with_default;
+
+/// Configuration for sync runner instances
+#[derive(Debug, Clone)]
+pub struct SyncRunnerConfig {
+    pub runner_id: String,
+    pub redis_url: String,
+}
+
+/// Synchronous runner that processes jobs sequentially
+pub struct SyncRunner {
+    pub config: SyncRunnerConfig,
+    pub engine_factory: Arc<dyn Fn() -> Engine + Send + Sync>,
+}
+
+impl SyncRunner {
+    /// Create a new SyncRunner with the provided engine factory
+    pub fn new<F>(config: SyncRunnerConfig, engine_factory: F) -> Self 
+    where
+        F: Fn() -> Engine + Send + Sync + 'static,
+    {
+        Self {
+            config,
+            engine_factory: Arc::new(engine_factory),
+        }
+    }
+
+    /// Execute a job with the given engine, setting proper job context
+    /// 
+    /// This function sets up the engine with job context (DB_PATH, CALLER_ID, CONTEXT_ID)
+    /// and evaluates the script. It returns the result or error.
+    fn execute_job_with_engine(
+        engine: &mut Engine,
+        job: &Job,
+    ) -> Result<Dynamic, Box<rhai::EvalAltResult>> {
+        // Set up job context in the engine
+        let mut db_config = rhai::Map::new();
+        db_config.insert("CALLER_ID".into(), job.caller_id.clone().into());
+        db_config.insert("CONTEXT_ID".into(), job.context_id.clone().into());
+        
+        // Extract signatories from job signatures, or fall back to env_vars
+        let signatories: Vec<Dynamic> = if !job.signatures.is_empty() {
+            // Use signatures from the job
+            job.signatures.iter()
+                .map(|sig| Dynamic::from(sig.public_key.clone()))
+                .collect()
+        } else {
+            Vec::new()
+        };
+        db_config.insert("SIGNATORIES".into(), Dynamic::from(signatories));
+        
+        engine.set_default_tag(Dynamic::from(db_config));
+        
+        debug!("Sync Runner for Context ID '{}': Evaluating script with Rhai engine (job context set).", job.context_id);
+        
+        // Execute the script with the configured engine
+        engine.eval::<Dynamic>(&job.payload)
+    }
+
+
+}
+
+impl Runner for SyncRunner {
+    fn process_job(&self, job: Job) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
+        let job_id = &job.id;
+        let runner_id = &self.config.runner_id;
+        
+        debug!("Sync Runner '{}', Job {}: Processing started.", runner_id, job_id);
+        info!("Sync Runner '{}' processing job_id: {}. Script: {:.50}...", job.context_id, job_id, job.payload);
+        
+        // Determine logs directory (default to ~/hero/logs)
+        let logs_root = if let Some(home) = std::env::var_os("HOME") {
+            std::path::PathBuf::from(home).join("hero").join("logs")
+        } else {
+            std::path::PathBuf::from("logs")
+        };
+        
+        // Create job-specific logger
+        let job_logger_result = hero_logger::create_job_logger_with_guard(
+            &logs_root,
+            runner_id,  // Use runner_id as the actor_type
+            job_id,
+        );
+        
+        // Verify signatures before executing (if any)
+        if let Err(e) = job.verify_signatures() {
+            error!("Job {} signature verification failed: {}", job_id, e);
+            return Err(Box::new(e));
+        }
+        
+        // Execute job within logging context
+        let result = match job_logger_result {
+            Ok((job_logger, _guard)) => {
+                // Execute ALL job processing within logging context
+                with_default(job_logger, || {
+                    tracing::info!("Job {} started", job_id);
+                    
+                    // Create a new engine instance and configure Rhai logging
+                    let mut engine = (self.engine_factory)();
+                    
+                    // Reconfigure Rhai logging for this specific job context
+                    // This ensures print() and debug() calls go to the job logger
+                    hero_logger::rhai_integration::configure_rhai_logging(&mut engine, runner_id);
+                    
+                    // Execute the script
+                    let script_result = Self::execute_job_with_engine(&mut engine, &job);
+                    
+                    tracing::info!("Job {} completed", job_id);
+                    
+                    script_result
+                })
+            }
+            Err(e) => {
+                error!("Failed to create job logger for job {}: {}", job_id, e);
+                // Fallback: execute without job-specific logging
+                let mut engine = (self.engine_factory)();
+                Self::execute_job_with_engine(&mut engine, &job)
+            }
+        };
+        
+        // Process result
+        match result {
+            Ok(result) => {
+                let output_str = if result.is::<String>() {
+                    result.into_string().unwrap()
+                } else {
+                    result.to_string()
+                };
+                info!("Sync Runner for Context ID '{}' job {} completed. Output: {}", job.context_id, job.id, output_str);
+                Ok(output_str)
+            }
+            Err(e) => {
+                let error_str = format!("{:?}", *e);
+                error!("Sync Runner for Context ID '{}' job {} script evaluation failed. Error: {}", job.context_id, job.id, error_str);
+                Err(Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
+            }
+        }
+    }
+
+    fn runner_type(&self) -> &'static str {
+        "Sync"
+    }
+    
+    fn runner_id(&self) -> &str {
+        &self.config.runner_id
+    }
+    
+    fn redis_url(&self) -> &str {
+        &self.config.redis_url
+    }
+}
+
+/// Convenience function to spawn a synchronous runner using the trait interface
+pub fn spawn_sync_runner<F>(
+    runner_id: String,
+    redis_url: String,
+    shutdown_rx: tokio::sync::mpsc::Receiver<()>,
+    engine_factory: F,
+) -> tokio::task::JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>> 
+where
+    F: Fn() -> Engine + Send + Sync + 'static,
+{
+    let config = SyncRunnerConfig {
+        runner_id,
+        redis_url,
+    };
+    
+    let runner = Arc::new(SyncRunner::new(config, engine_factory));
+    crate::runner_trait::spawn_runner(runner, shutdown_rx)
+}