initial commit

clients/admin-ui/src/services.rs

@@ -0,0 +1,145 @@
+use gloo::console;
+use std::rc::Rc;
+use std::cell::RefCell;
+use crate::wasm_client::{WasmSupervisorClient, WasmClientResult as ClientResult, RunnerConfig, ProcessManagerType, ProcessStatus, LogInfo, Job, RunnerType};
+use wasm_bindgen_futures::spawn_local;
+use yew::prelude::*;
+
+use crate::types::{RunnerInfo, AppState};
+
+/// Service for managing supervisor client operations
+#[derive(Clone)]
+pub struct SupervisorService {
+    client: Rc<RefCell<WasmSupervisorClient>>,
+}
+
+impl PartialEq for SupervisorService {
+    fn eq(&self, other: &Self) -> bool {
+        // Compare by server URL since that's the main identifier
+        self.client.borrow().server_url() == other.client.borrow().server_url()
+    }
+}
+
+impl SupervisorService {
+    pub fn new(server_url: &str) -> ClientResult<Self> {
+        let client = WasmSupervisorClient::new(server_url);
+        Ok(Self {
+            client: Rc::new(RefCell::new(client)),
+        })
+    }
+
+    /// Get all runners with their status and basic info
+    pub async fn get_all_runners(&self) -> ClientResult<Vec<RunnerInfo>> {
+        let runner_ids = self.client.borrow_mut().list_runners().await?;
+        let mut runners = Vec::new();
+
+        for id in runner_ids {
+            let status = self.client.borrow_mut().get_runner_status(&id).await.unwrap_or(ProcessStatus::Unknown);
+            let logs = self.client.borrow_mut().get_runner_logs(&id, Some(50), false).await.unwrap_or_default();
+            
+            // Create a basic runner config since we don't have a get_runner_config method
+            let config = RunnerConfig {
+                actor_id: id.clone(),
+                runner_type: RunnerType::SALRunner, // Default
+                binary_path: std::path::PathBuf::from("unknown"),
+                script_type: "unknown".to_string(),
+                args: vec![],
+                env_vars: std::collections::HashMap::new(),
+                working_dir: None,
+                restart_policy: "always".to_string(),
+                health_check_command: None,
+                dependencies: vec![],
+            };
+
+            runners.push(RunnerInfo {
+                id,
+                config,
+                status,
+                logs,
+            });
+        }
+
+        Ok(runners)
+    }
+
+    /// Add a new runner
+    pub async fn add_runner(&self, config: RunnerConfig, process_manager_type: ProcessManagerType) -> ClientResult<()> {
+        self.client.borrow_mut().add_runner(config, process_manager_type).await
+    }
+
+    /// Remove a runner
+    pub async fn remove_runner(&self, actor_id: &str) -> ClientResult<()> {
+        self.client.borrow_mut().remove_runner(actor_id).await
+    }
+
+    /// Start a runner
+    pub async fn start_runner(&self, actor_id: &str) -> ClientResult<()> {
+        self.client.borrow_mut().start_runner(actor_id).await
+    }
+
+    /// Stop a runner
+    pub async fn stop_runner(&self, actor_id: &str, force: bool) -> ClientResult<()> {
+        self.client.borrow_mut().stop_runner(actor_id, force).await
+    }
+
+    /// Get runner status
+    pub async fn get_runner_status(&self, actor_id: &str) -> ClientResult<ProcessStatus> {
+        self.client.borrow_mut().get_runner_status(actor_id).await
+    }
+
+    /// Get runner logs
+    pub async fn get_runner_logs(&self, actor_id: &str, lines: Option<usize>, follow: bool) -> ClientResult<Vec<LogInfo>> {
+        self.client.borrow_mut().get_runner_logs(actor_id, lines, follow).await
+    }
+
+    /// Start all runners
+    pub async fn start_all(&self) -> ClientResult<Vec<(String, bool)>> {
+        self.client.borrow_mut().start_all().await
+    }
+
+    /// Stop all runners
+    pub async fn stop_all(&self, force: bool) -> ClientResult<Vec<(String, bool)>> {
+        self.client.borrow_mut().stop_all(force).await
+    }
+
+    /// Queue a job to a runner
+    pub async fn queue_job(&self, runner_name: &str, job: Job) -> ClientResult<()> {
+        self.client.borrow_mut().queue_job_to_runner(runner_name, job).await
+    }
+
+    /// Queue a job and wait for result
+    pub async fn queue_and_wait(&self, runner_name: &str, job: Job, timeout_secs: u64) -> ClientResult<Option<String>> {
+        self.client.borrow_mut().queue_and_wait(runner_name, job, timeout_secs).await
+    }
+}
+
+/// Hook for managing supervisor service state
+#[hook]
+pub fn use_supervisor_service(server_url: &str) -> (Option<SupervisorService>, Option<String>) {
+    let server_url = server_url.to_string();
+    let service_state = use_state(|| None);
+    let error_state = use_state(|| None);
+
+    {
+        let service_state = service_state.clone();
+        let error_state = error_state.clone();
+        let server_url = server_url.clone();
+        
+        use_effect_with(server_url.clone(), move |_| {
+            spawn_local(async move {
+                match SupervisorService::new(&server_url) {
+                    Ok(service) => {
+                        service_state.set(Some(service));
+                        error_state.set(None);
+                    }
+                    Err(e) => {
+                        console::error!("Failed to create supervisor service:", e.to_string());
+                        error_state.set(Some(e.to_string()));
+                    }
+                }
+            });
+        });
+    }
+
+    ((*service_state).clone(), (*error_state).clone())
+}