Struct PluginResult 

pub struct PluginResult<P: PluginPayload> {
    pub continue_processing: bool,
    pub modified_payload: Option<P>,
    pub modified_extensions: Option<OwnedExtensions>,
    pub violation: Option<PluginViolation>,
    pub metadata: Option<Value>,
}

Result returned by a hook handler.

Payload and extension modifications are separate — this is a core design decision. Extension-only changes (add a label, set a header) don’t require copying the payload. The payload is only present in modified_payload when message content actually changed.

The executor interprets the result based on the plugin’s mode:

• Sequential/Transform: modified_payload and modified_extensions are accepted.
• Audit/Concurrent/FireAndForget: modifications are discarded.
• Sequential/Concurrent: continue_processing = false halts the pipeline.
• Transform/Audit/FireAndForget: blocks are suppressed.

Mirrors Python’s PluginResult[T] with separate modified_payload and modified_extensions fields.

Examples

use cpex_core::hooks::{PluginPayload, PluginResult};
use cpex_core::error::PluginViolation;

// Define a simple payload
#[derive(Debug, Clone)]
struct TestPayload { value: i32 }
cpex_core::impl_plugin_payload!(TestPayload);

// Allow — no changes
let result: PluginResult<TestPayload> = PluginResult::allow();
assert!(result.continue_processing);
assert!(result.modified_payload.is_none());

// Deny
let result: PluginResult<TestPayload> = PluginResult::deny(
    PluginViolation::new("forbidden", "not allowed")
);
assert!(!result.continue_processing);
assert!(result.violation.is_some());

Fields

continue_processing: bool

Whether the pipeline should continue processing. false halts the pipeline (deny). Only respected for Sequential and Concurrent modes.

modified_payload: Option<P>

Modified payload. None means no content modification. Only accepted from Sequential and Transform mode plugins.

modified_extensions: Option<OwnedExtensions>

Modified extensions. None means no extension changes. Return an OwnedExtensions from extensions.cow_copy(). The executor validates (immutable unchanged, monotonic superset) and merges back into the pipeline’s Extensions.

violation: Option<PluginViolation>

Policy violation. Present when continue_processing is false.

metadata: Option<Value>

Optional metadata from the plugin (telemetry, diagnostics). Not used for scheduling or policy decisions.

Implementations

impl<P: PluginPayload> PluginResult<P>

pub fn allow() -> Self

Allow — payload continues unchanged, no extension changes.

Examples found in repository

examples/plugin_demo.rs (line 96)

    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        if payload.user.is_empty() {
            println!("  [identity-resolver] DENIED: no user identity");
            return PluginResult::deny(PluginViolation::new(
                "no_identity",
                "User identity is required",
            ));
        }
        println!(
            "  [identity-resolver] OK: user '{}' identified",
            payload.user
        );
        PluginResult::allow()
    }
}

impl HookHandler<ToolPostInvoke> for IdentityResolver {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        println!(
            "  [identity-resolver] post-invoke: user '{}' completed '{}'",
            payload.user, payload.tool_name
        );
        PluginResult::allow()
    }
}

/// PII guard — blocks access to sensitive tools without clearance.
struct PiiGuard {
    cfg: PluginConfig,
}

#[async_trait]
impl Plugin for PiiGuard {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
    // initialize() and shutdown() use defaults — no setup needed
}

impl HookHandler<ToolPreInvoke> for PiiGuard {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        // Check if the user has PII clearance (simulated via context)
        let has_clearance = ctx
            .get_global("pii_clearance")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);

        if !has_clearance {
            println!(
                "  [pii-guard] DENIED: user '{}' lacks PII clearance for '{}'",
                payload.user, payload.tool_name
            );
            return PluginResult::deny(PluginViolation::new(
                "pii_access_denied",
                "PII clearance required",
            ));
        }

        println!(
            "  [pii-guard] OK: user '{}' has PII clearance",
            payload.user
        );
        PluginResult::allow()
    }
}

