use std::collections::HashMap;
use std::fmt;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, RwLock};
use tokio::sync::{OwnedSemaphorePermit, Semaphore};
use crate::error::{Error, Result};
use crate::timeout::ResponseDeadline;
#[derive(Debug, Clone, Default)]
pub struct PoolConfig {
pub max_idle_connections: Option<usize>,
pub max_idle_connections_per_host: Option<usize>,
pub max_connections: Option<usize>,
pub max_connections_per_host: Option<usize>,
pub max_in_flight_requests: Option<usize>,
pub max_in_flight_requests_per_origin: Option<usize>,
pub idle_timeout: Option<std::time::Duration>,
}
impl PoolConfig {
#[must_use]
pub(crate) fn effective_max_in_flight(&self) -> Option<usize> {
self.max_in_flight_requests.or(self.max_connections)
}
#[must_use]
pub(crate) fn effective_max_in_flight_per_origin(&self) -> Option<usize> {
self.max_in_flight_requests_per_origin
.or(self.max_connections_per_host)
}
#[must_use]
pub(crate) fn effective_max_idle_per_host(&self) -> Option<usize> {
self.max_idle_connections_per_host
.or(self.max_idle_connections)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(crate) struct OriginKey {
scheme: String,
host: String,
port: u16,
proxy_host: Option<String>,
proxy_port: Option<u16>,
proxy_scheme: Option<String>,
is_tunnel: bool,
}
impl OriginKey {
pub(crate) fn from_components(scheme: &str, host: &str, port: u16) -> Self {
Self {
scheme: scheme.to_owned(),
host: host.to_ascii_lowercase(),
port,
proxy_host: None,
proxy_port: None,
proxy_scheme: None,
is_tunnel: false,
}
}
pub(crate) fn from_origin(origin: &crate::http_origin::HttpOrigin) -> Self {
Self::from_components(origin.scheme_str(), origin.host(), origin.port_ref())
}
#[cfg(feature = "high-level-url")]
pub(crate) fn from_url(url: &url::Url) -> Option<Self> {
let origin = crate::http_origin::HttpOrigin::from_url(url)?;
Some(Self::from_origin(&origin))
}
#[cfg(feature = "proxy")]
pub(crate) fn from_url_with_proxy_scheme(
url: &url::Url,
proxy_host: Option<&str>,
proxy_port: Option<u16>,
proxy_scheme: Option<&str>,
is_tunnel: bool,
) -> Option<Self> {
let mut key = Self::from_url(url)?;
key.proxy_host = proxy_host.map(str::to_owned);
key.proxy_port = proxy_port;
key.proxy_scheme = proxy_scheme.map(str::to_owned);
key.is_tunnel = is_tunnel;
Some(key)
}
#[cfg(any(test, feature = "test-util"))]
#[allow(
dead_code,
reason = "the constructor is compiled into every test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn from_parts(scheme: &str, host: &str, port: u16) -> Self {
Self::from_components(scheme, host, port)
}
#[cfg(all(feature = "proxy", any(test, feature = "test-util")))]
#[allow(
dead_code,
reason = "the constructor is compiled into every proxy-enabled test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn from_parts_with_proxy(
scheme: &str,
host: &str,
port: u16,
proxy_host: Option<&str>,
proxy_port: Option<u16>,
proxy_scheme: Option<&str>,
is_tunnel: bool,
) -> Self {
Self {
scheme: scheme.to_owned(),
host: host.to_owned(),
port,
proxy_host: proxy_host.map(str::to_owned),
proxy_port,
proxy_scheme: proxy_scheme.map(str::to_owned),
is_tunnel,
}
}
#[cfg(any(test, feature = "test-util"))]
#[allow(
dead_code,
reason = "the accessor is compiled into every test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn scheme(&self) -> &str {
&self.scheme
}
pub(crate) fn host(&self) -> &str {
&self.host
}
#[cfg(any(test, feature = "test-util"))]
#[allow(
dead_code,
reason = "the accessor is compiled into every test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn port(&self) -> u16 {
self.port
}
#[cfg(any(test, feature = "test-util"))]
#[allow(
dead_code,
reason = "the accessor is compiled into every test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn proxy_host(&self) -> Option<&str> {
self.proxy_host.as_deref()
}
#[cfg(any(test, feature = "test-util"))]
#[allow(
dead_code,
reason = "the accessor is compiled into every test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn proxy_port(&self) -> Option<u16> {
self.proxy_port
}
#[cfg(any(test, feature = "test-util"))]
#[allow(
dead_code,
reason = "the accessor is compiled into every test-util build, but only the test modules call it, so a non-test test-util build has no caller"
)]
pub(crate) fn is_tunnel(&self) -> bool {
self.is_tunnel
}
}
impl fmt::Display for OriginKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}://{}:{}", self.scheme, self.host, self.port)?;
if let (Some(ref ph), Some(pp)) = (&self.proxy_host, self.proxy_port) {
if let Some(ref scheme) = self.proxy_scheme {
write!(f, " via {scheme}://{ph}:{pp}")?;
} else {
write!(f, " via {ph}:{pp}")?;
}
if self.is_tunnel {
write!(f, " tunnel")?;
}
}
Ok(())
}
}
#[derive(Debug, Default)]
pub struct PoolMetrics {
pub acquisition_waits: AtomicUsize,
pub acquisition_cancellations: AtomicUsize,
}
#[derive(Debug, Clone, Copy, Default)]
struct ResponseLifecycle {
read_timeout: Option<std::time::Duration>,
total_deadline: Option<ResponseDeadline>,
}
pub struct PoolGuard {
pool: Arc<PoolInner>,
pub(crate) origin: Option<OriginKey>,
#[allow(
dead_code,
reason = "the permit is released by its own Drop impl, so the field is never read by name"
)]
pub(crate) global_permit: Option<OwnedSemaphorePermit>,
#[allow(
dead_code,
reason = "the permit is released by its own Drop impl, so the field is never read by name"
)]
pub(crate) origin_permit: Option<OwnedSemaphorePermit>,
response_lifecycle: ResponseLifecycle,
}
impl PoolGuard {
fn new(
pool: Arc<PoolInner>,
origin: Option<OriginKey>,
global_permit: Option<OwnedSemaphorePermit>,
origin_permit: Option<OwnedSemaphorePermit>,
) -> Self {
Self {
pool,
origin,
global_permit,
origin_permit,
response_lifecycle: ResponseLifecycle::default(),
}
}
pub(crate) fn set_response_timeouts(
&mut self,
read_timeout: Option<std::time::Duration>,
total_deadline: Option<ResponseDeadline>,
) {
self.response_lifecycle = ResponseLifecycle {
read_timeout,
total_deadline,
};
}
pub(crate) fn response_read_timeout(&self) -> Option<std::time::Duration> {
self.response_lifecycle.read_timeout
}
pub(crate) fn response_total_deadline(&self) -> Option<ResponseDeadline> {
self.response_lifecycle.total_deadline
}
#[must_use]
pub(crate) fn has_response_state(&self) -> bool {
self.global_permit.is_some()
|| self.origin_permit.is_some()
|| self.response_lifecycle.read_timeout.is_some()
|| self.response_lifecycle.total_deadline.is_some()
}
#[must_use]
#[allow(
dead_code,
reason = "the accessor is exercised by the pool tests and is part of the guard's diagnostic surface"
)]
pub(crate) fn origin(&self) -> Option<&OriginKey> {
self.origin.as_ref()
}
#[allow(
dead_code,
reason = "the accessor is public API on the public PoolGuard type and is the host-only counterpart of origin()"
)]
pub fn host(&self) -> Option<&str> {
self.origin.as_ref().map(OriginKey::host)
}
#[must_use]
pub fn metrics(&self) -> &PoolMetrics {
&self.pool.metrics
}
}
impl Drop for PoolGuard {
fn drop(&mut self) {
}
}
struct PoolInner {
global_semaphore: Option<Arc<Semaphore>>,
per_origin: RwLock<HashMap<OriginKey, Arc<PerOriginSemaphore>>>,
config: PoolConfig,
metrics: PoolMetrics,
}
struct PerOriginSemaphore {
semaphore: Arc<Semaphore>,
waiters: AtomicUsize,
}
impl PerOriginSemaphore {
fn new(max_per_origin: usize) -> Self {
Self {
semaphore: Arc::new(Semaphore::new(max_per_origin)),
waiters: AtomicUsize::new(0),
}
}
}
struct WaiterGuard {
entry: Arc<PerOriginSemaphore>,
}
impl WaiterGuard {
fn from_registered(entry: Arc<PerOriginSemaphore>) -> Self {
Self { entry }
}
}
impl Drop for WaiterGuard {
fn drop(&mut self) {
self.entry.waiters.fetch_sub(1, Ordering::AcqRel);
}
}
#[derive(Clone)]
pub struct Pool {
inner: Arc<PoolInner>,
}
impl PoolInner {
fn lookup_or_create_registered(
&self,
origin: &OriginKey,
max_per_origin: usize,
) -> Result<(Arc<PerOriginSemaphore>, WaiterGuard)> {
{
let table = self
.per_origin
.read()
.map_err(|_| Error::Pool("per-origin table lock poisoned".to_owned()))?;
if let Some(entry) = table.get(origin).cloned() {
entry.waiters.fetch_add(1, Ordering::AcqRel);
let guard = WaiterGuard::from_registered(Arc::clone(&entry));
return Ok((entry, guard));
}
}
{
let mut table = self
.per_origin
.write()
.map_err(|_| Error::Pool("per-origin table lock poisoned".to_owned()))?;
if let Some(entry) = table.get(origin).cloned() {
entry.waiters.fetch_add(1, Ordering::AcqRel);
let guard = WaiterGuard::from_registered(Arc::clone(&entry));
return Ok((entry, guard));
}
if table.len() > max_per_origin.saturating_mul(16).max(64) {
table.retain(|_, entry| {
entry.semaphore.available_permits() < max_per_origin
|| entry.waiters.load(Ordering::Acquire) > 0
});
}
let entry = Arc::new(PerOriginSemaphore::new(max_per_origin));
entry.waiters.fetch_add(1, Ordering::AcqRel);
let guard = WaiterGuard::from_registered(Arc::clone(&entry));
table.insert(origin.clone(), Arc::clone(&entry));
Ok((entry, guard))
}
}
#[cfg(any(test, feature = "test-util"))]
#[allow(dead_code, reason = "test hook for pool-table assertions")]
fn per_origin_len_for_test(&self) -> usize {
self.per_origin.read().map_or(0, |t| t.len())
}
#[cfg(any(test, feature = "test-util"))]
#[allow(dead_code, reason = "test hook for pool-table assertions")]
fn per_origin_is_empty_for_test(&self) -> bool {
self.per_origin.read().map_or(true, |t| t.is_empty())
}
#[cfg(any(test, feature = "test-util"))]
#[allow(dead_code, reason = "test hook for pool-table assertions")]
fn per_origin_contains_for_test(&self, origin: &OriginKey) -> bool {
self.per_origin.read().is_ok_and(|t| t.contains_key(origin))
}
#[cfg(any(test, feature = "test-util"))]
#[allow(dead_code, reason = "test hook for pool-table assertions")]
fn per_origin_get_for_test(&self, origin: &OriginKey) -> Option<Arc<PerOriginSemaphore>> {
self.per_origin
.read()
.ok()
.and_then(|t| t.get(origin).cloned())
}
}
impl Pool {
#[must_use]
pub fn new(config: PoolConfig) -> Self {
let global_semaphore = config
.effective_max_in_flight()
.map(|n| Arc::new(Semaphore::new(n)));
Self {
inner: Arc::new(PoolInner {
global_semaphore,
per_origin: RwLock::new(HashMap::new()),
config,
metrics: PoolMetrics::default(),
}),
}
}
#[must_use]
pub(crate) fn idle_timeout(&self) -> Option<std::time::Duration> {
self.inner.config.idle_timeout
}
#[must_use]
pub(crate) fn max_idle_per_host(&self) -> Option<usize> {
self.inner.config.effective_max_idle_per_host()
}
#[must_use]
pub(crate) fn needs_origin_key(&self) -> bool {
self.inner
.config
.effective_max_in_flight_per_origin()
.is_some()
}
pub(crate) async fn acquire(&self, origin: Option<&OriginKey>) -> Result<PoolGuard> {
let mut waited = false;
let mut global_permit: Option<OwnedSemaphorePermit> = None;
let mut origin_permit: Option<OwnedSemaphorePermit> = None;
if let Some(ref sem) = self.inner.global_semaphore {
if let Ok(permit) = sem.clone().try_acquire_owned() {
global_permit = Some(permit);
} else if let Ok(permit) = sem.clone().acquire_owned().await {
global_permit = Some(permit);
waited = true;
} else {
self.inner
.metrics
.acquisition_cancellations
.fetch_add(1, Ordering::Relaxed);
return Err(Error::Pool("global semaphore is closed".into()));
}
}
if let (Some(max_per_origin), Some(origin)) = (
self.inner.config.effective_max_in_flight_per_origin(),
origin,
) {
let (entry, mut waiter_guard) = match self
.inner
.lookup_or_create_registered(origin, max_per_origin)
{
Ok(registered) => (registered.0, Some(registered.1)),
Err(e) => {
self.inner
.metrics
.acquisition_cancellations
.fetch_add(1, Ordering::Relaxed);
drop(global_permit);
return Err(e);
}
};
if let Ok(permit) = entry.semaphore.clone().try_acquire_owned() {
waiter_guard.take();
origin_permit = Some(permit);
} else {
let permit = entry.semaphore.clone().acquire_owned().await;
waiter_guard.take();
if let Ok(permit) = permit {
origin_permit = Some(permit);
waited = true;
} else {
self.inner
.metrics
.acquisition_cancellations
.fetch_add(1, Ordering::Relaxed);
drop(global_permit);
return Err(Error::Pool("per-origin semaphore is closed".into()));
}
}
}
if waited {
self.inner
.metrics
.acquisition_waits
.fetch_add(1, Ordering::Relaxed);
}
Ok(PoolGuard::new(
self.inner.clone(),
origin_permit.is_some().then(|| origin.cloned()).flatten(),
global_permit,
origin_permit,
))
}
#[must_use]
pub fn metrics(&self) -> &PoolMetrics {
&self.inner.metrics
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_config_has_no_limits() {
let config = PoolConfig::default();
assert!(config.max_idle_connections.is_none());
assert!(config.max_idle_connections_per_host.is_none());
assert!(config.max_connections.is_none());
assert!(config.max_connections_per_host.is_none());
assert!(config.max_in_flight_requests.is_none());
assert!(config.max_in_flight_requests_per_origin.is_none());
assert!(config.idle_timeout.is_none());
}
#[test]
fn effective_limits_prefer_new_names() {
let config = PoolConfig {
max_connections: Some(10),
max_in_flight_requests: Some(7),
max_connections_per_host: Some(5),
max_in_flight_requests_per_origin: Some(3),
..PoolConfig::default()
};
assert_eq!(config.effective_max_in_flight(), Some(7));
assert_eq!(config.effective_max_in_flight_per_origin(), Some(3));
}
#[test]
fn effective_limits_fall_back_to_aliases() {
let config = PoolConfig {
max_connections: Some(10),
max_connections_per_host: Some(5),
..PoolConfig::default()
};
assert_eq!(config.effective_max_in_flight(), Some(10));
assert_eq!(config.effective_max_in_flight_per_origin(), Some(5));
}
#[test]
fn effective_idle_cap_prefers_per_host() {
let config = PoolConfig {
max_idle_connections: Some(20),
max_idle_connections_per_host: Some(7),
..PoolConfig::default()
};
assert_eq!(config.effective_max_idle_per_host(), Some(7));
let pool = Pool::new(config);
assert_eq!(pool.max_idle_per_host(), Some(7));
}
#[test]
fn effective_idle_cap_falls_back_to_global() {
let config = PoolConfig {
max_idle_connections: Some(20),
..PoolConfig::default()
};
assert_eq!(config.effective_max_idle_per_host(), Some(20));
let pool = Pool::new(config);
assert_eq!(pool.max_idle_per_host(), Some(20));
}
#[test]
fn effective_idle_cap_absent_when_unset() {
let pool = Pool::new(PoolConfig::default());
assert_eq!(pool.max_idle_per_host(), None);
assert_eq!(pool.idle_timeout(), None);
}
#[tokio::test]
async fn new_names_enforce_logical_concurrency() {
let pool = Pool::new(PoolConfig {
max_in_flight_requests_per_origin: Some(1),
..PoolConfig::default()
});
let origin = OriginKey::from_parts("http", "example.com", 80);
let _guard = pool.acquire(Some(&origin)).await.unwrap();
assert!(
tokio::time::timeout(
std::time::Duration::from_millis(10),
pool.acquire(Some(&origin))
)
.await
.is_err(),
"second logical request must wait while first holds its permit"
);
}
#[test]
fn pool_constructs_with_defaults() {
let pool = Pool::new(PoolConfig::default());
assert!(pool.inner.global_semaphore.is_none());
assert!(pool.inner.per_origin_is_empty_for_test());
}
#[test]
fn pool_constructs_with_global_limit() {
let config = PoolConfig {
max_connections: Some(10),
..Default::default()
};
let pool = Pool::new(config);
assert!(pool.inner.global_semaphore.is_some());
}
#[test]
fn pool_metrics_starts_zeroed() {
let pool = Pool::new(PoolConfig::default());
let metrics = pool.metrics();
assert_eq!(metrics.acquisition_waits.load(Ordering::Relaxed), 0);
assert_eq!(metrics.acquisition_cancellations.load(Ordering::Relaxed), 0);
}
#[tokio::test]
async fn acquire_without_limits_returns_immediately() {
let pool = Pool::new(PoolConfig::default());
let guard = pool.acquire(None).await.unwrap();
assert!(guard.origin().is_none());
assert!(!guard.has_response_state());
}
#[tokio::test]
async fn response_state_tracks_permit_and_timeout_ownership() {
let global_pool = Pool::new(PoolConfig {
max_connections: Some(1),
..Default::default()
});
let guard = global_pool.acquire(None).await.unwrap();
assert!(guard.has_response_state());
let pool = Pool::new(PoolConfig::default());
let mut guard = pool.acquire(None).await.unwrap();
guard.set_response_timeouts(Some(std::time::Duration::from_secs(1)), None);
assert!(guard.has_response_state());
}
#[tokio::test]
async fn acquire_with_global_limit() {
let config = PoolConfig {
max_connections: Some(2),
..Default::default()
};
let pool = Pool::new(config);
let origin = OriginKey::from_parts("http", "example.com", 80);
let g1 = pool.acquire(Some(&origin)).await.unwrap();
let g2 = pool.acquire(Some(&origin)).await.unwrap();
assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 0);
drop(g1);
drop(g2);
}
#[tokio::test]
async fn acquire_with_per_origin_limit() {
let config = PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
};
let pool = Pool::new(config);
let origin = OriginKey::from_parts("http", "example.com", 80);
let g1 = pool.acquire(Some(&origin)).await.unwrap();
assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 0);
drop(g1);
}
#[tokio::test]
async fn closed_semaphores_count_cancellation_without_a_wait() {
let global_pool = Pool::new(PoolConfig {
max_connections: Some(1),
..Default::default()
});
let global_guard = global_pool.acquire(None).await.unwrap();
global_pool.inner.global_semaphore.as_ref().unwrap().close();
assert!(global_pool.acquire(None).await.is_err());
assert_eq!(
global_pool
.metrics()
.acquisition_waits
.load(Ordering::Relaxed),
0
);
assert_eq!(
global_pool
.metrics()
.acquisition_cancellations
.load(Ordering::Relaxed),
1
);
drop(global_guard);
let origin_pool = Pool::new(PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
});
let origin = OriginKey::from_parts("http", "example.com", 80);
let origin_guard = origin_pool.acquire(Some(&origin)).await.unwrap();
origin_pool
.inner
.per_origin_get_for_test(&origin)
.unwrap()
.semaphore
.close();
assert!(origin_pool.acquire(Some(&origin)).await.is_err());
assert_eq!(
origin_pool
.metrics()
.acquisition_waits
.load(Ordering::Relaxed),
0
);
assert_eq!(
origin_pool
.metrics()
.acquisition_cancellations
.load(Ordering::Relaxed),
1
);
drop(origin_guard);
}
#[test]
fn pool_is_clone() {
let pool = Pool::new(PoolConfig::default());
let pool2 = pool.clone();
assert!(Arc::ptr_eq(&pool.inner, &pool2.inner));
}
#[tokio::test]
async fn acquire_per_origin_limit_separate_origins() {
let config = PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
};
let pool = Pool::new(config);
let o1 = OriginKey::from_parts("http", "host-a", 80);
let o2 = OriginKey::from_parts("http", "host-b", 80);
let g1 = pool.acquire(Some(&o1)).await.unwrap();
let g2 = pool.acquire(Some(&o2)).await.unwrap();
assert!(g1.origin().is_some());
assert!(g2.origin().is_some());
drop(g1);
drop(g2);
}
#[cfg(feature = "high-level-url")]
#[test]
fn origin_key_from_url_http() {
let url = url::Url::parse("http://example.com:8080/path").unwrap();
let key = OriginKey::from_url(&url).unwrap();
assert_eq!(key.scheme(), "http");
assert_eq!(key.host(), "example.com");
assert_eq!(key.port(), 8080);
}
#[cfg(feature = "high-level-url")]
#[test]
fn origin_key_from_url_https_default_port() {
let url = url::Url::parse("https://example.com/path").unwrap();
let key = OriginKey::from_url(&url).unwrap();
assert_eq!(key.scheme(), "https");
assert_eq!(key.host(), "example.com");
assert_eq!(key.port(), 443);
}
#[cfg(feature = "high-level-url")]
#[test]
fn origin_key_from_url_http_default_port() {
let url = url::Url::parse("http://example.com/path").unwrap();
let key = OriginKey::from_url(&url).unwrap();
assert_eq!(key.scheme(), "http");
assert_eq!(key.port(), 80);
}
#[test]
fn origin_key_from_native_origin() {
let uri: http::Uri = "https://example.com:8443/path".parse().expect("valid URI");
let origin = crate::http_origin::HttpOrigin::from_uri(&uri).expect("native origin parses");
let key = OriginKey::from_origin(&origin);
assert_eq!(key.host(), "example.com");
assert_eq!(key.to_string(), "https://example.com:8443");
assert_eq!(
key,
OriginKey::from_components("https", "example.com", 8443)
);
}
#[test]
fn origin_keys_distinguish_scheme() {
let http = OriginKey::from_parts("http", "example.com", 80);
let https = OriginKey::from_parts("https", "example.com", 443);
assert_ne!(http, https);
}
#[test]
fn origin_keys_distinguish_port() {
let p80 = OriginKey::from_parts("http", "example.com", 80);
let p8080 = OriginKey::from_parts("http", "example.com", 8080);
assert_ne!(p80, p8080);
}
#[test]
fn origin_keys_equal_for_same_origin() {
let a = OriginKey::from_parts("http", "example.com", 80);
let b = OriginKey::from_parts("http", "example.com", 80);
assert_eq!(a, b);
}
#[test]
fn origin_key_display() {
let key = OriginKey::from_parts("https", "example.com", 443);
assert_eq!(key.to_string(), "https://example.com:443");
}
#[tokio::test]
async fn origin_keys_separate_per_origin_map_entries() {
let config = PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
};
let pool = Pool::new(config);
let a = OriginKey::from_parts("http", "example.com", 80);
let b = OriginKey::from_parts("http", "example.com", 8080);
assert!(pool.acquire(Some(&a)).await.unwrap().origin().is_some());
assert!(pool.acquire(Some(&b)).await.unwrap().origin().is_some());
}
#[test]
fn origin_keys_distinct_by_scheme() {
let http = OriginKey::from_parts("http", "example.com", 443);
let https = OriginKey::from_parts("https", "example.com", 443);
assert_ne!(http, https);
}
#[cfg(feature = "high-level-url")]
#[test]
fn origin_key_from_url_uses_scheme_default_port() {
let explicit = url::Url::parse("http://example.com:8080/path").unwrap();
let default = url::Url::parse("http://example.com/path").unwrap();
let k_explicit = OriginKey::from_url(&explicit).unwrap();
let k_default = OriginKey::from_url(&default).unwrap();
assert_eq!(k_explicit.port(), 8080);
assert_eq!(k_default.port(), 80);
}
#[test]
fn origin_key_direct_has_no_proxy() {
let key = OriginKey::from_parts("http", "example.com", 80);
assert!(key.proxy_host().is_none());
assert!(key.proxy_port().is_none());
assert!(!key.is_tunnel());
}
#[cfg(feature = "proxy")]
#[test]
fn origin_key_proxy_a_not_equal_proxy_b() {
let url = url::Url::parse("http://example.com/path").unwrap();
let a =
OriginKey::from_url_with_proxy_scheme(&url, Some("proxy-a"), Some(8080), None, false)
.unwrap();
let b =
OriginKey::from_url_with_proxy_scheme(&url, Some("proxy-b"), Some(8080), None, false)
.unwrap();
assert_ne!(a, b);
}
#[cfg(feature = "proxy")]
#[test]
fn origin_key_tunnel_not_equal_non_tunnel() {
let url = url::Url::parse("http://example.com/path").unwrap();
let tunnel =
OriginKey::from_url_with_proxy_scheme(&url, Some("proxy"), Some(8080), None, true)
.unwrap();
let direct =
OriginKey::from_url_with_proxy_scheme(&url, Some("proxy"), Some(8080), None, false)
.unwrap();
assert_ne!(tunnel, direct);
}
#[cfg(feature = "proxy")]
#[test]
fn origin_key_proxy_same_route_equal() {
let url = url::Url::parse("http://example.com/path").unwrap();
let a = OriginKey::from_url_with_proxy_scheme(&url, Some("proxy"), Some(8080), None, false)
.unwrap();
let b = OriginKey::from_url_with_proxy_scheme(&url, Some("proxy"), Some(8080), None, false)
.unwrap();
assert_eq!(a, b);
}
#[cfg(feature = "proxy")]
#[test]
fn origin_key_parts_preserves_proxy_scheme() {
let http = OriginKey::from_parts_with_proxy(
"https",
"example.com",
443,
Some("proxy"),
Some(8080),
Some("http"),
true,
);
let https = OriginKey::from_parts_with_proxy(
"https",
"example.com",
443,
Some("proxy"),
Some(8080),
Some("https"),
true,
);
assert_ne!(http, https);
assert_eq!(
http.to_string(),
"https://example.com:443 via http://proxy:8080 tunnel"
);
}
#[cfg(feature = "proxy")]
#[test]
fn origin_key_display_with_proxy() {
let url = url::Url::parse("https://example.com/path").unwrap();
let key =
OriginKey::from_url_with_proxy_scheme(&url, Some("proxy"), Some(8080), None, true)
.unwrap();
assert_eq!(
key.to_string(),
"https://example.com:443 via proxy:8080 tunnel"
);
}
#[cfg(feature = "proxy")]
#[test]
fn origin_key_display_without_tunnel() {
let url = url::Url::parse("http://example.com/path").unwrap();
let key =
OriginKey::from_url_with_proxy_scheme(&url, Some("proxy"), Some(8080), None, false)
.unwrap();
assert_eq!(key.to_string(), "http://example.com:80 via proxy:8080");
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn proxy_route_separate_from_direct() {
let config = PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
};
let pool = Pool::new(config);
let direct = OriginKey::from_parts("http", "example.com", 80);
let proxied = OriginKey::from_parts_with_proxy(
"http",
"example.com",
80,
Some("proxy"),
Some(8080),
None,
false,
);
let g1 = pool.acquire(Some(&direct)).await.unwrap();
let g2 = pool.acquire(Some(&proxied)).await.unwrap();
assert!(g1.origin().is_some());
assert!(g2.origin().is_some());
}
#[tokio::test]
async fn global_wait_does_not_hold_per_origin_slot() {
let pool = Pool::new(PoolConfig {
max_connections: Some(1),
max_connections_per_host: Some(1),
..Default::default()
});
let first_origin = OriginKey::from_parts("http", "first.example", 80);
let waiting_origin = OriginKey::from_parts("http", "waiting.example", 80);
let first = pool.acquire(Some(&first_origin)).await.unwrap();
let pool_for_task = pool.clone();
let waiting_origin_for_task = waiting_origin.clone();
let waiter =
tokio::spawn(
async move { pool_for_task.acquire(Some(&waiting_origin_for_task)).await },
);
for _ in 0..3 {
tokio::task::yield_now().await;
}
assert!(!pool.inner.per_origin_contains_for_test(&waiting_origin));
drop(first);
drop(waiter.await.unwrap().unwrap());
}
#[tokio::test]
async fn idle_per_origin_entries_are_swept_on_acquire() {
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
});
for index in 0..8 {
let origin = OriginKey::from_parts("http", &format!("host-{index}.example"), 80);
drop(pool.acquire(Some(&origin)).await.unwrap());
}
assert!(pool.inner.per_origin_len_for_test() <= 8);
if std::env::var("EGGFETCH_STRICT_POOL_EVICTION").is_ok() {
assert!(pool.inner.per_origin_len_for_test() <= 1);
}
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn tunnel_separate_from_non_tunnel() {
let config = PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
};
let pool = Pool::new(config);
let http_fwd = OriginKey::from_parts_with_proxy(
"http",
"example.com",
80,
Some("proxy"),
Some(8080),
None,
false,
);
let https_tunnel = OriginKey::from_parts_with_proxy(
"http",
"example.com",
80,
Some("proxy"),
Some(8080),
None,
true,
);
let g1 = pool.acquire(Some(&http_fwd)).await.unwrap();
let g2 = pool.acquire(Some(&https_tunnel)).await.unwrap();
assert!(g1.origin().is_some());
assert!(g2.origin().is_some());
}
#[cfg(feature = "proxy")]
#[tokio::test]
async fn different_proxies_separate_semaphores() {
let config = PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
};
let pool = Pool::new(config);
let a = OriginKey::from_parts_with_proxy(
"http",
"example.com",
80,
Some("proxy-a"),
Some(8080),
None,
false,
);
let b = OriginKey::from_parts_with_proxy(
"http",
"example.com",
80,
Some("proxy-b"),
Some(8080),
None,
false,
);
let g1 = pool.acquire(Some(&a)).await.unwrap();
let g2 = pool.acquire(Some(&b)).await.unwrap();
assert!(g1.origin().is_some());
assert!(g2.origin().is_some());
}
#[tokio::test]
async fn same_origin_concurrency_never_exceeds_limit() {
use std::sync::atomic::AtomicUsize;
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(3),
..Default::default()
});
let origin = OriginKey::from_parts("http", "hot.example", 80);
let current = Arc::new(AtomicUsize::new(0));
let max_seen = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::new();
for _ in 0..12 {
let pool = pool.clone();
let origin = origin.clone();
let current = current.clone();
let max_seen = max_seen.clone();
handles.push(tokio::spawn(async move {
let _guard = pool.acquire(Some(&origin)).await.unwrap();
let n = current.fetch_add(1, Ordering::AcqRel) + 1;
max_seen.fetch_max(n, Ordering::AcqRel);
tokio::task::yield_now().await;
current.fetch_sub(1, Ordering::AcqRel);
}));
}
for h in handles {
h.await.unwrap();
}
assert!(
max_seen.load(Ordering::Acquire) <= 3,
"same-origin concurrency exceeded the per-origin limit"
);
}
#[tokio::test]
async fn cancellation_releases_waiter_registration() {
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
});
let origin = OriginKey::from_parts("http", "cancel.example", 80);
let _holder = pool.acquire(Some(&origin)).await.unwrap();
let timed_out = tokio::time::timeout(
std::time::Duration::from_millis(20),
pool.acquire(Some(&origin)),
)
.await;
assert!(timed_out.is_err(), "waiter should have timed out");
let entry = pool.inner.per_origin_get_for_test(&origin).unwrap();
assert_eq!(
entry.waiters.load(Ordering::Acquire),
0,
"cancelled waiter must release its registration"
);
}
#[tokio::test]
async fn repeated_cancellation_does_not_wedge_origin() {
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
});
let origin = OriginKey::from_parts("http", "wedge.example", 80);
for _ in 0..10 {
let holder = pool.acquire(Some(&origin)).await.unwrap();
let timed_out = tokio::time::timeout(
std::time::Duration::from_millis(10),
pool.acquire(Some(&origin)),
)
.await;
assert!(timed_out.is_err());
drop(holder);
}
let _guard = tokio::time::timeout(
std::time::Duration::from_secs(2),
pool.acquire(Some(&origin)),
)
.await
.unwrap()
.unwrap();
let entry = pool.inner.per_origin_get_for_test(&origin).unwrap();
assert_eq!(entry.waiters.load(Ordering::Acquire), 0);
}
#[tokio::test]
async fn live_permit_blocks_eviction_on_churn() {
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
});
let pinned = OriginKey::from_parts("http", "pinned.example", 80);
let _holder = pool.acquire(Some(&pinned)).await.unwrap();
for index in 0..16 {
let origin = OriginKey::from_parts("http", &format!("churn-{index}.example"), 80);
drop(pool.acquire(Some(&origin)).await.unwrap());
}
assert!(
pool.inner.per_origin_contains_for_test(&pinned),
"entry with a live permit must not be evicted"
);
assert!(
tokio::time::timeout(
std::time::Duration::from_millis(10),
pool.acquire(Some(&pinned))
)
.await
.is_err(),
"pinned origin must still enforce its per-origin limit"
);
}
#[tokio::test]
async fn registered_waiter_blocks_eviction_on_churn() {
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(1),
..Default::default()
});
let origin = OriginKey::from_parts("http", "waited.example", 80);
let holder = pool.acquire(Some(&origin)).await.unwrap();
let pool_for_task = pool.clone();
let origin_for_task = origin.clone();
let waiter =
tokio::spawn(async move { pool_for_task.acquire(Some(&origin_for_task)).await });
let mut registered = false;
for _ in 0..200 {
tokio::task::yield_now().await;
if let Some(entry) = pool.inner.per_origin_get_for_test(&origin) {
if entry.waiters.load(Ordering::Acquire) == 1 {
registered = true;
break;
}
}
}
assert!(registered, "waiter must register before churn");
for index in 0..16 {
let churn = OriginKey::from_parts("http", &format!("churn-w-{index}.example"), 80);
drop(pool.acquire(Some(&churn)).await.unwrap());
}
assert!(
pool.inner.per_origin_contains_for_test(&origin),
"entry with a registered waiter must not be evicted"
);
drop(holder);
let guard = tokio::time::timeout(std::time::Duration::from_secs(2), waiter)
.await
.unwrap()
.unwrap()
.unwrap();
drop(guard);
}
#[tokio::test]
async fn concurrent_missing_origin_creation_shares_one_semaphore() {
use tokio::sync::Barrier;
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(3),
..Default::default()
});
let origin = OriginKey::from_parts("http", "race.example", 80);
let barrier = Arc::new(Barrier::new(16));
let mut handles = Vec::new();
for _ in 0..16 {
let pool = pool.clone();
let origin = origin.clone();
let barrier = barrier.clone();
handles.push(tokio::spawn(async move {
barrier.wait().await;
let (entry, guard) = pool.inner.lookup_or_create_registered(&origin, 3).unwrap();
let ptr = Arc::as_ptr(&entry) as usize;
drop(guard);
ptr
}));
}
let mut ptrs = Vec::new();
for h in handles {
ptrs.push(h.await.unwrap());
}
assert!(
ptrs.windows(2).all(|w| w[0] == w[1]),
"concurrent creation must share one semaphore allocation"
);
assert_eq!(pool.inner.per_origin_len_for_test(), 1);
}
#[tokio::test]
async fn churn_plus_cancellation_preserves_per_origin_limit() {
use std::sync::atomic::AtomicUsize;
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(2),
..Default::default()
});
let hot = OriginKey::from_parts("http", "hot-churn.example", 80);
let current = Arc::new(AtomicUsize::new(0));
let max_seen = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::new();
for index in 0..24 {
let pool = pool.clone();
let hot = hot.clone();
let current = current.clone();
let max_seen = max_seen.clone();
handles.push(tokio::spawn(async move {
if index % 3 == 0 {
let churn = OriginKey::from_parts("http", &format!("mix-{index}.example"), 80);
drop(pool.acquire(Some(&churn)).await.unwrap());
} else if index % 3 == 1 {
let _ = tokio::time::timeout(
std::time::Duration::from_millis(5),
pool.acquire(Some(&hot)),
)
.await;
} else {
let _guard = pool.acquire(Some(&hot)).await.unwrap();
let n = current.fetch_add(1, Ordering::AcqRel) + 1;
max_seen.fetch_max(n, Ordering::AcqRel);
tokio::task::yield_now().await;
current.fetch_sub(1, Ordering::AcqRel);
}
}));
}
for h in handles {
h.await.unwrap();
}
assert!(
max_seen.load(Ordering::Acquire) <= 2,
"churn plus cancellation must not exceed the per-origin limit"
);
let _guard =
tokio::time::timeout(std::time::Duration::from_secs(2), pool.acquire(Some(&hot)))
.await
.unwrap()
.unwrap();
}
#[tokio::test]
async fn pool_metrics_meanings_preserved() {
let pool = Pool::new(PoolConfig {
max_connections_per_host: Some(2),
..Default::default()
});
let origin = OriginKey::from_parts("http", "metrics.example", 80);
let _g = pool.acquire(Some(&origin)).await.unwrap();
assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 0);
let pool = Pool::new(PoolConfig {
max_connections: Some(1),
..Default::default()
});
let holder = pool.acquire(None).await.unwrap();
let pool_for_task = pool.clone();
let waiter = tokio::spawn(async move { pool_for_task.acquire(None).await.unwrap() });
tokio::task::yield_now().await;
drop(holder);
drop(waiter.await.unwrap());
assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 1);
assert_eq!(
pool.metrics()
.acquisition_cancellations
.load(Ordering::Relaxed),
0
);
}
#[cfg(feature = "high-level-url")]
fn legacy_permissive_components(scheme: &str, url: &url::Url) -> Option<(String, String, u16)> {
let host = url.host_str()?.to_owned();
let port = url.port_or_known_default()?;
Some((scheme.to_owned(), host.to_ascii_lowercase(), port))
}
#[cfg(feature = "high-level-url")]
struct OriginShape {
name: &'static str,
url: Option<&'static str>,
legacy_accepts: bool,
strict_accepts: bool,
}
#[cfg(feature = "high-level-url")]
fn origin_shapes() -> Vec<OriginShape> {
vec![
OriginShape {
name: "http",
url: Some("http://example.com/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "https",
url: Some("https://example.com/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "non-http(s) scheme",
url: Some("ftp://example.com/path"),
legacy_accepts: true,
strict_accepts: false,
},
OriginShape {
name: "empty host",
url: None,
legacy_accepts: false,
strict_accepts: false,
},
OriginShape {
name: "uppercase host",
url: Some("http://EXAMPLE.COM/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "ipv4 literal",
url: Some("http://127.0.0.1:8080/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "ipv6 literal",
url: Some("http://[::1]:8080/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "explicit default port",
url: Some("http://example.com:80/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "explicit non-default port",
url: Some("http://example.com:8080/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "punycode host",
url: Some("http://xn--bcher-kva.example/path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "trailing-dot host",
url: Some("http://example.com./path"),
legacy_accepts: true,
strict_accepts: true,
},
OriginShape {
name: "userinfo",
url: Some("http://user:pass@example.com/path"),
legacy_accepts: true,
strict_accepts: true,
},
]
}
#[cfg(feature = "high-level-url")]
#[test]
fn origin_verdict_agreement_table() {
for shape in origin_shapes() {
let url = if let Some(text) = shape.url {
url::Url::parse(text)
.unwrap_or_else(|error| panic!("shape {} must parse: {error}", shape.name))
} else {
assert!(!shape.legacy_accepts, "shape {}", shape.name);
assert!(!shape.strict_accepts, "shape {}", shape.name);
continue;
};
let legacy = legacy_permissive_components(url.scheme(), &url);
let strict = crate::http_origin::HttpOrigin::from_url(&url);
let key = OriginKey::from_url(&url);
assert_eq!(
legacy.is_some(),
shape.legacy_accepts,
"shape {}: legacy verdict",
shape.name
);
assert_eq!(
strict.is_some(),
shape.strict_accepts,
"shape {}: strict verdict",
shape.name
);
assert_eq!(
strict.is_some(),
key.is_some(),
"shape {}: HttpOrigin and OriginKey must agree",
shape.name
);
}
}
#[cfg(feature = "high-level-url")]
#[test]
fn pool_key_is_stable_for_every_supported_shape() {
for shape in origin_shapes() {
let Some(text) = shape.url else {
continue;
};
if !shape.strict_accepts {
continue;
}
let url = url::Url::parse(text).expect("supported shape parses");
let legacy = legacy_permissive_components(url.scheme(), &url)
.expect("supported shape has legacy components");
let key = OriginKey::from_url(&url).expect("supported shape has a pool key");
assert_eq!(
(key.scheme(), key.host(), key.port()),
(legacy.0.as_str(), legacy.1.as_str(), legacy.2),
"shape {}: pool key must not change",
shape.name
);
}
}
#[cfg(all(feature = "high-level-url", feature = "proxy"))]
#[test]
fn proxy_origin_key_keeps_the_shared_origin_identity() {
let url = url::Url::parse("https://example.com/path").expect("valid url");
let direct = OriginKey::from_url(&url).expect("pool key");
let proxied = OriginKey::from_url_with_proxy_scheme(
&url,
Some("proxy"),
Some(8080),
Some("http"),
true,
)
.expect("proxied pool key");
assert_eq!(direct.scheme(), proxied.scheme());
assert_eq!(direct.host(), proxied.host());
assert_eq!(direct.port(), proxied.port());
assert_eq!(proxied.proxy_host(), Some("proxy"));
assert!(proxied.is_tunnel());
}
#[test]
fn pool_config_and_pool_resolve_the_same_idle_policy() {
let configs = [
PoolConfig::default(),
PoolConfig {
max_idle_connections: Some(4),
max_idle_connections_per_host: Some(2),
..Default::default()
},
PoolConfig {
max_idle_connections: Some(7),
..Default::default()
},
];
for config in configs {
let pool = Pool::new(config.clone());
assert_eq!(pool.idle_timeout(), config.idle_timeout);
assert_eq!(
pool.max_idle_per_host(),
config.effective_max_idle_per_host()
);
}
}
}