Deuxfleurs/garage
48
56
Fork 73
Code Issues 100 Pull requests 13 Releases 30 Wiki Activity

Make use of website config, return error document on error

Browse source
This commit is contained in:
Alex 2022-01-06 12:55:49 +01:00
parent 9eb211948e
commit d4dd2e2640
No known key found for this signature in database
GPG key ID: EDABF9711E244EB1
3 changed files with 103 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/api/lib.rs
View file

@ -2,7 +2,7 @@
#[macro_use] #[macro_use]
extern crate log; extern crate log;
mod error; pub mod error;
pub use error::Error; pub use error::Error;
mod encoding; mod encoding;

2
src/util/config.rs
View file

@ -87,8 +87,6 @@ pub struct WebConfig {
pub bind_addr: SocketAddr, pub bind_addr: SocketAddr,
/// Suffix to remove from domain name to find bucket /// Suffix to remove from domain name to find bucket
pub root_domain: String, pub root_domain: String,
/// Suffix to add when user-agent request path end with "/"
pub index: String,
} }
fn default_sled_cache_capacity() -> u64 { fn default_sled_cache_capacity() -> u64 {

126
src/web/web_server.rs
View file

@ -3,7 +3,7 @@ use std::{borrow::Cow, convert::Infallible, net::SocketAddr, sync::Arc};
use futures::future::Future; use futures::future::Future;
use hyper::{ use hyper::{
header::HOST, header::{HeaderValue, HOST},
server::conn::AddrStream, server::conn::AddrStream,
service::{make_service_fn, service_fn}, service::{make_service_fn, service_fn},
Body, Method, Request, Response, Server, Body, Method, Request, Response, Server,
@ -11,10 +11,10 @@ use hyper::{
use crate::error::*; use crate::error::*;
use garage_api::error::{Error as ApiError, OkOrBadRequest};
use garage_api::helpers::{authority_to_host, host_to_bucket}; use garage_api::helpers::{authority_to_host, host_to_bucket};
use garage_api::s3_get::{handle_get, handle_head}; use garage_api::s3_get::{handle_get, handle_head};
use garage_model::bucket_table::Bucket;
use garage_model::garage::Garage; use garage_model::garage::Garage;
use garage_table::*; use garage_table::*;
@ -52,29 +52,45 @@ async fn handle_request(
addr: SocketAddr, addr: SocketAddr,
) -> Result<Response<Body>, Infallible> { ) -> Result<Response<Body>, Infallible> {
info!("{} {} {}", addr, req.method(), req.uri()); info!("{} {} {}", addr, req.method(), req.uri());
let res = serve_file(garage, req).await; match serve_file(garage, &req).await {
match &res { Ok(res) => {
Ok(r) => debug!("{} {:?}", r.status(), r.headers()), debug!("{} {} {}", req.method(), req.uri(), res.status());
Err(e) => warn!("Response: error {}, {}", e.http_status_code(), e), Ok(res)
}
Err(error) => {
info!(
"{} {} {} {}",
req.method(),
req.uri(),
error.http_status_code(),
error
);
Ok(error_to_res(error))
}
} }
Ok(res.unwrap_or_else(error_to_res))
} }
fn error_to_res(e: Error) -> Response<Body> { fn error_to_res(e: Error) -> Response<Body> {
let body: Body = Body::from(format!("{}\n", e)); // If we are here, it is either that:
// - there was an error before trying to get the requested URL
// from the bucket (e.g. bucket not found)
// - there was an error processing the request and (the request
// was a HEAD request or we couldn't get the error document)
// We do NOT enter this code path when returning the bucket's
// error document (this is handled in serve_file)
let body = Body::from(format!("{}\n", e));
let mut http_error = Response::new(body); let mut http_error = Response::new(body);
*http_error.status_mut() = e.http_status_code(); *http_error.status_mut() = e.http_status_code();
e.add_headers(http_error.headers_mut()); e.add_headers(http_error.headers_mut());
http_error http_error
} }
async fn serve_file(garage: Arc<Garage>, req: Request<Body>) -> Result<Response<Body>, Error> { async fn serve_file(garage: Arc<Garage>, req: &Request<Body>) -> Result<Response<Body>, Error> {
// Get http authority string (eg. [::1]:3902 or garage.tld:80) // Get http authority string (eg. [::1]:3902 or garage.tld:80)
let authority = req let authority = req
.headers() .headers()
.get(HOST) .get(HOST)
.ok_or_else(|| Error::BadRequest("HOST header required".to_owned()))? .ok_or_bad_request("HOST header required")?
.to_str()?; .to_str()?;
// Get bucket // Get bucket
@ -91,35 +107,95 @@ async fn serve_file(garage: Arc<Garage>, req: Request<Body>) -> Result<Response<
.ok_or(Error::NotFound)?; .ok_or(Error::NotFound)?;
// Check bucket isn't deleted and has website access enabled // Check bucket isn't deleted and has website access enabled
let _: Bucket = garage let bucket = garage
.bucket_table .bucket_table
.get(&EmptyKey, &bucket_id) .get(&EmptyKey, &bucket_id)
.await? .await?
.filter(|b| { .ok_or(Error::NotFound)?;
b.state
.as_option() let website_config = bucket
.map(|x| x.website_config.get().is_some()) .params()
.unwrap_or(false) .ok_or(Error::NotFound)?
}) .website_config
.get()
.as_ref()
.ok_or(Error::NotFound)?; .ok_or(Error::NotFound)?;
// Get path // Get path
let path = req.uri().path().to_string(); let path = req.uri().path().to_string();
let index = &garage.config.s3_web.index; let index = &website_config.index_document;
let key = path_to_key(&path, index)?; let key = path_to_key(&path, index)?;
info!( debug!(
"Selected bucket: \"{}\" {:?}, selected key: \"{}\"", "Selected bucket: \"{}\" {:?}, selected key: \"{}\"",
bucket_name, bucket_id, key bucket_name, bucket_id, key
); );
let res = match *req.method() { let ret_doc = match *req.method() {
Method::HEAD => handle_head(garage, &req, bucket_id, &key).await?, Method::HEAD => handle_head(garage.clone(), req, bucket_id, &key).await,
Method::GET => handle_get(garage, &req, bucket_id, &key).await?, Method::GET => handle_get(garage.clone(), req, bucket_id, &key).await,
_ => return Err(Error::BadRequest("HTTP method not supported".to_string())), _ => Err(ApiError::BadRequest("HTTP method not supported".into())),
}
.map_err(Error::from);
if let Err(error) = ret_doc {
if *req.method() == Method::HEAD || !error.http_status_code().is_client_error() {
// Do not return the error document in the following cases:
// - the error is not a 4xx error code
// - the request is a HEAD method
// In this case we just return the error code and the error message in the body,
// by relying on err_to_res that is called above when we return an Err.
return Err(error);
}
// Same if no error document is set: just return the error directly
let error_document = match &website_config.error_document {
Some(ed) => ed.trim_start_matches('/').to_owned(),
None => return Err(error),
}; };
Ok(res) // We want to return the error document
// Create a fake HTTP request with path = the error document
let req2 = Request::builder()
.uri(format!("http://{}/{}", host, &error_document))
.body(Body::empty())
.unwrap();
match handle_get(garage, &req2, bucket_id, &error_document).await {
Ok(mut error_doc) => {
// The error won't be logged back in handle_request,
// so log it here
info!(
"{} {} {} {}",
req.method(),
req.uri(),
error.http_status_code(),
error
);
*error_doc.status_mut() = error.http_status_code();
error.add_headers(error_doc.headers_mut());
// Preserve error message in a special header
for error_line in error.to_string().split('\n') {
if let Ok(v) = HeaderValue::from_bytes(error_line.as_bytes()) {
error_doc.headers_mut().append("X-Garage-Error", v);
}
}
Ok(error_doc)
}
Err(error_doc_error) => {
warn!(
"Couldn't get error document {} for bucket {:?}: {}",
error_document, bucket_id, error_doc_error
);
Err(error)
}
}
} else {
ret_doc
}
} }
/// Path to key /// Path to key