Struct actix_web::Scope

pub struct Scope<P, T = ScopeEndpoint<P>> { /* fields omitted */ }

Resources scope.

Scope is a set of resources with common root path. Scopes collect multiple paths under a common path prefix. Scope path can contain variable path segments as resources. Scope prefix is always complete path segment, i.e /app would be converted to a /app/ and it would not match /app path.

You can get variable path segments from HttpRequest::match_info(). Path extractor also is able to extract scope level variable segments.

use actix_web::{web, App, HttpResponse};

fn main() {
    let app = App::new().service(
        web::scope("/{project_id}/")
            .service(web::resource("/path1").to(|| HttpResponse::Ok()))
            .service(web::resource("/path2").route(web::get().to(|| HttpResponse::Ok())))
            .service(web::resource("/path3").route(web::head().to(|| HttpResponse::MethodNotAllowed())))
    );
}

In the above example three routes get registered:

• /{project_id}/path1 - reponds to all http method
• /{project_id}/path2 - GET requests
• /{project_id}/path3 - HEAD requests

Methods

impl<P: 'static> Scope<P>

pub fn new(path: &str) -> Scope<P>

Create a new scope

impl<P, T> Scope<P, T> where
    P: 'static,
    T: NewService<Request = ServiceRequest<P>, Response = ServiceResponse, Error = Error, InitError = ()>, 

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

Add match guard to a scope.

use actix_web::{web, guard, App, HttpRequest, HttpResponse};

fn index(data: web::Path<(String, String)>) -> &'static str {
    "Welcome!"
}

fn main() {
    let app = App::new().service(
        web::scope("/app")
            .guard(guard::Header("content-type", "text/plain"))
            .route("/test1", web::get().to(index))
            .route("/test2", web::post().to(|r: HttpRequest| {
                HttpResponse::MethodNotAllowed()
            }))
    );
}

pub fn service<F>(self, factory: F) -> Self where
    F: HttpServiceFactory<P> + 'static, 

Register http service.

This is similar to App's service registration.

Actix web provides several services implementations:

• Resource is an entry in resource table which corresponds to requested URL.
• Scope is a set of resources with common root path.
• "StaticFiles" is a service for static files support

use actix_web::{web, App, HttpRequest};

struct AppState;

fn index(req: HttpRequest) -> &'static str {
    "Welcome!"
}

fn main() {
    let app = App::new().service(
        web::scope("/app").service(
            web::scope("/v1")
                .service(web::resource("/test1").to(index)))
    );
}

pub fn route(self, path: &str, route: Route<P>) -> Self

Configure route for a specific path.

This is a simplified version of the Scope::service() method. This method can be called multiple times, in that case multiple resources with one route would be registered for same resource path.

use actix_web::{web, App, HttpResponse};

fn index(data: web::Path<(String, String)>) -> &'static str {
    "Welcome!"
}

fn main() {
    let app = App::new().service(
        web::scope("/app")
            .route("/test1", web::get().to(index))
            .route("/test2", web::post().to(|| HttpResponse::MethodNotAllowed()))
    );
}

pub fn default_resource<F, U>(self, f: F) -> Self where
    F: FnOnce(Resource<P>) -> Resource<P, U>,
    U: NewService<Request = ServiceRequest<P>, Response = ServiceResponse, Error = Error, InitError = ()> + 'static, 

Default resource to be used if no matching route could be found.

If default resource is not registered, app's default resource is being used.

pub fn wrap<M, F>(
    self,
    mw: F
) -> Scope<P, impl NewService<Request = ServiceRequest<P>, Response = ServiceResponse, Error = Error, InitError = ()>> where
    M: Transform<T::Service, Request = ServiceRequest<P>, Response = ServiceResponse, Error = Error, InitError = ()>,
    F: IntoTransform<M, T::Service>, 

Register a scope level middleware.

This is similar to App's middlewares, but middleware get invoked on scope level. Scope level middlewares are not allowed to change response type (i.e modify response's body).

pub fn wrap_fn<F, R>(
    self,
    mw: F
) -> Scope<P, impl NewService<Request = ServiceRequest<P>, Response = ServiceResponse, Error = Error, InitError = ()>> where
    F: FnMut(ServiceRequest<P>, &mut T::Service) -> R + Clone,
    R: IntoFuture<Item = ServiceResponse, Error = Error>, 

Register a scope level middleware function.

This function accepts instance of ServiceRequest type and mutable reference to the next middleware in chain.

use actix_service::Service;
use actix_web::{web, App};
use actix_web::http::{header::CONTENT_TYPE, HeaderValue};

fn index() -> &'static str {
    "Welcome!"
}

fn main() {
    let app = App::new().service(
        web::scope("/app")
            .wrap_fn(|req, srv|
                srv.call(req).map(|mut res| {
                    res.headers_mut().insert(
                       CONTENT_TYPE, HeaderValue::from_static("text/plain"),
                    );
                    res
                }))
            .route("/index.html", web::get().to(index)));
}

Trait Implementations

impl<P, T> HttpServiceFactory<P> for Scope<P, T> where
    P: 'static,
    T: NewService<Request = ServiceRequest<P>, Response = ServiceResponse, Error = Error, InitError = ()> + 'static, 

fn register(self, config: &mut ServiceConfig<P>)