use std::time::Duration;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TimeoutPhase {
Pool,
Connect,
ProxyConnect,
ProxyTls,
Write,
Read,
Total,
}
impl std::fmt::Display for TimeoutPhase {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Pool => write!(f, "pool"),
Self::Connect => write!(f, "connect"),
Self::ProxyConnect => write!(f, "proxy connect"),
Self::ProxyTls => write!(f, "proxy TLS"),
Self::Read => write!(f, "read"),
Self::Write => write!(f, "write"),
Self::Total => write!(f, "total"),
}
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct Timeout {
pub pool: Option<Duration>,
pub connect: Option<Duration>,
pub write: Option<Duration>,
pub read: Option<Duration>,
pub total: Option<Duration>,
}
impl Timeout {
#[must_use]
pub fn disabled() -> Self {
Self::default()
}
#[must_use]
pub fn from_secs(secs: u64) -> Self {
let d = Duration::from_secs(secs);
Self {
pool: Some(d),
connect: Some(d),
write: Some(d),
read: Some(d),
total: None,
}
}
#[must_use]
pub fn compat() -> Self {
let d = Duration::from_secs(5);
Self {
pool: Some(d),
connect: Some(d),
write: Some(d),
read: Some(d),
total: None,
}
}
#[must_use]
pub fn native() -> Self {
let d = Duration::from_secs(30);
Self {
pool: Some(d),
connect: Some(d),
write: Some(d),
read: Some(d),
total: None,
}
}
#[must_use]
pub fn builder() -> TimeoutBuilder {
TimeoutBuilder {
pool: None,
connect: None,
write: None,
read: None,
total: None,
}
}
#[must_use]
pub(crate) fn merge(self, override_timeout: Option<Self>) -> Self {
match override_timeout {
Some(req) => Self {
pool: req.pool.or(self.pool),
connect: req.connect.or(self.connect),
write: req.write.or(self.write),
read: req.read.or(self.read),
total: req.total.or(self.total),
},
None => self,
}
}
#[must_use]
pub fn has_any(&self) -> bool {
self.pool.is_some()
|| self.connect.is_some()
|| self.write.is_some()
|| self.read.is_some()
|| self.total.is_some()
}
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct ResponseDeadline {
deadline: std::time::Instant,
total: Duration,
}
impl ResponseDeadline {
#[must_use]
pub(crate) fn new(deadline: std::time::Instant, total: Duration) -> Self {
Self { deadline, total }
}
#[must_use]
pub(crate) fn deadline(&self) -> std::time::Instant {
self.deadline
}
#[must_use]
pub(crate) fn is_expired(&self) -> bool {
std::time::Instant::now() >= self.deadline
}
#[must_use]
pub(crate) fn elapsed(&self) -> Duration {
let started = self
.deadline
.checked_sub(self.total)
.unwrap_or(self.deadline);
std::time::Instant::now().saturating_duration_since(started)
}
}
#[must_use]
pub(crate) fn saturating_add_instant(
base: std::time::Instant,
duration: Duration,
) -> std::time::Instant {
base.checked_add(duration).unwrap_or_else(|| {
base.checked_add(Duration::from_secs(86400 * 365 * 10))
.unwrap_or(base)
})
}
#[must_use]
pub(crate) fn saturating_tokio_now_plus(duration: Duration) -> tokio::time::Instant {
let now = tokio::time::Instant::now();
now.checked_add(duration).unwrap_or_else(|| {
now.checked_add(Duration::from_secs(86400 * 365 * 10))
.unwrap_or(now)
})
}
#[derive(Debug, Clone)]
pub struct TimeoutBuilder {
pool: Option<Duration>,
connect: Option<Duration>,
write: Option<Duration>,
read: Option<Duration>,
total: Option<Duration>,
}
impl TimeoutBuilder {
#[must_use]
pub fn pool(mut self, timeout: Duration) -> Self {
self.pool = Some(timeout);
self
}
#[must_use]
pub fn connect(mut self, timeout: Duration) -> Self {
self.connect = Some(timeout);
self
}
#[must_use]
pub fn write(mut self, timeout: Duration) -> Self {
self.write = Some(timeout);
self
}
#[must_use]
pub fn read(mut self, timeout: Duration) -> Self {
self.read = Some(timeout);
self
}
#[must_use]
pub fn total(mut self, timeout: Duration) -> Self {
self.total = Some(timeout);
self
}
#[must_use]
pub fn build(self) -> Timeout {
Timeout {
pool: self.pool,
connect: self.connect,
write: self.write,
read: self.read,
total: self.total,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
#[test]
fn timeout_default_all_none() {
let t = Timeout::default();
assert!(t.pool.is_none());
assert!(t.connect.is_none());
assert!(t.write.is_none());
assert!(t.read.is_none());
assert!(t.total.is_none());
}
#[test]
fn saturating_add_instant_absorbs_duration_max() {
let started = std::time::Instant::now();
let deadline = saturating_add_instant(started, Duration::MAX);
assert!(deadline >= started);
}
#[test]
fn response_deadline_elapsed_never_panics_on_saturated_deadline() {
let saturated = saturating_add_instant(std::time::Instant::now(), Duration::MAX);
let deadline = ResponseDeadline::new(saturated, Duration::MAX);
assert_eq!(deadline.elapsed(), Duration::ZERO);
}
#[test]
fn timeout_disabled_same_as_default() {
let t = Timeout::disabled();
assert!(!t.has_any());
}
#[test]
fn timeout_from_secs_sets_phases() {
let t = Timeout::from_secs(10);
assert_eq!(t.pool, Some(Duration::from_secs(10)));
assert_eq!(t.connect, Some(Duration::from_secs(10)));
assert_eq!(t.write, Some(Duration::from_secs(10)));
assert_eq!(t.read, Some(Duration::from_secs(10)));
assert!(t.total.is_none());
}
#[test]
fn timeout_builder_sets_all() {
let t = Timeout::builder()
.pool(Duration::from_secs(1))
.connect(Duration::from_secs(2))
.write(Duration::from_secs(3))
.read(Duration::from_secs(4))
.total(Duration::from_secs(5))
.build();
assert_eq!(t.pool, Some(Duration::from_secs(1)));
assert_eq!(t.connect, Some(Duration::from_secs(2)));
assert_eq!(t.write, Some(Duration::from_secs(3)));
assert_eq!(t.read, Some(Duration::from_secs(4)));
assert_eq!(t.total, Some(Duration::from_secs(5)));
}
#[test]
fn timeout_merge_request_overrides_client() {
let client = Timeout::from_secs(10);
let request = Timeout {
read: Some(Duration::from_secs(30)),
..Timeout::default()
};
let merged = client.merge(Some(request));
assert_eq!(merged.pool, Some(Duration::from_secs(10)));
assert_eq!(merged.connect, Some(Duration::from_secs(10)));
assert_eq!(merged.write, Some(Duration::from_secs(10)));
assert_eq!(merged.read, Some(Duration::from_secs(30)));
assert!(merged.total.is_none());
}
#[test]
fn timeout_merge_no_override() {
let client = Timeout::from_secs(5);
let merged = client.merge(None);
assert_eq!(merged.pool, Some(Duration::from_secs(5)));
assert_eq!(merged.connect, Some(Duration::from_secs(5)));
}
#[test]
fn timeout_compat_sets_operational_phases_without_total() {
let t = Timeout::compat();
let d = Duration::from_secs(5);
assert_eq!(t.pool, Some(d));
assert_eq!(t.connect, Some(d));
assert_eq!(t.write, Some(d));
assert_eq!(t.read, Some(d));
assert!(t.total.is_none());
}
#[test]
fn timeout_native_sets_phases_without_total() {
let t = Timeout::native();
let d = Duration::from_secs(30);
assert_eq!(t.pool, Some(d));
assert_eq!(t.connect, Some(d));
assert_eq!(t.write, Some(d));
assert_eq!(t.read, Some(d));
assert!(t.total.is_none());
}
#[test]
fn timeout_has_any() {
assert!(!Timeout::default().has_any());
assert!(Timeout::from_secs(1).has_any());
assert!(Timeout {
total: Some(Duration::from_secs(1)),
..Timeout::default()
}
.has_any());
}
#[test]
fn timeout_phase_display() {
assert_eq!(TimeoutPhase::Pool.to_string(), "pool");
assert_eq!(TimeoutPhase::Connect.to_string(), "connect");
assert_eq!(TimeoutPhase::ProxyConnect.to_string(), "proxy connect");
assert_eq!(TimeoutPhase::ProxyTls.to_string(), "proxy TLS");
assert_eq!(TimeoutPhase::Write.to_string(), "write");
assert_eq!(TimeoutPhase::Read.to_string(), "read");
assert_eq!(TimeoutPhase::Total.to_string(), "total");
}
#[test]
fn timeout_merge_empty_override_preserves_client() {
let client = Timeout {
pool: Some(Duration::from_secs(1)),
connect: Some(Duration::from_secs(2)),
write: Some(Duration::from_secs(3)),
read: Some(Duration::from_secs(4)),
total: Some(Duration::from_secs(5)),
};
let merged = client.merge(Some(Timeout::default()));
assert_eq!(merged.pool, Some(Duration::from_secs(1)));
assert_eq!(merged.connect, Some(Duration::from_secs(2)));
assert_eq!(merged.write, Some(Duration::from_secs(3)));
assert_eq!(merged.read, Some(Duration::from_secs(4)));
assert_eq!(merged.total, Some(Duration::from_secs(5)));
}
#[test]
fn timeout_builder_matches_from_secs_for_phases() {
let scalar = Timeout::from_secs(5);
let builder = Timeout::builder()
.pool(Duration::from_secs(5))
.connect(Duration::from_secs(5))
.write(Duration::from_secs(5))
.read(Duration::from_secs(5))
.build();
assert_eq!(scalar.pool, builder.pool);
assert_eq!(scalar.connect, builder.connect);
assert_eq!(scalar.write, builder.write);
assert_eq!(scalar.read, builder.read);
assert_eq!(scalar.total, builder.total);
}
#[test]
fn timeout_merge_request_overrides_total() {
let client = Timeout::from_secs(10);
let request = Timeout {
total: Some(Duration::from_secs(60)),
..Timeout::default()
};
let merged = client.merge(Some(request));
assert_eq!(merged.total, Some(Duration::from_secs(60)));
assert_eq!(merged.pool, Some(Duration::from_secs(10)));
}
#[test]
fn zero_duration_timeout_is_valid() {
let t = Timeout::from_secs(0);
assert_eq!(t.pool, Some(Duration::ZERO));
assert_eq!(t.connect, Some(Duration::ZERO));
assert_eq!(t.write, Some(Duration::ZERO));
assert_eq!(t.read, Some(Duration::ZERO));
assert_eq!(t.total, None);
}
proptest::proptest! {
#[test]
fn from_secs_sets_correct_phases(secs in 0u64..86400) {
let t = Timeout::from_secs(secs);
let d = Duration::from_secs(secs);
prop_assert_eq!(t.pool, Some(d));
prop_assert_eq!(t.connect, Some(d));
prop_assert_eq!(t.write, Some(d));
prop_assert_eq!(t.read, Some(d));
prop_assert!(t.total.is_none());
}
#[test]
fn disabled_has_no_phases(_ in 0u64..100) {
let t = Timeout::disabled();
prop_assert!(!t.has_any());
prop_assert!(t.pool.is_none());
prop_assert!(t.connect.is_none());
prop_assert!(t.write.is_none());
prop_assert!(t.read.is_none());
prop_assert!(t.total.is_none());
}
#[test]
fn has_any_consistent_with_fields(
pool in proptest::option::of(0u64..3600),
connect in proptest::option::of(0u64..3600),
write in proptest::option::of(0u64..3600),
read in proptest::option::of(0u64..3600),
total in proptest::option::of(0u64..3600),
) {
let t = Timeout {
pool: pool.map(Duration::from_secs),
connect: connect.map(Duration::from_secs),
write: write.map(Duration::from_secs),
read: read.map(Duration::from_secs),
total: total.map(Duration::from_secs),
};
let expected = t.pool.is_some() || t.connect.is_some() || t.write.is_some() || t.read.is_some() || t.total.is_some();
prop_assert_eq!(t.has_any(), expected);
}
#[test]
fn builder_round_trip(
pool in 0u64..3600,
connect in 0u64..3600,
write in 0u64..3600,
read in 0u64..3600,
total in 0u64..3600,
) {
let t = Timeout::builder()
.pool(Duration::from_secs(pool))
.connect(Duration::from_secs(connect))
.write(Duration::from_secs(write))
.read(Duration::from_secs(read))
.total(Duration::from_secs(total))
.build();
prop_assert_eq!(t.pool, Some(Duration::from_secs(pool)));
prop_assert_eq!(t.connect, Some(Duration::from_secs(connect)));
prop_assert_eq!(t.write, Some(Duration::from_secs(write)));
prop_assert_eq!(t.read, Some(Duration::from_secs(read)));
prop_assert_eq!(t.total, Some(Duration::from_secs(total)));
}
}
}