garage/src/web/web_server.rs

use std::{borrow::Cow, convert::Infallible, net::SocketAddr, sync::Arc};

use futures::future::Future;

use http::header::{ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD};
use hyper::{
	header::{HeaderValue, HOST},
	server::conn::AddrStream,
	service::{make_service_fn, service_fn},
	Body, Method, Request, Response, Server, StatusCode,
};

use crate::error::*;

use garage_api::error::{Error as ApiError, OkOrBadRequest, OkOrInternalError};
use garage_api::helpers::{authority_to_host, host_to_bucket};
use garage_api::s3_cors::{add_cors_headers, cors_rule_matches};
use garage_api::s3_get::{handle_get, handle_head};

use garage_model::bucket_table::Bucket;
use garage_model::garage::Garage;

use garage_table::*;
use garage_util::error::Error as GarageError;

/// Run a web server
pub async fn run_web_server(
	garage: Arc<Garage>,
	shutdown_signal: impl Future<Output = ()>,
) -> Result<(), GarageError> {
	let addr = &garage.config.s3_web.bind_addr;

	let service = make_service_fn(|conn: &AddrStream| {
		let garage = garage.clone();
		let client_addr = conn.remote_addr();
		async move {
			Ok::<_, Error>(service_fn(move |req: Request<Body>| {
				let garage = garage.clone();
				handle_request(garage, req, client_addr)
			}))
		}
	});

	let server = Server::bind(addr).serve(service);
	let graceful = server.with_graceful_shutdown(shutdown_signal);
	info!("Web server listening on http://{}", addr);

	graceful.await?;
	Ok(())
}

async fn handle_request(
	garage: Arc<Garage>,
	req: Request<Body>,
	addr: SocketAddr,
) -> Result<Response<Body>, Infallible> {
	info!("{} {} {}", addr, req.method(), req.uri());
	match serve_file(garage, &req).await {
		Ok(res) => {
			debug!("{} {} {}", req.method(), req.uri(), res.status());
			Ok(res)
		}
		Err(error) => {
			info!(
				"{} {} {} {}",
				req.method(),
				req.uri(),
				error.http_status_code(),
				error
			);
			Ok(error_to_res(error))
		}
	}
}

fn error_to_res(e: Error) -> Response<Body> {
	// 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);
	*http_error.status_mut() = e.http_status_code();
	e.add_headers(http_error.headers_mut());
	http_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)
	let authority = req
		.headers()
		.get(HOST)
		.ok_or_bad_request("HOST header required")?
		.to_str()?;

	// Get bucket
	let host = authority_to_host(authority)?;
	let root = &garage.config.s3_web.root_domain;

	let bucket_name = host_to_bucket(&host, root).unwrap_or(&host);
	let bucket_id = garage
		.bucket_alias_table
		.get(&EmptyKey, &bucket_name.to_string())
		.await?
		.map(|x| x.state.take())
		.flatten()
		.ok_or(Error::NotFound)?;

	// Check bucket isn't deleted and has website access enabled
	let bucket = garage
		.bucket_table
		.get(&EmptyKey, &bucket_id)
		.await?
		.ok_or(Error::NotFound)?;

	let website_config = bucket
		.params()
		.ok_or(Error::NotFound)?
		.website_config
		.get()
		.as_ref()
		.ok_or(Error::NotFound)?;

	// Get path
	let path = req.uri().path().to_string();
	let index = &website_config.index_document;
	let key = path_to_key(&path, index)?;

	debug!(
		"Selected bucket: \"{}\" {:?}, selected key: \"{}\"",
		bucket_name, bucket_id, key
	);

	let ret_doc = match *req.method() {
		Method::OPTIONS => return handle_options(&bucket, req),
		Method::HEAD => {
			return handle_head(garage.clone(), req, bucket_id, &key)
				.await
				.map_err(Error::from)
		}
		Method::GET => handle_get(garage.clone(), req, bucket_id, &key).await,
		_ => Err(ApiError::BadRequest("HTTP method not supported".into())),
	}
	.map_err(Error::from);

	match ret_doc {
		Err(error) => {
			// For a HEAD or OPTIONS method, we don't return the error document
			// as content, we return above and just return the error message
			// by relying on err_to_res that is called when we return an Err.
			assert!(*req.method() != Method::HEAD && *req.method() != Method::OPTIONS);

			if !error.http_status_code().is_client_error() {
				// Do not return the error document if it is not a 4xx error code.
				return Err(error);
			}

			// 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),
			};

			// 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)
				}
			}
		}
		Ok(mut resp) => {
			// Maybe add CORS headers
			if let Some(cors_config) = bucket.params().unwrap().cors_config.get() {
				if let Some(origin) = req.headers().get("Origin") {
					let origin = origin.to_str()?;
					let request_headers = match req.headers().get(ACCESS_CONTROL_REQUEST_HEADERS) {
						Some(h) => h.to_str()?.split(',').map(|h| h.trim()).collect::<Vec<_>>(),
						None => vec![],
					};
					let matching_rule = cors_config.iter().find(|rule| {
						cors_rule_matches(
							rule,
							origin,
							&req.method().to_string(),
							request_headers.iter(),
						)
					});
					if let Some(rule) = matching_rule {
						add_cors_headers(&mut resp, rule)
							.ok_or_internal_error("Invalid CORS configuration")?;
					}
				}
			}
			Ok(resp)
		}
	}
}

