tricot/src/https.rs

use std::convert::Infallible;
use std::net::SocketAddr;
use std::sync::{atomic::Ordering, Arc};

use anyhow::Result;
use log::*;

use accept_encoding_fork::Encoding;
use async_compression::tokio::bufread::*;
use futures::StreamExt;
use futures::TryStreamExt;
use http::header::{HeaderName, HeaderValue};
use http::method::Method;
use hyper::server::conn::Http;
use hyper::service::service_fn;
use hyper::{header, Body, Request, Response, StatusCode};
use tokio::net::TcpListener;
use tokio::sync::watch;
use tokio_rustls::TlsAcceptor;
use tokio_util::io::{ReaderStream, StreamReader};

use crate::cert_store::{CertStore, StoreResolver};
use crate::proxy_config::ProxyConfig;
use crate::reverse_proxy;

pub struct HttpsConfig {
	pub bind_addr: SocketAddr,
	pub enable_compression: bool,
	pub compress_mime_types: Vec<String>,
}

pub async fn serve_https(
	config: HttpsConfig,
	cert_store: Arc<CertStore>,
	rx_proxy_config: watch::Receiver<Arc<ProxyConfig>>,
) -> Result<()> {
	let config = Arc::new(config);

	let mut tls_cfg = rustls::ServerConfig::builder()
		.with_safe_defaults()
		.with_no_client_auth()
		.with_cert_resolver(Arc::new(StoreResolver(cert_store)));

	tls_cfg.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
	let tls_acceptor = Arc::new(TlsAcceptor::from(Arc::new(tls_cfg)));

	info!("Starting to serve on https://{}.", config.bind_addr);

	let tcp = TcpListener::bind(config.bind_addr).await?;
	loop {
		let (socket, remote_addr) = tcp.accept().await?;

		let rx_proxy_config = rx_proxy_config.clone();
		let tls_acceptor = tls_acceptor.clone();
		let config = config.clone();

		tokio::spawn(async move {
			match tls_acceptor.accept(socket).await {
				Ok(stream) => {
					debug!("TLS handshake was successfull");
					let http_result = Http::new()
						.serve_connection(
							stream,
							service_fn(move |req: Request<Body>| {
								let https_config = config.clone();
								let proxy_config: Arc<ProxyConfig> =
									rx_proxy_config.borrow().clone();
								handle_outer(remote_addr, req, https_config, proxy_config)
							}),
						)
						.await;
					if let Err(http_err) = http_result {
						warn!("HTTP error: {}", http_err);
					}
				}
				Err(e) => warn!("Error in TLS connection: {}", e),
			}
		});
	}
}

async fn handle_outer(
	remote_addr: SocketAddr,
	req: Request<Body>,
	https_config: Arc<HttpsConfig>,
	proxy_config: Arc<ProxyConfig>,
) -> Result<Response<Body>, Infallible> {
	match handle(remote_addr, req, https_config, proxy_config).await {
		Err(e) => {
			warn!("Handler error: {}", e);
			Ok(Response::builder()
				.status(StatusCode::INTERNAL_SERVER_ERROR)
				.body(Body::from(format!("{}", e)))
				.unwrap())
		}
		Ok(r) => Ok(r),
	}
}

