1use std::collections::HashMap;
82use std::fmt;
83use std::sync::atomic::{AtomicUsize, Ordering};
84use std::sync::{Arc, RwLock};
85
86use tokio::sync::{OwnedSemaphorePermit, Semaphore};
87
88use crate::error::{Error, Result};
89use crate::timeout::ResponseDeadline;
90
91#[derive(Debug, Clone, Default)]
108pub struct PoolConfig {
109 pub max_idle_connections: Option<usize>,
115 pub max_idle_connections_per_host: Option<usize>,
119 pub max_connections: Option<usize>,
125 pub max_connections_per_host: Option<usize>,
132 pub max_in_flight_requests: Option<usize>,
137 pub max_in_flight_requests_per_origin: Option<usize>,
141 pub idle_timeout: Option<std::time::Duration>,
148}
149
150impl PoolConfig {
151 #[must_use]
153 pub(crate) fn effective_max_in_flight(&self) -> Option<usize> {
154 self.max_in_flight_requests.or(self.max_connections)
155 }
156
157 #[must_use]
159 pub(crate) fn effective_max_in_flight_per_origin(&self) -> Option<usize> {
160 self.max_in_flight_requests_per_origin
161 .or(self.max_connections_per_host)
162 }
163
164 #[must_use]
172 pub(crate) fn effective_max_idle_per_host(&self) -> Option<usize> {
173 self.max_idle_connections_per_host
174 .or(self.max_idle_connections)
175 }
176}
177
178#[derive(Debug, Clone, PartialEq, Eq, Hash)]
186pub(crate) struct OriginKey {
187 scheme: String,
189 host: String,
191 port: u16,
193 proxy_host: Option<String>,
195 proxy_port: Option<u16>,
197 proxy_scheme: Option<String>,
200 is_tunnel: bool,
203}
204
205impl OriginKey {
206 pub(crate) fn from_components(scheme: &str, host: &str, port: u16) -> Self {
211 Self {
212 scheme: scheme.to_owned(),
213 host: host.to_owned(),
214 port,
215 proxy_host: None,
216 proxy_port: None,
217 proxy_scheme: None,
218 is_tunnel: false,
219 }
220 }
221
222 pub(crate) fn from_origin(origin: &crate::http_origin::HttpOrigin) -> Self {
224 Self::from_components(origin.scheme_str(), origin.host(), origin.port_ref())
225 }
226
227 #[cfg(feature = "high-level-url")]
232 pub(crate) fn from_url(scheme: &str, url: &url::Url) -> Option<Self> {
233 let host = url.host_str()?.to_owned();
234 let port = url.port_or_known_default()?;
235 Some(Self::from_components(
236 scheme,
237 &host.to_ascii_lowercase(),
238 port,
239 ))
240 }
241
242 #[cfg(feature = "proxy")]
244 pub(crate) fn from_url_with_proxy_scheme(
245 scheme: &str,
246 url: &url::Url,
247 proxy_host: Option<&str>,
248 proxy_port: Option<u16>,
249 proxy_scheme: Option<&str>,
250 is_tunnel: bool,
251 ) -> Option<Self> {
252 let host = url.host_str()?.to_owned();
253 let port = url.port_or_known_default()?;
254 Some(Self {
255 scheme: scheme.to_owned(),
256 host: host.to_ascii_lowercase(),
257 port,
258 proxy_host: proxy_host.map(str::to_owned),
259 proxy_port,
260 proxy_scheme: proxy_scheme.map(str::to_owned),
261 is_tunnel,
262 })
263 }
264
265 #[cfg(any(test, feature = "test-util"))]
268 #[allow(dead_code)]
269 pub(crate) fn from_parts(scheme: &str, host: &str, port: u16) -> Self {
270 Self::from_components(scheme, host, port)
271 }
272
273 #[cfg(all(feature = "proxy", any(test, feature = "test-util")))]
276 #[allow(dead_code)]
277 pub(crate) fn from_parts_with_proxy(
278 scheme: &str,
279 host: &str,
280 port: u16,
281 proxy_host: Option<&str>,
282 proxy_port: Option<u16>,
283 proxy_scheme: Option<&str>,
284 is_tunnel: bool,
285 ) -> Self {
286 Self {
287 scheme: scheme.to_owned(),
288 host: host.to_owned(),
289 port,
290 proxy_host: proxy_host.map(str::to_owned),
291 proxy_port,
292 proxy_scheme: proxy_scheme.map(str::to_owned),
293 is_tunnel,
294 }
295 }
296
297 #[cfg(any(test, feature = "test-util"))]
299 #[allow(dead_code)]
300 pub(crate) fn scheme(&self) -> &str {
301 &self.scheme
302 }
303
304 pub(crate) fn host(&self) -> &str {
306 &self.host
307 }
308
309 #[cfg(any(test, feature = "test-util"))]
311 #[allow(dead_code)]
312 pub(crate) fn port(&self) -> u16 {
313 self.port
314 }
315
316 #[cfg(any(test, feature = "test-util"))]
318 #[allow(dead_code)]
319 pub(crate) fn proxy_host(&self) -> Option<&str> {
320 self.proxy_host.as_deref()
321 }
322
323 #[cfg(any(test, feature = "test-util"))]
325 #[allow(dead_code)]
326 pub(crate) fn proxy_port(&self) -> Option<u16> {
327 self.proxy_port
328 }
329
330 #[cfg(any(test, feature = "test-util"))]
332 #[allow(dead_code)]
333 pub(crate) fn is_tunnel(&self) -> bool {
334 self.is_tunnel
335 }
336}
337
338impl fmt::Display for OriginKey {
339 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
340 write!(f, "{}://{}:{}", self.scheme, self.host, self.port)?;
341 if let (Some(ref ph), Some(pp)) = (&self.proxy_host, self.proxy_port) {
342 if let Some(ref scheme) = self.proxy_scheme {
343 write!(f, " via {scheme}://{ph}:{pp}")?;
344 } else {
345 write!(f, " via {ph}:{pp}")?;
346 }
347 if self.is_tunnel {
348 write!(f, " tunnel")?;
349 }
350 }
351 Ok(())
352 }
353}
354
355#[derive(Debug, Default)]
378pub struct PoolMetrics {
379 pub acquisition_waits: AtomicUsize,
381 pub acquisition_cancellations: AtomicUsize,
383}
384
385#[derive(Debug, Clone, Copy, Default)]
394struct ResponseLifecycle {
395 read_timeout: Option<std::time::Duration>,
396 total_deadline: Option<ResponseDeadline>,
397}
398
399pub struct PoolGuard {
403 pool: Arc<PoolInner>,
404 pub(crate) origin: Option<OriginKey>,
405 #[allow(dead_code)]
409 pub(crate) global_permit: Option<OwnedSemaphorePermit>,
410 #[allow(dead_code)]
411 pub(crate) origin_permit: Option<OwnedSemaphorePermit>,
412 response_lifecycle: ResponseLifecycle,
413}
414
415impl PoolGuard {
416 fn new(
418 pool: Arc<PoolInner>,
419 origin: Option<OriginKey>,
420 global_permit: Option<OwnedSemaphorePermit>,
421 origin_permit: Option<OwnedSemaphorePermit>,
422 ) -> Self {
423 Self {
424 pool,
425 origin,
426 global_permit,
427 origin_permit,
428 response_lifecycle: ResponseLifecycle::default(),
429 }
430 }
431
432 pub(crate) fn set_response_timeouts(
435 &mut self,
436 read_timeout: Option<std::time::Duration>,
437 total_deadline: Option<ResponseDeadline>,
438 ) {
439 self.response_lifecycle = ResponseLifecycle {
440 read_timeout,
441 total_deadline,
442 };
443 }
444
445 pub(crate) fn response_read_timeout(&self) -> Option<std::time::Duration> {
447 self.response_lifecycle.read_timeout
448 }
449
450 pub(crate) fn response_total_deadline(&self) -> Option<ResponseDeadline> {
452 self.response_lifecycle.total_deadline
453 }
454
455 #[must_use]
457 #[allow(dead_code)] pub(crate) fn origin(&self) -> Option<&OriginKey> {
459 self.origin.as_ref()
460 }
461
462 #[allow(dead_code)]
464 pub fn host(&self) -> Option<&str> {
465 self.origin.as_ref().map(OriginKey::host)
466 }
467
468 #[must_use]
470 pub fn metrics(&self) -> &PoolMetrics {
471 &self.pool.metrics
472 }
473}
474
475impl Drop for PoolGuard {
476 fn drop(&mut self) {
477 }
480}
481
482struct PoolInner {
484 global_semaphore: Option<Arc<Semaphore>>,
486 per_origin: RwLock<HashMap<OriginKey, Arc<PerOriginSemaphore>>>,
494 config: PoolConfig,
496 metrics: PoolMetrics,
498}
499
500struct PerOriginSemaphore {
505 semaphore: Arc<Semaphore>,
506 waiters: AtomicUsize,
507}
508
509impl PerOriginSemaphore {
510 fn new(max_per_origin: usize) -> Self {
511 Self {
512 semaphore: Arc::new(Semaphore::new(max_per_origin)),
513 waiters: AtomicUsize::new(0),
514 }
515 }
516}
517
518struct WaiterGuard {
525 entry: Arc<PerOriginSemaphore>,
526}
527
528impl WaiterGuard {
529 fn from_registered(entry: Arc<PerOriginSemaphore>) -> Self {
532 Self { entry }
533 }
534}
535
536impl Drop for WaiterGuard {
537 fn drop(&mut self) {
538 self.entry.waiters.fetch_sub(1, Ordering::AcqRel);
539 }
540}
541
542#[derive(Clone)]
559pub struct Pool {
560 inner: Arc<PoolInner>,
561}
562
563impl PoolInner {
564 fn lookup_or_create_registered(
574 &self,
575 origin: &OriginKey,
576 max_per_origin: usize,
577 ) -> Result<(Arc<PerOriginSemaphore>, WaiterGuard)> {
578 {
580 let table = self
581 .per_origin
582 .read()
583 .map_err(|_| Error::Pool("per-origin table lock poisoned".to_owned()))?;
584 if let Some(entry) = table.get(origin).cloned() {
585 entry.waiters.fetch_add(1, Ordering::AcqRel);
586 let guard = WaiterGuard::from_registered(Arc::clone(&entry));
587 return Ok((entry, guard));
588 }
589 }
590 {
592 let mut table = self
593 .per_origin
594 .write()
595 .map_err(|_| Error::Pool("per-origin table lock poisoned".to_owned()))?;
596 if let Some(entry) = table.get(origin).cloned() {
597 entry.waiters.fetch_add(1, Ordering::AcqRel);
598 let guard = WaiterGuard::from_registered(Arc::clone(&entry));
599 return Ok((entry, guard));
600 }
601 table.retain(|_, entry| {
602 entry.semaphore.available_permits() < max_per_origin
603 || entry.waiters.load(Ordering::Acquire) > 0
604 });
605 let entry = Arc::new(PerOriginSemaphore::new(max_per_origin));
606 entry.waiters.fetch_add(1, Ordering::AcqRel);
607 let guard = WaiterGuard::from_registered(Arc::clone(&entry));
608 table.insert(origin.clone(), Arc::clone(&entry));
609 Ok((entry, guard))
610 }
611 }
612
613 #[cfg(any(test, feature = "test-util"))]
614 #[allow(dead_code, reason = "test hook for pool-table assertions")]
615 fn per_origin_len_for_test(&self) -> usize {
616 self.per_origin.read().map_or(0, |t| t.len())
617 }
618
619 #[cfg(any(test, feature = "test-util"))]
620 #[allow(dead_code, reason = "test hook for pool-table assertions")]
621 fn per_origin_is_empty_for_test(&self) -> bool {
622 self.per_origin.read().map_or(true, |t| t.is_empty())
623 }
624
625 #[cfg(any(test, feature = "test-util"))]
626 #[allow(dead_code, reason = "test hook for pool-table assertions")]
627 fn per_origin_contains_for_test(&self, origin: &OriginKey) -> bool {
628 self.per_origin.read().is_ok_and(|t| t.contains_key(origin))
629 }
630
631 #[cfg(any(test, feature = "test-util"))]
632 #[allow(dead_code, reason = "test hook for pool-table assertions")]
633 fn per_origin_get_for_test(&self, origin: &OriginKey) -> Option<Arc<PerOriginSemaphore>> {
634 self.per_origin
635 .read()
636 .ok()
637 .and_then(|t| t.get(origin).cloned())
638 }
639}
640
641impl Pool {
642 #[must_use]
644 pub fn new(config: PoolConfig) -> Self {
645 let global_semaphore = config
646 .effective_max_in_flight()
647 .map(|n| Arc::new(Semaphore::new(n)));
648
649 Self {
650 inner: Arc::new(PoolInner {
651 global_semaphore,
652 per_origin: RwLock::new(HashMap::new()),
653 config,
654 metrics: PoolMetrics::default(),
655 }),
656 }
657 }
658
659 #[must_use]
665 pub(crate) fn idle_timeout(&self) -> Option<std::time::Duration> {
666 self.inner.config.idle_timeout
667 }
668
669 #[must_use]
676 pub(crate) fn max_idle_per_host(&self) -> Option<usize> {
677 self.inner.config.effective_max_idle_per_host()
678 }
679
680 pub(crate) async fn acquire(&self, origin: Option<&OriginKey>) -> Result<PoolGuard> {
693 let mut waited = false;
694 let mut global_permit: Option<OwnedSemaphorePermit> = None;
695 let mut origin_permit: Option<OwnedSemaphorePermit> = None;
696
697 if let Some(ref sem) = self.inner.global_semaphore {
700 if let Ok(permit) = sem.clone().try_acquire_owned() {
701 global_permit = Some(permit);
702 } else if let Ok(permit) = sem.clone().acquire_owned().await {
703 global_permit = Some(permit);
704 waited = true;
705 } else {
706 self.inner
707 .metrics
708 .acquisition_cancellations
709 .fetch_add(1, Ordering::Relaxed);
710 return Err(Error::Pool("global semaphore is closed".into()));
711 }
712 }
713
714 if let (Some(max_per_origin), Some(origin)) = (
717 self.inner.config.effective_max_in_flight_per_origin(),
718 origin,
719 ) {
720 let (entry, mut waiter_guard) = match self
729 .inner
730 .lookup_or_create_registered(origin, max_per_origin)
731 {
732 Ok(registered) => (registered.0, Some(registered.1)),
733 Err(e) => {
734 self.inner
735 .metrics
736 .acquisition_cancellations
737 .fetch_add(1, Ordering::Relaxed);
738 drop(global_permit);
739 return Err(e);
740 }
741 };
742 if let Ok(permit) = entry.semaphore.clone().try_acquire_owned() {
746 waiter_guard.take();
747 origin_permit = Some(permit);
748 } else {
749 let permit = entry.semaphore.clone().acquire_owned().await;
750 waiter_guard.take();
751 if let Ok(permit) = permit {
752 origin_permit = Some(permit);
753 waited = true;
754 } else {
755 self.inner
756 .metrics
757 .acquisition_cancellations
758 .fetch_add(1, Ordering::Relaxed);
759 drop(global_permit);
760 return Err(Error::Pool("per-origin semaphore is closed".into()));
761 }
762 }
763 }
764
765 if waited {
766 self.inner
767 .metrics
768 .acquisition_waits
769 .fetch_add(1, Ordering::Relaxed);
770 }
771
772 Ok(PoolGuard::new(
773 self.inner.clone(),
774 origin.cloned(),
775 global_permit,
776 origin_permit,
777 ))
778 }
779
780 #[must_use]
782 pub fn metrics(&self) -> &PoolMetrics {
783 &self.inner.metrics
784 }
785}
786
787#[cfg(test)]
788mod tests {
789 use super::*;
790
791 #[test]
792 fn default_config_has_no_limits() {
793 let config = PoolConfig::default();
794 assert!(config.max_idle_connections.is_none());
795 assert!(config.max_idle_connections_per_host.is_none());
796 assert!(config.max_connections.is_none());
797 assert!(config.max_connections_per_host.is_none());
798 assert!(config.max_in_flight_requests.is_none());
799 assert!(config.max_in_flight_requests_per_origin.is_none());
800 assert!(config.idle_timeout.is_none());
801 }
802
803 #[test]
804 fn effective_limits_prefer_new_names() {
805 let config = PoolConfig {
806 max_connections: Some(10),
807 max_in_flight_requests: Some(7),
808 max_connections_per_host: Some(5),
809 max_in_flight_requests_per_origin: Some(3),
810 ..PoolConfig::default()
811 };
812 assert_eq!(config.effective_max_in_flight(), Some(7));
813 assert_eq!(config.effective_max_in_flight_per_origin(), Some(3));
814 }
815
816 #[test]
817 fn effective_limits_fall_back_to_aliases() {
818 let config = PoolConfig {
819 max_connections: Some(10),
820 max_connections_per_host: Some(5),
821 ..PoolConfig::default()
822 };
823 assert_eq!(config.effective_max_in_flight(), Some(10));
824 assert_eq!(config.effective_max_in_flight_per_origin(), Some(5));
825 }
826
827 #[test]
828 fn effective_idle_cap_prefers_per_host() {
829 let config = PoolConfig {
830 max_idle_connections: Some(20),
831 max_idle_connections_per_host: Some(7),
832 ..PoolConfig::default()
833 };
834 assert_eq!(config.effective_max_idle_per_host(), Some(7));
835 let pool = Pool::new(config);
836 assert_eq!(pool.max_idle_per_host(), Some(7));
837 }
838
839 #[test]
840 fn effective_idle_cap_falls_back_to_global() {
841 let config = PoolConfig {
842 max_idle_connections: Some(20),
843 ..PoolConfig::default()
844 };
845 assert_eq!(config.effective_max_idle_per_host(), Some(20));
846 let pool = Pool::new(config);
847 assert_eq!(pool.max_idle_per_host(), Some(20));
848 }
849
850 #[test]
851 fn effective_idle_cap_absent_when_unset() {
852 let pool = Pool::new(PoolConfig::default());
853 assert_eq!(pool.max_idle_per_host(), None);
854 assert_eq!(pool.idle_timeout(), None);
855 }
856
857 #[tokio::test]
858 async fn new_names_enforce_logical_concurrency() {
859 let pool = Pool::new(PoolConfig {
862 max_in_flight_requests_per_origin: Some(1),
863 ..PoolConfig::default()
864 });
865 let origin = OriginKey::from_parts("http", "example.com", 80);
866 let _guard = pool.acquire(Some(&origin)).await.unwrap();
867 assert!(
868 tokio::time::timeout(
869 std::time::Duration::from_millis(10),
870 pool.acquire(Some(&origin))
871 )
872 .await
873 .is_err(),
874 "second logical request must wait while first holds its permit"
875 );
876 }
877
878 #[test]
879 fn pool_constructs_with_defaults() {
880 let pool = Pool::new(PoolConfig::default());
881 assert!(pool.inner.global_semaphore.is_none());
882 assert!(pool.inner.per_origin_is_empty_for_test());
883 }
884
885 #[test]
886 fn pool_constructs_with_global_limit() {
887 let config = PoolConfig {
888 max_connections: Some(10),
889 ..Default::default()
890 };
891 let pool = Pool::new(config);
892 assert!(pool.inner.global_semaphore.is_some());
893 }
894
895 #[test]
896 fn pool_metrics_starts_zeroed() {
897 let pool = Pool::new(PoolConfig::default());
898 let metrics = pool.metrics();
899 assert_eq!(metrics.acquisition_waits.load(Ordering::Relaxed), 0);
900 assert_eq!(metrics.acquisition_cancellations.load(Ordering::Relaxed), 0);
901 }
902
903 #[tokio::test]
904 async fn acquire_without_limits_returns_immediately() {
905 let pool = Pool::new(PoolConfig::default());
906 let guard = pool.acquire(None).await.unwrap();
907 assert!(guard.origin().is_none());
908 }
909
910 #[tokio::test]
911 async fn acquire_with_global_limit() {
912 let config = PoolConfig {
913 max_connections: Some(2),
914 ..Default::default()
915 };
916 let pool = Pool::new(config);
917
918 let origin = OriginKey::from_parts("http", "example.com", 80);
919 let g1 = pool.acquire(Some(&origin)).await.unwrap();
920 let g2 = pool.acquire(Some(&origin)).await.unwrap();
921
922 assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 0);
924
925 drop(g1);
926 drop(g2);
927 }
928
929 #[tokio::test]
930 async fn acquire_with_per_origin_limit() {
931 let config = PoolConfig {
932 max_connections_per_host: Some(1),
933 ..Default::default()
934 };
935 let pool = Pool::new(config);
936
937 let origin = OriginKey::from_parts("http", "example.com", 80);
938 let g1 = pool.acquire(Some(&origin)).await.unwrap();
939 assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 0);
940
941 drop(g1);
942 }
943
944 #[tokio::test]
945 async fn closed_semaphores_count_cancellation_without_a_wait() {
946 let global_pool = Pool::new(PoolConfig {
947 max_connections: Some(1),
948 ..Default::default()
949 });
950 let global_guard = global_pool.acquire(None).await.unwrap();
951 global_pool.inner.global_semaphore.as_ref().unwrap().close();
952 assert!(global_pool.acquire(None).await.is_err());
953 assert_eq!(
954 global_pool
955 .metrics()
956 .acquisition_waits
957 .load(Ordering::Relaxed),
958 0
959 );
960 assert_eq!(
961 global_pool
962 .metrics()
963 .acquisition_cancellations
964 .load(Ordering::Relaxed),
965 1
966 );
967 drop(global_guard);
968
969 let origin_pool = Pool::new(PoolConfig {
970 max_connections_per_host: Some(1),
971 ..Default::default()
972 });
973 let origin = OriginKey::from_parts("http", "example.com", 80);
974 let origin_guard = origin_pool.acquire(Some(&origin)).await.unwrap();
975 origin_pool
976 .inner
977 .per_origin_get_for_test(&origin)
978 .unwrap()
979 .semaphore
980 .close();
981 assert!(origin_pool.acquire(Some(&origin)).await.is_err());
982 assert_eq!(
983 origin_pool
984 .metrics()
985 .acquisition_waits
986 .load(Ordering::Relaxed),
987 0
988 );
989 assert_eq!(
990 origin_pool
991 .metrics()
992 .acquisition_cancellations
993 .load(Ordering::Relaxed),
994 1
995 );
996 drop(origin_guard);
997 }
998
999 #[test]
1000 fn pool_is_clone() {
1001 let pool = Pool::new(PoolConfig::default());
1002 let pool2 = pool.clone();
1003 assert!(Arc::ptr_eq(&pool.inner, &pool2.inner));
1005 }
1006
1007 #[tokio::test]
1008 async fn acquire_per_origin_limit_separate_origins() {
1009 let config = PoolConfig {
1010 max_connections_per_host: Some(1),
1011 ..Default::default()
1012 };
1013 let pool = Pool::new(config);
1014 let o1 = OriginKey::from_parts("http", "host-a", 80);
1015 let o2 = OriginKey::from_parts("http", "host-b", 80);
1016 let g1 = pool.acquire(Some(&o1)).await.unwrap();
1017 let g2 = pool.acquire(Some(&o2)).await.unwrap();
1018 assert!(g1.origin().is_some());
1019 assert!(g2.origin().is_some());
1020 drop(g1);
1021 drop(g2);
1022 }
1023
1024 #[cfg(feature = "high-level-url")]
1025 #[test]
1026 fn origin_key_from_url_http() {
1027 let url = url::Url::parse("http://example.com:8080/path").unwrap();
1028 let key = OriginKey::from_url("http", &url).unwrap();
1029 assert_eq!(key.scheme(), "http");
1030 assert_eq!(key.host(), "example.com");
1031 assert_eq!(key.port(), 8080);
1032 }
1033
1034 #[cfg(feature = "high-level-url")]
1035 #[test]
1036 fn origin_key_from_url_https_default_port() {
1037 let url = url::Url::parse("https://example.com/path").unwrap();
1038 let key = OriginKey::from_url("https", &url).unwrap();
1039 assert_eq!(key.scheme(), "https");
1040 assert_eq!(key.host(), "example.com");
1041 assert_eq!(key.port(), 443);
1042 }
1043
1044 #[cfg(feature = "high-level-url")]
1045 #[test]
1046 fn origin_key_from_url_http_default_port() {
1047 let url = url::Url::parse("http://example.com/path").unwrap();
1048 let key = OriginKey::from_url("http", &url).unwrap();
1049 assert_eq!(key.scheme(), "http");
1050 assert_eq!(key.port(), 80);
1051 }
1052
1053 #[test]
1054 fn origin_key_from_native_origin() {
1055 let uri: http::Uri = "https://example.com:8443/path".parse().expect("valid URI");
1056 let origin = crate::http_origin::HttpOrigin::from_uri(&uri).expect("native origin parses");
1057 let key = OriginKey::from_origin(&origin);
1058 assert_eq!(key.host(), "example.com");
1059 assert_eq!(key.to_string(), "https://example.com:8443");
1060 assert_eq!(
1062 key,
1063 OriginKey::from_components("https", "example.com", 8443)
1064 );
1065 }
1066
1067 #[test]
1068 fn origin_keys_distinguish_scheme() {
1069 let http = OriginKey::from_parts("http", "example.com", 80);
1070 let https = OriginKey::from_parts("https", "example.com", 443);
1071 assert_ne!(http, https);
1072 }
1073
1074 #[test]
1075 fn origin_keys_distinguish_port() {
1076 let p80 = OriginKey::from_parts("http", "example.com", 80);
1077 let p8080 = OriginKey::from_parts("http", "example.com", 8080);
1078 assert_ne!(p80, p8080);
1079 }
1080
1081 #[test]
1082 fn origin_keys_equal_for_same_origin() {
1083 let a = OriginKey::from_parts("http", "example.com", 80);
1084 let b = OriginKey::from_parts("http", "example.com", 80);
1085 assert_eq!(a, b);
1086 }
1087
1088 #[test]
1089 fn origin_key_display() {
1090 let key = OriginKey::from_parts("https", "example.com", 443);
1091 assert_eq!(key.to_string(), "https://example.com:443");
1092 }
1093
1094 #[tokio::test]
1095 async fn origin_keys_separate_per_origin_map_entries() {
1096 let config = PoolConfig {
1097 max_connections_per_host: Some(1),
1098 ..Default::default()
1099 };
1100 let pool = Pool::new(config);
1101 let a = OriginKey::from_parts("http", "example.com", 80);
1102 let b = OriginKey::from_parts("http", "example.com", 8080);
1103 assert!(pool.acquire(Some(&a)).await.unwrap().origin().is_some());
1104 assert!(pool.acquire(Some(&b)).await.unwrap().origin().is_some());
1105 }
1106
1107 #[test]
1108 fn origin_keys_distinct_by_scheme() {
1109 let http = OriginKey::from_parts("http", "example.com", 443);
1111 let https = OriginKey::from_parts("https", "example.com", 443);
1112 assert_ne!(http, https);
1113 }
1114
1115 #[cfg(feature = "high-level-url")]
1116 #[test]
1117 fn origin_key_from_url_uses_scheme_default_port() {
1118 let explicit = url::Url::parse("http://example.com:8080/path").unwrap();
1120 let default = url::Url::parse("http://example.com/path").unwrap();
1121 let k_explicit = OriginKey::from_url("http", &explicit).unwrap();
1122 let k_default = OriginKey::from_url("http", &default).unwrap();
1123 assert_eq!(k_explicit.port(), 8080);
1124 assert_eq!(k_default.port(), 80);
1125 }
1126
1127 #[test]
1128 fn origin_key_direct_has_no_proxy() {
1129 let key = OriginKey::from_parts("http", "example.com", 80);
1130 assert!(key.proxy_host().is_none());
1131 assert!(key.proxy_port().is_none());
1132 assert!(!key.is_tunnel());
1133 }
1134
1135 #[cfg(feature = "proxy")]
1136 #[test]
1137 fn origin_key_proxy_a_not_equal_proxy_b() {
1138 let url = url::Url::parse("http://example.com/path").unwrap();
1139 let a = OriginKey::from_url_with_proxy_scheme(
1140 "http",
1141 &url,
1142 Some("proxy-a"),
1143 Some(8080),
1144 None,
1145 false,
1146 )
1147 .unwrap();
1148 let b = OriginKey::from_url_with_proxy_scheme(
1149 "http",
1150 &url,
1151 Some("proxy-b"),
1152 Some(8080),
1153 None,
1154 false,
1155 )
1156 .unwrap();
1157 assert_ne!(a, b);
1158 }
1159
1160 #[cfg(feature = "proxy")]
1161 #[test]
1162 fn origin_key_tunnel_not_equal_non_tunnel() {
1163 let url = url::Url::parse("http://example.com/path").unwrap();
1164 let tunnel = OriginKey::from_url_with_proxy_scheme(
1165 "http",
1166 &url,
1167 Some("proxy"),
1168 Some(8080),
1169 None,
1170 true,
1171 )
1172 .unwrap();
1173 let direct = OriginKey::from_url_with_proxy_scheme(
1174 "http",
1175 &url,
1176 Some("proxy"),
1177 Some(8080),
1178 None,
1179 false,
1180 )
1181 .unwrap();
1182 assert_ne!(tunnel, direct);
1183 }
1184
1185 #[cfg(feature = "proxy")]
1186 #[test]
1187 fn origin_key_proxy_same_route_equal() {
1188 let url = url::Url::parse("http://example.com/path").unwrap();
1189 let a = OriginKey::from_url_with_proxy_scheme(
1190 "http",
1191 &url,
1192 Some("proxy"),
1193 Some(8080),
1194 None,
1195 false,
1196 )
1197 .unwrap();
1198 let b = OriginKey::from_url_with_proxy_scheme(
1199 "http",
1200 &url,
1201 Some("proxy"),
1202 Some(8080),
1203 None,
1204 false,
1205 )
1206 .unwrap();
1207 assert_eq!(a, b);
1208 }
1209
1210 #[cfg(feature = "proxy")]
1211 #[test]
1212 fn origin_key_parts_preserves_proxy_scheme() {
1213 let http = OriginKey::from_parts_with_proxy(
1214 "https",
1215 "example.com",
1216 443,
1217 Some("proxy"),
1218 Some(8080),
1219 Some("http"),
1220 true,
1221 );
1222 let https = OriginKey::from_parts_with_proxy(
1223 "https",
1224 "example.com",
1225 443,
1226 Some("proxy"),
1227 Some(8080),
1228 Some("https"),
1229 true,
1230 );
1231 assert_ne!(http, https);
1232 assert_eq!(
1233 http.to_string(),
1234 "https://example.com:443 via http://proxy:8080 tunnel"
1235 );
1236 }
1237
1238 #[cfg(feature = "proxy")]
1239 #[test]
1240 fn origin_key_display_with_proxy() {
1241 let url = url::Url::parse("https://example.com/path").unwrap();
1242 let key = OriginKey::from_url_with_proxy_scheme(
1243 "https",
1244 &url,
1245 Some("proxy"),
1246 Some(8080),
1247 None,
1248 true,
1249 )
1250 .unwrap();
1251 assert_eq!(
1252 key.to_string(),
1253 "https://example.com:443 via proxy:8080 tunnel"
1254 );
1255 }
1256
1257 #[cfg(feature = "proxy")]
1258 #[test]
1259 fn origin_key_display_without_tunnel() {
1260 let url = url::Url::parse("http://example.com/path").unwrap();
1261 let key = OriginKey::from_url_with_proxy_scheme(
1262 "http",
1263 &url,
1264 Some("proxy"),
1265 Some(8080),
1266 None,
1267 false,
1268 )
1269 .unwrap();
1270 assert_eq!(key.to_string(), "http://example.com:80 via proxy:8080");
1271 }
1272
1273 #[cfg(feature = "proxy")]
1274 #[tokio::test]
1275 async fn proxy_route_separate_from_direct() {
1276 let config = PoolConfig {
1277 max_connections_per_host: Some(1),
1278 ..Default::default()
1279 };
1280 let pool = Pool::new(config);
1281 let direct = OriginKey::from_parts("http", "example.com", 80);
1282 let proxied = OriginKey::from_parts_with_proxy(
1283 "http",
1284 "example.com",
1285 80,
1286 Some("proxy"),
1287 Some(8080),
1288 None,
1289 false,
1290 );
1291 let g1 = pool.acquire(Some(&direct)).await.unwrap();
1292 let g2 = pool.acquire(Some(&proxied)).await.unwrap();
1293 assert!(g1.origin().is_some());
1294 assert!(g2.origin().is_some());
1295 }
1296
1297 #[tokio::test]
1298 async fn global_wait_does_not_hold_per_origin_slot() {
1299 let pool = Pool::new(PoolConfig {
1300 max_connections: Some(1),
1301 max_connections_per_host: Some(1),
1302 ..Default::default()
1303 });
1304 let first_origin = OriginKey::from_parts("http", "first.example", 80);
1305 let waiting_origin = OriginKey::from_parts("http", "waiting.example", 80);
1306 let first = pool.acquire(Some(&first_origin)).await.unwrap();
1307
1308 let pool_for_task = pool.clone();
1309 let waiting_origin_for_task = waiting_origin.clone();
1310 let waiter =
1311 tokio::spawn(
1312 async move { pool_for_task.acquire(Some(&waiting_origin_for_task)).await },
1313 );
1314 for _ in 0..3 {
1315 tokio::task::yield_now().await;
1316 }
1317
1318 assert!(!pool.inner.per_origin_contains_for_test(&waiting_origin));
1319 drop(first);
1320 drop(waiter.await.unwrap().unwrap());
1321 }
1322
1323 #[tokio::test]
1324 async fn idle_per_origin_entries_are_swept_on_acquire() {
1325 let pool = Pool::new(PoolConfig {
1326 max_connections_per_host: Some(1),
1327 ..Default::default()
1328 });
1329
1330 for index in 0..8 {
1331 let origin = OriginKey::from_parts("http", &format!("host-{index}.example"), 80);
1332 drop(pool.acquire(Some(&origin)).await.unwrap());
1333 }
1334
1335 assert!(pool.inner.per_origin_len_for_test() <= 8);
1342 if std::env::var("EGGFETCH_STRICT_POOL_EVICTION").is_ok() {
1346 assert!(pool.inner.per_origin_len_for_test() <= 1);
1347 }
1348 }
1349
1350 #[cfg(feature = "proxy")]
1351 #[tokio::test]
1352 async fn tunnel_separate_from_non_tunnel() {
1353 let config = PoolConfig {
1354 max_connections_per_host: Some(1),
1355 ..Default::default()
1356 };
1357 let pool = Pool::new(config);
1358 let http_fwd = OriginKey::from_parts_with_proxy(
1359 "http",
1360 "example.com",
1361 80,
1362 Some("proxy"),
1363 Some(8080),
1364 None,
1365 false,
1366 );
1367 let https_tunnel = OriginKey::from_parts_with_proxy(
1368 "http",
1369 "example.com",
1370 80,
1371 Some("proxy"),
1372 Some(8080),
1373 None,
1374 true,
1375 );
1376 let g1 = pool.acquire(Some(&http_fwd)).await.unwrap();
1377 let g2 = pool.acquire(Some(&https_tunnel)).await.unwrap();
1378 assert!(g1.origin().is_some());
1379 assert!(g2.origin().is_some());
1380 }
1381
1382 #[cfg(feature = "proxy")]
1383 #[tokio::test]
1384 async fn different_proxies_separate_semaphores() {
1385 let config = PoolConfig {
1386 max_connections_per_host: Some(1),
1387 ..Default::default()
1388 };
1389 let pool = Pool::new(config);
1390 let a = OriginKey::from_parts_with_proxy(
1391 "http",
1392 "example.com",
1393 80,
1394 Some("proxy-a"),
1395 Some(8080),
1396 None,
1397 false,
1398 );
1399 let b = OriginKey::from_parts_with_proxy(
1400 "http",
1401 "example.com",
1402 80,
1403 Some("proxy-b"),
1404 Some(8080),
1405 None,
1406 false,
1407 );
1408 let g1 = pool.acquire(Some(&a)).await.unwrap();
1409 let g2 = pool.acquire(Some(&b)).await.unwrap();
1410 assert!(g1.origin().is_some());
1411 assert!(g2.origin().is_some());
1412 }
1413
1414 #[tokio::test]
1415 async fn same_origin_concurrency_never_exceeds_limit() {
1416 use std::sync::atomic::AtomicUsize;
1417
1418 let pool = Pool::new(PoolConfig {
1419 max_connections_per_host: Some(3),
1420 ..Default::default()
1421 });
1422 let origin = OriginKey::from_parts("http", "hot.example", 80);
1423 let current = Arc::new(AtomicUsize::new(0));
1424 let max_seen = Arc::new(AtomicUsize::new(0));
1425 let mut handles = Vec::new();
1426 for _ in 0..12 {
1427 let pool = pool.clone();
1428 let origin = origin.clone();
1429 let current = current.clone();
1430 let max_seen = max_seen.clone();
1431 handles.push(tokio::spawn(async move {
1432 let _guard = pool.acquire(Some(&origin)).await.unwrap();
1433 let n = current.fetch_add(1, Ordering::AcqRel) + 1;
1434 max_seen.fetch_max(n, Ordering::AcqRel);
1435 tokio::task::yield_now().await;
1436 current.fetch_sub(1, Ordering::AcqRel);
1437 }));
1438 }
1439 for h in handles {
1440 h.await.unwrap();
1441 }
1442 assert!(
1443 max_seen.load(Ordering::Acquire) <= 3,
1444 "same-origin concurrency exceeded the per-origin limit"
1445 );
1446 }
1447
1448 #[tokio::test]
1449 async fn cancellation_releases_waiter_registration() {
1450 let pool = Pool::new(PoolConfig {
1451 max_connections_per_host: Some(1),
1452 ..Default::default()
1453 });
1454 let origin = OriginKey::from_parts("http", "cancel.example", 80);
1455 let _holder = pool.acquire(Some(&origin)).await.unwrap();
1456 let timed_out = tokio::time::timeout(
1457 std::time::Duration::from_millis(20),
1458 pool.acquire(Some(&origin)),
1459 )
1460 .await;
1461 assert!(timed_out.is_err(), "waiter should have timed out");
1462 let entry = pool.inner.per_origin_get_for_test(&origin).unwrap();
1463 assert_eq!(
1464 entry.waiters.load(Ordering::Acquire),
1465 0,
1466 "cancelled waiter must release its registration"
1467 );
1468 }
1469
1470 #[tokio::test]
1471 async fn repeated_cancellation_does_not_wedge_origin() {
1472 let pool = Pool::new(PoolConfig {
1473 max_connections_per_host: Some(1),
1474 ..Default::default()
1475 });
1476 let origin = OriginKey::from_parts("http", "wedge.example", 80);
1477 for _ in 0..10 {
1478 let holder = pool.acquire(Some(&origin)).await.unwrap();
1479 let timed_out = tokio::time::timeout(
1480 std::time::Duration::from_millis(10),
1481 pool.acquire(Some(&origin)),
1482 )
1483 .await;
1484 assert!(timed_out.is_err());
1485 drop(holder);
1486 }
1487 let _guard = tokio::time::timeout(
1490 std::time::Duration::from_secs(2),
1491 pool.acquire(Some(&origin)),
1492 )
1493 .await
1494 .unwrap()
1495 .unwrap();
1496 let entry = pool.inner.per_origin_get_for_test(&origin).unwrap();
1497 assert_eq!(entry.waiters.load(Ordering::Acquire), 0);
1498 }
1499
1500 #[tokio::test]
1501 async fn live_permit_blocks_eviction_on_churn() {
1502 let pool = Pool::new(PoolConfig {
1503 max_connections_per_host: Some(1),
1504 ..Default::default()
1505 });
1506 let pinned = OriginKey::from_parts("http", "pinned.example", 80);
1507 let _holder = pool.acquire(Some(&pinned)).await.unwrap();
1508 for index in 0..16 {
1509 let origin = OriginKey::from_parts("http", &format!("churn-{index}.example"), 80);
1510 drop(pool.acquire(Some(&origin)).await.unwrap());
1511 }
1512 assert!(
1513 pool.inner.per_origin_contains_for_test(&pinned),
1514 "entry with a live permit must not be evicted"
1515 );
1516 assert!(
1518 tokio::time::timeout(
1519 std::time::Duration::from_millis(10),
1520 pool.acquire(Some(&pinned))
1521 )
1522 .await
1523 .is_err(),
1524 "pinned origin must still enforce its per-origin limit"
1525 );
1526 }
1527
1528 #[tokio::test]
1529 async fn registered_waiter_blocks_eviction_on_churn() {
1530 let pool = Pool::new(PoolConfig {
1531 max_connections_per_host: Some(1),
1532 ..Default::default()
1533 });
1534 let origin = OriginKey::from_parts("http", "waited.example", 80);
1535 let holder = pool.acquire(Some(&origin)).await.unwrap();
1536 let pool_for_task = pool.clone();
1537 let origin_for_task = origin.clone();
1538 let waiter =
1539 tokio::spawn(async move { pool_for_task.acquire(Some(&origin_for_task)).await });
1540 let mut registered = false;
1542 for _ in 0..200 {
1543 tokio::task::yield_now().await;
1544 if let Some(entry) = pool.inner.per_origin_get_for_test(&origin) {
1545 if entry.waiters.load(Ordering::Acquire) == 1 {
1546 registered = true;
1547 break;
1548 }
1549 }
1550 }
1551 assert!(registered, "waiter must register before churn");
1552 for index in 0..16 {
1553 let churn = OriginKey::from_parts("http", &format!("churn-w-{index}.example"), 80);
1554 drop(pool.acquire(Some(&churn)).await.unwrap());
1555 }
1556 assert!(
1557 pool.inner.per_origin_contains_for_test(&origin),
1558 "entry with a registered waiter must not be evicted"
1559 );
1560 drop(holder);
1561 let guard = tokio::time::timeout(std::time::Duration::from_secs(2), waiter)
1562 .await
1563 .unwrap()
1564 .unwrap()
1565 .unwrap();
1566 drop(guard);
1567 }
1568
1569 #[tokio::test]
1570 async fn concurrent_missing_origin_creation_shares_one_semaphore() {
1571 use tokio::sync::Barrier;
1572
1573 let pool = Pool::new(PoolConfig {
1574 max_connections_per_host: Some(3),
1575 ..Default::default()
1576 });
1577 let origin = OriginKey::from_parts("http", "race.example", 80);
1578 let barrier = Arc::new(Barrier::new(16));
1582 let mut handles = Vec::new();
1583 for _ in 0..16 {
1584 let pool = pool.clone();
1585 let origin = origin.clone();
1586 let barrier = barrier.clone();
1587 handles.push(tokio::spawn(async move {
1588 barrier.wait().await;
1589 let (entry, guard) = pool.inner.lookup_or_create_registered(&origin, 3).unwrap();
1590 let ptr = Arc::as_ptr(&entry) as usize;
1591 drop(guard);
1592 ptr
1593 }));
1594 }
1595 let mut ptrs = Vec::new();
1596 for h in handles {
1597 ptrs.push(h.await.unwrap());
1598 }
1599 assert!(
1600 ptrs.windows(2).all(|w| w[0] == w[1]),
1601 "concurrent creation must share one semaphore allocation"
1602 );
1603 assert_eq!(pool.inner.per_origin_len_for_test(), 1);
1604 }
1605
1606 #[tokio::test]
1607 async fn churn_plus_cancellation_preserves_per_origin_limit() {
1608 use std::sync::atomic::AtomicUsize;
1609
1610 let pool = Pool::new(PoolConfig {
1611 max_connections_per_host: Some(2),
1612 ..Default::default()
1613 });
1614 let hot = OriginKey::from_parts("http", "hot-churn.example", 80);
1615 let current = Arc::new(AtomicUsize::new(0));
1618 let max_seen = Arc::new(AtomicUsize::new(0));
1619 let mut handles = Vec::new();
1620 for index in 0..24 {
1621 let pool = pool.clone();
1622 let hot = hot.clone();
1623 let current = current.clone();
1624 let max_seen = max_seen.clone();
1625 handles.push(tokio::spawn(async move {
1626 if index % 3 == 0 {
1627 let churn = OriginKey::from_parts("http", &format!("mix-{index}.example"), 80);
1628 drop(pool.acquire(Some(&churn)).await.unwrap());
1629 } else if index % 3 == 1 {
1630 let _ = tokio::time::timeout(
1631 std::time::Duration::from_millis(5),
1632 pool.acquire(Some(&hot)),
1633 )
1634 .await;
1635 } else {
1636 let _guard = pool.acquire(Some(&hot)).await.unwrap();
1637 let n = current.fetch_add(1, Ordering::AcqRel) + 1;
1638 max_seen.fetch_max(n, Ordering::AcqRel);
1639 tokio::task::yield_now().await;
1640 current.fetch_sub(1, Ordering::AcqRel);
1641 }
1642 }));
1643 }
1644 for h in handles {
1645 h.await.unwrap();
1646 }
1647 assert!(
1648 max_seen.load(Ordering::Acquire) <= 2,
1649 "churn plus cancellation must not exceed the per-origin limit"
1650 );
1651 let _guard =
1653 tokio::time::timeout(std::time::Duration::from_secs(2), pool.acquire(Some(&hot)))
1654 .await
1655 .unwrap()
1656 .unwrap();
1657 }
1658
1659 #[tokio::test]
1660 async fn pool_metrics_meanings_preserved() {
1661 let pool = Pool::new(PoolConfig {
1663 max_connections_per_host: Some(2),
1664 ..Default::default()
1665 });
1666 let origin = OriginKey::from_parts("http", "metrics.example", 80);
1667 let _g = pool.acquire(Some(&origin)).await.unwrap();
1668 assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 0);
1669 let pool = Pool::new(PoolConfig {
1671 max_connections: Some(1),
1672 ..Default::default()
1673 });
1674 let holder = pool.acquire(None).await.unwrap();
1675 let pool_for_task = pool.clone();
1676 let waiter = tokio::spawn(async move { pool_for_task.acquire(None).await.unwrap() });
1677 tokio::task::yield_now().await;
1678 drop(holder);
1679 drop(waiter.await.unwrap());
1680 assert_eq!(pool.metrics().acquisition_waits.load(Ordering::Relaxed), 1);
1681 assert_eq!(
1682 pool.metrics()
1683 .acquisition_cancellations
1684 .load(Ordering::Relaxed),
1685 0
1686 );
1687 }
1688}