Struct CompiledGraph 

pub struct CompiledGraph {
    nodes: HashMap<String, Box<dyn Plugin>>,
    edges: HashMap<String, HashMap<String, String>>,
    entry_node_id: String,
    terminal_node_ids: HashSet<String>,
    catch_all_handler: Option<String>,
    policy_name: String,
    resources: Arc<PluginResources>,
    stream_capable: HashSet<String>,
    buffering_reasons: Vec<BufferingReason>,
    cache_pair_warnings: Vec<CachePairWarning>,
    cache_targets: Vec<CacheTarget>,
}

A compiled, ready-to-execute graph with instantiated plugins.

Built by compile_policy and shared read-only by the data-plane; one instance serves all requests matching the route that references its policy.

Fields

nodes: HashMap<String, Box<dyn Plugin>>

edges: HashMap<String, HashMap<String, String>>

node_id -> (port -> target node_id). Ports normalized (out -> success).

entry_node_id: String

The node that starts the pipeline (first node after listener)

terminal_node_ids: HashSet<String>

Node IDs that are terminal (client nodes) — execution stops when we reach one

catch_all_handler: Option<String>

Policy-level catch-all error handler node ID

policy_name: String

Policy name, used as a metrics label.

resources: Arc<PluginResources>

Process-wide services (metrics registry, shared clients); per-node metrics recording is disabled when resources.metrics is None.

stream_capable: HashSet<String>

Ids of upstream nodes whose success path reaches client without passing any node that reads the response body. Read by is_stream_capable, consulted per node in run.

buffering_reasons: Vec<BufferingReason>

Why each non-capable upstream must buffer, for operator-visible reporting.

cache_pair_warnings: Vec<CachePairWarning>

cache_targets: Vec<CacheTarget>

Every proxy-cache half’s backend, for invalidation by pair id.

Implementations

impl CompiledGraph

pub async fn execute(&self, ctx: Context) -> Context

Executes the graph with the given initial context and returns the final context (with response populated).

Walks nodes starting at the entry node (the first node after the listener), following the success edge after each Ok result. On a plugin error the error is tagged with the failing node’s ID, pushed onto ctx.errors, and execution jumps to the node’s error edge if one exists, otherwise to the policy-level catch-all handler; with neither, execution stops and a generic JSON 500 response is written. Reaching a terminal client node (or a node with no success edge) ends the walk. This method never fails: every outcome is expressed through the returned context’s response.

pub async fn execute_traced( &self, ctx: Context, recorder: TraceRecorder, ) -> (Context, TraceRecorder)

Same walk as execute, additionally recording a [Trace] of every node: the context after each one, the outcome, and which edge the engine followed.

Used by debug mode and the sandbox. Deliberately the same loop rather than a parallel implementation — a trace that could drift from the real execution path would be worse than no trace at all.

async fn run( &self, ctx: Context, recorder: Option<TraceRecorder>, ) -> (Context, Option<TraceRecorder>)

The single graph walk, optionally recording each step.

When recorder is None the only added cost is one Option discriminant check per node — the same shape as the existing metrics branch, and perfectly branch-predicted.

pub fn is_stream_capable(&self, node_id: &str) -> bool

Whether the upstream node named node_id may stream its response body straight through to the client — nothing between it and client on the success path reads the buffered response body. Consulted by run to set the __may_stream reserved key before invoking the node.

pub fn cache_pair_warnings(&self) -> &[CachePairWarning]

Why each non-stream-capable upstream node must buffer, one entry per blocked upstream, for operator-visible reporting. proxy-cache halves with no counterpart. Informational, like CompiledGraph::buffering_reasons.

pub fn cache_targets(&self) -> &[CacheTarget]

Every proxy-cache half’s backend, for invalidation by pair id.

pub fn buffering_reasons(&self) -> &[BufferingReason]

Trait Implementations

impl Debug for CompiledGraph

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

Formats the value using the given formatter.