peresil：Rust插件管理与功能增强工具

简介

peresil是一个专为Rust设计的轻量级插件管理库，提供动态加载、热插拔和运行时扩展功能。它允许开发者在运行时加载和卸载编译为动态库的Rust代码模块，实现高度模块化的应用架构。

核心特性

• 动态插件加载与卸载
• 类型安全的插件接口
• 跨平台支持（Linux/macOS/Windows）
• 零成本抽象
• 内存安全保证

安装方法

在Cargo.toml中添加依赖：

[dependencies]
peresil = "0.3"

基本用法

1. 定义插件接口

// plugin_trait.rs
pub trait Calculator {
    fn add(&self, a: i32, b: i32) -> i32;
    fn multiply(&self, a: i32, b: i32) -> i32;
}

2. 实现插件

// src/plugins/basic_calculator.rs
use peresil::Plugin;
use plugin_trait::Calculator;

#[derive(Default)]
pub struct BasicCalculator;

impl Calculator for BasicCalculator {
    fn add(&self, a: i32, b: i32) -> i32 {
        a + b
    }
    
    fn multiply(&self, a: i32, b: i32) -> i32 {
        a * b
    }
}

// 必须的插件导出宏
peresil::export_plugin!(BasicCalculator);

3. 主程序加载插件

use peresil::{PluginManager, Plugin};
use plugin_trait::Calculator;
use std::path::Path;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut manager = PluginManager::new();
    
    // 加载插件
    let plugin_path = Path::new("./target/debug/libbasic_calculator.so");
    let plugin = manager.load_plugin::<dyn Calculator>(plugin_path)?;
    
    // 使用插件功能
    let result = plugin.add(5, 3);
    println!("5 + 3 = {}", result);
    
    // 卸载插件
    manager.unload_plugin(plugin_path)?;
    
    Ok(())
}

高级用法

多插件管理

let mut manager = PluginManager::new();

// 加载多个插件
manager.load_plugin::<dyn Calculator>("./plugins/calculator.so")?;
manager.load_plugin::<dyn Logger>("./plugins/logger.so")?;

// 获取特定类型的所有插件
let calculators = manager.get_plugins::<dyn Calculator>();
for calc in calculators {
    println!("Result: {}", calc.multiply(4, 5));
}

热重载示例

use std::time::Duration;
use std::thread;

fn hot_reload_example() -> Result<(), Box<dyn std::error::Error>> {
    let mut manager = PluginManager::new();
    let plugin_path = "./plugins/dynamic_module.so";
    
    loop {
        // 检查插件更新并重新加载
        if manager.check_update(plugin_path) {
            manager.reload_plugin::<dyn MyTrait>(plugin_path)?;
            println!("Plugin reloaded successfully");
        }
        
        thread::sleep(Duration::from_secs(1));
    }
}

构建配置

在插件的Cargo.toml中需要配置：

[lib]
crate-type = ["cdylib"]

[dependencies]
peresil = { version = "0.3", features = ["plugin"] }

注意事项

1. 插件和主程序必须使用相同的Rust版本
2. 确保 trait 定义在双方完全一致
3. 在Unix系统上使用.so，macOS使用.dylib，Windows使用.dll
4. 注意内存安全边界，避免跨插件边界传递复杂类型

错误处理

match manager.load_plugin::<dyn MyTrait>(path) {
    Ok(plugin) => {
        // 使用插件
    },
    Err(e) => {
        eprintln!("Failed to load plugin: {}", e);
        // 处理错误
    }
}

peresil为Rust应用程序提供了灵活的插件架构，使得功能扩展和维护变得更加简单高效。

完整示例demo

以下是一个完整的peresil使用示例，包含插件定义、实现和主程序：

插件接口定义 (shared/src/lib.rs)

// 定义插件接口trait
pub trait TextProcessor {
    fn process(&self, text: &str) -> String;
    fn get_name(&self) -> &'static str;
}

插件实现1 (plugin1/src/lib.rs)

use peresil::Plugin;
use shared::TextProcessor;

// 大写转换插件
pub struct UppercaseProcessor;

impl TextProcessor for UppercaseProcessor {
    fn process(&self, text: &str) -> String {
        text.to_uppercase()
    }
    
    fn get_name(&self) -> &'static str {
        "Uppercase Processor"
    }
}

// 导出插件
peresil::export_plugin!(UppercaseProcessor);

插件实现2 (plugin2/src/lib.rs)

use peresil::Plugin;
use shared::TextProcessor;

// 反转文本插件
pub struct ReverseProcessor;

impl TextProcessor for ReverseProcessor {
    fn process(&self, text: &str) -> String {
        text.chars().rev().collect()
    }
    
    fn get_name(&self) -> &'static str {
        "Reverse Processor"
    }
}

// 导出插件
peresil::export_plugin!(ReverseProcessor);

主程序 (main/src/main.rs)

use peresil::PluginManager;
use shared::TextProcessor;
use std::path::Path;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut manager = PluginManager::new();
    
    println!("Loading plugins...");
    
    // 加载第一个插件
    let plugin1_path = Path::new("../plugin1/target/debug/libplugin1.so");
    let plugin1 = manager.load_plugin::<dyn TextProcessor>(plugin1_path)?;
    
    // 加载第二个插件
    let plugin2_path = Path::new("../plugin2/target/debug/libplugin2.so");
    let plugin2 = manager.load_plugin::<dyn TextProcessor>(plugin2_path)?;
    
    let test_text = "Hello, World!";
    
    // 使用第一个插件
    println!("\nUsing {}:", plugin1.get_name());
    let result1 = plugin1.process(test_text);
    println!("Input: {}, Output: {}", test_text, result1);
    
    // 使用第二个插件
    println!("\nUsing {}:", plugin2.get_name());
    let result2 = plugin2.process(test_text);
    println!("Input: {}, Output: {}", test_text, result2);
    
    // 获取所有文本处理器插件
    println!("\nAll loaded text processors:");
    let processors = manager.get_plugins::<dyn TextProcessor>();
    for processor in processors {
        println!("- {}", processor.get_name());
    }
    
    // 卸载插件
    manager.unload_plugin(plugin1_path)?;
    manager.unload_plugin(plugin2_path)?;
    
    println!("\nPlugins unloaded successfully!");
    
    Ok(())
}

构建配置示例

主程序Cargo.toml:

[package]
name = "main-app"
version = "0.1.0"
edition = "2021"

[dependencies]
peresil = "0.3"
shared = { path = "../shared" }

插件Cargo.toml (示例):

[package]
name = "plugin1"
version = "0.1.0"
edition = "2021"

[lib]
name = "plugin1"
crate-type = ["cdylib"]

[dependencies]
peresil = { version = "0.3", features = ["plugin"] }
shared = { path = "../shared" }

这个完整示例展示了如何创建多个不同类型的插件并在主程序中动态加载和使用它们，体现了peresil库的强大功能和灵活性。