fn handle_options(bucket: &Bucket, req: &Request<Body>) -> Result<Response<Body>, Error> {
	let origin = req
		.headers()
		.get("Origin")
		.ok_or_bad_request("Missing Origin header")?
		.to_str()?;
	let request_method = req
		.headers()
		.get(ACCESS_CONTROL_REQUEST_METHOD)
		.ok_or_bad_request("Missing Access-Control-Request-Method header")?
		.to_str()?;
	let request_headers = match req.headers().get(ACCESS_CONTROL_REQUEST_HEADERS) {
		Some(h) => h.to_str()?.split(',').map(|h| h.trim()).collect::<Vec<_>>(),
		None => vec![],
	};

	if let Some(cors_config) = bucket.params().unwrap().cors_config.get() {
		let matching_rule = cors_config
			.iter()
			.find(|rule| cors_rule_matches(rule, origin, request_method, request_headers.iter()));
		if let Some(rule) = matching_rule {
			let mut resp = Response::builder()
				.status(StatusCode::OK)
				.body(Body::empty())
				.map_err(ApiError::from)?;
			add_cors_headers(&mut resp, rule).ok_or_internal_error("Invalid CORS configuration")?;
			return Ok(resp);
		}
	}

	Err(ApiError::Forbidden("No matching CORS rule".into()).into())
}