/// Audit logger — logs all tool invocations (fire-and-forget).
struct AuditLogger {
    cfg: PluginConfig,
}

#[async_trait]
impl Plugin for AuditLogger {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
    // initialize() and shutdown() use defaults — no setup needed
}

impl HookHandler<ToolPreInvoke> for AuditLogger {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        println!(
            "  [audit-logger] LOG: user='{}' tool='{}' args='{}'",
            payload.user, payload.tool_name, payload.arguments
        );
        PluginResult::allow()
    }
}

impl HookHandler<ToolPostInvoke> for AuditLogger {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        println!(
            "  [audit-logger] LOG: post-invoke user='{}' tool='{}'",
            payload.user, payload.tool_name
        );
        PluginResult::allow()
    }
}

// ---------------------------------------------------------------------------
// Awaiting plugin example — RemoteAuthz
// ---------------------------------------------------------------------------
//
// `HookHandler<H>` is async by design — `handle` is `async fn`.
// Plugins that don't need to `.await` anything still write
// `async fn handle` and return synchronously; this plugin shows the
// other direction, where the body genuinely awaits per-invocation
// work. The realistic version would call a remote authz service
// (gRPC, HTTP, OPA, Cedarling, etc.); here we simulate the network
// round-trip with a small `tokio::time::sleep` so the demo runs
// offline.
//
// Key things this shows:
//   1. Per-request latency state is *cached at init* — the handler
//      consults the in-memory ACL and only "calls out" on a miss.
//      Hot-path I/O is the most common source of latency regressions
//      in plugins, so prefer initialize-time loading wherever you can.
//   2. Registration uses the exact same factory pattern as any other
//      plugin — `TypedHandlerAdapter::<H, _>` and the same
//      `register_factory` call. There is no separate async path.
struct RemoteAuthz {
    cfg: PluginConfig,
    /// ACL "fetched" at init. Populated in Plugin::initialize.
    allowed_users: tokio::sync::RwLock<std::collections::HashSet<String>>,
}

#[async_trait]
impl Plugin for RemoteAuthz {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
    /// Pretend we're loading the ACL from a remote service. In a real
    /// plugin this would be `client.fetch_acl().await`; we simulate
    /// the round-trip with a small sleep so the demo runs offline.
    async fn initialize(&self) -> Result<(), Box<PluginError>> {
        tokio::time::sleep(std::time::Duration::from_millis(2)).await;
        let mut acl = self.allowed_users.write().await;
        acl.extend(["alice", "bob"].iter().map(|s| s.to_string()));
        println!(
            "  [remote-authz] initialized — ACL cached ({} users)",
            acl.len()
        );
        Ok(())
    }
    async fn shutdown(&self) -> Result<(), Box<PluginError>> {
        println!("  [remote-authz] shutdown");
        Ok(())
    }
}

impl HookHandler<ToolPreInvoke> for RemoteAuthz {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        // Cache hit path — fast.
        let acl = self.allowed_users.read().await;
        if acl.contains(&payload.user) {
            println!(
                "  [remote-authz] OK (cache hit): user '{}' allowed",
                payload.user
            );
            return PluginResult::allow();
        }
        drop(acl); // release read lock before the fake remote call
                   // Cache miss path — simulate a remote authz check. In a real
                   // plugin this is where you'd `.await` a gRPC or HTTP call.
                   // The latency cost is real and shows up on the request path.
        tokio::time::sleep(std::time::Duration::from_millis(1)).await;
        println!(
            "  [remote-authz] DENIED (cache miss + remote check): user '{}'",
            payload.user
        );
        PluginResult::deny(PluginViolation::new(
            "remote_authz_denied",
            format!("User '{}' not in remote ACL", payload.user),
        ))
    }