// Custom echo service, handling two different routes and a
// catch-all 404 responder.
async fn handle(
	remote_addr: SocketAddr,
	req: Request<Body>,
	https_config: Arc<HttpsConfig>,
	proxy_config: Arc<ProxyConfig>,
) -> Result<Response<Body>, anyhow::Error> {
	let method = req.method().clone();
	let uri = req.uri().to_string();

	let host = if let Some(auth) = req.uri().authority() {
		auth.as_str()
	} else {
		req.headers()
			.get("host")
			.ok_or_else(|| anyhow!("Missing host header"))?
			.to_str()?
	};
	let path = req.uri().path();
	let accept_encoding = accept_encoding_fork::encodings(req.headers()).unwrap_or_else(|_| vec![]);

	let best_match = proxy_config
		.entries
		.iter()
		.filter(|ent| {
			ent.host.matches(host)
				&& ent
					.path_prefix
					.as_ref()
					.map(|prefix| path.starts_with(prefix))
					.unwrap_or(true)
		})
		.max_by_key(|ent| {
			(
				ent.priority,
				ent.path_prefix
					.as_ref()
					.map(|x| x.len() as i32)
					.unwrap_or(0),
				-ent.calls.load(Ordering::SeqCst),
			)
		});

	if let Some(proxy_to) = best_match {
		proxy_to.calls.fetch_add(1, Ordering::SeqCst);

		debug!("{}{} -> {}", host, path, proxy_to);
		trace!("Request: {:?}", req);

		let mut response = if proxy_to.https_target {
			let to_addr = format!("https://{}", proxy_to.target_addr);
			reverse_proxy::call_https(remote_addr.ip(), &to_addr, req).await?
		} else {
			let to_addr = format!("http://{}", proxy_to.target_addr);
			reverse_proxy::call(remote_addr.ip(), &to_addr, req).await?
		};

		for (header, value) in proxy_to.add_headers.iter() {
			response.headers_mut().insert(
				HeaderName::from_bytes(header.as_bytes())?,
				HeaderValue::from_str(value)?,
			);
		}
		trace!("Response: {:?}", response);
		info!("{} {} {}", method, response.status().as_u16(), uri);

		if https_config.enable_compression {
			try_compress(response, method, accept_encoding, &https_config).await
		} else {
			Ok(response)
		}
	} else {
		debug!("{}{} -> NOT FOUND", host, path);
		info!("{} 404 {}", method, uri);

		Ok(Response::builder()
			.status(StatusCode::NOT_FOUND)
			.body(Body::from("No matching proxy entry"))?)
	}
}

async fn try_compress(
	response: Response<Body>,
	method: Method,
	accept_encoding: Vec<(Option<Encoding>, f32)>,
	https_config: &HttpsConfig,
) -> Result<Response<Body>> {
	// Don't bother compressing successfull responses for HEAD and PUT (they should have an empty body)
	// Don't compress partial content, that would be wierd
	// If already compressed, return as is
	if (response.status().is_success() && (method == Method::HEAD || method == Method::PUT))
		|| response.status() == StatusCode::PARTIAL_CONTENT
		|| response.headers().get(header::CONTENT_ENCODING).is_some()
	{
		return Ok(response);
	}

	// Select preferred encoding among those proposed in accept_encoding
	let max_q: f32 = accept_encoding
		.iter()
		.max_by_key(|(_, q)| (q * 10000f32) as i64)
		.unwrap_or(&(None, 1.))
		.1;
	let preference = [
		Encoding::Zstd,
		//Encoding::Brotli,
		Encoding::Deflate,
		Encoding::Gzip,
	];
	#[allow(clippy::float_cmp)]
	let encoding_opt = accept_encoding
		.iter()
		.filter(|(_, q)| *q == max_q)
		.filter_map(|(enc, _)| *enc)
		.filter(|enc| preference.contains(enc))
		.min_by_key(|enc| preference.iter().position(|x| x == enc).unwrap());

	// If preferred encoding is none, return as is
	let encoding = match encoding_opt {
		None | Some(Encoding::Identity) => return Ok(response),
		Some(enc) => enc,
	};

	// If content type not in mime types for which to compress, return as is
	match response.headers().get(header::CONTENT_TYPE) {
		Some(ct) => {
			let ct_str = ct.to_str()?;
			let mime_type = match ct_str.split_once(';') {
				Some((mime_type, _params)) => mime_type,
				None => ct_str,
			};
			if !https_config
				.compress_mime_types
				.iter()
				.any(|x| x == mime_type)
			{
				return Ok(response);
			}
		}
		None => return Ok(response), // don't compress if unknown mime type
	};

	let (mut head, mut body) = response.into_parts();

	// ---- If body is smaller than 1400 bytes, don't compress ----
	let mut chunks = vec![];
	let mut sum_lengths = 0;
	while sum_lengths < 1400 {
		match body.next().await {
			Some(chunk) => {
				let chunk = chunk?;
				sum_lengths += chunk.len();
				chunks.push(chunk);
			}
			None => {
				return Ok(Response::from_parts(head, Body::from(chunks.concat())));
			}
		}
	}

	// put beginning chunks back into body
	let body = futures::stream::iter(chunks.into_iter().map(Ok)).chain(body);

	// make an async reader from that for compressor
	let body_rd =
		StreamReader::new(body.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e)));

	trace!(
		"Compressing response body as {:?} (at least {} bytes)",
		encoding,
		sum_lengths
	);

	// we don't know the compressed content-length so remove that header
	head.headers.remove(header::CONTENT_LENGTH);

	let (encoding, compressed_body) = match encoding {
		Encoding::Gzip => (
			"gzip",
			Body::wrap_stream(ReaderStream::new(GzipEncoder::new(body_rd))),
		),
		// Encoding::Brotli => {
		// 	head.headers.insert(header::CONTENT_ENCODING, "br".parse()?);
		// 	Body::wrap_stream(ReaderStream::new(BrotliEncoder::new(body_rd)))
		// }
		Encoding::Deflate => (
			"deflate",
			Body::wrap_stream(ReaderStream::new(DeflateEncoder::new(body_rd))),
		),
		Encoding::Zstd => (
			"zstd",
			Body::wrap_stream(ReaderStream::new(ZstdEncoder::new(body_rd))),
		),
		_ => unreachable!(),
	};
	head.headers
		.insert(header::CONTENT_ENCODING, encoding.parse()?);

	Ok(Response::from_parts(head, compressed_body))
}
Compression 2021-12-09 14:43:19 +00:00			`use std::convert::Infallible;`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`use std::net::SocketAddr;`
Round robin backends 2021-12-07 15:37:22 +00:00			`use std::sync::{atomic::Ordering, Arc};`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
			`use anyhow::Result;`
			`use log::*;`

