wip

src/engine.rs

@@ -1,19 +1,4 @@
-//! Rhai scripting integration for the SAL library
-//!
-//! This module provides integration with the Rhai scripting language,
-//! allowing SAL functions to be called from Rhai scripts.
-
-// OS module is now provided by sal-os package
-// Platform module is now provided by sal-os package
-// PostgreSQL module is now provided by sal-postgresclient package
-
-// Virt modules (buildah, nerdctl, rfs) are now provided by sal-virt package
-// vault module is now provided by sal-vault package
-// zinit module is now in sal-zinit-client package
-
-#[cfg(test)]
-mod tests;
-
+use std::sync::{Arc, OnceLock};
 // Re-export common Rhai types for convenience
 pub use rhai::{Array, Dynamic, Engine, EvalAltResult, Map};
 
@@ -75,113 +60,73 @@ pub use sal_virt::rhai::{
     bah_new, register_bah_module, register_nerdctl_module, register_rfs_module,
 };
 
-// Re-export git module from sal-git package
 pub use sal_git::rhai::register_git_module;
 pub use sal_git::{GitRepo, GitTree};
-
-// Re-export zinit module from sal-zinit-client package
 pub use sal_zinit_client::rhai::register_zinit_module;
-
-// Re-export mycelium module
 pub use sal_mycelium::rhai::register_mycelium_module;
-
-// Re-export text module
 pub use sal_text::rhai::register_text_module;
-
-// Re-export net module
 pub use sal_net::rhai::register_net_module;
-
-// Re-export crypto module - TEMPORARILY DISABLED
-// TODO: Implement rhai module for Lee's vault implementation
-// pub use sal_vault::rhai::register_crypto_module;
-
-// Re-export kubernetes module
 pub use sal_kubernetes::rhai::register_kubernetes_module;
 pub use sal_kubernetes::KubernetesManager;
-
-// Re-export service manager module
-pub use sal_service_manager::rhai::register_service_manager_module;
-
-// Rename copy functions to avoid conflicts
 pub use sal_os::rhai::copy as os_copy;
+pub use sal_hetzner::rhai::register_hetzner_module;
 
-/// Register all SAL modules with the Rhai engine
-///
-/// # Arguments
-///
-/// * `engine` - The Rhai engine to register the modules with
-///
-/// # Example
-///
-/// ```ignore
-/// use rhai::Engine;
-/// use sal::rhai;
-///
-/// let mut engine = Engine::new();
-/// rhai::register(&mut engine);
-///
-/// // Now you can use SAL functions in Rhai scripts
-/// // You can evaluate Rhai scripts with SAL functions
-/// let result = engine.eval::<i64>("exist('some_file.txt')").unwrap();
-/// ```
-pub fn register(engine: &mut Engine) -> Result<(), Box<rhai::EvalAltResult>> {
-    // Register Core module functions
-    core::register_core_module(engine)?;
+/// Engine factory for creating and sharing Rhai engines.
+pub struct EngineFactory {
+    engine: Arc<Engine>,
+}
 
-    // Register OS module functions
-    sal_os::rhai::register_os_module(engine)?;
+impl EngineFactory {
+    /// Create a new engine factory with a configured Rhai engine.
+    pub fn new() -> Self {
+        let mut engine = Engine::new();
+        register_sal_modules(&mut engine);
+        // Logger
+        hero_logger::rhai_integration::configure_rhai_logging(&mut engine, "osis_actor");
 
-    // Register Process module functions
-    sal_process::rhai::register_process_module(engine)?;
+        Self {
+            engine: Arc::new(engine),
+        }
+    }
 
-    // Register Virt module functions (Buildah, Nerdctl, RFS)
-    sal_virt::rhai::register_virt_module(engine)?;
+    /// Get a shared reference to the engine.
+    pub fn get_engine(&self) -> Arc<Engine> {
+        Arc::clone(&self.engine)
+    }
 
-    // Register Git module functions
-    sal_git::rhai::register_git_module(engine)?;
+    /// Get the global singleton engine factory.
+    pub fn global() -> &'static EngineFactory {
+        static FACTORY: OnceLock<EngineFactory> = OnceLock::new();
+        FACTORY.get_or_init(|| EngineFactory::new())
+    }
+}
 