examples/cmf_capabilities_demo.rs (line 117)

    async fn handle(
        &self,
        payload: &MessagePayload,
        extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<MessagePayload> {
        // Determine if this is pre or post invoke based on message content
        let is_result = payload.message.is_tool_result();

        if is_result {
            // POST-INVOKE: verify the tool result came from an authorized call
            let tool_name = payload
                .message
                .get_tool_results()
                .first()
                .map(|tr| tr.tool_name.as_str())
                .unwrap_or("unknown");
            println!(
                "  [identity-checker] POST-INVOKE: verifying result from '{}'",
                tool_name
            );

            if let Some(ref security) = extensions.security {
                if let Some(ref subject) = security.subject {
                    println!(
                        "  [identity-checker] Result authorized for subject: {:?}",
                        subject.id
                    );
                }
            }
            println!("  [identity-checker] POST-INVOKE ALLOWED");
        } else {
            // PRE-INVOKE: check caller identity and roles
            let tool_name = payload
                .message
                .get_tool_calls()
                .first()
                .map(|tc| tc.name.as_str())
                .unwrap_or("unknown");
            println!(
                "  [identity-checker] PRE-INVOKE: checking identity for '{}'",
                tool_name
            );

            if let Some(ref security) = extensions.security {
                let labels: Vec<&String> = security.labels.iter().collect();
                println!("  [identity-checker] Security labels: {:?}", labels);

                if let Some(ref subject) = security.subject {
                    println!(
                        "  [identity-checker] Subject: {:?}, Roles: {:?}",
                        subject.id,
                        subject.roles.iter().collect::<Vec<_>>()
                    );

                    if security.has_label("PII") && !subject.roles.contains("hr_admin") {
                        return PluginResult::deny(PluginViolation::new(
                            "insufficient_role",
                            format!("Tool '{}' requires 'hr_admin' role for PII data", tool_name),
                        ));
                    }
                }
            }

            if extensions.http.is_some() {
                println!("  [identity-checker] WARNING: HTTP visible (unexpected!)");
            } else {
                println!("  [identity-checker] HTTP: not visible (correct — no read_headers)");
            }
            println!("  [identity-checker] PRE-INVOKE ALLOWED");
        }

        PluginResult::allow()
    }
}

// ---------------------------------------------------------------------------
// Plugin: HeaderInjector
// Has read_headers, write_headers, append_labels capabilities.
// Uses COW to add a security label and inject a header.
// ---------------------------------------------------------------------------

struct HeaderInjector {
    cfg: PluginConfig,
}

#[async_trait]
impl Plugin for HeaderInjector {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
}

