mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-04 21:37:58 +03:00
Code Issues Projects Releases Packages Wiki Activity

Fix search order for normal and prefix paths

Browse source
This commit is contained in:
Nikolay Kim 2021-06-14 21:41:08 +06:00
parent f4006c72ae
commit 391cf24fa9
5 changed files with 248 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex-router/CHANGES.txt
View file

@ -1,5 +1,9 @@
# Changes # Changes
## [0.4.4] - 2021-06-14
* Fix search order for normal and prefix paths
## [0.4.3] - 2021-04-03 ## [0.4.3] - 2021-04-03
* Disable some of regex features * Disable some of regex features

4
ntex-router/Cargo.toml
View file

@ -1,6 +1,6 @@
[package] [package]
name = "ntex-router" name = "ntex-router"
version = "0.4.3" version = "0.4.4"
authors = ["ntex contributors <team@ntex.rs>"] authors = ["ntex contributors <team@ntex.rs>"]
description = "Path router" description = "Path router"
keywords = ["ntex"] keywords = ["ntex"]
@ -21,7 +21,7 @@ serde = "1.0"
bytestring = "1.0" bytestring = "1.0"
log = "0.4" log = "0.4"
http = { version = "0.2", optional = true } http = { version = "0.2", optional = true }
regex = { version = "1.4.5", default-features = false, features = ["std"] } regex = { version = "1.5.4", default-features = false, features = ["std"] }
[dev-dependencies] [dev-dependencies]
http = "0.2" http = "0.2"

417
ntex-router/src/tree.rs
View file

