Struct Webhooks 

pub struct Webhooks { /* private fields */ }

Available on crate feature k8s only.

Webhook routes, an Application.

Implementations

impl Webhooks

pub fn new() -> Webhooks

pub fn validate<K, F>(self, path: &str, check: F) -> Webhooks

where K: Resource + DeserializeOwned + Serialize + Clone + 'static, F: Fn(&AdmissionRequest<K>) -> Result<(), String> + Send + Sync + 'static,

A validating webhook at path: check gets the request (its operation, object, old_object, user_info) and answers Ok to allow or Err(message) to deny.

pub fn mutate<K, F>(self, path: &str, change: F) -> Webhooks

where K: Resource + DeserializeOwned + Serialize + Clone + 'static, F: Fn(K) -> Result<K, String> + Send + Sync + 'static,

A mutating webhook at path: change gets the object (on create and update) and returns it changed; the JSON patch from the old to the new is what the API server applies. Err denies.

pub fn convert<F>(self, path: &str, convert: F) -> Webhooks

where F: Fn(Value, &str) -> Result<Value, String> + Send + Sync + 'static,

A CRD conversion webhook at path (see manifests::with_conversion_webhook): convert(object, desired_api_version) returns the object in that version (its apiVersion is set for you).

pub fn wrap(self, app: impl Application + Send + Sync + 'static) -> Webhooks

Requests to other paths go to app.

Trait Implementations

impl Application for Webhooks

fn execute( &self, request: &Request, connection: &ConnectionInfo, ) -> Result<Response, String>

Receives a parsed request and returns a fully-built response. Walk your controller list with is_matching / process and return the first match.

fn runs_inline(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true when executing request is quick and never waits on anything but the local filesystem — health checks, metrics, small static files. The async servers (HTTP/1.1, HTTP/2, HTTP/3) then call execute directly on the event loop, as nginx does, instead of handing the request to tokio’s blocking pool: that handoff (a shared lock and two cross-thread wake-ups) costs more than serving a small file.

fn execute_async<'a>( &'a self, _request: &'a Request, _connection: &'a ConnectionInfo, ) -> Option<Pin<Box<dyn Future<Output = Result<Response, String>> + Send + 'a>>>

Available on crate feature http2 only.

An asynchronous version of execute for this request, when the application has one: the async servers await it on the connection’s task instead of tying up a blocking-pool thread while it waits (the config-driven proxy uses this to wait for a backend without holding a thread). None (the default) means “use execute”. Wrappers return Some only when they add no synchronous work of their own.

fn streams_body(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true to receive this request’s body as a stream (Body::Stream) instead of read into memory first: execute then runs while the body is still arriving, on a blocking-pool thread, and reads it with std::io::Read — a multi-gigabyte upload in a few chunks of memory. Asked after the head is read, so request.body is empty here; decide from the method, path and headers.

fn registered_routes(&self) -> Vec<RouteInfo>

The routes this application registers, as (method, pattern) — what AppWithState::route_entries returns; wrappers (WithMiddleware, McpServer) report the routes of the application inside. For tools that describe an app (the dev MCP server’s routes tool), not for dispatch. Default: none. Since 18.28.0.

fn middleware_names(&self) -> Vec<&'static str>

The names of the middleware layers around this application’s routes, in the order a request passes them (Middleware::layer_name). Default: none; WithMiddleware lists its layers, then the inner application’s. Since 18.28.0.

impl Clone for Webhooks

fn clone(&self) -> Webhooks

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Webhooks

fn default() -> Webhooks

Returns the “default value” for a type.