mirror of
https://github.com/actix/actix-web.git
synced 2024-06-02 21:39:26 +00:00
344 lines
9.3 KiB
Rust
344 lines
9.3 KiB
Rust
//! Route match predicates
|
|
#![allow(non_snake_case)]
|
|
use http;
|
|
use http::{header, HttpTryFrom};
|
|
use httpmessage::HttpMessage;
|
|
use httprequest::HttpRequest;
|
|
use std::marker::PhantomData;
|
|
|
|
/// Trait defines resource route predicate.
|
|
/// Predicate can modify request object. It is also possible to
|
|
/// to store extra attributes on request by using `Extensions` container,
|
|
/// Extensions container available via `HttpRequest::extensions()` method.
|
|
pub trait Predicate<S> {
|
|
/// Check if request matches predicate
|
|
fn check(&self, &mut HttpRequest<S>) -> bool;
|
|
}
|
|
|
|
/// Return predicate that matches if any of supplied predicate matches.
|
|
///
|
|
/// ```rust
|
|
/// # extern crate actix_web;
|
|
/// use actix_web::{pred, App, HttpResponse};
|
|
///
|
|
/// fn main() {
|
|
/// App::new()
|
|
/// .resource("/index.html", |r| r.route()
|
|
/// .filter(pred::Any(pred::Get()).or(pred::Post()))
|
|
/// .f(|r| HttpResponse::MethodNotAllowed()));
|
|
/// }
|
|
/// ```
|
|
pub fn Any<S: 'static, P: Predicate<S> + 'static>(pred: P) -> AnyPredicate<S> {
|
|
AnyPredicate(vec![Box::new(pred)])
|
|
}
|
|
|
|
/// Matches if any of supplied predicate matches.
|
|
pub struct AnyPredicate<S>(Vec<Box<Predicate<S>>>);
|
|
|
|
impl<S> AnyPredicate<S> {
|
|
/// Add new predicate to list of predicates to check
|
|
pub fn or<P: Predicate<S> + 'static>(mut self, pred: P) -> Self {
|
|
self.0.push(Box::new(pred));
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<S: 'static> Predicate<S> for AnyPredicate<S> {
|
|
fn check(&self, req: &mut HttpRequest<S>) -> bool {
|
|
for p in &self.0 {
|
|
if p.check(req) {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Return predicate that matches if all of supplied predicate matches.
|
|
///
|
|
/// ```rust
|
|
/// # extern crate actix_web;
|
|
/// use actix_web::{pred, App, HttpResponse};
|
|
///
|
|
/// fn main() {
|
|
/// App::new()
|
|
/// .resource("/index.html", |r| r.route()
|
|
/// .filter(pred::All(pred::Get())
|
|
/// .and(pred::Header("content-type", "plain/text")))
|
|
/// .f(|_| HttpResponse::MethodNotAllowed()));
|
|
/// }
|
|
/// ```
|
|
pub fn All<S: 'static, P: Predicate<S> + 'static>(pred: P) -> AllPredicate<S> {
|
|
AllPredicate(vec![Box::new(pred)])
|
|
}
|
|
|
|
/// Matches if all of supplied predicate matches.
|
|
pub struct AllPredicate<S>(Vec<Box<Predicate<S>>>);
|
|
|
|
impl<S> AllPredicate<S> {
|
|
/// Add new predicate to list of predicates to check
|
|
pub fn and<P: Predicate<S> + 'static>(mut self, pred: P) -> Self {
|
|
self.0.push(Box::new(pred));
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<S: 'static> Predicate<S> for AllPredicate<S> {
|
|
fn check(&self, req: &mut HttpRequest<S>) -> bool {
|
|
for p in &self.0 {
|
|
if !p.check(req) {
|
|
return false;
|
|
}
|
|
}
|
|
true
|
|
}
|
|
}
|
|
|
|
/// Return predicate that matches if supplied predicate does not match.
|
|
pub fn Not<S: 'static, P: Predicate<S> + 'static>(pred: P) -> NotPredicate<S> {
|
|
NotPredicate(Box::new(pred))
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub struct NotPredicate<S>(Box<Predicate<S>>);
|
|
|
|
impl<S: 'static> Predicate<S> for NotPredicate<S> {
|
|
fn check(&self, req: &mut HttpRequest<S>) -> bool {
|
|
!self.0.check(req)
|
|
}
|
|
}
|
|
|
|
/// Http method predicate
|
|
#[doc(hidden)]
|
|
pub struct MethodPredicate<S>(http::Method, PhantomData<S>);
|
|
|
|
impl<S: 'static> Predicate<S> for MethodPredicate<S> {
|
|
fn check(&self, req: &mut HttpRequest<S>) -> bool {
|
|
*req.method() == self.0
|
|
}
|
|
}
|
|
|
|
/// Predicate to match *GET* http method
|
|
pub fn Get<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::GET, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *POST* http method
|
|
pub fn Post<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::POST, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *PUT* http method
|
|
pub fn Put<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::PUT, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *DELETE* http method
|
|
pub fn Delete<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::DELETE, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *HEAD* http method
|
|
pub fn Head<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::HEAD, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *OPTIONS* http method
|
|
pub fn Options<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::OPTIONS, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *CONNECT* http method
|
|
pub fn Connect<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::CONNECT, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *PATCH* http method
|
|
pub fn Patch<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::PATCH, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match *TRACE* http method
|
|
pub fn Trace<S: 'static>() -> MethodPredicate<S> {
|
|
MethodPredicate(http::Method::TRACE, PhantomData)
|
|
}
|
|
|
|
/// Predicate to match specified http method
|
|
pub fn Method<S: 'static>(method: http::Method) -> MethodPredicate<S> {
|
|
MethodPredicate(method, PhantomData)
|
|
}
|
|
|
|
/// Return predicate that matches if request contains specified header and
|
|
/// value.
|
|
pub fn Header<S: 'static>(
|
|
name: &'static str, value: &'static str
|
|
) -> HeaderPredicate<S> {
|
|
HeaderPredicate(
|
|
header::HeaderName::try_from(name).unwrap(),
|
|
header::HeaderValue::from_static(value),
|
|
PhantomData,
|
|
)
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub struct HeaderPredicate<S>(
|
|
header::HeaderName,
|
|
header::HeaderValue,
|
|
PhantomData<S>,
|
|
);
|
|
|
|
impl<S: 'static> Predicate<S> for HeaderPredicate<S> {
|
|
fn check(&self, req: &mut HttpRequest<S>) -> bool {
|
|
if let Some(val) = req.headers().get(&self.0) {
|
|
return val == self.1;
|
|
}
|
|
false
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use http::header::{self, HeaderMap};
|
|
use http::{Method, Uri, Version};
|
|
use std::str::FromStr;
|
|
|
|
#[test]
|
|
fn test_header() {
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert(
|
|
header::TRANSFER_ENCODING,
|
|
header::HeaderValue::from_static("chunked"),
|
|
);
|
|
let mut req = HttpRequest::new(
|
|
Method::GET,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
headers,
|
|
None,
|
|
);
|
|
|
|
let pred = Header("transfer-encoding", "chunked");
|
|
assert!(pred.check(&mut req));
|
|
|
|
let pred = Header("transfer-encoding", "other");
|
|
assert!(!pred.check(&mut req));
|
|
|
|
let pred = Header("content-type", "other");
|
|
assert!(!pred.check(&mut req));
|
|
}
|
|
|
|
#[test]
|
|
fn test_methods() {
|
|
let mut req = HttpRequest::new(
|
|
Method::GET,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
let mut req2 = HttpRequest::new(
|
|
Method::POST,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
|
|
assert!(Get().check(&mut req));
|
|
assert!(!Get().check(&mut req2));
|
|
assert!(Post().check(&mut req2));
|
|
assert!(!Post().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::PUT,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Put().check(&mut r));
|
|
assert!(!Put().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::DELETE,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Delete().check(&mut r));
|
|
assert!(!Delete().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::HEAD,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Head().check(&mut r));
|
|
assert!(!Head().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::OPTIONS,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Options().check(&mut r));
|
|
assert!(!Options().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::CONNECT,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Connect().check(&mut r));
|
|
assert!(!Connect().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::PATCH,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Patch().check(&mut r));
|
|
assert!(!Patch().check(&mut req));
|
|
|
|
let mut r = HttpRequest::new(
|
|
Method::TRACE,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
assert!(Trace().check(&mut r));
|
|
assert!(!Trace().check(&mut req));
|
|
}
|
|
|
|
#[test]
|
|
fn test_preds() {
|
|
let mut r = HttpRequest::new(
|
|
Method::TRACE,
|
|
Uri::from_str("/").unwrap(),
|
|
Version::HTTP_11,
|
|
HeaderMap::new(),
|
|
None,
|
|
);
|
|
|
|
assert!(Not(Get()).check(&mut r));
|
|
assert!(!Not(Trace()).check(&mut r));
|
|
|
|
assert!(All(Trace()).and(Trace()).check(&mut r));
|
|
assert!(!All(Get()).and(Trace()).check(&mut r));
|
|
|
|
assert!(Any(Get()).or(Trace()).check(&mut r));
|
|
assert!(!Any(Get()).or(Get()).check(&mut r));
|
|
}
|
|
}
|