@ -8,22 +8,27 @@ use super::{Resource, ResourcePath};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub(super) struct Tree { pub(super) struct Tree {
key: Vec<Segment>, key: Vec<Segment>,
value: Vec<Value>, items: Vec<Item>,
children: Vec<Tree>, }
#[derive(Clone, Debug)]
enum Item {
Value(Value),
Subtree(Tree),
} }
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
enum Value { enum Value {
Val(usize), Val(usize),
Slesh(usize), Slash(usize),
Prefix(usize), Prefix(usize),
PrefixSlesh(usize), PrefixSlash(usize),
} }
#[derive(Copy, Clone, Debug, PartialEq, Eq)] #[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum PathState { enum PathState {
Empty, Empty,
Slesh, Slash,
Tail, Tail,
} }
@ -31,9 +36,9 @@ impl Value {
fn value(&self) -> usize { fn value(&self) -> usize {
match self { match self {
Value::Val(v) => *v, Value::Val(v) => *v,
Value::Slesh(v) => *v, Value::Slash(v) => *v,
Value::Prefix(v) => *v, Value::Prefix(v) => *v,
Value::PrefixSlesh(v) => *v, Value::PrefixSlash(v) => *v,
} }
} }
} }
@ -42,8 +47,7 @@ impl Default for Tree {
fn default() -> Tree { fn default() -> Tree {
Tree { Tree {
key: Vec::new(), key: Vec::new(),
value: Vec::new(), items: Vec::new(),
children: Vec::new(),
} }
} }
} }
@ -56,9 +60,9 @@ impl Tree {
let val = if resource.tp[0].slesh { let val = if resource.tp[0].slesh {
if resource.prefix { if resource.prefix {
Value::PrefixSlesh(value) Value::PrefixSlash(value)
} else { } else {
Value::Slesh(value) Value::Slash(value)
} }
} else if resource.prefix { } else if resource.prefix {
Value::Prefix(value) Value::Prefix(value)
@ -71,9 +75,9 @@ impl Tree {
for seg in &resource.tp[1..] { for seg in &resource.tp[1..] {
let val = if seg.slesh { let val = if seg.slesh {
if resource.prefix { if resource.prefix {
Value::PrefixSlesh(value) Value::PrefixSlash(value)
} else { } else {
Value::Slesh(value) Value::Slash(value)
} }
} else if resource.prefix { } else if resource.prefix {
Value::Prefix(value) Value::Prefix(value)
@ -86,25 +90,21 @@ impl Tree {
} }
fn child(key: Vec<Segment>, value: Option<Value>) -> Tree { fn child(key: Vec<Segment>, value: Option<Value>) -> Tree {
let value = if let Some(val) = value { let items = if let Some(val) = value {
vec![val] vec![Item::Value(val)]
} else { } else {
Vec::new() Vec::new()
}; };
Tree { Tree { key, items }
key,
value,
children: Vec::new(),
}
} }
pub(super) fn insert(&mut self, resource: &ResourceDef, value: usize) { pub(super) fn insert(&mut self, resource: &ResourceDef, value: usize) {
for seg in &resource.tp { for seg in &resource.tp {
let value = if seg.slesh { let value = if seg.slesh {
if resource.prefix { if resource.prefix {
Value::PrefixSlesh(value) Value::PrefixSlash(value)
} else { } else {
Value::Slesh(value) Value::Slash(value)
} }
} else if resource.prefix { } else if resource.prefix {
Value::Prefix(value) Value::Prefix(value)
@ -123,33 +123,34 @@ impl Tree {
if p < self.key.len() { if p < self.key.len() {
let child = Tree { let child = Tree {
key: self.key.split_off(p), key: self.key.split_off(p),
value: mem::take(&mut self.value), items: mem::take(&mut self.items),
children: mem::take(&mut self.children),
}; };
self.children.push(child); self.items.push(Item::Subtree(child));
} }
// update value if key is the same // update value if key is the same
if p == key.len() { if p == key.len() {
match value { match value {
Value::PrefixSlesh(v) => { Value::PrefixSlash(v) => {
self.children self.items.push(Item::Subtree(Tree::child(
.push(Tree::child(Vec::new(), Some(Value::Prefix(v)))); Vec::new(),
Some(Value::Prefix(v)),
)));
} }
value => self.value.push(value), value => self.items.push(Item::Value(value)),
} }
} else { } else {
// insert into sub tree // insert into sub tree
let mut child = self for child in &mut self.items {
.children if let Item::Subtree(ref mut tree) = child {
.iter_mut() if common_prefix(&tree.key, &key[p..]) > 0 {
.find(|x| common_prefix(&x.key, &key[p..]) > 0); tree.insert_path(key[p..].to_vec(), value);
if let Some(ref mut child) = child { return;
child.insert_path(key[p..].to_vec(), value) }
} else { }
self.children
.push(Tree::child(key[p..].to_vec(), Some(value)));
} }
self.items
.push(Item::Subtree(Tree::child(key[p..].to_vec(), Some(value))));
} }
} }
@ -213,98 +214,133 @@ impl Tree {
if self.key.is_empty() { if self.key.is_empty() {
if path == "/" { if path == "/" {
for val in &self.value { for val in &self.items {
let v = match val { match val {
Value::Slesh(v) | Value::Prefix(v) | Value::PrefixSlesh(v) => *v, Item::Value(val) => {
_ => continue, let v = match val {
}; Value::Slash(v)
if check(v, resource) { | Value::Prefix(v)
return Some(v); | Value::PrefixSlash(v) => *v,
_ => continue,
};
if check(v, resource) {
return Some(v);
}
}
Item::Subtree(ref tree) => {
let result = tree.find_inner_wrapped(
"",
resource,
check,
1,
&mut segments,
insensitive,
base_skip - 1,
);
if let Some((val, skip)) = result {
let path = resource.resource_path();
path.segments = segments;
path.skip += skip as u16;
return Some(val);
}
}
} }
} }
} else if path.is_empty() { } else if path.is_empty() {
for val in &self.value { for val in &self.items {
let v = match val { match val {
Value::Val(v) | Value::Prefix(v) => *v, Item::Value(val) => {
_ => continue, let v = match val {
}; Value::Val(v) | Value::Prefix(v) => *v,
if check(v, resource) { _ => continue,
return Some(v); };
if check(v, resource) {
return Some(v);
}
}
Item::Subtree(ref tree) => {
let result = tree.find_inner_wrapped(
"",
resource,
check,
1,
&mut segments,
insensitive,
base_skip,
);
if let Some((val, skip)) = result {
let path = resource.resource_path();
path.segments = segments;
path.skip += skip as u16;
return Some(val);
}
}
} }
} }
} else { } else {
for val in &self.value { let subtree_path = if let Some(spath) = path.strip_prefix('/') {
let v = match val { spath
Value::PrefixSlesh(v) => *v, } else {
_ => continue, base_skip -= 1;
}; path
if check(v, resource) { };
return Some(v);
for val in &self.items {
match val {
Item::Value(val) => {
let v = match val {
Value::PrefixSlash(v) => *v,
_ => continue,
};
if check(v, resource) {
return Some(v);
}
}
Item::Subtree(ref tree) => {
let result = tree.find_inner_wrapped(
subtree_path,
resource,
check,
1,
&mut segments,
insensitive,
base_skip,
);
if let Some((val, skip)) = result {
let path = resource.resource_path();
path.segments = segments;
path.skip += skip as u16;
return Some(val);
}
}
} }
} }
} }
} else if !path.is_empty() {
let path = if let Some(path) = path.strip_prefix('/') { let subtree_path = if let Some(spath) = path.strip_prefix('/') {
path spath
} else { } else {
base_skip -= 1; base_skip -= 1;
path path
}; };
let res = self.find_inner_wrapped(
subtree_path,
resource,
check,
1,
&mut segments,
insensitive,
base_skip,
);
let res = self if let Some((val, skip)) = res {
.children
.iter()
.map(|x| {
x.find_inner_wrapped(
path,
resource,
check,
1,
&mut segments,
insensitive,
base_skip,
)
})
.flatten()
.next();
return if let Some((val, skip)) = res {
let path = resource.resource_path(); let path = resource.resource_path();
path.segments = segments; path.segments = segments;
path.skip += skip as u16; path.skip += skip as u16;
Some(val) return Some(val);
} else { }
None
};
}
if path.is_empty() {
return None;
}
let path = if let Some(path) = path.strip_prefix('/') {
path
} else {
base_skip -= 1;
path
};
if let Some((val, skip)) = self.find_inner_wrapped(
path,
resource,
check,
1,
&mut segments,
insensitive,
base_skip,
) {
let path = resource.resource_path();
path.segments = segments;
path.skip += skip as u16;
Some(val)
} else {
None
} }
None
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
@ -357,9 +393,9 @@ impl Tree {
{ {
if self.key.is_empty() { if self.key.is_empty() {
if path.is_empty() { if path.is_empty() {
for val in &self.value { for val in &self.items {
let v = match val { let v = match val {
Value::Val(v) | Value::Prefix(v) => *v, Item::Value(Value::Val(v)) | Item::Value(Value::Prefix(v)) => *v,
_ => continue, _ => continue,
}; };
if check(v, resource) { if check(v, resource) {
@ -367,9 +403,9 @@ impl Tree {
} }
} }
} else { } else {
for val in &self.value { for val in &self.items {
let v = match val { let v = match val {
Value::Prefix(v) => *v, Item::Value(Value::Prefix(v)) => *v,
_ => continue, _ => continue,
}; };
if check(v, resource) { if check(v, resource) {
@ -434,10 +470,12 @@ impl Tree {
// we have to process checker for tail matches separately // we have to process checker for tail matches separately
if tail && is_match { if tail && is_match {
// checker // checker
for val in &self.value { for val in &self.items {
let v = val.value(); if let Item::Value(ref val) = val {
if check(v, resource) { let v = val.value();
return Some((v, skip + idx)); if check(v, resource) {
return Some((v, skip + idx));
}
} }
} }
} }
@ -458,13 +496,17 @@ impl Tree {
return { return {
if key.is_empty() { if key.is_empty() {
// checker // checker
for val in &self.value { for val in &self.items {
let v = match val { if let Item::Value(ref val) = val {
Value::Val(v) | Value::Prefix(v) => *v, let v = match val {
Value::Slesh(_) | Value::PrefixSlesh(_) => continue, Value::Val(v) | Value::Prefix(v) => *v,
}; Value::Slash(_) | Value::PrefixSlash(_) => {
if check(v, resource) { continue
return Some((v, skip)); }
};
if check(v, resource) {
return Some((v, skip));
}
} }
} }
} }
@ -472,95 +514,72 @@ impl Tree {
}; };
} else if key.is_empty() { } else if key.is_empty() {
path = &path[idx..]; path = &path[idx..];
let subtree_path = if path.len() != 1 { &path[1..] } else { path };
let p = if path.is_empty() { let p = if path.is_empty() {
PathState::Empty PathState::Empty
} else if path == "/" { } else if path == "/" {
PathState::Slesh PathState::Slash
} else { } else {
PathState::Tail PathState::Tail
}; };
for val in &self.value { for val in &self.items {
let v = match val { match val {
Value::Val(v) => { Item::Value(val) => {
if p == PathState::Empty { let v = match val {
*v Value::Val(v) => {
} else { if p == PathState::Empty {
continue; *v
}
}
Value::Slesh(v) => {
if p == PathState::Slesh {
*v
} else {
continue;
}
}
Value::Prefix(v) => {
if p == PathState::Slesh || p == PathState::Tail {
if !self.children.is_empty() {
let p = if path.len() != 1 {
&path[1..]
} else { } else {
path continue;
};
if let Some(res) = self
.children
.iter()
.map(|x| {
x.find_inner_wrapped(
p,
resource,
check,
skip,
segments,
insensitive,
base_skip,
)
})
.flatten()
.next()
{
return Some(res);
} }
} }
*v Value::Slash(v) => {
} else { if p == PathState::Slash {
continue; *v
} else {
continue;
}
}
Value::Prefix(v) => {
if p == PathState::Slash || p == PathState::Tail
{
*v
} else {
continue;
}
}
Value::PrefixSlash(v) => {
if p == PathState::Slash || p == PathState::Tail
{
*v
} else {
continue;
}
}
};
if check(v, resource) {
return Some((v, skip - 1));
} }
} }
Value::PrefixSlesh(v) => { Item::Subtree(ref tree) => {
if p == PathState::Slesh || p == PathState::Tail { let result = tree.find_inner_wrapped(
*v subtree_path,
} else { resource,
continue; check,
skip,
segments,
insensitive,
base_skip,
);
if result.is_some() {
return result;
} }
} }
};
if check(v, resource) {
return Some((v, skip - 1));
} }
} }
return None;
let path = if path.len() != 1 { &path[1..] } else { path };
return self
.children
.iter()
.map(|x| {
x.find_inner_wrapped(
path,
resource,
check,
skip,
segments,
insensitive,
base_skip,
)
})
.flatten()
.next();
} else { } else {
path = &path[idx + 1..]; path = &path[idx + 1..];
} }

10
ntex/Cargo.toml
View file

@ -45,7 +45,7 @@ http-framework = ["h2", "http", "httparse",
[dependencies] [dependencies]
ntex-codec = "0.4.1" ntex-codec = "0.4.1"
ntex-rt = "0.2.2" ntex-rt = "0.2.2"
ntex-router = "0.4.3" ntex-router = "0.4.4"
ntex-service = "0.1.9" ntex-service = "0.1.9"
ntex-macros = "0.1.3" ntex-macros = "0.1.3"
ntex-util = "0.1.1" ntex-util = "0.1.1"
@ -55,15 +55,15 @@ base64 = "0.13"
bitflags = "1.2" bitflags = "1.2"
bytes = "1.0" bytes = "1.0"
bytestring = { version = "1.0", features = ["serde"] } bytestring = { version = "1.0", features = ["serde"] }
derive_more = "0.99.13" derive_more = "0.99.14"
futures-core = { version = "0.3.15", default-features = false, features = ["alloc"] } futures-core = { version = "0.3.15", default-features = false, features = ["alloc"] }
futures-sink = { version = "0.3.15", default-features = false, features = ["alloc"] } futures-sink = { version = "0.3.15", default-features = false, features = ["alloc"] }
log = "0.4" log = "0.4"
mio = "0.7.10" mio = "0.7.11"
num_cpus = "1.13" num_cpus = "1.13"
nanorand = { version = "0.5", default-features = false, features = ["std", "wyrand"] } nanorand = { version = "0.5", default-features = false, features = ["std", "wyrand"] }
pin-project-lite = "0.2" pin-project-lite = "0.2"
regex = { version = "1.4.5", default-features = false, features = ["std"] } regex = { version = "1.5.4", default-features = false, features = ["std"] }
sha-1 = "0.9" sha-1 = "0.9"
slab = "0.4" slab = "0.4"
serde = { version = "1.0", features=["derive"] } serde = { version = "1.0", features=["derive"] }
@ -73,7 +73,7 @@ tokio = { version = "1", default-features = false, features = ["sync"] }
# http/web framework # http/web framework
h2 = { version = "0.3", optional = true } h2 = { version = "0.3", optional = true }
http = { version = "0.2", optional = true } http = { version = "0.2", optional = true }
httparse = { version = "1.3", optional = true } httparse = { version = "1.4.1", optional = true }
httpdate = { version = "1.0", optional = true } httpdate = { version = "1.0", optional = true }
encoding_rs = { version = "0.8", optional = true } encoding_rs = { version = "0.8", optional = true }
mime = { version = "0.3", optional = true } mime = { version = "0.3", optional = true }

25
ntex/src/web/scope.rs
View file

@ -900,25 +900,38 @@ mod tests {
#[crate::rt_test] #[crate::rt_test]
async fn test_scope_guard() { async fn test_scope_guard() {
let srv = let srv = init_service(
init_service(App::new().service( App::new()
web::scope("/app").guard(guard::Get()).service( .service(web::scope("/app").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }), web::resource("/path1").to(|| async { HttpResponse::Ok() }),
))
.service(web::scope("/app").guard(guard::Post()).service(
web::resource("/path1").to(|| async { HttpResponse::NotModified() }),
))
.service(
web::resource("/app/path1")
.to(|| async { HttpResponse::NoContent() }),
), ),
)) )
.await; .await;
let req = TestRequest::with_uri("/app/path1") let req = TestRequest::with_uri("/app/path1")
.method(Method::POST) .method(Method::POST)
.to_request(); .to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
let req = TestRequest::with_uri("/app/path1") let req = TestRequest::with_uri("/app/path1")
.method(Method::GET) .method(Method::GET)
.to_request(); .to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/app/path1")
.method(Method::DELETE)
.to_request();
let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NO_CONTENT);
} }
#[crate::rt_test] #[crate::rt_test]