Struct actix_web::Scope [−][src]
pub struct Scope<T = ScopeEndpoint> { /* fields omitted */ }
Expand description
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(|| async { 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 - responds to all http method
- /{project_id}/path2 -
GET
requests - /{project_id}/path3 -
HEAD
requests
Implementations
impl<T> Scope<T> where
T: ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>,
impl<T> Scope<T> where
T: ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>,
Add match guard to a scope.
use actix_web::{web, guard, App, HttpRequest, HttpResponse};
async 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()
}))
);
}
Set or override application data. Application data could be accessed
by using Data<T>
extractor where T
is data type.
use std::cell::Cell;
use actix_web::{web, App, HttpResponse, Responder};
struct MyData {
counter: Cell<usize>,
}
async fn index(data: web::Data<MyData>) -> impl Responder {
data.counter.set(data.counter.get() + 1);
HttpResponse::Ok()
}
fn main() {
let app = App::new().service(
web::scope("/app")
.data(MyData{ counter: Cell::new(0) })
.service(
web::resource("/index.html").route(
web::get().to(index)))
);
}
Add scope data.
Data of different types from parent contexts will still be accessible.
Run external configuration as part of the scope building process
This function is useful for moving parts of configuration to a different module or even library. For example, some of the resource’s configuration could be moved to different module.
use actix_web::{web, middleware, App, HttpResponse};
// this function could be located in different module
fn config(cfg: &mut web::ServiceConfig) {
cfg.service(web::resource("/test")
.route(web::get().to(|| HttpResponse::Ok()))
.route(web::head().to(|| HttpResponse::MethodNotAllowed()))
);
}
fn main() {
let app = App::new()
.wrap(middleware::Logger::default())
.service(
web::scope("/api")
.configure(config)
)
.route("/index.html", web::get().to(|| HttpResponse::Ok()));
}
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;
async 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)))
);
}
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};
async 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_service<F, U>(self, f: F) -> Self where
F: IntoServiceFactory<U>,
U: ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error> + 'static,
U::InitError: Debug,
pub fn default_service<F, U>(self, f: F) -> Self where
F: IntoServiceFactory<U>,
U: ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error> + 'static,
U::InitError: Debug,
Default service 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>(
self,
mw: M
) -> Scope<impl ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>> where
M: Transform<T::Service, Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>,
pub fn wrap<M>(
self,
mw: M
) -> Scope<impl ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>> where
M: Transform<T::Service, Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>,
Registers middleware, in the form of a middleware component (type), that runs during inbound processing in the request life-cycle (request -> response), modifying request as necessary, across all requests managed by the Scope. Scope-level middleware is more limited in what it can modify, relative to Route or Application level middleware, in that Scope-level middleware can not modify ServiceResponse.
Use middleware when you need to read or modify every request in some way.
pub fn wrap_fn<F, R>(
self,
mw: F
) -> Scope<impl ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>> where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>,
pub fn wrap_fn<F, R>(
self,
mw: F
) -> Scope<impl ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()>> where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>,
Registers middleware, in the form of a closure, that runs during inbound processing in the request life-cycle (request -> response), modifying request as necessary, across all requests managed by the Scope. Scope-level middleware is more limited in what it can modify, relative to Route or Application level middleware, in that Scope-level middleware can not modify ServiceResponse.
use actix_service::Service;
use actix_web::{web, App};
use actix_web::http::{header::CONTENT_TYPE, HeaderValue};
async fn index() -> &'static str {
"Welcome!"
}
fn main() {
let app = App::new().service(
web::scope("/app")
.wrap_fn(|req, srv| {
let fut = srv.call(req);
async {
let mut res = fut.await?;
res.headers_mut().insert(
CONTENT_TYPE, HeaderValue::from_static("text/plain"),
);
Ok(res)
}
})
.route("/index.html", web::get().to(index)));
}
Trait Implementations
impl<T> HttpServiceFactory for Scope<T> where
T: ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()> + 'static,
impl<T> HttpServiceFactory for Scope<T> where
T: ServiceFactory<Config = (), Request = ServiceRequest, Response = ServiceResponse, Error = Error, InitError = ()> + 'static,
Auto Trait Implementations
impl<T = ScopeEndpoint> !RefUnwindSafe for Scope<T>
impl<T = ScopeEndpoint> !UnwindSafe for Scope<T>
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
pub fn vzip(self) -> V
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more