Compression 2021-12-09 14:43:19 +00:00			`use accept_encoding_fork::Encoding;`
			`use async_compression::tokio::bufread::*;`
Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00			`use futures::StreamExt;`
Compression 2021-12-09 14:43:19 +00:00			`use futures::TryStreamExt;`
Better handle get_cert for https request (faster path, hostname verification) 2021-12-07 17:50:58 +00:00			`use http::header::{HeaderName, HeaderValue};`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`use http::method::Method;`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`use hyper::server::conn::Http;`
			`use hyper::service::service_fn;`
Compression 2021-12-09 14:43:19 +00:00			`use hyper::{header, Body, Request, Response, StatusCode};`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`use tokio::net::TcpListener;`
			`use tokio::sync::watch;`
			`use tokio_rustls::TlsAcceptor;`
Compression 2021-12-09 14:43:19 +00:00			`use tokio_util::io::{ReaderStream, StreamReader};`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
			`use crate::cert_store::{CertStore, StoreResolver};`
			`use crate::proxy_config::ProxyConfig;`
			`use crate::reverse_proxy;`

Compression 2021-12-09 14:43:19 +00:00			`pub struct HttpsConfig {`
			`pub bind_addr: SocketAddr,`
			`pub enable_compression: bool,`
			`pub compress_mime_types: Vec<String>,`
			`}`

Got a reverse proxy 2021-12-07 14:20:45 +00:00			`pub async fn serve_https(`
Compression 2021-12-09 14:43:19 +00:00			`config: HttpsConfig,`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`cert_store: Arc<CertStore>,`
Compression 2021-12-09 14:43:19 +00:00			`rx_proxy_config: watch::Receiver<Arc<ProxyConfig>>,`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`) -> Result<()> {`
Compression 2021-12-09 14:43:19 +00:00			`let config = Arc::new(config);`

			`let mut tls_cfg = rustls::ServerConfig::builder()`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`.with_safe_defaults()`
			`.with_no_client_auth()`
			`.with_cert_resolver(Arc::new(StoreResolver(cert_store)));`

Compression 2021-12-09 14:43:19 +00:00			`tls_cfg.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];`
			`let tls_acceptor = Arc::new(TlsAcceptor::from(Arc::new(tls_cfg)));`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
Compression 2021-12-09 14:43:19 +00:00			`info!("Starting to serve on https://{}.", config.bind_addr);`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
Compression 2021-12-09 14:43:19 +00:00			`let tcp = TcpListener::bind(config.bind_addr).await?;`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`loop {`
			`let (socket, remote_addr) = tcp.accept().await?;`

