herocode/baobab
Archived
13
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

rename worker to actor

Browse Source
This commit is contained in:
Timur Gordon
2025-08-05 15:44:33 +02:00
parent 5283f383b3
commit 89e953ca1d
67 changed files with 1629 additions and 1737 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
core/supervisor/examples/lifecycle_demo.rs
View File

@@ -1,6 +1,6 @@
use hero_supervisor::{
Supervisor, SupervisorBuilder, WorkerConfig, WorkerLifecycleManager,
WorkerLifecycleManagerBuilder, ScriptType
Supervisor, SupervisorBuilder, ActorConfig, ActorLifecycleManager,
ActorLifecycleManagerBuilder, ScriptType
};
use log::{info, warn, error};
use std::collections::HashMap;
@@ -13,7 +13,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Initialize logging
env_logger::init();
info!("Starting Worker Lifecycle Management Demo");
info!("Starting Actor Lifecycle Management Demo");
// Configuration
let redis_url = "redis://localhost:6379";
@@ -25,154 +25,154 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
.context_id("demo_context")
.build()?;
// Configure workers for different script types
let mut worker_configs = Vec::new();
// Configure actors for different script types
let mut actor_configs = Vec::new();
// OSIS workers (Rhai/HeroScript)
// OSIS actors (Rhai/HeroScript)
for i in 0..2 {
let config = WorkerConfig::new(
format!("osis_worker_{}", i),
PathBuf::from("/usr/local/bin/osis_worker"),
let config = ActorConfig::new(
format!("osis_actor_{}", i),
PathBuf::from("/usr/local/bin/osis_actor"),
ScriptType::OSIS,
)
.with_args(vec![
"--redis-url".to_string(),
redis_url.to_string(),
"--worker-id".to_string(),
format!("osis_worker_{}", i),
"--actor-id".to_string(),
format!("osis_actor_{}", i),
])
.with_env({
let mut env = HashMap::new();
env.insert("RUST_LOG".to_string(), "info".to_string());
env.insert("WORKER_TYPE".to_string(), "osis".to_string());
env.insert("ACTOR_TYPE".to_string(), "osis".to_string());
env
})
.with_health_check("/usr/local/bin/osis_worker --health-check".to_string())
.with_health_check("/usr/local/bin/osis_actor --health-check".to_string())
.with_dependencies(vec!["redis".to_string()]);
worker_configs.push(config);
actor_configs.push(config);
}
// SAL workers (System Abstraction Layer)
// SAL actors (System Abstraction Layer)
for i in 0..3 {
let config = WorkerConfig::new(
format!("sal_worker_{}", i),
PathBuf::from("/usr/local/bin/sal_worker"),
let config = ActorConfig::new(
format!("sal_actor_{}", i),
PathBuf::from("/usr/local/bin/sal_actor"),
ScriptType::SAL,
)
.with_args(vec![
"--redis-url".to_string(),
redis_url.to_string(),
"--worker-id".to_string(),
format!("sal_worker_{}", i),
"--actor-id".to_string(),
format!("sal_actor_{}", i),
])
.with_env({
let mut env = HashMap::new();
env.insert("RUST_LOG".to_string(), "info".to_string());
env.insert("WORKER_TYPE".to_string(), "sal".to_string());
env.insert("ACTOR_TYPE".to_string(), "sal".to_string());
env
})
.with_health_check("/usr/local/bin/sal_worker --health-check".to_string())
.with_health_check("/usr/local/bin/sal_actor --health-check".to_string())
.with_dependencies(vec!["redis".to_string()]);
worker_configs.push(config);
actor_configs.push(config);
}
// V workers (HeroScript in V language)
// V actors (HeroScript in V language)
for i in 0..2 {
let config = WorkerConfig::new(
format!("v_worker_{}", i),
PathBuf::from("/usr/local/bin/v_worker"),
let config = ActorConfig::new(
format!("v_actor_{}", i),
PathBuf::from("/usr/local/bin/v_actor"),
ScriptType::V,
)
.with_args(vec![
"--redis-url".to_string(),
redis_url.to_string(),
"--worker-id".to_string(),
format!("v_worker_{}", i),
"--actor-id".to_string(),
format!("v_actor_{}", i),
])
.with_env({
let mut env = HashMap::new();
env.insert("RUST_LOG".to_string(), "info".to_string());
env.insert("WORKER_TYPE".to_string(), "v".to_string());
env.insert("ACTOR_TYPE".to_string(), "v".to_string());
env
})
.with_health_check("/usr/local/bin/v_worker --health-check".to_string())
.with_health_check("/usr/local/bin/v_actor --health-check".to_string())
.with_dependencies(vec!["redis".to_string()]);
worker_configs.push(config);
actor_configs.push(config);
}
// Create lifecycle manager
let mut lifecycle_manager = WorkerLifecycleManagerBuilder::new(zinit_socket.to_string())
let mut lifecycle_manager = ActorLifecycleManagerBuilder::new(zinit_socket.to_string())
.with_supervisor(supervisor.clone());
// Add all worker configurations
for config in worker_configs {
lifecycle_manager = lifecycle_manager.add_worker(config);
// Add all actor configurations
for config in actor_configs {
lifecycle_manager = lifecycle_manager.add_actor(config);
}
let mut lifecycle_manager = lifecycle_manager.build();
// Demonstrate lifecycle operations
info!("=== Starting Worker Lifecycle Demo ===");
info!("=== Starting Actor Lifecycle Demo ===");
// 1. Start all workers
info!("1. Starting all workers...");
match lifecycle_manager.start_all_workers().await {
Ok(_) => info!("✅ All workers started successfully"),
// 1. Start all actors
info!("1. Starting all actors...");
match lifecycle_manager.start_all_actors().await {
Ok(_) => info!("✅ All actors started successfully"),
Err(e) => {
error!("❌ Failed to start workers: {}", e);
error!("❌ Failed to start actors: {}", e);
return Err(e.into());
}
}
// Wait for workers to initialize
// Wait for actors to initialize
sleep(Duration::from_secs(5)).await;
// 2. Check worker status
info!("2. Checking worker status...");
match lifecycle_manager.get_all_worker_status().await {
// 2. Check actor status
info!("2. Checking actor status...");
match lifecycle_manager.get_all_actor_status().await {
Ok(status_map) => {
for (worker_name, status) in status_map {
info!(" Worker '{}': State={:?}, PID={}", worker_name, status.state, status.pid);
for (actor_name, status) in status_map {
info!(" Actor '{}': State={:?}, PID={}", actor_name, status.state, status.pid);
}
}
Err(e) => warn!("Failed to get worker status: {}", e),
Err(e) => warn!("Failed to get actor status: {}", e),
}
// 3. Demonstrate scaling
info!("3. Demonstrating worker scaling...");
info!("3. Demonstrating actor scaling...");
// Scale up OSIS workers
info!(" Scaling up OSIS workers to 3...");
if let Err(e) = lifecycle_manager.scale_workers(&ScriptType::OSIS, 3).await {
warn!("Failed to scale OSIS workers: {}", e);
// Scale up OSIS actors
info!(" Scaling up OSIS actors to 3...");
if let Err(e) = lifecycle_manager.scale_actors(&ScriptType::OSIS, 3).await {
warn!("Failed to scale OSIS actors: {}", e);
}
sleep(Duration::from_secs(3)).await;
// Scale down SAL workers
info!(" Scaling down SAL workers to 1...");
if let Err(e) = lifecycle_manager.scale_workers(&ScriptType::SAL, 1).await {
warn!("Failed to scale SAL workers: {}", e);
// Scale down SAL actors
info!(" Scaling down SAL actors to 1...");
if let Err(e) = lifecycle_manager.scale_actors(&ScriptType::SAL, 1).await {
warn!("Failed to scale SAL actors: {}", e);
}
sleep(Duration::from_secs(3)).await;
// 4. Check running worker counts
info!("4. Checking running worker counts after scaling...");
// 4. Check running actor counts
info!("4. Checking running actor counts after scaling...");
for script_type in [ScriptType::OSIS, ScriptType::SAL, ScriptType::V] {
let count = lifecycle_manager.get_running_worker_count(&script_type).await;
info!(" {:?}: {} workers running", script_type, count);
let count = lifecycle_manager.get_running_actor_count(&script_type).await;
info!(" {:?}: {} actors running", script_type, count);
}
// 5. Demonstrate restart functionality
info!("5. Demonstrating worker restart...");
if let Err(e) = lifecycle_manager.restart_worker("osis_worker_0").await {
warn!("Failed to restart worker: {}", e);
info!("5. Demonstrating actor restart...");
if let Err(e) = lifecycle_manager.restart_actor("osis_actor_0").await {
warn!("Failed to restart actor: {}", e);
} else {
info!(" ✅ Successfully restarted osis_worker_0");
info!(" ✅ Successfully restarted osis_actor_0");
}
sleep(Duration::from_secs(3)).await;
@@ -180,12 +180,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// 6. Simulate job dispatch and health monitoring
info!("6. Simulating job dispatch and health monitoring...");
// Update job time for a worker (simulating job dispatch)
lifecycle_manager.update_worker_job_time("sal_worker_0");
info!(" Updated job time for sal_worker_0");
// Update job time for a actor (simulating job dispatch)
lifecycle_manager.update_actor_job_time("sal_actor_0");
info!(" Updated job time for sal_actor_0");
// Perform health monitoring check
if let Err(e) = lifecycle_manager.monitor_worker_health().await {
if let Err(e) = lifecycle_manager.monitor_actor_health().await {
warn!("Health monitoring failed: {}", e);
} else {
info!(" ✅ Health monitoring completed");
@@ -196,7 +196,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let test_job = supervisor
.new_job()
.script_type(ScriptType::OSIS)
.script_content("println!(\"Hello from worker!\");".to_string())
.script_content("println!(\"Hello from actor!\");".to_string())
.timeout(Duration::from_secs(30))
.build()?;
@@ -208,27 +208,27 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// 8. Demonstrate graceful shutdown
info!("8. Demonstrating graceful shutdown...");
// Stop specific workers
info!(" Stopping specific workers...");
for worker_name in ["osis_worker_1", "v_worker_0"] {
if let Err(e) = lifecycle_manager.stop_worker(worker_name).await {
warn!("Failed to stop worker {}: {}", worker_name, e);
// Stop specific actors
info!(" Stopping specific actors...");
for actor_name in ["osis_actor_1", "v_actor_0"] {
if let Err(e) = lifecycle_manager.stop_actor(actor_name).await {
warn!("Failed to stop actor {}: {}", actor_name, e);
} else {
info!(" ✅ Stopped worker: {}", worker_name);
info!(" ✅ Stopped actor: {}", actor_name);
}
}
sleep(Duration::from_secs(2)).await;
// Stop all remaining workers
info!(" Stopping all remaining workers...");
if let Err(e) = lifecycle_manager.stop_all_workers().await {
error!("Failed to stop all workers: {}", e);
// Stop all remaining actors
info!(" Stopping all remaining actors...");
if let Err(e) = lifecycle_manager.stop_all_actors().await {
error!("Failed to stop all actors: {}", e);
} else {
info!(" ✅ All workers stopped successfully");
info!(" ✅ All actors stopped successfully");
}
info!("=== Worker Lifecycle Demo Completed ===");
info!("=== Actor Lifecycle Demo Completed ===");
// Optional: Start health monitoring loop (commented out for demo)
// info!("Starting health monitoring loop (Ctrl+C to stop)...");