tokio-rs/axum
1
0
Fork 0
mirror of https://github.com/tokio-rs/axum.git synced 2026-08-22 00:00:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

not quite working

Browse Source
This commit is contained in:
David Pedersen
2021-06-03 21:36:39 +02:00
parent 00737c4e0a
commit e156bc40e1
3 changed files with 147 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/routing.rs
+24 -223
View File
@@ -66,7 +66,7 @@ macro_rules! define_route_at_methods {
where
S: Service<Request<Body>, Response = Response<B>, Error = Infallible> + Clone,
{
self.add_route_service(service, MethodOrPrefix::Method(Method::$method))
self.add_route_service(service, Method::$method)
}
};
@@ -103,19 +103,6 @@ impl<R> RouteAt<R> {
define_route_at_methods!(RouteAt: connect, connect_service, CONNECT);
define_route_at_methods!(RouteAt: trace, trace_service, TRACE);
pub fn nest<T>(
self,
other: RouteBuilder<T>,
) -> RouteBuilder<Or<StripPrefix<IntoService<T>>, R>> {
let route_spec = self.route_spec.clone();
let other = StripPrefix::new(other.into_service(), route_spec.clone());
self.add_route_service_with_spec(
other,
RouteSpec::new(MethodOrPrefix::Prefix(route_spec.clone()), route_spec),
)
}
fn add_route<H, B, T>(
self,
handler: H,
@@ -124,16 +111,12 @@ impl<R> RouteAt<R> {
where
H: Handler<B, T>,
{
self.add_route_service(HandlerSvc::new(handler), MethodOrPrefix::Method(method))
self.add_route_service(HandlerSvc::new(handler), method)
}
fn add_route_service<S>(
self,
service: S,
method_or_prefix: MethodOrPrefix,
) -> RouteBuilder<Or<S, R>> {
fn add_route_service<S>(self, service: S, method: Method) -> RouteBuilder<Or<S, R>> {
let route_spec = self.route_spec.clone();
self.add_route_service_with_spec(service, RouteSpec::new(method_or_prefix, route_spec))
self.add_route_service_with_spec(service, RouteSpec::new(method, route_spec))
}
fn add_route_service_with_spec<S>(
@@ -276,58 +259,24 @@ where
#[derive(Debug, Clone)]
struct RouteSpec {
method_or_prefix: MethodOrPrefix,
method: Method,
spec: Bytes,
length_match: LengthMatch,
}
#[derive(Debug, Clone)]
enum MethodOrPrefix {
AnyMethod,
Method(Method),
Prefix(Bytes),
}
#[derive(Debug, Clone, Copy)]
enum LengthMatch {
Exact,
UriCanBeLonger,
}
impl RouteSpec {
fn new(method_or_prefix: MethodOrPrefix, spec: impl Into<Bytes>) -> Self {
fn new(method: Method, spec: impl Into<Bytes>) -> Self {
Self {
method_or_prefix,
method,
spec: spec.into(),
length_match: LengthMatch::Exact,
}
}
fn length_match(mut self, length_match: LengthMatch) -> Self {
self.length_match = length_match;
self
}
}
impl RouteSpec {
fn matches<B>(&self, req: &Request<B>) -> Option<Vec<(String, String)>> {
// println!("route spec comparing `{:?}` and `{:?}`", self, req.uri());
match &self.method_or_prefix {
MethodOrPrefix::Method(method) => {
if req.method() != method {
return None;
}
}
MethodOrPrefix::AnyMethod => {}
MethodOrPrefix::Prefix(prefix) => {
let route_spec = RouteSpec::new(MethodOrPrefix::AnyMethod, prefix.clone())
.length_match(LengthMatch::UriCanBeLonger);
if let Some(params) = route_spec.matches(req) {
return Some(params);
}
}
// TODO(david): perform this matching outside
if req.method() != self.method {
return None;
}
let spec_parts = self.spec.split(|b| *b == b'/');
@@ -340,11 +289,6 @@ impl RouteSpec {
for pair in spec_parts.zip_longest(path_parts) {
match pair {
EitherOrBoth::Both(spec, path) => {
println!(
"both: ({:?}, {:?})",
str::from_utf8(spec).unwrap(),
str::from_utf8(path).unwrap()
);
if let Some(key) = spec.strip_prefix(b":") {
let key = str::from_utf8(key).unwrap().to_string();
if let Ok(value) = std::str::from_utf8(path) {
@@ -356,21 +300,9 @@ impl RouteSpec {
return None;
}
}
EitherOrBoth::Left(spec) => {
println!("left: {:?}", str::from_utf8(spec).unwrap());
EitherOrBoth::Left(_) | EitherOrBoth::Right(_) => {
return None;
}
EitherOrBoth::Right(path) => {
println!("right: {:?}", str::from_utf8(path).unwrap());
match self.length_match {
LengthMatch::Exact => {
return None;
}
LengthMatch::UriCanBeLonger => {
return Some(params);
}
}
}
}
}
@@ -419,7 +351,7 @@ where
self.handler_ready = false;
req.extensions_mut().insert(Some(UrlParams(params)));
insert_url_params(&mut req, params);
future::Either::Left(BoxResponseBody(self.service.call(req)))
} else {
@@ -436,6 +368,7 @@ where
}
}
#[derive(Debug)]
pub(crate) struct UrlParams(pub(crate) Vec<(String, String)>);
#[pin_project]
@@ -583,92 +516,13 @@ where
.unwrap()
}
#[derive(Debug, Clone)]
pub struct StripPrefix<S> {
inner: S,
prefix: Bytes,
}
impl<S> StripPrefix<S> {
fn new(inner: S, prefix: impl Into<Bytes>) -> Self {
Self {
inner,
prefix: prefix.into(),
}
}
}
impl<S, B> Service<Request<B>> for StripPrefix<S>
where
S: Service<Request<B>>,
{
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
#[inline]
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, req: Request<B>) -> Self::Future {
use http::uri::{PathAndQuery, Uri};
use std::convert::TryFrom;
println!("strip prefix {:?} of {:?}", self.prefix, req.uri().path());
let (mut request_parts, body) = req.into_parts();
let mut uri_parts = request_parts.uri.into_parts();
enum Control<T> {
Continue(T),
Break,
}
if let Some(path_and_query) = &uri_parts.path_and_query {
let path = path_and_query.path();
let prefix = str::from_utf8(&self.prefix).unwrap();
let iter = path
.split('/')
.zip_longest(prefix.split('/'))
.map(|pair| match pair {
EitherOrBoth::Both(path, prefix) => {
if prefix.starts_with(':') || path == prefix {
Control::Continue(path)
} else {
Control::Break
}
}
EitherOrBoth::Left(_) | EitherOrBoth::Right(_) => Control::Break,
})
.take_while(|item| matches!(item, Control::Continue(_)))
.map(|item| {
if let Control::Continue(item) = item {
item
} else {
unreachable!()
}
});
let prefix_with_captures_updated =
Itertools::intersperse(iter, "/").collect::<String>();
if let Some(path_without_prefix) = path.strip_prefix(&prefix_with_captures_updated) {
let new = if let Some(query) = path_and_query.query() {
PathAndQuery::try_from(format!("{}?{}", &path_without_prefix, query)).unwrap()
} else {
PathAndQuery::try_from(path_without_prefix).unwrap()
};
uri_parts.path_and_query = Some(new);
}
}
request_parts.uri = Uri::from_parts(uri_parts).unwrap();
let req = Request::from_parts(request_parts, body);
self.inner.call(req)
fn insert_url_params<B>(req: &mut Request<B>, params: Vec<(String, String)>) {
if let Some(current) = req.extensions_mut().get_mut::<Option<UrlParams>>() {
let mut current = current.take().unwrap();
current.0.extend(params);
req.extensions_mut().insert(Some(current));
} else {
req.extensions_mut().insert(Some(UrlParams(params)));
}
}
@@ -709,7 +563,7 @@ mod tests {
}
fn assert_match(route_spec: (Method, &'static str), req_spec: (Method, &'static str)) {
let route = RouteSpec::new(MethodOrPrefix::Method(route_spec.0.clone()), route_spec.1);
let route = RouteSpec::new(route_spec.0.clone(), route_spec.1);
let req = Request::builder()
.method(req_spec.0.clone())
.uri(req_spec.1)
@@ -721,13 +575,13 @@ mod tests {
"`{} {}` doesn't match `{:?} {}`",
req.method(),
req.uri().path(),
route.method_or_prefix,
route.method,
str::from_utf8(&route.spec).unwrap(),
);
}
fn refute_match(route_spec: (Method, &'static str), req_spec: (Method, &'static str)) {
let route = RouteSpec::new(MethodOrPrefix::Method(route_spec.0.clone()), route_spec.1);
let route = RouteSpec::new(route_spec.0.clone(), route_spec.1);
let req = Request::builder()
.method(req_spec.0.clone())
.uri(req_spec.1)
@@ -739,61 +593,8 @@ mod tests {
"`{} {}` shouldn't match `{:?} {}`",
req.method(),
req.uri().path(),
route.method_or_prefix,
route.method,
str::from_utf8(&route.spec).unwrap(),
);
}
#[tokio::test]
async fn strip_prefix() {
let mut svc = StripPrefix::new(
tower::service_fn(
|req: Request<()>| async move { Ok::<_, Infallible>(req.uri().clone()) },
),
"/foo",
);
assert_eq!(
svc.call(Request::builder().uri("/foo/bar").body(()).unwrap())
.await
.unwrap(),
"/bar"
);
assert_eq!(
svc.call(Request::builder().uri("/foo").body(()).unwrap())
.await
.unwrap(),
""
);
assert_eq!(
svc.call(
Request::builder()
.uri("http://example.com/foo/bar?key=value")
.body(())
.unwrap()
)
.await
.unwrap(),
"http://example.com/bar?key=value"
);
}
#[tokio::test]
async fn strip_prefix_with_capture() {
let mut svc = StripPrefix::new(
tower::service_fn(
|req: Request<()>| async move { Ok::<_, Infallible>(req.uri().clone()) },
),
"/:version/api",
);
assert_eq!(
svc.call(Request::builder().uri("/v0/api/foo").body(()).unwrap())
.await
.unwrap(),
"/foo"
);
}
}