/// Path to key
///
/// Convert the provided path to the internal key
/// When a path ends with "/", we append the index name to match traditional web server behavior
/// which is also AWS S3 behavior.
fn path_to_key<'a>(path: &'a str, index: &str) -> Result<Cow<'a, str>, Error> {
	let path_utf8 = percent_encoding::percent_decode_str(path).decode_utf8()?;

	if !path_utf8.starts_with('/') {
		return Err(Error::BadRequest(
			"Path must start with a / (slash)".to_string(),
		));
	}

	match path_utf8.chars().last() {
		None => unreachable!(),
		Some('/') => {
			let mut key = String::with_capacity(path_utf8.len() + index.len());
			key.push_str(&path_utf8[1..]);
			key.push_str(index);
			Ok(key.into())
		}
		Some(_) => match path_utf8 {
			Cow::Borrowed(pu8) => Ok((&pu8[1..]).into()),
			Cow::Owned(pu8) => Ok((&pu8[1..]).to_string().into()),
		},
	}
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn path_to_key_test() -> Result<(), Error> {
		assert_eq!(path_to_key("/file%20.jpg", "index.html")?, "file .jpg");
		assert_eq!(path_to_key("/%20t/", "index.html")?, " t/index.html");
		assert_eq!(path_to_key("/", "index.html")?, "index.html");
		assert_eq!(path_to_key("/hello", "index.html")?, "hello");
		assert!(path_to_key("", "index.html").is_err());
		assert!(path_to_key("i/am/relative", "index.html").is_err());
		Ok(())
	}
}
Use handle_get 2020-11-21 16:50:19 +00:00			`use std::{borrow::Cow, convert::Infallible, net::SocketAddr, sync::Arc};`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00
			`use futures::future::Future;`

Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`use http::header::{ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD};`
We are able to serve a file 2020-11-21 14:15:25 +00:00			`use hyper::{`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`header::{HeaderValue, HOST},`
We are able to serve a file 2020-11-21 14:15:25 +00:00			`server::conn::AddrStream,`
			`service::{make_service_fn, service_fn},`
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`Body, Method, Request, Response, Server, StatusCode,`
Use handle_get 2020-11-21 16:50:19 +00:00			`};`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00
Use handle_get 2020-11-21 16:50:19 +00:00			`use crate::error::*;`
Model changes 2021-12-16 10:47:58 +00:00
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`use garage_api::error::{Error as ApiError, OkOrBadRequest, OkOrInternalError};`
add support for vhost-style s3 bucket 2021-11-11 10:26:02 +00:00			`use garage_api::helpers::{authority_to_host, host_to_bucket};`
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`use garage_api::s3_cors::{add_cors_headers, cors_rule_matches};`
Handle HEAD 2020-11-21 16:58:14 +00:00			`use garage_api::s3_get::{handle_get, handle_head};`
Model changes 2021-12-16 10:47:58 +00:00
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`use garage_model::bucket_table::Bucket;`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00			`use garage_model::garage::Garage;`
Model changes 2021-12-16 10:47:58 +00:00
Fix formatting 2020-12-17 21:51:44 +00:00			`use garage_table::*;`
Make it compile again 2020-11-19 13:56:00 +00:00			`use garage_util::error::Error as GarageError;`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00
document web crate 2021-03-26 21:05:16 +00:00			`/// Run a web server`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00			`pub async fn run_web_server(`
			`garage: Arc<Garage>,`
			`shutdown_signal: impl Future<Output = ()>,`
Make it compile again 2020-11-19 13:56:00 +00:00			`) -> Result<(), GarageError> {`
Extract bucket 2020-11-10 08:57:07 +00:00			`let addr = &garage.config.s3_web.bind_addr;`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00
			`let service = make_service_fn(\|conn: &AddrStream\| {`
			`let garage = garage.clone();`
			`let client_addr = conn.remote_addr();`
Fix formatting 2020-11-10 08:59:52 +00:00			`async move {`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00			`Ok::<_, Error>(service_fn(move \|req: Request<Body>\| {`
			`let garage = garage.clone();`
Build error 2020-11-11 20:17:34 +00:00			`handle_request(garage, req, client_addr)`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00			`}))`
			`}`
			`});`

