A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
perf(media-proxy): gzip static assets on the fly (#3079)
Hampuscfed6cc4e01a
diff --git a/Cargo.lock b/Cargo.lockindex 57ceed7fc..1948a481d 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -1823,6 +1823,7 @@ dependencies = ["cc","clap","criterion",+ "flate2","fluxer_common","futures-util","hex",@@ -1850,6 +1851,7 @@ dependencies = ["tokio","tokio-util","tower",+ "tower-http 0.7.1","tracing","tracing-subscriber","url",diff --git a/fluxer_media_proxy/Cargo.toml b/fluxer_media_proxy/Cargo.tomlindex 2408c4a27..5a8532b86 100644--- a/fluxer_media_proxy/Cargo.toml+++ b/fluxer_media_proxy/Cargo.toml@@ -48,6 +48,7 @@ tempfile = "3.27.0"thiserror = "2.0.20"tokio = {version = "1.53.1", features = ["fs", "io-util", "macros", "net", "rt-multi-thread", "signal", "sync", "time"]}tokio-util = {version = "0.7.19", features = ["io"]}+tower-http = {version = "0.7.1", features = ["compression-gzip"]}tracing = "0.1.44"tracing-subscriber = {version = "0.3.23", features = ["fmt", "json"]}url = "2.5.8"@@ -59,5 +60,6 @@ pkg-config = "0.3.34"[dev-dependencies]criterion = "0.8.2"+flate2 = "1.1.10"proptest = "1.11.0"tower = {version = "0.5.3", features = ["util"]}diff --git a/fluxer_media_proxy/src/server/download_stream.rs b/fluxer_media_proxy/src/server/download_stream.rsindex 25598ceef..210b8be3c 100644--- a/fluxer_media_proxy/src/server/download_stream.rs+++ b/fluxer_media_proxy/src/server/download_stream.rs@@ -75,10 +75,13 @@ impl DownloadStreamPolicy {total_deadline: Instant::now().checked_add(total_timeout),overruns: self.overruns,};- Body::from_stream(futures_util::stream::unfold(- Some(stream),- |stream: Option<ActiveDownloadStream>| async move { stream?.next().await },- ))+ Body::from_stream(+ futures_util::stream::unfold(+ Some(stream),+ |stream: Option<ActiveDownloadStream>| async move { stream?.next().await },+ )+ .fuse(),+ )}}diff --git a/fluxer_media_proxy/src/server/runtime.rs b/fluxer_media_proxy/src/server/runtime.rsindex 1ef6cc2e7..2e6cafd92 100644--- a/fluxer_media_proxy/src/server/runtime.rs+++ b/fluxer_media_proxy/src/server/runtime.rs@@ -9,15 +9,18 @@ use super::{};use crate::{aggregate_error::aggregate_results,- config::{Config, PolicyMode},- media_process, request_log,+ config::{Config, DeploymentMode, PolicyMode},+ media_process, mime, request_log,};use axum::{- Router, middleware,+ Router,+ http::{Extensions, HeaderMap, StatusCode, Version, header},+ middleware,routing::{any, get, post, put},};use std::{net::SocketAddr, sync::Arc, time::Duration};use tokio::{net::TcpListener, time::timeout_at};+use tower_http::compression::{CompressionLayer, CompressionLevel};use tracing::info;pub async fn run(cfg: Config) -> anyhow::Result<()> {@@ -68,8 +71,44 @@ pub async fn run(cfg: Config) -> anyhow::Result<()> {drain_and_shutdown(&state, &drain).await}+const STATIC_COMPRESSIBLE_CONTENT_TYPES: [&str; 9] = [+ "application/javascript",+ "text/javascript",+ "text/css",+ "text/html",+ "application/json",+ "application/manifest+json",+ "application/xml",+ "application/wasm",+ "image/svg+xml",+];++const STATIC_COMPRESSION_MIN_BYTES: u64 = 1024;++fn is_compressible_static_response(+ status: StatusCode,+ _version: Version,+ headers: &HeaderMap,+ _extensions: &Extensions,+) -> bool {+ let content_type = headers+ .get(header::CONTENT_TYPE)+ .and_then(|value| value.to_str().ok());+ status == StatusCode::OK+ && headers+ .get(header::CONTENT_LENGTH)+ .and_then(|value| value.to_str().ok())+ .and_then(|value| value.parse::<u64>().ok())+ .is_some_and(|length| length >= STATIC_COMPRESSION_MIN_BYTES)+ && mime::normalize(content_type).is_some_and(|content_type| {+ STATIC_COMPRESSIBLE_CONTENT_TYPES+ .iter()+ .any(|compressible| compressible.eq_ignore_ascii_case(content_type))+ })+}+fn build_router(state: Arc<AppState>, drain: HttpRequestDrain) -> Router {- Router::new()+ let router = Router::new().route("/_health", get(routes::ops::health)).route("/_metrics", get(routes::ops::metrics_handler)).route("/_metadata", post(routes::internal::metadata_handler))@@ -80,7 +119,20 @@ fn build_router(state: Arc<AppState>, drain: HttpRequestDrain) -> Router {"/v1/relay/{*key}",put(routes::relay::relay_put).options(routes::relay::relay_options),)- .fallback(any(routes::dispatch::catch_all))+ .fallback(any(routes::dispatch::catch_all));+ let router = if state.cfg.mode == DeploymentMode::Static {+ router.layer(+ CompressionLayer::new()+ .no_br()+ .no_deflate()+ .no_zstd()+ .quality(CompressionLevel::Precise(5))+ .compress_when(is_compressible_static_response),+ )+ } else {+ router+ };+ router.layer(middleware::from_fn(add_version_header)).layer(middleware::from_fn_with_state(state.metrics.request(),@@ -142,7 +194,10 @@ async fn shutdown_signal() {#[cfg(test)]mod tests {use super::*;- use crate::http_headers;+ use crate::{+ http_headers,+ storage::tests::{FakeObject, FakeS3, fake_s3},+ };use axum::{body::Body,extract::ConnectInfo,@@ -325,6 +380,292 @@ mod tests {);}+ async fn static_router_serving(objects: &[(&str, &str, &[u8])]) -> (FakeS3, Router) {+ let fake = fake_s3().await;+ let tmp = tempfile::tempdir().expect("config root");+ let mut cfg = fake.config(tmp.path());+ cfg.mode = DeploymentMode::Static;+ for (key, content_type, body) in objects {+ fake.put_object(+ &format!("{}/{key}", cfg.storage.bucket_static),+ FakeObject {+ body: body.to_vec(),+ content_type: Some((*content_type).to_owned()),+ ..FakeObject::default()+ },+ );+ }+ (fake, test_router_for(cfg))+ }++ async fn fetch(+ router: Router,+ path: &str,+ accept_encoding: Option<&str>,+ range: Option<&str>,+ ) -> (Response, Vec<u8>) {+ let mut builder = Request::builder().uri(path);+ if let Some(value) = accept_encoding {+ builder = builder.header(header::ACCEPT_ENCODING, value);+ }+ if let Some(value) = range {+ builder = builder.header(header::RANGE, value);+ }+ let response = send(router, builder.body(Body::empty()).expect("request")).await;+ let (parts, body) = response.into_parts();+ let bytes = axum::body::to_bytes(body, usize::MAX)+ .await+ .expect("response body")+ .to_vec();+ (Response::from_parts(parts, Body::empty()), bytes)+ }++ fn decoded(encoding: Option<&str>, body: &[u8]) -> Vec<u8> {+ let mut out = Vec::new();+ match encoding {+ Some("gzip") => {+ std::io::Read::read_to_end(&mut flate2::read::GzDecoder::new(body), &mut out)+ .expect("gzip body");+ }+ None => out.extend_from_slice(body),+ Some(other) => panic!("unexpected content-encoding {other}"),+ }+ out+ }++ fn compressible_bytes(len: usize) -> Vec<u8> {+ (0..len).map(|index| b"asm_module_"[index % 11]).collect()+ }++ #[tokio::test]+ async fn static_mode_gzips_scripts_styles_and_wasm_for_clients_that_accept_it() {+ let body = compressible_bytes(64 * 1024);+ let objects = [+ ("assets/0123456789abcdef.wasm", "application/wasm"),+ (+ "assets/0123456789abcdef.js",+ "application/javascript; charset=utf-8",+ ),+ ("assets/0123456789abcdef.css", "text/css; charset=utf-8"),+ (+ "assets/0123456789abcdef.js.map",+ "application/json; charset=utf-8",+ ),+ ("emoji/1f600.svg", "image/svg+xml"),+ ];+ let stored: Vec<(&str, &str, &[u8])> = objects+ .iter()+ .map(|(key, content_type)| (*key, *content_type, &body[..]))+ .collect();+ let (_fake, router) = static_router_serving(&stored).await;+ for (key, _) in objects {+ let path = format!("/{key}");+ for (accept, expected) in [+ ("br, gzip, zstd", Some("gzip")),+ ("gzip, deflate", Some("gzip")),+ ("gzip;q=0.5, br;q=1", Some("gzip")),+ ("br", None),+ ("deflate", None),+ ("identity", None),+ ("zstd", None),+ ] {+ let (response, bytes) = fetch(router.clone(), &path, Some(accept), None).await;+ assert_eq!(StatusCode::OK, response.status(), "{key} {accept}");+ let encoding = header_text(&response, header::CONTENT_ENCODING);+ assert_eq!(expected, encoding, "{key} {accept}");+ assert_eq!(body, decoded(encoding, &bytes), "{key} {accept}");+ assert_eq!(+ vec!["Accept-Encoding"],+ response+ .headers()+ .get_all(header::VARY)+ .iter()+ .map(|value| value.to_str().expect("vary is ascii"))+ .collect::<Vec<_>>(),+ "{key} {accept}"+ );+ if expected.is_some() {+ assert!(bytes.len() < body.len() / 4, "{key} {accept}");+ assert_eq!(None, header_text(&response, header::CONTENT_LENGTH));+ assert_eq!(None, header_text(&response, header::ACCEPT_RANGES));+ } else {+ assert_eq!(+ Some(body.len().to_string().as_str()),+ header_text(&response, header::CONTENT_LENGTH),+ "{key} {accept}"+ );+ }+ }+ let (response, bytes) = fetch(router.clone(), &path, None, None).await;+ assert_eq!(+ None,+ header_text(&response, header::CONTENT_ENCODING),+ "{key}"+ );+ assert_eq!(body, bytes, "{key}");+ }+ }++ #[tokio::test]+ async fn static_mode_serves_archives_images_ranges_and_small_files_as_stored() {+ let body = compressible_bytes(64 * 1024);+ let small = compressible_bytes(512);+ let (_fake, router) = static_router_serving(&[+ ("assets/0123456789abcdef.tar.gz", "application/gzip", &body),+ ("avatars/0.png", "image/png", &body),+ (+ "desktop/fluxer-setup.exe",+ "application/octet-stream",+ &body,+ ),+ (+ "assets/fedcba9876543210.js",+ "application/javascript; charset=utf-8",+ &small,+ ),+ ("assets/0123456789abcdef.wasm", "application/wasm", &body),+ ])+ .await;+ for (path, stored) in [+ ("/assets/0123456789abcdef.tar.gz", &body),+ ("/avatars/0.png", &body),+ ("/desktop/fluxer-setup.exe", &body),+ ("/assets/fedcba9876543210.js", &small),+ ] {+ let (response, bytes) = fetch(router.clone(), path, Some("br, gzip"), None).await;+ assert_eq!(StatusCode::OK, response.status(), "{path}");+ assert_eq!(+ None,+ header_text(&response, header::CONTENT_ENCODING),+ "{path}"+ );+ assert_eq!(stored, &bytes, "{path}");+ }+ let (response, bytes) = fetch(+ router,+ "/assets/0123456789abcdef.wasm",+ Some("br, gzip"),+ Some("bytes=100-199"),+ )+ .await;+ assert_eq!(StatusCode::PARTIAL_CONTENT, response.status());+ assert_eq!(None, header_text(&response, header::CONTENT_ENCODING));+ assert_eq!(&body[100..200], &bytes[..]);+ }++ #[tokio::test]+ async fn static_head_matches_get_representation_headers_without_a_body() {+ let body = compressible_bytes(1024);+ let small = compressible_bytes(1023);+ let (_fake, router) = static_router_serving(&[+ ("assets/0123456789abcdef.wasm", "application/wasm", &body),+ (+ "assets/fedcba9876543210.js",+ "application/javascript",+ &small,+ ),+ ("assets/0123456789abcdef.tar.gz", "application/gzip", &body),+ ])+ .await;+ let listener = TcpListener::bind("127.0.0.1:0")+ .await+ .expect("local listener");+ let address = listener.local_addr().expect("local address");+ let server = tokio::spawn(async move {+ axum::serve(+ listener,+ router.into_make_service_with_connect_info::<SocketAddr>(),+ )+ .await+ .expect("local server");+ });+ let client = reqwest::Client::builder()+ .no_proxy()+ .no_gzip()+ .no_brotli()+ .no_deflate()+ .no_zstd()+ .build()+ .expect("http client");+ for (path, accept_encoding, range, expected_encoding, expected_body) in [+ (+ "/assets/0123456789abcdef.wasm",+ "gzip",+ None,+ Some("gzip"),+ &body[..],+ ),+ (+ "/assets/0123456789abcdef.wasm",+ "identity",+ None,+ None,+ &body[..],+ ),+ (+ "/assets/fedcba9876543210.js",+ "gzip",+ None,+ None,+ &small[..],+ ),+ (+ "/assets/0123456789abcdef.tar.gz",+ "gzip",+ None,+ None,+ &body[..],+ ),+ (+ "/assets/0123456789abcdef.wasm",+ "gzip",+ Some("bytes=100-199"),+ None,+ &body[100..200],+ ),+ ] {+ let url = format!("http://{address}{path}");+ let mut get = client+ .get(&url)+ .header(header::ACCEPT_ENCODING, accept_encoding);+ let mut head = client+ .head(&url)+ .header(header::ACCEPT_ENCODING, accept_encoding);+ if let Some(range) = range {+ get = get.header(header::RANGE, range);+ head = head.header(header::RANGE, range);+ }+ let get = get.send().await.expect("get response");+ let status = get.status();+ let get_headers = get.headers().clone();+ let get_body = get.bytes().await.expect("get body");+ let encoding = get_headers+ .get(header::CONTENT_ENCODING)+ .map(|value| value.to_str().expect("encoding is ascii"));+ assert_eq!(expected_encoding, encoding, "{path} {accept_encoding}");+ assert_eq!(expected_body, decoded(encoding, &get_body));+ let head = head.send().await.expect("head response");+ assert_eq!(status, head.status(), "{path} {accept_encoding}");+ for name in [+ header::CONTENT_ENCODING,+ header::CONTENT_LENGTH,+ header::CONTENT_TYPE,+ header::CONTENT_RANGE,+ header::ACCEPT_RANGES,+ header::VARY,+ ] {+ assert_eq!(+ get_headers.get(&name),+ head.headers().get(&name),+ "{path} {accept_encoding} {name}"+ );+ }+ assert!(head.bytes().await.expect("head body").is_empty());+ }+ server.abort();+ let _ = server.await;+ }+#[tokio::test]async fn router_exposes_exactly_the_declared_route_and_method_table() {for mode in ["mp", "static", "upload", "relay"] {