Expand description
§Overview
This library provides middlewares and various utilities for HTTP-clients.
Thus, it extends the tower_http functionality for creating HTTP clients
using tower middlewares.
At the moment, the de facto standard client library is reqwest, which is
poorly compatible with the tower services, but thanks to the
tower_reqwest crate, it can be used with the any tower_http layers.
The first goal of the project is to create a more flexible and extensible
alternative for reqwest_middleware.
§Examples
Simple client usage with layers from the tower_http.
use http::{header::USER_AGENT, HeaderValue};
use tower::{ServiceBuilder, ServiceExt};
use tower_http::ServiceBuilderExt;
use tower_http_client::{ServiceExt as _, ResponseExt as _};
use tower_reqwest::HttpClientLayer;
/// Implementation agnostic HTTP client.
type HttpClient = tower::util::BoxCloneService<
http::Request<reqwest::Body>,
http::Response<reqwest::Body>,
anyhow::Error,
>;
/// Creates HTTP client with Tower layers on top of the given client.
fn make_client(client: reqwest::Client) -> HttpClient {
ServiceBuilder::new()
// Add some layers.
.override_request_header(USER_AGENT, HeaderValue::from_static("tower-http-client"))
// Make client compatible with the `tower-http` layers.
.layer(HttpClientLayer)
.service(client)
.map_err(anyhow::Error::from)
.boxed_clone()
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
// Create a new client
let client = make_client(reqwest::Client::new());
// Execute request by using this service.
let response = client
.clone()
.get("http://ip.jsontest.com")
.send()?
.await?;
let text = response.body_reader().utf8().await?;
println!("{text}");
Ok(())
}An example of multi-threaded concurrent requests sending routine with the requests rate limit.
use std::time::Duration;
use http::{Request, Response};
use reqwest::Body;
use tower::{ServiceBuilder, ServiceExt as _};
use tower_http_client::ServiceExt as _;
use tower_reqwest::HttpClientLayer;
use wiremock::{
matchers::{method, path},
Mock, MockServer, ResponseTemplate,
};
type HttpClient = tower::util::BoxCloneService<Request<Body>, Response<Body>, anyhow::Error>;
#[derive(Clone)]
struct State {
host: String,
client: HttpClient,
}
impl State {
async fn get_hello(&mut self) -> anyhow::Result<()> {
let response = self
.client
.get(format!("{}/hello", self.host))
.send()?
.await?;
anyhow::ensure!(response.status().is_success(), "response failed");
Ok(())
}
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
eprintln!("-> Spawning a mock http server...");
let mock_server = MockServer::start().await;
let mock_uri = mock_server.uri();
// Arrange the behaviour of the MockServer adding a Mock:
// when it receives a GET request on '/hello' it will respond with a 200.
Mock::given(method("GET"))
.and(path("/hello"))
.respond_with(ResponseTemplate::new(200))
// Mounting the mock on the mock server - it's now effective!
.mount(&mock_server)
.await;
eprintln!("-> Creating an HTTP client with Tower layers...");
let state = State {
host: mock_uri,
client: ServiceBuilder::new()
// Add some layers.
.buffer(64)
.rate_limit(2, Duration::from_secs(1))
.concurrency_limit(5)
// Make client compatible with the `tower-http` layers.
.layer(HttpClientLayer)
.service(reqwest::Client::new())
.map_err(anyhow::Error::msg)
.boxed_clone(),
};
eprintln!("-> Sending concurrent requests...");
let tasks = (0..5).map({
|i| {
let state = state.clone();
tokio::spawn(async move {
let mut state = state.clone();
for j in 0..5 {
state.get_hello().await?;
eprintln!("[task {i}]: Request #{j} completed successfully!");
}
anyhow::Ok(())
})
}
});
let results = futures_util::future::join_all(tasks).await;
for result in results {
result??;
}
Ok(())
}Re-exports§
pub use client::ResponseExt;pub use client::ServiceExt;