rama::http::layer

Module decompression

Expand description

Middleware that decompresses request and response bodies.

§Examples

§Request
use std::{error::Error, io::Write};

use bytes::{Bytes, BytesMut};
use flate2::{write::GzEncoder, Compression};

use rama_http::{Body, header, HeaderValue, Request, Response};
use rama_core::service::service_fn;
use rama_core::{Context, Service, Layer};
use rama_http::layer::decompression::{DecompressionBody, RequestDecompressionLayer};
use rama_http::dep::http_body_util::BodyExt;
use rama_core::error::BoxError;

// A request encoded with gzip coming from some HTTP client.
let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
encoder.write_all(b"Hello?")?;
let request = Request::builder()
    .header(header::CONTENT_ENCODING, "gzip")
    .body(Body::from(encoder.finish()?))?;

// Our HTTP server
let mut server = (
    // Automatically decompress request bodies.
    RequestDecompressionLayer::new(),
).into_layer(service_fn(handler));

// Send the request, with the gzip encoded body, to our server.
let _response = server.serve(Context::default(), request).await?;

// Handler receives request whose body is decoded when read
async fn handler(mut req: Request<DecompressionBody<Body>>) -> Result<Response, BoxError>{
    let data = req.into_body().collect().await?.to_bytes();
    assert_eq!(&data[..], b"Hello?");
    Ok(Response::new(Body::from("Hello, World!")))
}
§Response
use std::convert::Infallible;

use bytes::{Bytes, BytesMut};

use rama_http::{Body, Request, Response};
use rama_core::service::service_fn;
use rama_core::{Context, Service, Layer};
use rama_http::layer::{compression::Compression, decompression::DecompressionLayer};
use rama_http::dep::http_body_util::BodyExt;
use rama_core::error::BoxError;


// Some opaque service that applies compression.
let service = Compression::new(service_fn(handle));

// Our HTTP client.
let mut client = (
    // Automatically decompress response bodies.
    DecompressionLayer::new(),
).into_layer(service);

// Call the service.
//
// `DecompressionLayer` takes care of setting `Accept-Encoding`.
let request = Request::new(Body::default());

let response = client
    .serve(Context::default(), request)
    .await?;

// Read the body
let body = response.into_body();
let bytes = body.collect().await?.to_bytes().to_vec();
let body = String::from_utf8(bytes).map_err(Into::<BoxError>::into)?;

assert_eq!(body, "Hello, World!");

Structs§

Decompression
Decompresses response bodies of the underlying service.
DecompressionBody
Response body of RequestDecompression and Decompression.
DecompressionLayer
Decompresses response bodies of the underlying service.
RequestDecompression
Decompresses request bodies and calls its underlying service.
RequestDecompressionLayer
Decompresses request bodies and calls its underlying service.