llm_test_bench_core/plugins/
manager.rs1use 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#[derive(Debug, Clone)]
28pub struct ManagerConfig {
29 pub runtime_config: RuntimeConfig,
31
32 pub max_concurrent_plugins: usize,
34
35 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
49struct LoadedPlugin {
51 info: PluginInfo,
52 instance: Arc<WasmInstance>,
53 config: PluginConfig,
54}
55
56pub struct PluginManager {
58 config: ManagerConfig,
59 runtime: Arc<WasmRuntime>,
60 loader: PluginLoader,
61 plugins: Arc<RwLock<HashMap<String, LoadedPlugin>>>,
62}
63
64impl PluginManager {
65 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 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 pub async fn load_plugin_from_bytes(&self, name: String, wasm_bytes: Vec<u8>) -> Result<String> {
96 {
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 let module = self.runtime.load_module(&wasm_bytes)
106 .context("Failed to load WASM module")?;
107
108 let instance = self.runtime.instantiate(&module).await
110 .context("Failed to instantiate WASM module")?;
111
112 let metadata = self.get_plugin_metadata(&instance).await
114 .context("Failed to get plugin metadata")?;
115
116 let plugin_id = format!("{}_{}", metadata.name, uuid::Uuid::new_v4());
118
119 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 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 self.initialize_plugin(&instance).await?;
142
143 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 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 plugin.info.status = PluginStatus::Unloading;
169
170 self.shutdown_plugin(&plugin.instance).await?;
172
173 plugins.remove(plugin_id);
175
176 tracing::info!("Plugin unloaded: {}", plugin_id);
177
178 Ok(())
179 }
180
181 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 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 let input_bytes = serde_json::to_vec(&input)
202 .context("Failed to serialize plugin input")?;
203
204 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 let mut output: PluginOutput = serde_json::from_slice(&output_bytes)
230 .context("Failed to deserialize plugin output")?;
231
232 let elapsed = start.elapsed();
234 output.metadata.execution_time_ms = elapsed.as_millis() as u64;
235
236 self.update_plugin_stats(plugin_id, elapsed.as_millis() as u64).await;
238
239 Ok(output)
240 }
241
242 async fn execute_plugin_internal(
244 &self,
245 instance: &WasmInstance,
246 input_bytes: &[u8],
247 ) -> Result<Vec<u8>> {
248 let memory = instance.get_memory("memory")
250 .context("Plugin memory not found")?;
251
252 let input_ptr = instance.allocate(input_bytes.len()).await
254 .context("Failed to allocate input memory")?;
255
256 instance.write_memory(&memory, input_ptr as usize, input_bytes)
258 .context("Failed to write input to plugin memory")?;
259
260 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 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 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 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 let output_bytes = instance.read_memory(&memory, output_ptr as usize, output_len)
292 .context("Failed to read output from plugin memory")?;
293
294 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 async fn get_plugin_metadata(&self, instance: &WasmInstance) -> Result<PluginMetadata> {
303 let memory = instance.get_memory("memory")
305 .context("Plugin memory not found")?;
306
307 let max_metadata_size = 64 * 1024; let output_ptr = instance.allocate(max_metadata_size).await
310 .context("Failed to allocate metadata buffer")?;
311
312 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 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 let metadata_bytes = instance.read_memory(&memory, output_ptr as usize, metadata_len)
330 .context("Failed to read metadata")?;
331
332 instance.free(output_ptr, max_metadata_size).await.ok();
334
335 let metadata: PluginMetadata = serde_json::from_slice(&metadata_bytes)
337 .context("Failed to deserialize plugin metadata")?;
338
339 Ok(metadata)
340 }
341
342 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 async fn shutdown_plugin(&self, instance: &WasmInstance) -> Result<()> {
365 instance.call_function(wasm_interface::PLUGIN_SHUTDOWN, &[]).await.ok();
366 Ok(())
367 }
368
369 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 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 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 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 pub fn plugin_count(&self) -> usize {
402 self.plugins.read().len()
403 }
404}
405
406mod 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}