use std::{
collections::HashMap,
net::SocketAddr,
pin::Pin,
sync::{Arc, Mutex, PoisonError, Weak},
task::{Context, Poll},
time::{Duration, Instant},
};
use async_lock::{Semaphore, SemaphoreGuardArc};
use http::{
HeaderMap, Method, Uri, Version,
header::{CONNECTION, CONTENT_LENGTH, HOST, PROXY_AUTHORIZATION, TRANSFER_ENCODING, UPGRADE},
};
use http_body::Body as _;
use hyper::body::Incoming;
use crate::{
Body, Error, Limits, Request, Result,
runtime::{Deadline, DeadlineBody, Runtime},
transport::Transport,
};
use super::{
Connection, Http1 as Http1Settings, Http2 as Http2Settings, Origin, Protocol,
handshake::{self, http1, http2},
};
#[derive(Clone)]
pub(crate) struct Pool {
inner: Arc<PoolInner>,
}
struct PoolInner {
transport: Transport,
runtime: Runtime,
state: Mutex<State>,
limits: Limits,
connect_timeout: Option<Duration>,
idle_timeout: Option<Duration>,
read_timeout: Option<Duration>,
http1: Http1Settings,
http2: Http2Settings,
}
#[derive(Default)]
struct State {
h1: HashMap<Origin, Vec<Http1>>,
h2: HashMap<Origin, Http2>,
gates: HashMap<Origin, Weak<OriginGate>>,
}
struct OriginGate {
capacity: Arc<Semaphore>,
negotiation: Arc<Semaphore>,
protocol: Mutex<Option<Protocol>>,
}
struct OriginPermit {
_gate: Arc<OriginGate>,
_permit: SemaphoreGuardArc,
}
struct Http1 {
sender: http1::Sender,
_gate: Arc<OriginGate>,
remote_addr: SocketAddr,
absolute_form: bool,
proxy_authorization: Option<http::HeaderValue>,
permit: Option<OriginPermit>,
idle_since: Instant,
reused: bool,
}
#[derive(Clone)]
struct Http2 {
sender: http2::Sender,
remote_addr: SocketAddr,
identity: Arc<()>,
}
enum Checkout {
Http1(Http1),
Http2(Http2),
Vacant {
gate: Arc<OriginGate>,
permit: Option<SemaphoreGuardArc>,
},
}
pub(crate) struct Received {
pub(crate) parts: http::response::Parts,
pub(crate) body: Body,
pub(crate) remote_addr: SocketAddr,
}
impl Pool {
pub(crate) fn new(
transport: Transport,
runtime: Runtime,
settings: super::Settings,
limits: Limits,
connect_timeout: Option<Duration>,
idle_timeout: Option<Duration>,
read_timeout: Option<Duration>,
) -> Self {
Self {
inner: Arc::new(PoolInner {
transport,
runtime,
http1: settings.http1_policy(),
http2: settings.http2_policy(),
state: Mutex::new(State::default()),
limits,
connect_timeout,
idle_timeout,
read_timeout,
}),
}
}
pub(crate) async fn send(&self, request: Request, deadline: Deadline) -> Result<Received> {
let origin = Origin::from_uri(request.uri())?;
let (gate, permit) = match self.checkout(&origin) {
Checkout::Http1(connection) => {
return self.send_h1(connection, origin, request, deadline).await;
}
Checkout::Http2(connection) => {
return self
.send_h2(origin, connection, request, deadline, true)
.await;
}
Checkout::Vacant { gate, permit } => (gate, permit),
};
let permit = match permit {
Some(permit) => permit,
None => {
deadline
.run(async { Ok(gate.capacity.acquire_arc().await) })
.await?
}
};
let permit = OriginPermit {
_gate: Arc::clone(&gate),
_permit: permit,
};
if let Some(mut connection) = self.h1(&origin) {
connection.permit = Some(permit);
return self.send_h1(connection, origin, request, deadline).await;
}
let mut negotiation = if gate.protocol() == Some(Protocol::Http1) {
None
} else {
Some(
if let Some(negotiation) = gate.negotiation.try_acquire_arc() {
negotiation
} else {
deadline
.run(async { Ok(gate.negotiation.acquire_arc().await) })
.await?
},
)
};
if let Some(mut connection) = self.h1(&origin) {
connection.permit = Some(permit);
return self.send_h1(connection, origin, request, deadline).await;
}
if let Some(connection) = self.h2(&origin) {
drop(permit);
return self
.send_h2(origin, connection, request, deadline, true)
.await;
}
if gate.protocol() == Some(Protocol::Http1) {
drop(negotiation.take());
}
let connect_deadline = deadline.within(self.inner.connect_timeout)?;
let Connection {
io,
protocol,
remote_addr,
absolute_form,
proxy_authorization,
} = self
.inner
.transport
.connect(&origin, connect_deadline.clone())
.await?;
gate.remember(protocol);
match protocol {
Protocol::Http1 => {
let sender = connect_deadline
.run(http1::connect(
io,
self.inner.runtime.executor(),
self.inner.http1,
))
.await?;
drop(negotiation);
self.send_h1(
Http1 {
sender,
_gate: Arc::clone(&gate),
remote_addr,
absolute_form,
proxy_authorization,
permit: Some(permit),
idle_since: Instant::now(),
reused: false,
},
origin,
request,
deadline,
)
.await
}
Protocol::Http2 => {
let sender = connect_deadline
.run(http2::connect(
io,
self.inner.runtime.executor(),
self.inner.runtime.timer(),
self.inner.http2,
))
.await?;
let connection = Http2 {
sender,
remote_addr,
identity: Arc::new(()),
};
self.store_h2(origin.clone(), connection.clone());
drop(permit);
drop(negotiation);
self.send_h2(origin, connection, request, deadline, false)
.await
}
}
}
pub(crate) fn timer(&self) -> crate::runtime::Timer {
self.inner.runtime.timer().clone()
}
async fn send_h1(
&self,
mut connection: Http1,
origin: Origin,
request: Request,
deadline: Deadline,
) -> Result<Received> {
let ready = if connection.sender.is_ready() {
Ok(())
} else {
deadline
.run(async {
connection
.sender
.ready()
.await
.map_err(|error| handshake::classify_error(&error))?;
Ok(())
})
.await
};
if let Err(error) = ready {
if connection.reused {
drop(connection);
return Box::pin(self.send(request, deadline)).await;
}
return Err(error);
}
if request.version() == Version::HTTP_2 {
return Err(Error::request(
"the connected server did not negotiate HTTP/2",
));
}
let request = prepare(
request,
&origin,
Protocol::Http1,
connection.absolute_form,
connection.proxy_authorization.as_ref(),
)?;
let request_closes = connection_closes(request.headers());
let response = deadline
.run(async {
connection
.sender
.send_request(request)
.await
.map_err(|error| handshake::classify_error(&error))
})
.await?;
let (mut parts, incoming) = response.into_parts();
let upgraded = normalize_upgrade(&mut parts);
let reusable = !request_closes && !upgraded && !connection_closes(&parts.headers);
let remote_addr = connection.remote_addr;
let pooled = PooledBody {
incoming,
returned: false,
return_to: Some(ReturnTo {
pool: Arc::clone(&self.inner),
origin,
connection: Some(connection),
reusable,
}),
};
let body = Body::from_http_body(
DeadlineBody::new(pooled, deadline, self.inner.read_timeout),
|error| error,
);
Ok(Received {
parts,
body,
remote_addr,
})
}
async fn send_h2(
&self,
origin: Origin,
mut connection: Http2,
request: Request,
deadline: Deadline,
reused: bool,
) -> Result<Received> {
if let Err(error) = deadline
.run(async {
connection
.sender
.ready()
.await
.map_err(|error| handshake::classify_error(&error))?;
Ok(())
})
.await
{
self.retire_h2(&origin, &connection);
if reused {
return Box::pin(self.send(request, deadline)).await;
}
return Err(error);
}
let request = prepare(request, &origin, Protocol::Http2, false, None)?;
let response = match deadline
.run(async {
connection
.sender
.send_request(request)
.await
.map_err(|error| handshake::classify_error(&error))
})
.await
{
Ok(response) => response,
Err(error) => {
self.retire_h2(&origin, &connection);
return Err(error);
}
};
let (mut parts, incoming) = response.into_parts();
normalize_upgrade(&mut parts);
let incoming = Body::from_http_body(incoming, |_| Error::body());
let body = Body::from_http_body(
DeadlineBody::new(incoming, deadline, self.inner.read_timeout),
|error| error,
);
Ok(Received {
parts,
body,
remote_addr: connection.remote_addr,
})
}
fn h1(&self, origin: &Origin) -> Option<Http1> {
let mut state = self
.inner
.state
.lock()
.unwrap_or_else(PoisonError::into_inner);
take_h1(&mut state, origin, self.inner.idle_timeout)
}
fn h2(&self, origin: &Origin) -> Option<Http2> {
let mut state = self
.inner
.state
.lock()
.unwrap_or_else(PoisonError::into_inner);
let connection = state.h2.get(origin).cloned()?;
if connection.sender.is_closed() {
state.h2.remove(origin);
None
} else {
Some(connection)
}
}
fn store_h2(&self, origin: Origin, connection: Http2) {
self.inner
.state
.lock()
.unwrap_or_else(PoisonError::into_inner)
.h2
.insert(origin, connection);
}
fn retire_h2(&self, origin: &Origin, connection: &Http2) {
let mut state = self
.inner
.state
.lock()
.unwrap_or_else(PoisonError::into_inner);
let current = state
.h2
.get(origin)
.is_some_and(|current| Arc::ptr_eq(¤t.identity, &connection.identity));
if current {
state.h2.remove(origin);
}
}
fn checkout(&self, origin: &Origin) -> Checkout {
let mut state = self
.inner
.state
.lock()
.unwrap_or_else(PoisonError::into_inner);
if let Some(connection) = state.h2.get(origin).cloned() {
if !connection.sender.is_closed() {
return Checkout::Http2(connection);
}
state.h2.remove(origin);
}
let gate = if let Some(gate) = state.gates.get(origin).and_then(Weak::upgrade) {
gate
} else {
state.gates.retain(|_, gate| gate.strong_count() > 0);
let gate = Arc::new(OriginGate {
capacity: Arc::new(Semaphore::new(self.inner.limits.connections())),
negotiation: Arc::new(Semaphore::new(1)),
protocol: Mutex::new(None),
});
state.gates.insert(origin.clone(), Arc::downgrade(&gate));
gate
};
let permit = gate.capacity.try_acquire_arc();
if let Some(permit) = permit {
if let Some(mut connection) = take_h1(&mut state, origin, self.inner.idle_timeout) {
connection.permit = Some(OriginPermit {
_gate: Arc::clone(&gate),
_permit: permit,
});
return Checkout::Http1(connection);
}
Checkout::Vacant {
gate,
permit: Some(permit),
}
} else {
Checkout::Vacant { gate, permit: None }
}
}
}
fn take_h1(state: &mut State, origin: &Origin, idle_timeout: Option<Duration>) -> Option<Http1> {
let connections = state.h1.get_mut(origin)?;
while let Some(connection) = connections.pop() {
let expired =
idle_timeout.is_some_and(|timeout| connection.idle_since.elapsed() >= timeout);
if !expired && !connection.sender.is_closed() {
return Some(connection);
}
}
state.h1.remove(origin);
None
}
impl OriginGate {
fn protocol(&self) -> Option<Protocol> {
*self.protocol.lock().unwrap_or_else(PoisonError::into_inner)
}
fn remember(&self, protocol: Protocol) {
*self.protocol.lock().unwrap_or_else(PoisonError::into_inner) = Some(protocol);
}
}
struct ReturnTo {
pool: Arc<PoolInner>,
origin: Origin,
connection: Option<Http1>,
reusable: bool,
}
impl ReturnTo {
fn release(mut self) {
let Some(mut connection) = self.connection.take() else {
return;
};
if !self.reusable || connection.sender.is_closed() {
return;
}
connection.permit = None;
connection.idle_since = Instant::now();
connection.reused = true;
let mut state = self
.pool
.state
.lock()
.unwrap_or_else(PoisonError::into_inner);
let connections = state.h1.entry(self.origin).or_default();
if connections.len() < self.pool.limits.idle_connections() {
connections.push(connection);
}
}
}
struct PooledBody {
incoming: Incoming,
returned: bool,
return_to: Option<ReturnTo>,
}
impl http_body::Body for PooledBody {
type Data = bytes::Bytes;
type Error = Error;
fn poll_frame(
mut self: Pin<&mut Self>,
context: &mut Context<'_>,
) -> Poll<Option<Result<http_body::Frame<Self::Data>>>> {
let this = &mut *self;
poll_incoming(this, context)
}
fn is_end_stream(&self) -> bool {
self.incoming.is_end_stream()
}
fn size_hint(&self) -> http_body::SizeHint {
self.incoming.size_hint()
}
}
fn poll_incoming(
body: &mut PooledBody,
context: &mut Context<'_>,
) -> Poll<Option<Result<http_body::Frame<bytes::Bytes>>>> {
match Pin::new(&mut body.incoming).poll_frame(context) {
Poll::Ready(None) => {
body.returned = true;
if let Some(return_to) = body.return_to.take() {
return_to.release();
}
Poll::Ready(None)
}
Poll::Ready(Some(Err(_))) => {
body.return_to = None;
Poll::Ready(Some(Err(Error::body())))
}
Poll::Ready(Some(Ok(frame))) => {
if body.incoming.is_end_stream() {
body.returned = true;
if let Some(return_to) = body.return_to.take() {
return_to.release();
}
}
Poll::Ready(Some(Ok(frame)))
}
Poll::Pending => Poll::Pending,
}
}
impl Drop for PooledBody {
fn drop(&mut self) {
if self.incoming.is_end_stream()
&& !self.returned
&& let Some(return_to) = self.return_to.take()
{
return_to.release();
}
}
}
fn prepare(
mut request: Request,
origin: &Origin,
protocol: Protocol,
absolute_form: bool,
proxy_authorization: Option<&http::HeaderValue>,
) -> Result<Request> {
request.headers_mut().remove(PROXY_AUTHORIZATION);
if protocol == Protocol::Http1 && !request.headers().contains_key(HOST) {
request.headers_mut().insert(
HOST,
origin
.host_header()
.parse()
.map_err(|_| Error::request("request host is invalid"))?,
);
}
if !request.headers().contains_key(CONTENT_LENGTH)
&& !request.headers().contains_key(TRANSFER_ENCODING)
&& let Some(length) = request
.body()
.size_hint()
.exact()
.filter(|length| *length > 0)
{
request.headers_mut().insert(
CONTENT_LENGTH,
length
.to_string()
.parse()
.map_err(|_| Error::request("request content length is invalid"))?,
);
}
if let Some(authorization) = proxy_authorization {
request
.headers_mut()
.insert(PROXY_AUTHORIZATION, authorization.clone());
}
if protocol == Protocol::Http2 {
for name in [
CONNECTION,
http::HeaderName::from_static("keep-alive"),
http::HeaderName::from_static("proxy-connection"),
TRANSFER_ENCODING,
UPGRADE,
] {
request.headers_mut().remove(name);
}
}
*request.version_mut() = match protocol {
Protocol::Http1 => Version::HTTP_11,
Protocol::Http2 => Version::HTTP_2,
};
if request.method() == Method::CONNECT {
*request.uri_mut() = origin
.authority()
.parse()
.map_err(|_| Error::request("request authority is invalid"))?;
return Ok(request);
}
if protocol == Protocol::Http1 && !absolute_form {
let path = request
.uri()
.path_and_query()
.map_or("/", http::uri::PathAndQuery::as_str);
*request.uri_mut() = path
.parse::<Uri>()
.map_err(|_| Error::request("request path is invalid"))?;
}
Ok(request)
}
fn connection_closes(headers: &HeaderMap) -> bool {
headers.get_all(CONNECTION).iter().any(|value| {
value
.to_str()
.ok()
.into_iter()
.flat_map(|value| value.split(','))
.any(|token| token.trim().eq_ignore_ascii_case("close"))
})
}
fn normalize_upgrade(parts: &mut http::response::Parts) -> bool {
let Some(upgrade) = parts.extensions.remove::<hyper::upgrade::OnUpgrade>() else {
return false;
};
parts.extensions.insert(crate::Upgrade::new(upgrade));
true
}
#[cfg(test)]
mod tests {
use super::*;
fn request(uri: &str) -> Request {
http::Request::builder()
.uri(uri)
.body(Body::empty())
.unwrap()
}
fn prepare_request(
request: Request,
protocol: Protocol,
absolute_form: bool,
proxy_authorization: Option<&http::HeaderValue>,
) -> Result<Request> {
let origin = Origin::from_uri(request.uri())?;
prepare(
request,
&origin,
protocol,
absolute_form,
proxy_authorization,
)
}
#[test]
fn caller_proxy_credentials_never_reach_a_connection() {
let mut request = request("https://origin.example/resource");
request
.headers_mut()
.insert(PROXY_AUTHORIZATION, "Basic caller-secret".parse().unwrap());
let request = prepare_request(request, Protocol::Http1, false, None).unwrap();
assert!(!request.headers().contains_key(PROXY_AUTHORIZATION));
}
#[test]
fn configured_proxy_credentials_are_only_added_for_the_proxy_hop() {
let credential = "Basic configured-secret".parse().unwrap();
let request = prepare_request(
request("http://origin.example/resource"),
Protocol::Http1,
true,
Some(&credential),
)
.unwrap();
assert_eq!(request.headers()[PROXY_AUTHORIZATION], credential);
}
#[test]
fn http2_requests_drop_connection_specific_headers() {
let mut request = request("https://origin.example/resource");
for (name, value) in [
(CONNECTION, "upgrade"),
(http::HeaderName::from_static("keep-alive"), "timeout=5"),
(
http::HeaderName::from_static("proxy-connection"),
"keep-alive",
),
(TRANSFER_ENCODING, "chunked"),
(UPGRADE, "websocket"),
] {
request.headers_mut().insert(name, value.parse().unwrap());
}
let request = prepare_request(request, Protocol::Http2, false, None).unwrap();
for name in [
CONNECTION,
http::HeaderName::from_static("keep-alive"),
http::HeaderName::from_static("proxy-connection"),
TRANSFER_ENCODING,
UPGRADE,
] {
assert!(!request.headers().contains_key(name));
}
assert!(!request.headers().contains_key(HOST));
}
}