Struct Chain 

pub struct Chain { /* private fields */ }

Actix-Web service chaining service.

The chain is constructed from a series of Link instances which encode when services should be run and when their responses should be reguarded in favor of running the next service.

Chain service must be registered with App::service() method.

Examples

use actix_web::{App, HttpRequest, HttpResponse, Responder, web};
use actix_chain::{Chain, Link};

async fn might_fail(req: HttpRequest) -> impl Responder {
    if !req.headers().contains_key("Required-Header") {
        return HttpResponse::NotFound().body("Request Failed");
    }
    HttpResponse::Ok().body("It worked!")
}

async fn default() -> &'static str {
    "First link failed!"
}

App::new().service(
    Chain::default()
        .link(Link::new(web::get().to(might_fail)))
        .link(Link::new(web::get().to(default)))
);

Implementations

impl Chain

pub fn new(mount_path: &str) -> Self

Creates new Chain instance.

The first argument (mount_path) is the root URL at which the static files are served. For example, /assets will serve files at example.com/assets/....

pub fn guard<G: Guard + 'static>(self, guards: G) -> Self

Adds a routing guard.

Use this to allow multiple chained services that respond to strictly different properties of a request. Due to the way routing works, if a guard check returns true and the request starts being handled by the file service, it will not be able to back-out and try the next service, you will simply get a 404 (or 405) error response.

Examples

use actix_web::{guard::Header, App};
use actix_chain::Chain;

App::new().service(
    Chain::default()
        .guard(Header("Host", "example.com"))
);

pub fn link(self, link: Link) -> Self

Add a new Link to the established chain.

pub fn push_link(&mut self, link: Link) -> &mut Self

Append a Link via mutable reference for dynamic assignment.

Trait Implementations

impl Clone for Chain

fn clone(&self) -> Chain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Chain

fn default() -> Self

Returns the “default value” for a type.

impl HttpServiceFactory for Chain

fn register(self, config: &mut AppService)

impl ServiceFactory<ServiceRequest> for Chain

type Response = ServiceResponse

Responses given by the created services.

type Error = Error

Errors produced by the created services.

type Config = ()

Service factory configuration.

type Service = ChainService

The kind of Service created by this factory.

type InitError = ()

Errors potentially raised while building a service.

type Future = Pin<Box<dyn Future<Output = Result<<Chain as ServiceFactory<ServiceRequest>>::Service, <Chain as ServiceFactory<ServiceRequest>>::InitError>>>>

The future of the Service instance.g

fn new_service(&self, _: ()) -> Self::Future

Create and return a new service asynchronously.