impl HookHandler<CmfHook> for HeaderInjector {
    async fn handle(
        &self,
        _payload: &MessagePayload,
        extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<MessagePayload> {
        // Can see HTTP (has read_headers)
        if let Some(ref http) = extensions.http {
            println!(
                "  [header-injector] HTTP headers visible: {:?}",
                http.request_headers
            );
        }

        // Can NOT see security subject (no read_subject)
        if let Some(ref security) = extensions.security {
            if security.subject.is_some() {
                println!("  [header-injector] WARNING: Subject visible (unexpected!)");
            } else {
                println!("  [header-injector] Security subject: not visible (no read_subject)");
            }
        }

        // COW copy to modify — tokens propagate from the executor
        let mut modified = extensions.cow_copy();

        // Add a label via MonotonicSet (has append_labels)
        if modified.labels_write_token.is_some() {
            modified.security.as_mut().unwrap().add_label("PROCESSED");
            println!("  [header-injector] Added label 'PROCESSED'");
        }

        // Inject a header via Guarded (has write_headers)
        if let Some(ref token) = modified.http_write_token {
            modified
                .http
                .as_mut()
                .unwrap()
                .write(token)
                .set_header("X-Processed-By", "header-injector");
            println!("  [header-injector] Injected header 'X-Processed-By'");
        }

        PluginResult::modify_extensions(modified)
    }
}

// ---------------------------------------------------------------------------
// Plugin: AuditLogger
// Has read_headers, read_security, read_labels capabilities.
// Read-only — just logs what it can see.
// ---------------------------------------------------------------------------

struct AuditLogger {
    cfg: PluginConfig,
}

#[async_trait]
impl Plugin for AuditLogger {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
}

impl HookHandler<CmfHook> for AuditLogger {
    async fn handle(
        &self,
        payload: &MessagePayload,
        extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<MessagePayload> {
        let is_result = payload.message.is_tool_result();
        let phase = if is_result { "POST" } else { "PRE" };

        let tool_name = if is_result {
            payload
                .message
                .get_tool_results()
                .first()
                .map(|tr| tr.tool_name.as_str())
                .unwrap_or("unknown")
        } else {
            payload
                .message
                .get_tool_calls()
                .first()
                .map(|tc| tc.name.as_str())
                .unwrap_or("unknown")
        };

        print!("  [audit-logger] AUDIT[{}]: tool='{}' ", phase, tool_name);

        if let Some(ref security) = extensions.security {
            let labels: Vec<&String> = security.labels.iter().collect();
            print!("labels={:?} ", labels);
        }

        if let Some(ref http) = extensions.http {
            if let Some(req_id) = http.get_header("X-Request-ID") {
                print!("request_id='{}' ", req_id);
            }
        }

        if is_result {
            let is_error = payload
                .message
                .get_tool_results()
                .first()
                .map(|tr| tr.is_error)
                .unwrap_or(false);
            print!("error={} ", is_error);
        }

        println!();
        PluginResult::allow()
    }

pub fn deny(violation: PluginViolation) -> Self

Deny — pipeline halts with a violation.

Examples found in repository

examples/plugin_demo.rs (lines 87-90)

    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        if payload.user.is_empty() {
            println!("  [identity-resolver] DENIED: no user identity");
            return PluginResult::deny(PluginViolation::new(
                "no_identity",
                "User identity is required",
            ));
        }
        println!(
            "  [identity-resolver] OK: user '{}' identified",
            payload.user
        );
        PluginResult::allow()
    }
}

impl HookHandler<ToolPostInvoke> for IdentityResolver {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        println!(
            "  [identity-resolver] post-invoke: user '{}' completed '{}'",
            payload.user, payload.tool_name
        );
        PluginResult::allow()
    }
}

/// PII guard — blocks access to sensitive tools without clearance.
struct PiiGuard {
    cfg: PluginConfig,
}

#[async_trait]
impl Plugin for PiiGuard {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
    // initialize() and shutdown() use defaults — no setup needed
}

impl HookHandler<ToolPreInvoke> for PiiGuard {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        // Check if the user has PII clearance (simulated via context)
        let has_clearance = ctx
            .get_global("pii_clearance")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);

        if !has_clearance {
            println!(
                "  [pii-guard] DENIED: user '{}' lacks PII clearance for '{}'",
                payload.user, payload.tool_name
            );
            return PluginResult::deny(PluginViolation::new(
                "pii_access_denied",
                "PII clearance required",
            ));
        }

        println!(
            "  [pii-guard] OK: user '{}' has PII clearance",
            payload.user
        );
        PluginResult::allow()
    }
}

/// Audit logger — logs all tool invocations (fire-and-forget).
struct AuditLogger {
    cfg: PluginConfig,
}

#[async_trait]
impl Plugin for AuditLogger {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
    // initialize() and shutdown() use defaults — no setup needed
}

impl HookHandler<ToolPreInvoke> for AuditLogger {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        println!(
            "  [audit-logger] LOG: user='{}' tool='{}' args='{}'",
            payload.user, payload.tool_name, payload.arguments
        );
        PluginResult::allow()
    }
}

impl HookHandler<ToolPostInvoke> for AuditLogger {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        println!(
            "  [audit-logger] LOG: post-invoke user='{}' tool='{}'",
            payload.user, payload.tool_name
        );
        PluginResult::allow()
    }
}