Fix clippy lints (fix #121) 2021-10-26 08:20:05 +00:00			`let server = Server::bind(addr).serve(service);`
Skeleton to the new web API 2020-11-02 14:48:39 +00:00			`let graceful = server.with_graceful_shutdown(shutdown_signal);`
			`info!("Web server listening on http://{}", addr);`

			`graceful.await?;`
			`Ok(())`
			`}`
Parse host header 2020-11-08 14:47:25 +00:00
Build error 2020-11-11 20:17:34 +00:00			`async fn handle_request(`
Parse host header 2020-11-08 14:47:25 +00:00			`garage: Arc<Garage>,`
			`req: Request<Body>,`
			`addr: SocketAddr,`
Build error 2020-11-11 20:17:34 +00:00			`) -> Result<Response<Body>, Infallible> {`
			`info!("{} {} {}", addr, req.method(), req.uri());`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`match serve_file(garage, &req).await {`
			`Ok(res) => {`
			`debug!("{} {} {}", req.method(), req.uri(), res.status());`
			`Ok(res)`
			`}`
			`Err(error) => {`
			`info!(`
			`"{} {} {} {}",`
			`req.method(),`
			`req.uri(),`
			`error.http_status_code(),`
			`error`
			`);`
			`Ok(error_to_res(error))`
			`}`
Build error 2020-11-11 20:17:34 +00:00			`}`
			`}`

			`fn error_to_res(e: Error) -> Response<Body> {`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`// 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));`
Build error 2020-11-11 20:17:34 +00:00			`let mut http_error = Response::new(body);`
			`*http_error.status_mut() = e.http_status_code();`
Improved handling of HTTP ranges - correct HTTP code when range syntax is invalid (fix #140) - when multiple ranges are given, simply ignore and send whole file Co-authored-by: Trinity Pointard <trinity.pointard@gmail.com> Reviewed-on: https://git.deuxfleurs.fr/Deuxfleurs/garage/pulls/157 Reviewed-by: Alex <alex@adnab.me> Co-authored-by: trinity-1686a <trinity.pointard@gmail.com> Co-committed-by: trinity-1686a <trinity.pointard@gmail.com> 2021-11-29 10:52:42 +00:00			`e.add_headers(http_error.headers_mut());`
Build error 2020-11-11 20:17:34 +00:00			`http_error`
			`}`

Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`async fn serve_file(garage: Arc<Garage>, req: &Request<Body>) -> Result<Response<Body>, Error> {`
Extract bucket 2020-11-10 08:57:07 +00:00			`// Get http authority string (eg. [::1]:3902 or garage.tld:80)`
Parse host header 2020-11-08 14:47:25 +00:00			`let authority = req`
			`.headers()`
			`.get(HOST)`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`.ok_or_bad_request("HOST header required")?`
Parse host header 2020-11-08 14:47:25 +00:00			`.to_str()?;`

Extract bucket 2020-11-10 08:57:07 +00:00			`// Get bucket`
add support for vhost-style s3 bucket 2021-11-11 10:26:02 +00:00			`let host = authority_to_host(authority)?;`
Fix formatting 2020-11-10 08:59:52 +00:00			`let root = &garage.config.s3_web.root_domain;`
Extract bucket 2020-11-10 08:57:07 +00:00
New model for buckets 2021-12-14 12:55:11 +00:00			`let bucket_name = host_to_bucket(&host, root).unwrap_or(&host);`
			`let bucket_id = garage`
			`.bucket_alias_table`
			`.get(&EmptyKey, &bucket_name.to_string())`
			`.await?`
New buckets for 0.6.0: small changes - Fix bucket delete - fix merge of bucket creation date - Replace deletable with option in aliases Rationale: if two aliases point to conflicting bucket, resolving by making an arbitrary choice risks making data accessible when it shouldn't be. We'd rather resolve to deleting the alias until someone puts it back. 2022-01-03 17:32:15 +00:00			`.map(\|x\| x.state.take())`
New model for buckets 2021-12-14 12:55:11 +00:00			`.flatten()`
			`.ok_or(Error::NotFound)?;`

Model changes 2021-12-16 10:47:58 +00:00			`// Check bucket isn't deleted and has website access enabled`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`let bucket = garage`
Fix formatting 2020-12-17 21:51:44 +00:00			`.bucket_table`
New buckets for 0.6.0: make bucket id a SK and not a HK, CLI updates 2022-01-03 18:06:04 +00:00			`.get(&EmptyKey, &bucket_id)`
Fix formatting 2020-12-17 21:51:44 +00:00			`.await?`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`.ok_or(Error::NotFound)?;`

			`let website_config = bucket`
			`.params()`
			`.ok_or(Error::NotFound)?`
			`.website_config`
			`.get()`
			`.as_ref()`
Fix formatting 2020-12-17 21:51:44 +00:00			`.ok_or(Error::NotFound)?;`

Extract bucket 2020-11-10 08:57:07 +00:00			`// Get path`
			`let path = req.uri().path().to_string();`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`let index = &website_config.index_document;`
Fix clippy lints (fix #121) 2021-10-26 08:20:05 +00:00			`let key = path_to_key(&path, index)?;`
Fix formatting 2020-11-10 08:59:52 +00:00
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`debug!(`
New model for buckets 2021-12-14 12:55:11 +00:00			`"Selected bucket: \"{}\" {:?}, selected key: \"{}\"",`
			`bucket_name, bucket_id, key`
			`);`
Build path correctly 2020-11-11 18:48:01 +00:00
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`let ret_doc = match *req.method() {`
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`Method::OPTIONS => return handle_options(&bucket, req),`
			`Method::HEAD => {`
			`return handle_head(garage.clone(), req, bucket_id, &key)`
			`.await`
			`.map_err(Error::from)`
			`}`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`Method::GET => handle_get(garage.clone(), req, bucket_id, &key).await,`
			`_ => Err(ApiError::BadRequest("HTTP method not supported".into())),`
			`}`
			`.map_err(Error::from);`

Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`match ret_doc {`
			`Err(error) => {`
			`// For a HEAD or OPTIONS method, we don't return the error document`
			`// as content, we return above and just return the error message`
			`// by relying on err_to_res that is called when we return an Err.`
			`assert!(req.method() != Method::HEAD && req.method() != Method::OPTIONS);`

			`if !error.http_status_code().is_client_error() {`
			`// Do not return the error document if it is not a 4xx error code.`
			`return Err(error);`
			`}`

			`// 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),`
			`};`

			`// 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();`
We are able to serve a file 2020-11-21 14:15:25 +00:00
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`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);`
			`}`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`}`

Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`Ok(error_doc)`
			`}`
			`Err(error_doc_error) => {`
			`warn!(`
			`"Couldn't get error document {} for bucket {:?}: {}",`
			`error_document, bucket_id, error_doc_error`
			`);`
			`Err(error)`
			`}`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`}`
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`}`
			`Ok(mut resp) => {`
			`// Maybe add CORS headers`
			`if let Some(cors_config) = bucket.params().unwrap().cors_config.get() {`
			`if let Some(origin) = req.headers().get("Origin") {`
			`let origin = origin.to_str()?;`
			`let request_headers = match req.headers().get(ACCESS_CONTROL_REQUEST_HEADERS) {`
			`Some(h) => h.to_str()?.split(',').map(\|h\| h.trim()).collect::<Vec<_>>(),`
			`None => vec![],`
			`};`
			`let matching_rule = cors_config.iter().find(\|rule\| {`
			`cors_rule_matches(`
			`rule,`
			`origin,`
			`&req.method().to_string(),`
			`request_headers.iter(),`
			`)`
			`});`
			`if let Some(rule) = matching_rule {`
			`add_cors_headers(&mut resp, rule)`
			`.ok_or_internal_error("Invalid CORS configuration")?;`
			`}`
			`}`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`}`
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00			`Ok(resp)`
			`}`
			`}`
			`}`

			`fn handle_options(bucket: &Bucket, req: &Request<Body>) -> Result<Response<Body>, Error> {`
			`let origin = req`
			`.headers()`
			`.get("Origin")`
			`.ok_or_bad_request("Missing Origin header")?`
			`.to_str()?;`
			`let request_method = req`
			`.headers()`
			`.get(ACCESS_CONTROL_REQUEST_METHOD)`
			`.ok_or_bad_request("Missing Access-Control-Request-Method header")?`
			`.to_str()?;`
			`let request_headers = match req.headers().get(ACCESS_CONTROL_REQUEST_HEADERS) {`
			`Some(h) => h.to_str()?.split(',').map(\|h\| h.trim()).collect::<Vec<_>>(),`
			`None => vec![],`
			`};`

			`if let Some(cors_config) = bucket.params().unwrap().cors_config.get() {`
			`let matching_rule = cors_config`
			`.iter()`
			`.find(\|rule\| cors_rule_matches(rule, origin, request_method, request_headers.iter()));`
			`if let Some(rule) = matching_rule {`
			`let mut resp = Response::builder()`
			`.status(StatusCode::OK)`
			`.body(Body::empty())`
			`.map_err(ApiError::from)?;`
			`add_cors_headers(&mut resp, rule).ok_or_internal_error("Invalid CORS configuration")?;`
			`return Ok(resp);`
Make use of website config, return error document on error 2022-01-06 11:55:49 +00:00			`}`
			`}`
Implement {Put,Get,Delete}BucketCors and CORS in web server 2022-01-07 15:23:04 +00:00
			`Err(ApiError::Forbidden("No matching CORS rule".into()).into())`
Parse host header 2020-11-08 14:47:25 +00:00			`}`

Build path correctly 2020-11-11 18:48:01 +00:00			`/// Path to key`
			`///`
			`/// Convert the provided path to the internal key`
			`/// When a path ends with "/", we append the index name to match traditional web server behavior`
			`/// which is also AWS S3 behavior.`
			`fn path_to_key<'a>(path: &'a str, index: &str) -> Result<Cow<'a, str>, Error> {`
Fix clippy lints (fix #121) 2021-10-26 08:20:05 +00:00			`let path_utf8 = percent_encoding::percent_decode_str(path).decode_utf8()?;`
Use handle_get 2020-11-21 16:50:19 +00:00
fix clippy warnings on web 2021-04-23 20:26:27 +00:00			`if !path_utf8.starts_with('/') {`
			`return Err(Error::BadRequest(`
			`"Path must start with a / (slash)".to_string(),`
			`));`
Fix host to key 2020-11-21 11:01:02 +00:00			`}`

Build path correctly 2020-11-11 18:48:01 +00:00			`match path_utf8.chars().last() {`
Explicitly set code path unreachable 2021-01-15 16:11:15 +00:00			`None => unreachable!(),`
Build path correctly 2020-11-11 18:48:01 +00:00			`Some('/') => {`
			`let mut key = String::with_capacity(path_utf8.len() + index.len());`
Fix host to key 2020-11-21 11:01:02 +00:00			`key.push_str(&path_utf8[1..]);`
Build path correctly 2020-11-11 18:48:01 +00:00			`key.push_str(index);`
			`Ok(key.into())`
			`}`
Use handle_get 2020-11-21 16:50:19 +00:00			`Some(_) => match path_utf8 {`
			`Cow::Borrowed(pu8) => Ok((&pu8[1..]).into()),`
			`Cow::Owned(pu8) => Ok((&pu8[1..]).to_string().into()),`
			`},`
Build path correctly 2020-11-11 18:48:01 +00:00			`}`
			`}`

Parse host header 2020-11-08 14:47:25 +00:00			`#[cfg(test)]`
			`mod tests {`
			`use super::*;`

Build path correctly 2020-11-11 18:48:01 +00:00			`#[test]`
			`fn path_to_key_test() -> Result<(), Error> {`
Fix host to key 2020-11-21 11:01:02 +00:00			`assert_eq!(path_to_key("/file%20.jpg", "index.html")?, "file .jpg");`
			`assert_eq!(path_to_key("/%20t/", "index.html")?, " t/index.html");`
			`assert_eq!(path_to_key("/", "index.html")?, "index.html");`
			`assert_eq!(path_to_key("/hello", "index.html")?, "hello");`
Build path correctly 2020-11-11 18:48:01 +00:00			`assert!(path_to_key("", "index.html").is_err());`
Fix host to key 2020-11-21 11:01:02 +00:00			`assert!(path_to_key("i/am/relative", "index.html").is_err());`
Build path correctly 2020-11-11 18:48:01 +00:00			`Ok(())`
			`}`
Parse host header 2020-11-08 14:47:25 +00:00			`}`