Skip to main content

llm_test_bench_core/plugins/
manager.rs

1// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
4// option. This file may not be copied, modified, or distributed
5// except according to those terms.
6
7//! Plugin manager for loading and executing plugins.
8
9use anyhow::{Result, Context, bail};
10use std::collections::HashMap;
11use std::sync::Arc;
12use std::path::Path;
13use parking_lot::RwLock;
14use chrono::Utc;
15
16use crate::plugins::{
17    types::{
18        PluginError, PluginInfo, PluginMetadata, PluginConfig, PluginPermissions,
19    },
20    api::{PluginInput, PluginOutput, wasm_interface},
21    runtime::{WasmRuntime, RuntimeConfig, WasmInstance},
22    loader::PluginLoader,
23    PluginStatus,
24};
25
26/// Plugin manager configuration
27#[derive(Debug, Clone)]
28pub struct ManagerConfig {
29    /// Runtime configuration
30    pub runtime_config: RuntimeConfig,
31
32    /// Maximum number of concurrent plugins
33    pub max_concurrent_plugins: usize,
34
35    /// Plugin cache directory
36    pub cache_dir: Option<std::path::PathBuf>,
37}
38
39impl Default for ManagerConfig {
40    fn default() -> Self {
41        Self {
42            runtime_config: RuntimeConfig::default(),
43            max_concurrent_plugins: 100,
44            cache_dir: None,
45        }
46    }
47}
48
49/// Loaded plugin state
50struct LoadedPlugin {
51    info: PluginInfo,
52    instance: Arc<WasmInstance>,
53    config: PluginConfig,
54}
55
56/// Plugin manager
57pub struct PluginManager {
58    config: ManagerConfig,
59    runtime: Arc<WasmRuntime>,
60    loader: PluginLoader,
61    plugins: Arc<RwLock<HashMap<String, LoadedPlugin>>>,
62}
63
64impl PluginManager {
65    /// Create a new plugin manager
66    pub fn new(config: ManagerConfig) -> Result<Self> {
67        let runtime = Arc::new(WasmRuntime::new(config.runtime_config.clone())?);
68        let loader = PluginLoader::new();
69
70        Ok(Self {
71            config,
72            runtime,
73            loader,
74            plugins: Arc::new(RwLock::new(HashMap::new())),
75        })
76    }
77
78    /// Load a plugin from a file
79    pub async fn load_plugin(&self, path: impl AsRef<Path>) -> Result<String> {
80        let path = path.as_ref();
81        let wasm_bytes = tokio::fs::read(path)
82            .await
83            .context("Failed to read plugin file")?;
84
85        let plugin_name = path
86            .file_stem()
87            .and_then(|s| s.to_str())
88            .unwrap_or("unknown")
89            .to_string();
90
91        self.load_plugin_from_bytes(plugin_name, wasm_bytes).await
92    }
93
94    /// Load a plugin from bytes
95    pub async fn load_plugin_from_bytes(&self, name: String, wasm_bytes: Vec<u8>) -> Result<String> {
96        // Check concurrent plugin limit
97        {
98            let plugins = self.plugins.read();
99            if plugins.len() >= self.config.max_concurrent_plugins {
100                bail!("Maximum concurrent plugins limit reached");
101            }
102        }
103
104        // Load the WASM module
105        let module = self.runtime.load_module(&wasm_bytes)
106            .context("Failed to load WASM module")?;
107
108        // Instantiate the module
109        let instance = self.runtime.instantiate(&module).await
110            .context("Failed to instantiate WASM module")?;
111
112        // Get plugin metadata
113        let metadata = self.get_plugin_metadata(&instance).await
114            .context("Failed to get plugin metadata")?;
115
116        // Generate plugin ID
117        let plugin_id = format!("{}_{}", metadata.name, uuid::Uuid::new_v4());
118
119        // Create plugin config
120        let plugin_config = PluginConfig {
121            id: plugin_id.clone(),
122            metadata: metadata.clone(),
123            permissions: PluginPermissions::default(),
124            limits: self.config.runtime_config.limits.clone(),
125            config: HashMap::new(),
126        };
127
128        // Create plugin info
129        let plugin_info = PluginInfo {
130            id: plugin_id.clone(),
131            metadata,
132            status: PluginStatus::Ready,
133            loaded_at: Utc::now(),
134            last_executed: None,
135            execution_count: 0,
136            total_execution_time_ms: 0,
137            error_count: 0,
138        };
139
140        // Initialize the plugin
141        self.initialize_plugin(&instance).await?;
142
143        // Store the loaded plugin
144        let loaded_plugin = LoadedPlugin {
145            info: plugin_info,
146            instance: Arc::new(instance),
147            config: plugin_config,
148        };
149
150        let mut plugins = self.plugins.write();
151        plugins.insert(plugin_id.clone(), loaded_plugin);
152
153        tracing::info!("Plugin loaded: {}", plugin_id);
154
155        Ok(plugin_id)
156    }
157
158    /// Unload a plugin
159    pub async fn unload_plugin(&self, plugin_id: &str) -> Result<()> {
160        let mut plugins = self.plugins.write();
161
162        let plugin = plugins.get_mut(plugin_id)
163            .ok_or_else(|| PluginError::NotFound {
164                plugin_id: plugin_id.to_string(),
165            })?;
166
167        // Update status
168        plugin.info.status = PluginStatus::Unloading;
169
170        // Shutdown the plugin
171        self.shutdown_plugin(&plugin.instance).await?;
172
173        // Remove from loaded plugins
174        plugins.remove(plugin_id);
175
176        tracing::info!("Plugin unloaded: {}", plugin_id);
177
178        Ok(())
179    }
180
181    /// Execute a plugin
182    pub async fn execute_plugin(
183        &self,
184        plugin_id: &str,
185        input: PluginInput,
186    ) -> Result<PluginOutput> {
187        let start = std::time::Instant::now();
188
189        // Get the plugin
190        let (instance, plugin_info) = {
191            let plugins = self.plugins.read();
192            let plugin = plugins.get(plugin_id)
193                .ok_or_else(|| PluginError::NotFound {
194                    plugin_id: plugin_id.to_string(),
195                })?;
196
197            (plugin.instance.clone(), plugin.info.clone())
198        };
199
200        // Serialize input
201        let input_bytes = serde_json::to_vec(&input)
202            .context("Failed to serialize plugin input")?;
203
204        // Execute with timeout
205        let timeout_duration = std::time::Duration::from_millis(
206            self.config.runtime_config.limits.max_execution_time_ms
207        );
208
209        let result = tokio::time::timeout(
210            timeout_duration,
211            self.execute_plugin_internal(&instance, &input_bytes)
212        ).await;
213
214        let output_bytes = match result {
215            Ok(Ok(bytes)) => bytes,
216            Ok(Err(e)) => {
217                self.update_plugin_error(plugin_id).await;
218                return Err(e);
219            }
220            Err(_) => {
221                self.update_plugin_error(plugin_id).await;
222                bail!(PluginError::Timeout {
223                    duration_ms: self.config.runtime_config.limits.max_execution_time_ms
224                });
225            }
226        };
227
228        // Deserialize output
229        let mut output: PluginOutput = serde_json::from_slice(&output_bytes)
230            .context("Failed to deserialize plugin output")?;
231
232        // Update execution metadata
233        let elapsed = start.elapsed();
234        output.metadata.execution_time_ms = elapsed.as_millis() as u64;
235
236        // Update plugin statistics
237        self.update_plugin_stats(plugin_id, elapsed.as_millis() as u64).await;
238
239        Ok(output)
240    }
241
242    /// Internal plugin execution
243    async fn execute_plugin_internal(
244        &self,
245        instance: &WasmInstance,
246        input_bytes: &[u8],
247    ) -> Result<Vec<u8>> {
248        // Get memory
249        let memory = instance.get_memory("memory")
250            .context("Plugin memory not found")?;
251
252        // Allocate input memory in plugin
253        let input_ptr = instance.allocate(input_bytes.len()).await
254            .context("Failed to allocate input memory")?;
255
256        // Write input to plugin memory
257        instance.write_memory(&memory, input_ptr as usize, input_bytes)
258            .context("Failed to write input to plugin memory")?;
259
260        // Allocate output buffer (max 10MB)
261        let max_output_size = 10 * 1024 * 1024;
262        let output_ptr = instance.allocate(max_output_size).await
263            .context("Failed to allocate output memory")?;
264
265        // Call plugin execute function
266        let args = [
267            wasmtime::Val::I32(input_ptr as i32),
268            wasmtime::Val::I32(input_bytes.len() as i32),
269            wasmtime::Val::I32(output_ptr as i32),
270            wasmtime::Val::I32(max_output_size as i32),
271        ];
272
273        let results = instance.call_function(wasm_interface::PLUGIN_EXECUTE, &args).await
274            .context("Failed to call plugin execute function")?;
275
276        // Check result code
277        if let Some(wasmtime::Val::I32(code)) = results.first() {
278            if *code != wasm_interface::RESULT_OK {
279                bail!("Plugin execution failed with code: {}", code);
280            }
281        }
282
283        // Get output length (returned in second result)
284        let output_len = if let Some(wasmtime::Val::I32(len)) = results.get(1) {
285            *len as usize
286        } else {
287            bail!("Invalid plugin output length");
288        };
289
290        // Read output from plugin memory
291        let output_bytes = instance.read_memory(&memory, output_ptr as usize, output_len)
292            .context("Failed to read output from plugin memory")?;
293
294        // Free memory
295        instance.free(input_ptr, input_bytes.len()).await.ok();
296        instance.free(output_ptr, max_output_size).await.ok();
297
298        Ok(output_bytes)
299    }
300
301    /// Get plugin metadata from WASM instance
302    async fn get_plugin_metadata(&self, instance: &WasmInstance) -> Result<PluginMetadata> {
303        // Get memory
304        let memory = instance.get_memory("memory")
305            .context("Plugin memory not found")?;
306
307        // Allocate output buffer
308        let max_metadata_size = 64 * 1024; // 64KB
309        let output_ptr = instance.allocate(max_metadata_size).await
310            .context("Failed to allocate metadata buffer")?;
311
312        // Call metadata function
313        let args = [
314            wasmtime::Val::I32(output_ptr as i32),
315            wasmtime::Val::I32(max_metadata_size as i32),
316        ];
317
318        let results = instance.call_function(wasm_interface::PLUGIN_METADATA, &args).await
319            .context("Failed to call plugin metadata function")?;
320
321        // Get metadata length
322        let metadata_len = if let Some(wasmtime::Val::I32(len)) = results.get(1) {
323            *len as usize
324        } else {
325            bail!("Invalid metadata length");
326        };
327
328        // Read metadata
329        let metadata_bytes = instance.read_memory(&memory, output_ptr as usize, metadata_len)
330            .context("Failed to read metadata")?;
331
332        // Free memory
333        instance.free(output_ptr, max_metadata_size).await.ok();
334
335        // Deserialize metadata
336        let metadata: PluginMetadata = serde_json::from_slice(&metadata_bytes)
337            .context("Failed to deserialize plugin metadata")?;
338
339        Ok(metadata)
340    }
341
342    /// Initialize a plugin
343    async fn initialize_plugin(&self, instance: &WasmInstance) -> Result<()> {
344        let config = serde_json::json!({});
345        let config_bytes = serde_json::to_vec(&config)?;
346
347        let memory = instance.get_memory("memory")?;
348        let config_ptr = instance.allocate(config_bytes.len()).await?;
349
350        instance.write_memory(&memory, config_ptr as usize, &config_bytes)?;
351
352        let args = [
353            wasmtime::Val::I32(config_ptr as i32),
354            wasmtime::Val::I32(config_bytes.len() as i32),
355        ];
356
357        instance.call_function(wasm_interface::PLUGIN_INIT, &args).await?;
358        instance.free(config_ptr, config_bytes.len()).await.ok();
359
360        Ok(())
361    }
362
363    /// Shutdown a plugin
364    async fn shutdown_plugin(&self, instance: &WasmInstance) -> Result<()> {
365        instance.call_function(wasm_interface::PLUGIN_SHUTDOWN, &[]).await.ok();
366        Ok(())
367    }
368
369    /// Update plugin statistics
370    async fn update_plugin_stats(&self, plugin_id: &str, execution_time_ms: u64) {
371        let mut plugins = self.plugins.write();
372        if let Some(plugin) = plugins.get_mut(plugin_id) {
373            plugin.info.execution_count += 1;
374            plugin.info.total_execution_time_ms += execution_time_ms;
375            plugin.info.last_executed = Some(Utc::now());
376        }
377    }
378
379    /// Update plugin error count
380    async fn update_plugin_error(&self, plugin_id: &str) {
381        let mut plugins = self.plugins.write();
382        if let Some(plugin) = plugins.get_mut(plugin_id) {
383            plugin.info.error_count += 1;
384            plugin.info.status = PluginStatus::Error;
385        }
386    }
387
388    /// List all loaded plugins
389    pub async fn list_plugins(&self) -> Vec<PluginInfo> {
390        let plugins = self.plugins.read();
391        plugins.values().map(|p| p.info.clone()).collect()
392    }
393
394    /// Get plugin info
395    pub async fn get_plugin_info(&self, plugin_id: &str) -> Option<PluginInfo> {
396        let plugins = self.plugins.read();
397        plugins.get(plugin_id).map(|p| p.info.clone())
398    }
399
400    /// Get plugin count
401    pub fn plugin_count(&self) -> usize {
402        self.plugins.read().len()
403    }
404}
405
406// Helper to generate UUID without the uuid crate
407mod uuid {
408    pub struct Uuid;
409    impl Uuid {
410        pub fn new_v4() -> String {
411            use std::sync::atomic::{AtomicU64, Ordering};
412            static COUNTER: AtomicU64 = AtomicU64::new(0);
413            let id = COUNTER.fetch_add(1, Ordering::SeqCst);
414            format!("{:016x}", id)
415        }
416    }
417}
418
419#[cfg(test)]
420mod tests {
421    use super::*;
422
423    #[test]
424    fn test_manager_config() {
425        let config = ManagerConfig::default();
426        assert_eq!(config.max_concurrent_plugins, 100);
427    }
428
429    #[tokio::test]
430    async fn test_manager_creation() {
431        let config = ManagerConfig::default();
432        let manager = PluginManager::new(config);
433        assert!(manager.is_ok());
434    }
435
436    #[tokio::test]
437    async fn test_manager_empty_list() {
438        let manager = PluginManager::new(ManagerConfig::default()).unwrap();
439        let plugins = manager.list_plugins().await;
440        assert_eq!(plugins.len(), 0);
441    }
442}