// ---------------------------------------------------------------------------
// Awaiting plugin example — RemoteAuthz
// ---------------------------------------------------------------------------
//
// `HookHandler<H>` is async by design — `handle` is `async fn`.
// Plugins that don't need to `.await` anything still write
// `async fn handle` and return synchronously; this plugin shows the
// other direction, where the body genuinely awaits per-invocation
// work. The realistic version would call a remote authz service
// (gRPC, HTTP, OPA, Cedarling, etc.); here we simulate the network
// round-trip with a small `tokio::time::sleep` so the demo runs
// offline.
//
// Key things this shows:
//   1. Per-request latency state is *cached at init* — the handler
//      consults the in-memory ACL and only "calls out" on a miss.
//      Hot-path I/O is the most common source of latency regressions
//      in plugins, so prefer initialize-time loading wherever you can.
//   2. Registration uses the exact same factory pattern as any other
//      plugin — `TypedHandlerAdapter::<H, _>` and the same
//      `register_factory` call. There is no separate async path.
struct RemoteAuthz {
    cfg: PluginConfig,
    /// ACL "fetched" at init. Populated in Plugin::initialize.
    allowed_users: tokio::sync::RwLock<std::collections::HashSet<String>>,
}

#[async_trait]
impl Plugin for RemoteAuthz {
    fn config(&self) -> &PluginConfig {
        &self.cfg
    }
    /// Pretend we're loading the ACL from a remote service. In a real
    /// plugin this would be `client.fetch_acl().await`; we simulate
    /// the round-trip with a small sleep so the demo runs offline.
    async fn initialize(&self) -> Result<(), Box<PluginError>> {
        tokio::time::sleep(std::time::Duration::from_millis(2)).await;
        let mut acl = self.allowed_users.write().await;
        acl.extend(["alice", "bob"].iter().map(|s| s.to_string()));
        println!(
            "  [remote-authz] initialized — ACL cached ({} users)",
            acl.len()
        );
        Ok(())
    }
    async fn shutdown(&self) -> Result<(), Box<PluginError>> {
        println!("  [remote-authz] shutdown");
        Ok(())
    }
}

