Struct ChioService 

pub struct ChioService<S> { /* private fields */ }

Tower Service that evaluates HTTP requests against the Chio kernel.

For each request, the service:

1. Extracts the caller identity from request headers
2. Evaluates the request against the Chio policy
3. If denied, returns a 403 JSON error response
4. If allowed, forwards to the inner service with receipt ID in response headers

Request bodies must be replayable after inspection. The current middleware supports body types that implement both http_body::Body and From<Bytes>.

Implementations

impl<S> ChioService<S>

pub fn new(inner: S, evaluator: ChioEvaluator) -> Self

Create a new Chio service wrapping the inner service.

pub fn with_max_body_bytes(self, max_body_bytes: usize) -> Self

Override the maximum body size buffered for hashing.

Requests whose advertised or observed body size exceeds this limit are rejected with 413 Payload Too Large before reaching the inner service. Defaults to DEFAULT_MAX_BODY_BYTES.

Trait Implementations

impl<S: Clone> Clone for ChioService<S>

fn clone(&self) -> ChioService<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for ChioService<S>

where S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone + Send + 'static, S::Future: Send, S::Error: Into<Box<dyn Error + Send + Sync>>, ReqBody: Body + From<Bytes> + Send + 'static, ReqBody::Data: Send, ReqBody::Error: Into<Box<dyn Error + Send + Sync>>, ResBody: Default + From<Bytes> + Send + 'static,

type Response = Response<ResBody>

Responses given by the service.

type Error = Box<dyn Error + Sync + Send>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<ChioService<S> as Service<Request<ReqBody>>>::Response, <ChioService<S> as Service<Request<ReqBody>>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<ReqBody>) -> Self::Future

Process the request and return the response asynchronously.