mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
backend-client: route requests through HTTP client factory
This commit is contained in:
@@ -5,6 +5,7 @@ mod default_client;
|
||||
mod error;
|
||||
mod outbound_proxy;
|
||||
mod request;
|
||||
mod route_aware_client_pool;
|
||||
mod transport;
|
||||
|
||||
pub use crate::chatgpt_cloudflare_cookies::with_chatgpt_cloudflare_cookie_store;
|
||||
@@ -36,6 +37,8 @@ pub use crate::request::Request;
|
||||
pub use crate::request::RequestBody;
|
||||
pub use crate::request::RequestCompression;
|
||||
pub use crate::request::Response;
|
||||
pub use crate::route_aware_client_pool::RouteAwareClientPool;
|
||||
pub use crate::route_aware_client_pool::RouteAwareClientPoolError;
|
||||
pub use crate::transport::ByteStream;
|
||||
pub use crate::transport::HttpTransport;
|
||||
pub use crate::transport::ReqwestTransport;
|
||||
|
||||
@@ -12,6 +12,7 @@ use std::sync::Mutex;
|
||||
use std::sync::OnceLock;
|
||||
use std::time::Duration;
|
||||
use std::time::Instant;
|
||||
use tokio::sync::Semaphore;
|
||||
|
||||
use crate::custom_ca::BuildCustomCaTransportError;
|
||||
use crate::custom_ca::build_reqwest_client_with_custom_ca;
|
||||
@@ -25,6 +26,7 @@ use thiserror::Error;
|
||||
const SYSTEM_PROXY_SUCCESS_CACHE_TTL: Duration = Duration::from_secs(60);
|
||||
const SYSTEM_PROXY_UNAVAILABLE_CACHE_TTL: Duration = Duration::from_secs(5);
|
||||
const SYSTEM_PROXY_CACHE_MAX_ENTRIES: usize = 256;
|
||||
static ASYNC_SYSTEM_PROXY_RESOLUTION_PERMIT: Semaphore = Semaphore::const_new(1);
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod macos;
|
||||
@@ -102,7 +104,7 @@ pub enum OutboundProxyPolicy {
|
||||
///
|
||||
/// `TransportDefault` delegates environment-proxy handling to the underlying transport. Proxy
|
||||
/// URLs are intentionally redacted from `Debug` output because they may contain credentials.
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
#[derive(Clone, Hash, PartialEq, Eq)]
|
||||
pub enum OutboundProxyRoute {
|
||||
/// Preserve the underlying transport's existing proxy behavior.
|
||||
TransportDefault,
|
||||
@@ -159,6 +161,33 @@ impl HttpClientFactory {
|
||||
)
|
||||
}
|
||||
|
||||
/// Resolves the proxy route for a concrete destination without blocking a Tokio worker.
|
||||
pub async fn resolve_proxy_route_async(
|
||||
&self,
|
||||
request_url: String,
|
||||
) -> io::Result<OutboundProxyRoute> {
|
||||
if matches!(
|
||||
self.outbound_proxy_policy,
|
||||
OutboundProxyPolicy::ReqwestDefault
|
||||
) {
|
||||
return Ok(OutboundProxyRoute::TransportDefault);
|
||||
}
|
||||
|
||||
let permit = ASYNC_SYSTEM_PROXY_RESOLUTION_PERMIT
|
||||
.acquire()
|
||||
.await
|
||||
.map_err(io::Error::other)?;
|
||||
let factory = self.clone();
|
||||
tokio::task::spawn_blocking(move || {
|
||||
// Keep the permit with the blocking task: cancelling the caller must not allow a
|
||||
// second PAC/WinHTTP lookup to start while this one is still running.
|
||||
let _permit = permit;
|
||||
factory.resolve_proxy_route(&request_url)
|
||||
})
|
||||
.await
|
||||
.map_err(io::Error::other)
|
||||
}
|
||||
|
||||
/// Builds an HTTP client for a concrete outbound route.
|
||||
pub fn build_client(
|
||||
&self,
|
||||
@@ -183,6 +212,22 @@ impl HttpClientFactory {
|
||||
self.outbound_proxy_policy,
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn build_reqwest_client_for_resolved_route(
|
||||
&self,
|
||||
builder: reqwest::ClientBuilder,
|
||||
route_class: ClientRouteClass,
|
||||
route: &OutboundProxyRoute,
|
||||
) -> Result<reqwest::Client, BuildRouteAwareHttpClientError> {
|
||||
let builder = match route {
|
||||
OutboundProxyRoute::TransportDefault => builder,
|
||||
OutboundProxyRoute::Direct => builder.no_proxy(),
|
||||
OutboundProxyRoute::Proxy { url } => {
|
||||
configure_concrete_proxy(builder, route_class, url, /*no_proxy*/ None)?
|
||||
}
|
||||
};
|
||||
build_reqwest_client_with_custom_ca(builder).map_err(Into::into)
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_proxy_route(
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
use std::collections::HashMap;
|
||||
use std::fmt;
|
||||
use std::io;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
|
||||
use crate::BuildRouteAwareHttpClientError;
|
||||
use crate::ClientRouteClass;
|
||||
use crate::HttpClient;
|
||||
use crate::HttpClientFactory;
|
||||
use crate::OutboundProxyRoute;
|
||||
use crate::with_chatgpt_cloudflare_cookie_store;
|
||||
|
||||
const MAX_CACHED_ROUTES: usize = 16;
|
||||
|
||||
/// Reuses reqwest clients by resolved route while evaluating the exact URL of every request.
|
||||
///
|
||||
/// PAC and system-proxy selection remains request-specific, but requests that resolve to the same
|
||||
/// direct or proxy route share one connection pool. Named constructors apply transport-wide
|
||||
/// settings such as the ChatGPT Cloudflare cookie store without exposing reqwest to callers.
|
||||
#[derive(Clone)]
|
||||
pub struct RouteAwareClientPool {
|
||||
http_client_factory: HttpClientFactory,
|
||||
route_class: ClientRouteClass,
|
||||
builder_factory: Arc<dyn Fn() -> reqwest::ClientBuilder + Send + Sync>,
|
||||
clients: Arc<Mutex<HashMap<OutboundProxyRoute, HttpClient>>>,
|
||||
}
|
||||
|
||||
impl fmt::Debug for RouteAwareClientPool {
|
||||
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
formatter
|
||||
.debug_struct("RouteAwareClientPool")
|
||||
.field("http_client_factory", &self.http_client_factory)
|
||||
.field("route_class", &self.route_class)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
/// Error returned when selecting a route or constructing its pooled HTTP client.
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum RouteAwareClientPoolError {
|
||||
#[error("failed to resolve the outbound proxy route: {0}")]
|
||||
Resolve(#[source] io::Error),
|
||||
#[error(transparent)]
|
||||
Build(#[from] BuildRouteAwareHttpClientError),
|
||||
}
|
||||
|
||||
impl RouteAwareClientPool {
|
||||
/// Creates a pool with the shared default HTTP transport settings.
|
||||
pub fn new(http_client_factory: HttpClientFactory, route_class: ClientRouteClass) -> Self {
|
||||
Self::with_builder_factory(http_client_factory, route_class, reqwest::Client::builder)
|
||||
}
|
||||
|
||||
/// Creates a pool that retains the Cloudflare cookies required by ChatGPT endpoints.
|
||||
pub fn with_chatgpt_cloudflare_cookies(
|
||||
http_client_factory: HttpClientFactory,
|
||||
route_class: ClientRouteClass,
|
||||
) -> Self {
|
||||
Self::with_builder_factory(http_client_factory, route_class, || {
|
||||
with_chatgpt_cloudflare_cookie_store(reqwest::Client::builder())
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn with_builder_factory(
|
||||
http_client_factory: HttpClientFactory,
|
||||
route_class: ClientRouteClass,
|
||||
builder_factory: impl Fn() -> reqwest::ClientBuilder + Send + Sync + 'static,
|
||||
) -> Self {
|
||||
Self {
|
||||
http_client_factory,
|
||||
route_class,
|
||||
builder_factory: Arc::new(builder_factory),
|
||||
clients: Arc::new(Mutex::new(HashMap::new())),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a pooled client configured for the proxy route selected for `request_url`.
|
||||
pub async fn client_for_url(
|
||||
&self,
|
||||
request_url: &str,
|
||||
) -> Result<HttpClient, RouteAwareClientPoolError> {
|
||||
let route = self
|
||||
.http_client_factory
|
||||
.resolve_proxy_route_async(request_url.to_string())
|
||||
.await
|
||||
.map_err(RouteAwareClientPoolError::Resolve)?;
|
||||
let clients = match self.clients.lock() {
|
||||
Ok(clients) => clients,
|
||||
Err(error) => panic!("route-aware client cache lock should not be poisoned: {error}"),
|
||||
};
|
||||
if let Some(client) = clients.get(&route) {
|
||||
return Ok(client.clone());
|
||||
}
|
||||
drop(clients);
|
||||
|
||||
let client = self
|
||||
.http_client_factory
|
||||
.build_reqwest_client_for_resolved_route(
|
||||
(self.builder_factory)(),
|
||||
self.route_class,
|
||||
&route,
|
||||
)?;
|
||||
let client = HttpClient::new(client);
|
||||
let mut clients = match self.clients.lock() {
|
||||
Ok(clients) => clients,
|
||||
Err(error) => panic!("route-aware client cache lock should not be poisoned: {error}"),
|
||||
};
|
||||
if let Some(existing_client) = clients.get(&route) {
|
||||
return Ok(existing_client.clone());
|
||||
}
|
||||
if clients.len() >= MAX_CACHED_ROUTES
|
||||
&& let Some(route_to_evict) = clients.keys().next().cloned()
|
||||
{
|
||||
clients.remove(&route_to_evict);
|
||||
}
|
||||
clients.insert(route, client.clone());
|
||||
Ok(client)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "route_aware_client_pool_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,31 @@
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::AtomicUsize;
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
use pretty_assertions::assert_eq;
|
||||
|
||||
use super::*;
|
||||
use crate::OutboundProxyPolicy;
|
||||
|
||||
#[tokio::test]
|
||||
async fn reuses_client_for_urls_with_the_same_route() {
|
||||
let builder_count = Arc::new(AtomicUsize::new(0));
|
||||
let observed_builder_count = Arc::clone(&builder_count);
|
||||
let pool = RouteAwareClientPool::with_builder_factory(
|
||||
HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),
|
||||
ClientRouteClass::Api,
|
||||
move || {
|
||||
observed_builder_count.fetch_add(1, Ordering::SeqCst);
|
||||
reqwest::Client::builder()
|
||||
},
|
||||
);
|
||||
|
||||
pool.client_for_url("https://example.com/first")
|
||||
.await
|
||||
.expect("first client should build");
|
||||
pool.client_for_url("https://example.com/second")
|
||||
.await
|
||||
.expect("second client should reuse the route");
|
||||
|
||||
assert_eq!(builder_count.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
Reference in New Issue
Block a user