Struct RequestPlugins 

pub struct RequestPlugins { /* private fields */ }

The per-request plugin execution state (DW-157): the unified chain plus the fail-closed helpers that drive it. Constructed by RequestPlugins::build only on routes that reference plugins; Drop runs the on_done cleanup callback on every exit path (early short-circuits, failures, and the natural tail alike).

Implementations

impl RequestPlugins

pub fn build( lifecycle: &PluginLifecycle, configs: &HashMap<String, PluginConfig>, registry: &NativeRegistry, route: &Route, obs: &Observability, rid: &str, ssrf: SsrfFilter, ) -> Result<Option<Self>, PluginExit>

Build the per-request chain for route. Ok(None) — with zero allocations — when the route references no plugins (the fast path). Err(response) is the fail-closed 500 a caller returns immediately: a referenced plugin is Crashed/Disabled/not loaded, a native name is missing from the registry, a native factory errors while the chain is built, or per-request WASM instantiation failed or did not cover every WASM plugin.

pub fn needs_request_body(&self) -> bool

Whether the chain has any plugin declaring request_body (buffers the request body when true — see the module docs).

pub fn needs_response_body(&self) -> bool

Whether the chain has any plugin declaring response_body (buffers the response body when true — see the module docs).

pub async fn request_headers_phase( &mut self, method: &Method, path_and_query: &str, headers: &mut HeaderMap, obs: &Observability, rid: &str, route: &str, ) -> Result<PluginTargetRewrite, PluginExit>

Run the request_headers phase: after route resolution, before authn (the documented contract — authn sees plugin-modified headers). path_and_query is the full request target (path including any query string). On Ok the (possibly rewritten) header map is in place and the returned PluginTargetRewrite carries the chain’s validated :path/:method/:authority writes (see the module’s “Header conventions” section) for the caller to apply at the forward build; on Err the caller returns the response immediately. Async because a plugin may dispatch HTTP callouts here (DW-167): the phase pauses, the callouts are performed off-thread, and the chain resumes with the plugin’s post-callout output.

pub async fn request_body_phase<B>( &mut self, req: Request<B>, cap: u64, obs: &Observability, rid: &str, route: &str, ) -> Result<Request<Full<Bytes>>, PluginExit>

where B: Body<Data = Bytes> + Send + 'static, B::Error: Into<Box<dyn Error + Send + Sync>>,

Run the request_body phase: buffer the request body (capped — over-cap answers 500 plugin_body_too_large, fail-closed), let the chain rewrite it, and hand the action a fully-buffered Full<Bytes> body with a rewritten Content-Length. Runs after authz/rate-limit, before the route action (and before request validation, which then sees the post-plugin bytes).

pub async fn response_headers_phase( &mut self, status: StatusCode, headers: &mut HeaderMap, obs: &Observability, rid: &str, route: &str, ) -> Result<(), PluginExit>

Run the response_headers phase: after the response arrives (any action: proxy, mock, respond, redirect alike — plugins are route-level), before masking. :status rides the map for visibility; plugin writes to it are IGNORED — a deliberate asymmetry with the request-side target rewrite: by the time this phase runs the status is bound to the response’s framing (204/304/101 carry no body, and Content-Length already matches the upstream bytes a later phase may rewrite), so a mid-pipeline flip would desynchronize both. A plugin that wants to DECIDE the answer has send_http_response at the request phases. Async for the callout pause/resume path (DW-167), like every phase method.

pub async fn response_body_phase( &mut self, resp: Response<ProxyBody>, cap: u64, obs: &Observability, rid: &str, route: &str, ) -> Result<Response<ProxyBody>, PluginExit>

Run the response_body phase: after masking, before the operator transforms and compression. Bodiless statuses (informational, 101, 204, 304) have nothing to inspect and pass through untouched, exactly like masking; STREAMING bodies (text/event-stream, or a body of unknown length — chunked or otherwise un-framed) and CONTENT-ENCODED bodies are skipped, documented and logged once per response: buffering an endless SSE stream would stall the route, and an encoded body is opaque bytes to the plugin (dwara never decompresses on this path — compression is applied downstream, after this phase). Every other response on a chain with a response_body plugin is buffered up to cap (over-cap answers 500 plugin_body_too_large, fail-closed), the chain may rewrite the bytes, and the response is rebuilt with a Full body and a rewritten Content-Length. When masking already buffered the body (its fail-closed path) this rides the same buffered bytes.

Trait Implementations

impl Drop for RequestPlugins

fn drop(&mut self)

Executes the destructor for this type.