Compression 2021-12-09 14:43:19 +00:00			`let rx_proxy_config = rx_proxy_config.clone();`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`let tls_acceptor = tls_acceptor.clone();`
Compression 2021-12-09 14:43:19 +00:00			`let config = config.clone();`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
			`tokio::spawn(async move {`
			`match tls_acceptor.accept(socket).await {`
			`Ok(stream) => {`
			`debug!("TLS handshake was successfull");`
			`let http_result = Http::new()`
			`.serve_connection(`
			`stream,`
			`service_fn(move \|req: Request<Body>\| {`
Compression 2021-12-09 14:43:19 +00:00			`let https_config = config.clone();`
			`let proxy_config: Arc<ProxyConfig> =`
			`rx_proxy_config.borrow().clone();`
			`handle_outer(remote_addr, req, https_config, proxy_config)`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`}),`
			`)`
			`.await;`
			`if let Err(http_err) = http_result {`
Logging output improvements 2021-12-08 10:24:25 +00:00			`warn!("HTTP error: {}", http_err);`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`}`
			`}`
Logging output improvements 2021-12-08 10:24:25 +00:00			`Err(e) => warn!("Error in TLS connection: {}", e),`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`}`
			`});`
			`}`
			`}`

Compression 2021-12-09 14:43:19 +00:00			`async fn handle_outer(`
			`remote_addr: SocketAddr,`
			`req: Request<Body>,`
			`https_config: Arc<HttpsConfig>,`
			`proxy_config: Arc<ProxyConfig>,`
			`) -> Result<Response<Body>, Infallible> {`
			`match handle(remote_addr, req, https_config, proxy_config).await {`
			`Err(e) => {`
			`warn!("Handler error: {}", e);`
			`Ok(Response::builder()`
			`.status(StatusCode::INTERNAL_SERVER_ERROR)`
			`.body(Body::from(format!("{}", e)))`
			`.unwrap())`
			`}`
			`Ok(r) => Ok(r),`
			`}`
			`}`

Got a reverse proxy 2021-12-07 14:20:45 +00:00			`// Custom echo service, handling two different routes and a`
			`// catch-all 404 responder.`
			`async fn handle(`
			`remote_addr: SocketAddr,`
			`req: Request<Body>,`
Compression 2021-12-09 14:43:19 +00:00			`https_config: Arc<HttpsConfig>,`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`proxy_config: Arc<ProxyConfig>,`
			`) -> Result<Response<Body>, anyhow::Error> {`
Handle HTTPS targets 2021-12-08 21:58:19 +00:00			`let method = req.method().clone();`
			`let uri = req.uri().to_string();`

Got a reverse proxy 2021-12-07 14:20:45 +00:00			`let host = if let Some(auth) = req.uri().authority() {`
			`auth.as_str()`
			`} else {`
			`req.headers()`
			`.get("host")`
			`.ok_or_else(\|\| anyhow!("Missing host header"))?`
			`.to_str()?`
			`};`
			`let path = req.uri().path();`
cargo clippy 2021-12-09 22:38:56 +00:00			`let accept_encoding = accept_encoding_fork::encodings(req.headers()).unwrap_or_else(\|_\| vec![]);`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
Handle HTTPS targets 2021-12-08 21:58:19 +00:00			`let best_match = proxy_config`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`.entries`
			`.iter()`
			`.filter(\|ent\| {`
Implement glob pattern hostnames no wildcard certificates: one certificate per matching hostname that actually recieves requests 2021-12-08 10:11:22 +00:00			`ent.host.matches(host)`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`&& ent`
			`.path_prefix`
			`.as_ref()`
			`.map(\|prefix\| path.starts_with(prefix))`
			`.unwrap_or(true)`
			`})`
Inverse how priorities work 2021-12-08 21:29:08 +00:00			`.max_by_key(\|ent\| {`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`(`
			`ent.priority,`
Inverse how priorities work 2021-12-08 21:29:08 +00:00			`ent.path_prefix`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`.as_ref()`
			`.map(\|x\| x.len() as i32)`
Inverse how priorities work 2021-12-08 21:29:08 +00:00			`.unwrap_or(0),`
			`-ent.calls.load(Ordering::SeqCst),`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`)`
			`});`

