+357 -53

crates/gordian-knot/src/extract/if_none_match.rs

reviewed

··· 1 1 use core::fmt; 2 2 3 3 use axum::extract::FromRequestParts; 4 4 - use axum::extract::OptionalFromRequestParts; 5 5 - use axum::http::HeaderMap; 4 4 + use axum::http::HeaderValue; 6 5 use axum::http::StatusCode; 6 6 + use axum::http::header::ETAG; 7 7 + use axum::http::header::IF_NONE_MATCH; 8 8 + use axum::http::header::InvalidHeaderValue; 9 9 + use axum::http::request::Parts; 7 10 use axum::response::IntoResponse; 8 8 - use reqwest::header::IF_NONE_MATCH; 9 9 - 10 10 - #[derive(Debug, PartialEq, Eq)] 11 11 - pub enum ETag { 12 12 - Strong(String), 13 13 - Weak(String), 14 14 - } 15 15 - 16 16 - impl fmt::Display for ETag { 17 17 - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 18 18 - match self { 19 19 - Self::Strong(value) => write!(f, "\"{value}\""), 20 20 - Self::Weak(value) => write!(f, "W/\"{value}\""), 21 21 - } 22 22 - } 23 23 - } 11 11 + use axum::response::IntoResponseParts; 12 12 + use axum::response::ResponseParts; 24 13 25 14 #[derive(Debug)] 26 26 - pub struct IfNoneMatch(pub Vec<ETag>); 15 15 + pub struct EntityTag { 16 16 + weak: bool, 17 17 + value: String, 18 18 + } 27 19 28 28 - impl IfNoneMatch { 29 29 - pub fn contains_strong(&self, value: &str) -> bool { 30 30 - for tag in &self.0 { 31 31 - match tag { 32 32 - ETag::Strong(strong) if strong == value => return true, 33 33 - _ => continue, 34 34 - } 35 35 - } 36 36 - false 20 20 + impl EntityTag { 21 21 + /// Create a strong [`EntityTag`]. 22 22 + /// 23 23 + /// # Example 24 24 + /// 25 25 + /// ```rust 26 26 + /// # use gordian_knot::extract::if_none_match::EntityTag; 27 27 + /// let etag = EntityTag::strong("a16f46ac"); 28 28 + /// assert_eq!(etag.to_string(), r#""a16f46ac""#); 29 29 + /// assert!(!etag.is_weak()); 30 30 + /// ``` 31 31 + /// 32 32 + /// # Panics 33 33 + /// 34 34 + /// Panics if `value` contains non-ascii characters. 35 35 + pub fn strong(value: impl Into<String>) -> Self { 36 36 + Self::new(false, value.into()) 37 37 } 38 38 39 39 - pub fn contains(&self, value: &str) -> bool { 40 40 - for tag in &self.0 { 41 41 - match tag { 42 42 - ETag::Strong(strong) if strong == value => return true, 43 43 - ETag::Weak(weak) if weak == value => return true, 44 44 - _ => continue, 45 45 - } 39 39 + /// Create a weak [`EntityTag`]. 40 40 + /// 41 41 + /// # Example 42 42 + /// 43 43 + /// ```rust 44 44 + /// # use gordian_knot::extract::if_none_match::EntityTag; 45 45 + /// let etag = EntityTag::weak("a16f46ac"); 46 46 + /// assert_eq!(etag.to_string(), r#"W/"a16f46ac""#); 47 47 + /// assert!(etag.is_weak()); 48 48 + /// ``` 49 49 + /// 50 50 + /// # Panics 51 51 + /// 52 52 + /// Panics if `value` contains non-ascii characters. 53 53 + pub fn weak(value: impl Into<String>) -> Self { 54 54 + Self::new(true, value.into()) 55 55 + } 56 56 + 57 57 + pub const fn is_weak(&self) -> bool { 58 58 + self.weak 59 59 + } 60 60 + 61 61 + /// Compare `self` with `other` using strong comparison. 62 62 + /// 63 63 + /// # Example 64 64 + /// 65 65 + /// ```rust 66 66 + /// # use gordian_knot::extract::if_none_match::EntityTag; 67 67 + /// assert!(!EntityTag::weak("1").strong_eq(&EntityTag::weak("1"))); 68 68 + /// assert!(!EntityTag::weak("1").strong_eq(&EntityTag::weak("2"))); 69 69 + /// assert!(!EntityTag::weak("1").strong_eq(&EntityTag::strong("1"))); 70 70 + /// assert!(EntityTag::strong("1").strong_eq(&EntityTag::strong("1"))); 71 71 + /// ``` 72 72 + /// 73 73 + pub fn strong_eq(&self, other: &Self) -> bool { 74 74 + !self.weak && !other.weak && self.value == other.value 75 75 + } 76 76 + 77 77 + /// Compare `self` with `other` using weak comparison. 78 78 + /// 79 79 + /// # Example 80 80 + /// 81 81 + /// ```rust 82 82 + /// # use gordian_knot::extract::if_none_match::EntityTag; 83 83 + /// assert!(EntityTag::weak("1").weak_eq(&EntityTag::weak("1"))); 84 84 + /// assert!(!EntityTag::weak("1").weak_eq(&EntityTag::weak("2"))); 85 85 + /// assert!(EntityTag::weak("1").weak_eq(&EntityTag::strong("1"))); 86 86 + /// assert!(EntityTag::strong("1").weak_eq(&EntityTag::strong("1"))); 87 87 + /// ``` 88 88 + /// 89 89 + pub fn weak_eq(&self, other: &Self) -> bool { 90 90 + self.value == other.value 91 91 + } 92 92 + 93 93 + /// Convert the [`EntityTag`] to a [`HeaderValue`]. 94 94 + pub fn to_header_value(&self) -> Result<HeaderValue, InvalidHeaderValue> { 95 95 + self.to_string().parse() 96 96 + } 97 97 + 98 98 + fn new(weak: bool, value: String) -> Self { 99 99 + assert!(value.is_ascii()); 100 100 + Self { weak, value } 101 101 + } 102 102 + } 103 103 + 104 104 + impl fmt::Display for EntityTag { 105 105 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 106 106 + if self.weak { 107 107 + f.write_str("W/")?; 46 108 } 47 47 - false 109 109 + write!(f, "\"{}\"", self.value) 110 110 + } 111 111 + } 112 112 + 113 113 + impl std::str::FromStr for EntityTag { 114 114 + type Err = &'static str; 115 115 + 116 116 + fn from_str(value: &str) -> Result<Self, Self::Err> { 117 117 + let (weak, value) = match value.strip_prefix("W/") { 118 118 + Some(value) => (true, value), 119 119 + None => (false, value), 120 120 + }; 121 121 + 122 122 + if !value.is_ascii() { 123 123 + return Err("entity tag contains non-ascii characters"); 124 124 + } 125 125 + 126 126 + Ok(Self { 127 127 + weak, 128 128 + value: value.trim_matches('"').to_string(), 129 129 + }) 130 130 + } 131 131 + } 132 132 + 133 133 + impl IntoResponseParts for EntityTag { 134 134 + type Error = StatusCode; 135 135 + 136 136 + fn into_response_parts(self, mut res: ResponseParts) -> Result<ResponseParts, Self::Error> { 137 137 + let header_value = self 138 138 + .to_string() 139 139 + .parse() 140 140 + .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; 141 141 + res.headers_mut().insert(ETAG, header_value); 142 142 + Ok(res) 143 143 + } 144 144 + } 145 145 + 146 146 + impl IntoResponse for EntityTag { 147 147 + fn into_response(self) -> axum::response::Response { 148 148 + (self, ()).into_response() 149 149 + } 150 150 + } 151 151 + 152 152 + pub trait StrongEq { 153 153 + fn strong_eq(&self, other: &EntityTag) -> bool; 154 154 + } 155 155 + 156 156 + impl StrongEq for EntityTag { 157 157 + fn strong_eq(&self, other: &EntityTag) -> bool { 158 158 + EntityTag::strong_eq(self, other) 159 159 + } 160 160 + } 161 161 + 162 162 + impl StrongEq for str { 163 163 + fn strong_eq(&self, other: &EntityTag) -> bool { 164 164 + !other.weak && self == other.value 165 165 + } 166 166 + } 167 167 + 168 168 + impl StrongEq for String { 169 169 + fn strong_eq(&self, other: &EntityTag) -> bool { 170 170 + !other.weak && self == &other.value 171 171 + } 172 172 + } 173 173 + 174 174 + pub trait WeakEq { 175 175 + fn weak_eq(&self, other: &EntityTag) -> bool; 176 176 + } 177 177 + 178 178 + impl WeakEq for EntityTag { 179 179 + fn weak_eq(&self, other: &EntityTag) -> bool { 180 180 + EntityTag::weak_eq(self, other) 181 181 + } 182 182 + } 183 183 + 184 184 + impl WeakEq for str { 185 185 + fn weak_eq(&self, other: &EntityTag) -> bool { 186 186 + self == other.value 187 187 + } 188 188 + } 189 189 + 190 190 + impl WeakEq for String { 191 191 + fn weak_eq(&self, other: &EntityTag) -> bool { 192 192 + self == &other.value 193 193 + } 194 194 + } 195 195 + 196 196 + /// Extractor for the `If-None-Match` header. 197 197 + /// 198 198 + /// If the header contains invalid utf8, the request will be rejected 199 199 + /// with a `400 Bad Request` response. 200 200 + #[derive(Debug)] 201 201 + pub struct IfNoneMatch { 202 202 + wild: bool, 203 203 + tags: Vec<EntityTag>, 204 204 + } 205 205 + 206 206 + impl IfNoneMatch { 207 207 + pub fn match_strong(&self, value: &(impl StrongEq + ?Sized)) -> bool { 208 208 + self.wild || self.tags.iter().find(|tag| value.strong_eq(tag)).is_some() 209 209 + } 210 210 + 211 211 + pub fn match_weak(&self, value: &(impl WeakEq + ?Sized)) -> bool { 212 212 + self.wild || self.tags.iter().find(|tag| value.weak_eq(tag)).is_some() 213 213 + } 214 214 + 215 215 + fn wild() -> Self { 216 216 + Self { 217 217 + wild: true, 218 218 + tags: Vec::new(), 219 219 + } 48 220 } 49 221 } 50 222 ··· 235 63 } 236 64 } 237 65 238 238 - impl<S: Send + Sync> OptionalFromRequestParts<S> for IfNoneMatch { 66 66 + impl<S: Send + Sync> FromRequestParts<S> for IfNoneMatch { 239 67 type Rejection = ETagRejection; 240 68 241 241 - async fn from_request_parts( 242 242 - parts: &mut axum::http::request::Parts, 243 243 - state: &S, 244 244 - ) -> Result<Option<Self>, Self::Rejection> { 245 245 - let headers = HeaderMap::from_request_parts(parts, state) 246 246 - .await 247 247 - .expect("HeaderMap extractor is infallible"); 248 248 - 69 69 + async fn from_request_parts(parts: &mut Parts, _: &S) -> Result<Self, Self::Rejection> { 249 70 let mut tags = Vec::new(); 250 250 - for header_value in headers.get_all(IF_NONE_MATCH) { 251 251 - let value = std::str::from_utf8(header_value.as_bytes())?; 252 252 - for tag in value.split(',').map(|val| val.trim()) { 253 253 - tags.push(match tag.strip_prefix("W/") { 254 254 - None => ETag::Strong(tag.trim_matches('"').to_string()), 255 255 - Some(tag) => ETag::Weak(tag.trim_matches('"').to_string()), 256 256 - }); 71 71 + 72 72 + for header_value in parts.headers.get_all(IF_NONE_MATCH) { 73 73 + let header_str = std::str::from_utf8(header_value.as_bytes())?; 74 74 + if let Some("*") = header_str.get(..1) { 75 75 + return Ok(Self::wild()); 76 76 + } 77 77 + 78 78 + for tag_str in header_str.split(',').map(|val| val.trim()) { 79 79 + let Ok(tag) = tag_str.parse() else { 80 80 + tracing::warn!(?tag_str, "failed to parse entity tag from if-none-match"); 81 81 + continue; 82 82 + }; 83 83 + tags.push(tag); 257 84 } 258 85 } 259 86 260 260 - Ok((!tags.is_empty()).then_some(Self(tags))) 87 87 + Ok(Self { wild: false, tags }) 88 88 + } 89 89 + } 90 90 + 91 91 + #[cfg(test)] 92 92 + mod tests { 93 93 + use core::error; 94 94 + 95 95 + use axum::Router; 96 96 + use axum::body::Body; 97 97 + use axum::http::Request; 98 98 + use axum::http::StatusCode; 99 99 + use axum::http::header::IF_NONE_MATCH; 100 100 + use axum::response::IntoResponse; 101 101 + use tower::ServiceExt as _; 102 102 + 103 103 + use crate::extract::if_none_match::EntityTag; 104 104 + use crate::extract::if_none_match::StrongEq; 105 105 + use crate::extract::if_none_match::WeakEq as _; 106 106 + 107 107 + use super::IfNoneMatch; 108 108 + 109 109 + async fn weak_0815(if_none_match: IfNoneMatch) -> impl IntoResponse { 110 110 + if if_none_match.match_weak("0815") { 111 111 + StatusCode::NOT_MODIFIED 112 112 + } else { 113 113 + StatusCode::OK 114 114 + } 115 115 + } 116 116 + 117 117 + async fn strong_0815(if_none_match: IfNoneMatch) -> impl IntoResponse { 118 118 + if if_none_match.match_strong("0815") { 119 119 + StatusCode::NOT_MODIFIED 120 120 + } else { 121 121 + StatusCode::OK 122 122 + } 123 123 + } 124 124 + 125 125 + fn app() -> Router { 126 126 + Router::new() 127 127 + .route("/weak_0815", axum::routing::get(weak_0815)) 128 128 + .route("/strong_0815", axum::routing::get(strong_0815)) 129 129 + } 130 130 + 131 131 + fn request<'a>(path: &str, etags: impl IntoIterator<Item = &'a str>) -> Request<Body> { 132 132 + let mut request = Request::get(path); 133 133 + let headers = request.headers_mut().unwrap(); 134 134 + for etag in etags { 135 135 + headers.append(IF_NONE_MATCH, etag.parse().unwrap()); 136 136 + } 137 137 + request.body(Body::empty()).unwrap() 138 138 + } 139 139 + 140 140 + #[test] 141 141 + fn can_parse_weak() { 142 142 + let tag: EntityTag = r#"W/"a16f46ac""#.parse().unwrap(); 143 143 + assert!(tag.is_weak()); 144 144 + assert_eq!(tag.value, "a16f46ac"); 145 145 + } 146 146 + 147 147 + #[test] 148 148 + fn can_parse_strong() { 149 149 + let tag: EntityTag = r#""a16f46ac""#.parse().unwrap(); 150 150 + assert!(!tag.is_weak()); 151 151 + assert_eq!(tag.value, "a16f46ac"); 152 152 + } 153 153 + 154 154 + #[test] 155 155 + fn strong_eq_str() { 156 156 + assert!("a16f46ac".strong_eq(&EntityTag::strong("a16f46ac"))); 157 157 + assert!(!"a16f46ac".strong_eq(&EntityTag::weak("a16f46ac"))); 158 158 + 159 159 + assert!(!"4abc05c9".strong_eq(&EntityTag::strong("a16f46ac"))); 160 160 + assert!(!"4abc05c9".strong_eq(&EntityTag::weak("a16f46ac"))); 161 161 + } 162 162 + 163 163 + #[test] 164 164 + fn weak_eq_str() { 165 165 + assert!("a16f46ac".weak_eq(&EntityTag::strong("a16f46ac"))); 166 166 + assert!("a16f46ac".weak_eq(&EntityTag::weak("a16f46ac"))); 167 167 + 168 168 + assert!(!"4abc05c9".weak_eq(&EntityTag::strong("a16f46ac"))); 169 169 + assert!(!"4abc05c9".weak_eq(&EntityTag::weak("a16f46ac"))); 170 170 + } 171 171 + 172 172 + #[tokio::test] 173 173 + async fn if_none_match_weak() -> Result<(), Box<dyn error::Error>> { 174 174 + let response = app() 175 175 + .oneshot(request("/weak_0815", Some(r#"W/"0815""#))) 176 176 + .await?; 177 177 + assert_eq!(response.status(), StatusCode::NOT_MODIFIED); 178 178 + 179 179 + // Strong should also match. 180 180 + let response = app() 181 181 + .oneshot(request("/weak_0815", Some(r#""0815""#))) 182 182 + .await?; 183 183 + assert_eq!(response.status(), StatusCode::NOT_MODIFIED); 184 184 + 185 185 + // Wild-card should also match. 186 186 + let response = app().oneshot(request("/weak_0815", Some(r#"*"#))).await?; 187 187 + assert_eq!(response.status(), StatusCode::NOT_MODIFIED); 188 188 + 189 189 + // Ensure it doesn't just accept everything. 190 190 + let response = app() 191 191 + .oneshot(request("/weak_0815", Some(r#"W/"08159""#))) 192 192 + .await?; 193 193 + assert_eq!(response.status(), StatusCode::OK); 194 194 + 195 195 + Ok(()) 196 196 + } 197 197 + 198 198 + #[tokio::test] 199 199 + async fn if_none_match_strong() -> Result<(), Box<dyn error::Error>> { 200 200 + const PATH: &str = "/strong_0815"; 201 201 + 202 202 + let response = app().oneshot(request(PATH, Some(r#"W/"0815""#))).await?; 203 203 + assert_eq!(response.status(), StatusCode::OK); 204 204 + 205 205 + // Strong should also match. 206 206 + let response = app().oneshot(request(PATH, Some(r#""0815""#))).await?; 207 207 + assert_eq!(response.status(), StatusCode::NOT_MODIFIED); 208 208 + 209 209 + // Wild-card should also match. 210 210 + let response = app().oneshot(request(PATH, Some(r#"*"#))).await?; 211 211 + assert_eq!(response.status(), StatusCode::NOT_MODIFIED); 212 212 + 213 213 + // Ensure it doesn't just accept everything. 214 214 + let response = app().oneshot(request(PATH, Some(r#"W/"08159""#))).await?; 215 215 + assert_eq!(response.status(), StatusCode::OK); 216 216 + 217 217 + let response = app().oneshot(request(PATH, Some(r#""08159""#))).await?; 218 218 + assert_eq!(response.status(), StatusCode::OK); 219 219 + 220 220 + Ok(()) 261 221 } 262 222 }