impl HookHandler<ToolPreInvoke> for RemoteAuthz {
    async fn handle(
        &self,
        payload: &ToolInvokePayload,
        _extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<ToolInvokePayload> {
        // Cache hit path — fast.
        let acl = self.allowed_users.read().await;
        if acl.contains(&payload.user) {
            println!(
                "  [remote-authz] OK (cache hit): user '{}' allowed",
                payload.user
            );
            return PluginResult::allow();
        }
        drop(acl); // release read lock before the fake remote call
                   // Cache miss path — simulate a remote authz check. In a real
                   // plugin this is where you'd `.await` a gRPC or HTTP call.
                   // The latency cost is real and shows up on the request path.
        tokio::time::sleep(std::time::Duration::from_millis(1)).await;
        println!(
            "  [remote-authz] DENIED (cache miss + remote check): user '{}'",
            payload.user
        );
        PluginResult::deny(PluginViolation::new(
            "remote_authz_denied",
            format!("User '{}' not in remote ACL", payload.user),
        ))
    }

examples/cmf_capabilities_demo.rs (lines 101-104)

    async fn handle(
        &self,
        payload: &MessagePayload,
        extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<MessagePayload> {
        // Determine if this is pre or post invoke based on message content
        let is_result = payload.message.is_tool_result();

        if is_result {
            // POST-INVOKE: verify the tool result came from an authorized call
            let tool_name = payload
                .message
                .get_tool_results()
                .first()
                .map(|tr| tr.tool_name.as_str())
                .unwrap_or("unknown");
            println!(
                "  [identity-checker] POST-INVOKE: verifying result from '{}'",
                tool_name
            );

            if let Some(ref security) = extensions.security {
                if let Some(ref subject) = security.subject {
                    println!(
                        "  [identity-checker] Result authorized for subject: {:?}",
                        subject.id
                    );
                }
            }
            println!("  [identity-checker] POST-INVOKE ALLOWED");
        } else {
            // PRE-INVOKE: check caller identity and roles
            let tool_name = payload
                .message
                .get_tool_calls()
                .first()
                .map(|tc| tc.name.as_str())
                .unwrap_or("unknown");
            println!(
                "  [identity-checker] PRE-INVOKE: checking identity for '{}'",
                tool_name
            );

            if let Some(ref security) = extensions.security {
                let labels: Vec<&String> = security.labels.iter().collect();
                println!("  [identity-checker] Security labels: {:?}", labels);

                if let Some(ref subject) = security.subject {
                    println!(
                        "  [identity-checker] Subject: {:?}, Roles: {:?}",
                        subject.id,
                        subject.roles.iter().collect::<Vec<_>>()
                    );

                    if security.has_label("PII") && !subject.roles.contains("hr_admin") {
                        return PluginResult::deny(PluginViolation::new(
                            "insufficient_role",
                            format!("Tool '{}' requires 'hr_admin' role for PII data", tool_name),
                        ));
                    }
                }
            }

            if extensions.http.is_some() {
                println!("  [identity-checker] WARNING: HTTP visible (unexpected!)");
            } else {
                println!("  [identity-checker] HTTP: not visible (correct — no read_headers)");
            }
            println!("  [identity-checker] PRE-INVOKE ALLOWED");
        }

        PluginResult::allow()
    }

pub fn modify_payload(payload: P) -> Self

Modify payload only — extensions unchanged.

pub fn modify_extensions(extensions: OwnedExtensions) -> Self

Modify extensions only — payload unchanged. Takes an OwnedExtensions from extensions.cow_copy().

Examples found in repository

examples/cmf_capabilities_demo.rs (line 182)

    async fn handle(
        &self,
        _payload: &MessagePayload,
        extensions: &Extensions,
        _ctx: &mut PluginContext,
    ) -> PluginResult<MessagePayload> {
        // Can see HTTP (has read_headers)
        if let Some(ref http) = extensions.http {
            println!(
                "  [header-injector] HTTP headers visible: {:?}",
                http.request_headers
            );
        }

        // Can NOT see security subject (no read_subject)
        if let Some(ref security) = extensions.security {
            if security.subject.is_some() {
                println!("  [header-injector] WARNING: Subject visible (unexpected!)");
            } else {
                println!("  [header-injector] Security subject: not visible (no read_subject)");
            }
        }

        // COW copy to modify — tokens propagate from the executor
        let mut modified = extensions.cow_copy();

        // Add a label via MonotonicSet (has append_labels)
        if modified.labels_write_token.is_some() {
            modified.security.as_mut().unwrap().add_label("PROCESSED");
            println!("  [header-injector] Added label 'PROCESSED'");
        }

        // Inject a header via Guarded (has write_headers)
        if let Some(ref token) = modified.http_write_token {
            modified
                .http
                .as_mut()
                .unwrap()
                .write(token)
                .set_header("X-Processed-By", "header-injector");
            println!("  [header-injector] Injected header 'X-Processed-By'");
        }

        PluginResult::modify_extensions(modified)
    }

pub fn modify(payload: P, extensions: OwnedExtensions) -> Self

Modify both payload and extensions. Takes an OwnedExtensions from extensions.cow_copy().

pub fn is_denied(&self) -> bool

Whether this result represents a denial.

pub fn is_payload_modified(&self) -> bool

Whether this result carries a modified payload.

pub fn is_extensions_modified(&self) -> bool

Whether this result carries modified extensions.

Trait Implementations

impl<P: Debug + PluginPayload> Debug for PluginResult<P>

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

Formats the value using the given formatter.

impl<P: PluginPayload> Default for PluginResult<P>

fn default() -> Self

Returns the “default value” for a type.