Handle HTTPS targets 2021-12-08 21:58:19 +00:00			`if let Some(proxy_to) = best_match {`
			`proxy_to.calls.fetch_add(1, Ordering::SeqCst);`
Different logging 2021-12-08 21:24:58 +00:00
			`debug!("{}{} -> {}", host, path, proxy_to);`
Try to fix things 2021-12-08 12:28:07 +00:00			`trace!("Request: {:?}", req);`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
Handle HTTPS targets 2021-12-08 21:58:19 +00:00			`let mut response = if proxy_to.https_target {`
			`let to_addr = format!("https://{}", proxy_to.target_addr);`
			`reverse_proxy::call_https(remote_addr.ip(), &to_addr, req).await?`
			`} else {`
			`let to_addr = format!("http://{}", proxy_to.target_addr);`
			`reverse_proxy::call(remote_addr.ip(), &to_addr, req).await?`
			`};`
Add support for custom headers 2021-12-07 17:19:51 +00:00
			`for (header, value) in proxy_to.add_headers.iter() {`
Better handle get_cert for https request (faster path, hostname verification) 2021-12-07 17:50:58 +00:00			`response.headers_mut().insert(`
			`HeaderName::from_bytes(header.as_bytes())?,`
			`HeaderValue::from_str(value)?,`
			`);`
Add support for custom headers 2021-12-07 17:19:51 +00:00			`}`
Try to fix things 2021-12-08 12:28:07 +00:00			`trace!("Response: {:?}", response);`
Different logging 2021-12-08 21:24:58 +00:00			`info!("{} {} {}", method, response.status().as_u16(), uri);`
Add support for custom headers 2021-12-07 17:19:51 +00:00
Compression 2021-12-09 14:43:19 +00:00			`if https_config.enable_compression {`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`try_compress(response, method, accept_encoding, &https_config).await`
Compression 2021-12-09 14:43:19 +00:00			`} else {`
			`Ok(response)`
			`}`
Got a reverse proxy 2021-12-07 14:20:45 +00:00			`} else {`
Handle HTTPS targets 2021-12-08 21:58:19 +00:00			`debug!("{}{} -> NOT FOUND", host, path);`
			`info!("{} 404 {}", method, uri);`
Got a reverse proxy 2021-12-07 14:20:45 +00:00
			`Ok(Response::builder()`
			`.status(StatusCode::NOT_FOUND)`
			`.body(Body::from("No matching proxy entry"))?)`
			`}`
			`}`
Compression 2021-12-09 14:43:19 +00:00
Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00			`async fn try_compress(`
Compression 2021-12-09 14:43:19 +00:00			`response: Response<Body>,`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`method: Method,`
Better compression choices 2021-12-09 15:03:19 +00:00			`accept_encoding: Vec<(Option<Encoding>, f32)>,`
Compression 2021-12-09 14:43:19 +00:00			`https_config: &HttpsConfig,`
			`) -> Result<Response<Body>> {`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`// Don't bother compressing successfull responses for HEAD and PUT (they should have an empty body)`
			`// Don't compress partial content, that would be wierd`
			`// If already compressed, return as is`
			`if (response.status().is_success() && (method == Method::HEAD \|\| method == Method::PUT))`
			`\|\| response.status() == StatusCode::PARTIAL_CONTENT`
			`\|\| response.headers().get(header::CONTENT_ENCODING).is_some()`
			`{`
			`return Ok(response);`
			`}`

			`// Select preferred encoding among those proposed in accept_encoding`
Better compression choices 2021-12-09 15:03:19 +00:00			`let max_q: f32 = accept_encoding`
			`.iter()`
			`.max_by_key(\|(_, q)\| (q * 10000f32) as i64)`
			`.unwrap_or(&(None, 1.))`
			`.1;`
			`let preference = [`
			`Encoding::Zstd,`
Brotli seems to cause issues, disable it 2021-12-09 23:03:34 +00:00			`//Encoding::Brotli,`
Better compression choices 2021-12-09 15:03:19 +00:00			`Encoding::Deflate,`
			`Encoding::Gzip,`
			`];`