+6 -4

crates/gordian-knot/src/public/xrpc/sh_tangled/repo/impl_blob.rs

reviewed

··· 18 18 use reqwest::header::ETAG; 19 19 use tokio_rayon::AsyncThreadPool as _; 20 20 21 21 + use crate::extract::if_none_match::EntityTag; 21 22 use crate::extract::if_none_match::IfNoneMatch; 22 23 use crate::model::Knot; 23 24 use crate::model::repository::ResolveRevspec as _; ··· 36 35 )] 37 36 pub async fn handle( 38 37 State(knot): State<Knot>, 39 39 - if_none_match: Option<IfNoneMatch>, 38 38 + if_none_match: IfNoneMatch, 40 39 XrpcQuery(Input { 41 40 repo, 42 41 rev, ··· 50 49 let ResolvedRevspec { commit, immutable } = 51 50 repository.resolve_revspec(&Some(rev.as_str()))?; 52 51 53 53 - // Use the tree object ID as an ETag. 52 52 + // Use the tree object ID as an entity tag. 54 53 // 55 54 // 1. If the blob content has changed, the blob object ID will be different, and 56 55 // therefore the tree object ID will also be different. ··· 58 57 // 2. Using the tree object ID avoids searching the tree for the blob path. 59 58 60 59 let tree = repository.get_tree(&commit)?; 61 61 - if if_none_match.is_some_and(|etags| etags.contains(&tree.id.to_string())) { 60 60 + let etag = EntityTag::strong(tree.id.to_hex().to_string()); 61 61 + if if_none_match.match_weak(&etag) { 62 62 return Ok(StatusCode::NOT_MODIFIED.into_response()); 63 63 } 64 64 ··· 85 83 86 84 headers.insert( 87 85 ETAG, 88 88 - HeaderValue::from_str(&format!("\"{}\"", tree.id)) 86 86 + etag.to_header_value() 89 87 .expect("Hex-string should be a valid header value"), 90 88 ); 91 89