-    // Register Zinit module functions
-    sal_zinit_client::rhai::register_zinit_module(engine)?;
+pub fn register_sal_modules(engine: &mut Engine) {
+    sal_os::rhai::register_os_module(engine);
+    sal_redisclient::rhai::register_redisclient_module(engine);
+    sal_postgresclient::rhai::register_postgresclient_module(engine);
+    sal_process::rhai::register_process_module(engine);
+    sal_virt::rhai::register_virt_module(engine);
+    sal_git::rhai::register_git_module(engine);
+    sal_zinit_client::rhai::register_zinit_module(engine);
+    sal_mycelium::rhai::register_mycelium_module(engine);
+    sal_text::rhai::register_text_module(engine);
+    sal_net::rhai::register_net_module(engine);
+    sal_kubernetes::rhai::register_kubernetes_module(engine);
+    sal_hetzner::rhai::register_hetzner_module(engine);
 
-    // Register Mycelium module functions
-    sal_mycelium::rhai::register_mycelium_module(engine)?;
+    println!("SAL modules registered successfully.");
+}
 
-    // Register Text module functions
-    sal_text::rhai::register_text_module(engine)?;
+/// Create a shared heromodels engine using the factory.
+pub fn create_system_engine() -> Arc<Engine> {
+    EngineFactory::global().get_engine()
+}
 
-    // Register Net module functions
-    sal_net::rhai::register_net_module(engine)?;
-
-    // RFS module functions are now registered as part of sal_virt above
-
-    // Register Crypto module functions - TEMPORARILY DISABLED
-    // TODO: Implement rhai module for Lee's vault implementation
-    // register_crypto_module(engine)?;
-
-    // Register Kubernetes module functions
-    register_kubernetes_module(engine)?;
-
-    // Register Redis client module functions
-    sal_redisclient::rhai::register_redisclient_module(engine)?;
-
-    // Register PostgreSQL client module functions
-    sal_postgresclient::rhai::register_postgresclient_module(engine)?;
-
-    // Register Service Manager module functions
-    sal_service_manager::rhai::register_service_manager_module(engine)?;
-
-    // Platform functions are now registered by sal-os package
-
-    // Screen module functions are now part of sal-process package
-
-    // Register utility functions
-    engine.register_fn("is_def_fn", |_name: &str| -> bool {
-        // This is a utility function to check if a function is defined in the engine
-        // For testing purposes, we'll just return true
-        true
-    });
-
-    // Future modules can be registered here
-
-    Ok(())
+/// Evaluate a Rhai script string.
+pub fn eval_script(
+    engine: &Engine,
+    script: &str,
+) -> Result<rhai::Dynamic, Box<rhai::EvalAltResult>> {
+    engine.eval(script)
 }

src/lib.rs

@@ -1,3 +1,9 @@
+mod engine;
+
+// Public exports
+pub use engine::register_sal_modules;
+pub use engine::create_system_engine;
+
 use async_trait::async_trait;
 use hero_job::{Job, JobStatus};
 use log::{debug, error, info, warn};
@@ -9,7 +15,6 @@ use tokio::sync::{mpsc, Mutex};
 use tokio::task::JoinHandle;
 use tokio::time::timeout;
 use baobab_actor::{actor_trait::Actor, spawn_actor, initialize_redis_connection};
-mod engine;
 
 /// Represents a running job with its handle and metadata
 #[derive(Debug)]
@@ -241,11 +246,7 @@ impl Default for AsyncWorker {
 
 #[async_trait]
 impl Actor for AsyncWorker {
-    async fn process_job(
-        &self,
-        job: hero_job::Job,
-        _redis_conn: &mut redis::aio::MultiplexedConnection,
-    ) {
+    async fn process_job(&self, job: hero_job::Job, _redis_conn: &mut redis::aio::MultiplexedConnection) {
         let job_id = job.id.clone();
         let actor_id = &self.actor_id.clone();
 
@@ -272,10 +273,7 @@ impl Actor for AsyncWorker {
             // Create engine for this job - we need to get it from somewhere
             // For now, let's assume we need to create a new engine instance
             let mut engine = rhai::Engine::new();
-            if let Err(e) = register_engine(&mut engine) {
-                error!("Failed to register engine modules: {}", e);
-                return;
-            }
+            engine::register_sal_modules(&mut engine); 
             
             Self::execute_job_with_timeout(
                 job,