cargo clippy 2021-12-09 22:38:56 +00:00			`#[allow(clippy::float_cmp)]`
Better compression choices 2021-12-09 15:03:19 +00:00			`let encoding_opt = accept_encoding`
			`.iter()`
			`.filter(\|(_, q)\| *q == max_q)`
			`.filter_map(\|(enc, _)\| *enc)`
			`.filter(\|enc\| preference.contains(enc))`
			`.min_by_key(\|enc\| preference.iter().position(\|x\| x == enc).unwrap());`

			`// If preferred encoding is none, return as is`
			`let encoding = match encoding_opt {`
Compression 2021-12-09 14:43:19 +00:00			`None \| Some(Encoding::Identity) => return Ok(response),`
			`Some(enc) => enc,`
			`};`

			`// If content type not in mime types for which to compress, return as is`
			`match response.headers().get(header::CONTENT_TYPE) {`
			`Some(ct) => {`
			`let ct_str = ct.to_str()?;`
Better compression choices 2021-12-09 15:03:19 +00:00			`let mime_type = match ct_str.split_once(';') {`
			`Some((mime_type, _params)) => mime_type,`
			`None => ct_str,`
			`};`
cargo fmt 2021-12-09 15:19:41 +00:00			`if !https_config`
			`.compress_mime_types`
			`.iter()`
			`.any(\|x\| x == mime_type)`
			`{`
Compression 2021-12-09 14:43:19 +00:00			`return Ok(response);`
			`}`
			`}`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`None => return Ok(response), // don't compress if unknown mime type`
Compression 2021-12-09 14:43:19 +00:00			`};`

Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00			`let (mut head, mut body) = response.into_parts();`
Compression 2021-12-09 14:43:19 +00:00
Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00			`// ---- If body is smaller than 1400 bytes, don't compress ----`
			`let mut chunks = vec![];`
			`let mut sum_lengths = 0;`
			`while sum_lengths < 1400 {`
			`match body.next().await {`
			`Some(chunk) => {`
			`let chunk = chunk?;`
			`sum_lengths += chunk.len();`
			`chunks.push(chunk);`
			`}`
			`None => {`
			`return Ok(Response::from_parts(head, Body::from(chunks.concat())));`
			`}`
			`}`
			`}`

			`// put beginning chunks back into body`
cargo clippy 2021-12-09 22:38:56 +00:00			`let body = futures::stream::iter(chunks.into_iter().map(Ok)).chain(body);`
Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00
			`// make an async reader from that for compressor`
Compression 2021-12-09 14:43:19 +00:00			`let body_rd =`
			`StreamReader::new(body.map_err(\|e\| std::io::Error::new(std::io::ErrorKind::Other, e)));`
Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`trace!(`
cargo clippy 2021-12-09 22:38:56 +00:00			`"Compressing response body as {:?} (at least {} bytes)",`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`encoding,`
			`sum_lengths`
cargo clippy 2021-12-09 22:38:56 +00:00			`);`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00
			`// we don't know the compressed content-length so remove that header`
Remove content-length when compressed; don't compress small response 2021-12-09 18:00:50 +00:00			`head.headers.remove(header::CONTENT_LENGTH);`

Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`let (encoding, compressed_body) = match encoding {`
			`Encoding::Gzip => (`
			`"gzip",`
			`Body::wrap_stream(ReaderStream::new(GzipEncoder::new(body_rd))),`
			`),`
Brotli seems to cause issues, disable it 2021-12-09 23:03:34 +00:00			`// Encoding::Brotli => {`
			`// head.headers.insert(header::CONTENT_ENCODING, "br".parse()?);`
			`// Body::wrap_stream(ReaderStream::new(BrotliEncoder::new(body_rd)))`
			`// }`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`Encoding::Deflate => (`
			`"deflate",`
			`Body::wrap_stream(ReaderStream::new(DeflateEncoder::new(body_rd))),`
			`),`
			`Encoding::Zstd => (`
			`"zstd",`
			`Body::wrap_stream(ReaderStream::new(ZstdEncoder::new(body_rd))),`
			`),`
Compression 2021-12-09 14:43:19 +00:00			`_ => unreachable!(),`
			`};`
Exclude partial content from compression 2021-12-10 15:40:05 +00:00			`head.headers`
			`.insert(header::CONTENT_ENCODING, encoding.parse()?);`
Compression 2021-12-09 14:43:19 +00:00
			`Ok(Response::from_parts(head, compressed_body))`
			`}`