Struct PluginConfig 

pub struct PluginConfig {
    pub data: Value,
    pub init_params: Option<Value>,
    pub worker_threads: Option<usize>,
    pub log_level: String,
    pub max_concurrent_ops: usize,
    pub shutdown_timeout_ms: u64,
}

Plugin configuration passed during initialization

Fields

data: Value

Plugin-specific configuration data

General runtime configuration such as database URLs, API keys, feature flags, etc. Accessible throughout the plugin’s lifetime.

init_params: Option<Value>

Initialization parameters

Structured data passed to the plugin during initialization. Intended for one-time setup parameters that are only needed during on_start(). Provides better separation from runtime configuration in data.

worker_threads: Option<usize>

Number of async worker threads (default: number of CPU cores)

log_level: String

Initial log level

max_concurrent_ops: usize

Maximum concurrent async operations

shutdown_timeout_ms: u64

Shutdown timeout in milliseconds

Implementations

impl PluginConfig

pub fn new() -> Self

Create a new empty configuration

pub fn from_json(bytes: &[u8]) -> Result<Self, Error>

Create configuration from JSON bytes

pub fn get<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Option<T>

Get a typed value from the configuration data

pub fn set<T: Serialize>(&mut self, key: &str, value: T) -> Result<(), Error>

Set a value in the configuration data

pub fn get_init_param<T: for<'de> Deserialize<'de>>( &self, key: &str, ) -> Option<T>

Get a typed value from initialization parameters

Returns None if init_params is not set or the key doesn’t exist.

Example

#[derive(Deserialize)]
struct DatabaseInit {
    migrations_path: String,
    seed_data: bool,
}

async fn on_start(&self, ctx: &PluginContext) -> PluginResult<()> {
    if let Some(db_init) = ctx.config().get_init_param::<DatabaseInit>("database") {
        if db_init.seed_data {
            self.seed_database(&db_init.migrations_path).await?;
        }
    }
    Ok(())
}

pub fn init_params_as<T: for<'de> Deserialize<'de>>(&self) -> Option<T>

Get the entire initialization parameters as a typed value

Returns None if init_params is not set.

Example

#[derive(Deserialize)]
struct InitParams {
    setup_mode: String,
    enable_features: Vec<String>,
}

async fn on_start(&self, ctx: &PluginContext) -> PluginResult<()> {
    if let Some(params) = ctx.config().init_params_as::<InitParams>() {
        // Use initialization parameters...
    }
    Ok(())
}

pub fn set_init_params(&mut self, params: Value)

Set initialization parameters

This is typically called by the host application before initializing the plugin.

Example

let mut config = PluginConfig::default();
config.set_init_params(serde_json::json!({
    "setup_mode": "development",
    "seed_data": true
}));

Trait Implementations

impl Clone for PluginConfig

fn clone(&self) -> PluginConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PluginConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PluginConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PluginConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PluginConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.