oxidite-plugin 2.2.0

Plugin system for Oxidite web framework with dynamic loading and extension capabilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::collections::HashMap;
use std::path::Path;
use std::sync::Arc;
use oxidite_core::{Result, Error};

use crate::{Plugin, PluginInfo, PluginHook, HookResult, PluginLoader, PluginConfig};

/// Main plugin manager
pub struct PluginManager {
    plugins: HashMap<String, Arc<dyn Plugin>>,
    config: PluginConfig,
}

impl PluginManager {
    pub fn new(config: PluginConfig) -> Self {
        Self {
            plugins: HashMap::new(),
            config,
        }
    }
    
    /// Load plugins from a directory
    pub async fn load_plugins_from_directory<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {
        let loader = PluginLoader::new();
        let loaded_plugins = loader.load_from_directory(path).await?;
        for plugin in loaded_plugins {
            self.register_plugin(plugin)?;
        }

        if self.config.enabled_plugins.is_empty() {
            return Ok(());
        }

        for plugin_id in self.config.enabled_plugins.clone() {
            let _ = self.enable_plugin(&plugin_id).await;
        }
        Ok(())
    }
    
    /// Register a plugin
    pub fn register_plugin(&mut self, plugin: Arc<dyn Plugin>) -> Result<()> {
        let info = plugin.info();
        
        if self.plugins.contains_key(&info.id) {
            return Err(Error::InternalServerError(
                format!("Plugin with id '{}' already exists", info.id)
            ));
        }
        
        self.plugins.insert(info.id.clone(), plugin);
        
        Ok(())
    }
    
    /// Enable a plugin
    pub async fn enable_plugin(&mut self, plugin_id: &str) -> Result<()> {
        if let Some(plugin) = self.plugins.get(plugin_id) {
            plugin.on_enable().await?;
            
            // Update plugin info to enabled
            // Note: In a real implementation, we'd need mutable access to update the info
            
            Ok(())
        } else {
            Err(Error::NotFound(format!("Plugin '{}' not found", plugin_id)))
        }
    }
    
    /// Disable a plugin
    pub async fn disable_plugin(&mut self, plugin_id: &str) -> Result<()> {
        if let Some(plugin) = self.plugins.get(plugin_id) {
            plugin.on_disable().await?;
            Ok(())
        } else {
            Err(Error::NotFound(format!("Plugin '{}' not found", plugin_id)))
        }
    }
    
    /// Execute a hook across all registered plugins
    pub async fn execute_hook(&self, hook: PluginHook) -> Result<HookResult> {
        let mut result = HookResult::Continue;
        
        for plugin in self.plugins.values() {
            if !plugin.info().enabled {
                continue;
            }
            
            result = plugin.hook(hook.clone()).await;
            
            match result {
                HookResult::Stop => break,
                HookResult::Response(_) => return Ok(result),
                HookResult::Error(_) => return Ok(result),
                _ => continue,
            }
        }
        
        Ok(result)
    }
    
    /// Get a list of all plugins
    pub fn list_plugins(&self) -> Vec<PluginInfo> {
        self.plugins.values()
            .map(|p| p.info())
            .collect()
    }
    
    /// Initialize all enabled plugins
    pub async fn initialize(&self) -> Result<()> {
        for plugin in self.plugins.values() {
            if plugin.info().enabled {
                plugin.on_load().await?;
            }
        }
        
        Ok(())
    }
    
    /// Shutdown all plugins
    pub async fn shutdown(&self) -> Result<()> {
        for plugin in self.plugins.values() {
            plugin.on_unload().await?;
        }
        
        Ok(())
    }
}

/// Helper function to create a plugin manager
pub fn create_manager(config: PluginConfig) -> PluginManager {
    PluginManager::new(config)
}