use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};
use std::time::Duration;
use bytes::Bytes;
use futures_util::{StreamExt as _, TryStreamExt as _};
use mlua::{
AnyUserData, ExternalResult, Function, Lua, Table, UserData, UserDataMethods, Value, Variadic,
};
use reqwest::header::{CONTENT_TYPE, HeaderMap, HeaderName, HeaderValue, LOCATION};
use reqwest::{Client as HttpClient, Method as HttpMethod, StatusCode, Url, redirect};
use tracing::Instrument as _;
use crate::config::FetchOptions;
use crate::fetch::budget::{OutboundBudget, traceparent};
use crate::fetch::policy::{ConnectPolicy, GuardedResolver, check_url};
use crate::fetch::response::LuaResponse;
use crate::fetch::retry::{Retry, backoff, is_retryable, parse_retry};
const MAX_REDIRECTS: usize = 5;
#[derive(Clone)]
struct RequestSpec {
method: HttpMethod,
url: Url,
headers: HeaderMap,
body: Option<Bytes>,
timeout: Option<Duration>,
retry: Option<Retry>,
}
impl RequestSpec {
fn is_idempotent(&self) -> bool {
self.retry.is_some_and(|retry| retry.idempotent)
|| matches!(
self.method,
HttpMethod::GET
| HttpMethod::HEAD
| HttpMethod::PUT
| HttpMethod::DELETE
| HttpMethod::OPTIONS
)
}
}
pub(crate) struct LuaFetch {
client: Arc<HttpClient>,
spec: RequestSpec,
opts: Arc<FetchOptions>,
budget: Arc<OutboundBudget>,
}
impl UserData for LuaFetch {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
methods.add_async_method("send", |lua, this, ()| {
let client = this.client.clone();
let spec = this.spec.clone();
let opts = this.opts.clone();
let budget = this.budget.clone();
let doubles = crate::testing::installed(&lua);
async move {
budget.take(opts.max_per_request)?;
if let Some(doubles) = doubles
&& let Some(canned) = mocked(&doubles, &spec, &opts)?
{
return Ok(canned);
}
send_with_retries(&client, spec, &opts).await
}
});
}
}
fn mocked(
doubles: &crate::testing::Doubles,
spec: &RequestSpec,
opts: &FetchOptions,
) -> mlua::Result<Option<LuaResponse>> {
use crate::testing::FetchAnswer;
let headers = spec
.headers
.iter()
.map(|(k, v)| {
(
k.as_str().to_string(),
String::from_utf8_lossy(v.as_bytes()).into_owned(),
)
})
.collect();
let body = spec.body.as_ref().map(|b| b.to_vec());
let answer = doubles
.fetch()?
.answer(spec.method.as_str(), spec.url.as_str(), headers, body);
let canned = match answer {
FetchAnswer::PassThrough => return Ok(None),
FetchAnswer::Refused => {
return Err(mlua::Error::RuntimeError(format!(
"no fetch mock matched {} {} (nitr.test.fetch.strict is on)",
spec.method, spec.url
)));
}
FetchAnswer::Error(message) => {
return Err(mlua::Error::external(crate::testing::MockedFailure(
message,
)));
}
FetchAnswer::Canned(canned) => canned,
};
use reqwest::ResponseBuilderExt as _;
let mut builder = http::Response::builder()
.status(canned.status)
.url(spec.url.clone());
for (name, value) in &canned.headers {
builder = builder.header(name.as_str(), value.as_str());
}
let resp = builder
.body(canned.body)
.map_err(|err| mlua::Error::RuntimeError(format!("invalid fetch mock response: {err}")))?;
Ok(Some(LuaResponse::new(
reqwest::Response::from(resp),
opts.max_response_bytes,
)))
}
async fn send_with_retries(
client: &HttpClient,
spec: RequestSpec,
opts: &FetchOptions,
) -> mlua::Result<LuaResponse> {
let attempts = match spec.retry {
Some(retry) if spec.is_idempotent() => retry.attempts.min(opts.max_retries).max(1),
_ => 1,
};
let exponential = spec.retry.is_none_or(|r| r.exponential);
let mut attempt = 0;
loop {
attempt += 1;
let last = attempt >= attempts;
let reason = match execute(client, spec.clone(), opts).await {
Ok(resp) if last || !is_retryable(resp.status()) => return Ok(resp),
Ok(resp) => format!("upstream answered {}", resp.status()),
Err(err) if last || !is_transient(&err) => return Err(err),
Err(err) => err.to_string(),
};
let delay = backoff(attempt, exponential);
tracing::debug!(
"fetch {} {} failed (attempt {attempt}/{attempts}), retrying in {:?}: {reason}",
spec.method,
spec.url,
delay
);
tokio::time::sleep(delay).await;
}
}
fn is_transient(err: &mlua::Error) -> bool {
if let Some(err) = err.downcast_ref::<reqwest::Error>() {
return !err.is_builder() && !refused_by_policy(err);
}
err.downcast_ref::<std::io::Error>().is_some()
|| err
.downcast_ref::<crate::testing::MockedFailure>()
.is_some()
}
fn refused_by_policy(err: &reqwest::Error) -> bool {
let mut source: Option<&(dyn std::error::Error + 'static)> = Some(err);
while let Some(err) = source {
if err.is::<super::policy::Refused>() {
return true;
}
source = err.source();
}
false
}
async fn execute(
client: &HttpClient,
spec: RequestSpec,
opts: &FetchOptions,
) -> mlua::Result<LuaResponse> {
let RequestSpec {
mut method,
mut url,
mut headers,
mut body,
timeout,
..
} = spec;
let mut hops = 0usize;
loop {
check_url(&url, opts).await?;
let mut builder = client
.request(method.clone(), url.clone())
.headers(headers.clone());
if let Some(bytes) = &body {
builder = builder.body(bytes.clone());
}
if let Some(timeout) = timeout {
builder = builder.timeout(timeout);
}
let span = tracing::debug_span!(
"fetch",
host = %url.host_str().unwrap_or_default(),
method = %method,
status = tracing::field::Empty,
ip = tracing::field::Empty,
elapsed_ms = tracing::field::Empty,
);
let started = std::time::Instant::now();
let sent = builder.send().instrument(span.clone()).await;
span.record("elapsed_ms", started.elapsed().as_millis() as u64);
let resp = sent.into_lua_err()?;
span.record("status", resp.status().as_u16());
if let Some(addr) = resp.remote_addr() {
span.record("ip", tracing::field::display(addr.ip()));
}
if !resp.status().is_redirection() {
return Ok(LuaResponse::new(resp, opts.max_response_bytes));
}
let Some(location) = resp
.headers()
.get(LOCATION)
.and_then(|v| v.to_str().ok())
.map(str::to_owned)
else {
return Ok(LuaResponse::new(resp, opts.max_response_bytes));
};
hops += 1;
if hops > MAX_REDIRECTS {
return Err(mlua::Error::RuntimeError(format!(
"fetch exceeded {MAX_REDIRECTS} redirects for `{url}`"
)));
}
let next = url.join(&location).into_lua_err()?;
if !same_origin(&url, &next) {
strip_sensitive_headers(&mut headers);
}
url = next;
if matches!(
resp.status(),
StatusCode::MOVED_PERMANENTLY | StatusCode::FOUND | StatusCode::SEE_OTHER
) && method != HttpMethod::GET
&& method != HttpMethod::HEAD
{
method = HttpMethod::GET;
body = None;
}
}
}
fn same_origin(a: &Url, b: &Url) -> bool {
a.scheme() == b.scheme()
&& a.host_str().map(str::to_ascii_lowercase) == b.host_str().map(str::to_ascii_lowercase)
&& a.port_or_known_default() == b.port_or_known_default()
}
fn strip_sensitive_headers(headers: &mut HeaderMap) {
use reqwest::header::{AUTHORIZATION, COOKIE, PROXY_AUTHORIZATION, WWW_AUTHENTICATE};
for name in [AUTHORIZATION, COOKIE, PROXY_AUTHORIZATION, WWW_AUTHENTICATE] {
headers.remove(name);
}
}
fn client_for(opts: &FetchOptions) -> mlua::Result<Arc<HttpClient>> {
static CLIENTS: OnceLock<Mutex<HashMap<ConnectPolicy, Arc<HttpClient>>>> = OnceLock::new();
let clients = CLIENTS.get_or_init(|| Mutex::new(HashMap::new()));
let policy = opts.connect_policy();
let mut clients = clients
.lock()
.map_err(|_| mlua::Error::RuntimeError("the fetch client cache is poisoned".into()))?;
if let Some(client) = clients.get(&policy) {
return Ok(client.clone());
}
let _ = rustls::crypto::ring::default_provider().install_default();
let mut builder = HttpClient::builder()
.connect_timeout(policy.connect_timeout)
.timeout(policy.timeout)
.pool_max_idle_per_host(policy.pool_max_idle_per_host)
.redirect(redirect::Policy::none())
.dns_resolver(Arc::new(GuardedResolver::new(
policy.allow_private_networks,
policy.private_hosts.clone(),
)));
if policy.no_proxy {
builder = builder.no_proxy();
}
if let Some(url) = &policy.proxy {
builder = builder.proxy(reqwest::Proxy::all(url.as_str()).map_err(|err| {
mlua::Error::RuntimeError(format!("invalid [fetch] proxy `{url}`: {err}"))
})?);
}
let client = Arc::new(builder.build().into_lua_err()?);
clients.insert(policy, client.clone());
Ok(client)
}
const OPTION_KEYS: &[&str] = &["headers", "query", "json", "body", "timeout", "retry"];
fn parse_spec(method: String, url: String, arg: Option<Table>) -> mlua::Result<RequestSpec> {
let method = HttpMethod::from_bytes(method.to_uppercase().as_bytes()).into_lua_err()?;
let mut url = url.parse::<Url>().into_lua_err()?;
let mut headers = HeaderMap::new();
let mut body = None;
let mut timeout = None;
let mut retry = None;
if let Some(table) = arg {
let is_options = OPTION_KEYS
.iter()
.any(|k| table.contains_key(*k).unwrap_or(false));
if is_options {
if let Some(header_table) = table.get::<Option<Table>>("headers")? {
fill_headers(&mut headers, &header_table)?;
}
if let Some(query) = table.get::<Option<Table>>("query")? {
let mut pairs = url.query_pairs_mut();
for pair in query.pairs::<String, String>() {
let (k, v) = pair?;
pairs.append_pair(&k, &v);
}
}
if let Some(value) = table.get::<Option<Value>>("json")? {
let bytes = crate::bounded::to_json_vec(&value).into_lua_err()?;
headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
body = Some(Bytes::from(bytes));
}
if body.is_none()
&& let Some(raw) = table.get::<Option<mlua::LuaString>>("body")?
{
body = Some(Bytes::copy_from_slice(&raw.as_bytes()));
}
if let Some(secs) = table.get::<Option<f64>>("timeout")? {
let requested = Duration::try_from_secs_f64(secs.max(0.0)).map_err(|_| {
mlua::Error::RuntimeError(format!("fetch timeout `{secs}` is not a duration"))
})?;
timeout = Some(requested);
}
if let Some(table) = table.get::<Option<Table>>("retry")? {
retry = Some(parse_retry(&table)?);
}
} else {
fill_headers(&mut headers, &table)?;
}
}
Ok(RequestSpec {
method,
url,
headers,
body,
timeout,
retry,
})
}
fn fill_headers(headers: &mut HeaderMap, table: &Table) -> mlua::Result<()> {
for pair in table.pairs::<String, String>() {
let (k, v) = pair.into_lua_err()?;
headers.insert(
HeaderName::from_bytes(k.as_bytes()).into_lua_err()?,
HeaderValue::from_bytes(v.as_bytes()).into_lua_err()?,
);
}
Ok(())
}
pub(crate) fn create_fetch_fn(lua: &Lua, opts: Arc<FetchOptions>) -> mlua::Result<Function> {
let http_client = client_for(&opts)?;
let budget = Arc::new(OutboundBudget::default());
lua.set_app_data(budget.clone());
lua.create_function(
move |lua, (method, url, arg): (String, String, Option<Table>)| {
let mut spec = parse_spec(method, url, arg)?;
spec.timeout = spec.timeout.map(|t| t.min(opts.timeout));
if opts.propagate_trace_context
&& let Some(value) = traceparent(lua)
{
spec.headers
.entry(HeaderName::from_static("traceparent"))
.or_insert(value);
}
Ok(LuaFetch {
client: http_client.clone(),
spec,
opts: opts.clone(),
budget: budget.clone(),
})
},
)
}
pub(crate) fn create_await_all_fn(lua: &Lua, opts: Arc<FetchOptions>) -> mlua::Result<Function> {
lua.create_async_function(move |lua, handles: Variadic<AnyUserData>| {
let opts = opts.clone();
async move {
enum Job {
Fetch(Box<(Arc<HttpClient>, RequestSpec, Arc<FetchOptions>)>),
Mocked(Box<LuaResponse>),
#[cfg(feature = "db")]
Query(crate::db::PendingQuery),
}
let budget = lua.app_data_ref::<Arc<OutboundBudget>>().map(|b| b.clone());
let doubles = crate::testing::installed(&lua);
let mut jobs = Vec::with_capacity(handles.len());
for handle in handles.iter() {
if let Ok(fetch) = handle.borrow::<LuaFetch>() {
if let Some(budget) = &budget {
budget.take(opts.max_per_request)?;
}
if let Some(doubles) = &doubles
&& let Some(canned) = mocked(doubles, &fetch.spec, &fetch.opts)?
{
jobs.push(Job::Mocked(Box::new(canned)));
continue;
}
jobs.push(Job::Fetch(Box::new((
fetch.client.clone(),
fetch.spec.clone(),
fetch.opts.clone(),
))));
continue;
}
#[cfg(feature = "db")]
if let Ok(query) = handle.borrow::<crate::db::LuaPendingQuery>() {
jobs.push(Job::Query(query.take()?));
continue;
}
return Err(mlua::Error::RuntimeError(
"await_all expects fetch(...) or db:query_async(...) handles".into(),
));
}
let results: Vec<Value> = futures_util::stream::iter(jobs)
.map(|job| {
let lua = lua.clone();
async move {
match job {
Job::Fetch(job) => {
let (client, spec, opts) = *job;
let resp = send_with_retries(&client, spec, &opts).await?;
lua.create_userdata(resp).map(Value::UserData)
}
Job::Mocked(resp) => lua.create_userdata(*resp).map(Value::UserData),
#[cfg(feature = "db")]
Job::Query(query) => query.run(&lua).await,
}
}
})
.buffered(opts.max_concurrent.max(1))
.try_collect()
.await?;
Ok(Variadic::from_iter(results))
}
})
}
#[cfg(test)]
mod tests {
use super::*;
fn spec(method: &str) -> RequestSpec {
RequestSpec {
method: HttpMethod::from_bytes(method.as_bytes()).expect("method"),
url: "https://example.com/".parse().expect("url"),
headers: HeaderMap::new(),
body: None,
timeout: None,
retry: None,
}
}
#[test]
fn credentials_stop_at_the_origin_boundary() {
let a: Url = "https://api.example.com/x".parse().expect("url");
let same: Url = "https://api.example.com:443/y".parse().expect("url");
let other: Url = "https://evil.example/".parse().expect("url");
let scheme: Url = "http://api.example.com/x".parse().expect("url");
assert!(same_origin(&a, &same));
assert!(!same_origin(&a, &other));
assert!(
!same_origin(&a, &scheme),
"a scheme downgrade is a new origin"
);
let mut headers = HeaderMap::new();
headers.insert("authorization", HeaderValue::from_static("Bearer t"));
headers.insert("cookie", HeaderValue::from_static("s=1"));
headers.insert("x-custom", HeaderValue::from_static("kept"));
strip_sensitive_headers(&mut headers);
assert!(headers.get("authorization").is_none());
assert!(headers.get("cookie").is_none());
assert_eq!(headers.get("x-custom").expect("kept"), "kept");
}
#[test]
fn timeout_option_is_total_and_capped() {
let lua = Lua::new();
for bad in ["math.huge", "0/0", "1e300"] {
let opts: Table = lua
.load(format!("return {{ timeout = {bad} }}"))
.eval()
.expect("opts");
let result = parse_spec("GET".into(), "https://example.com/".into(), Some(opts));
if bad != "0/0" {
assert!(result.is_err(), "`timeout = {bad}` must be refused");
}
}
let opts: Table = lua.load("return { timeout = 3600 }").eval().expect("opts");
let spec =
parse_spec("GET".into(), "https://example.com/".into(), Some(opts)).expect("spec");
let policy = FetchOptions::default();
let capped = spec.timeout.map(|t| t.min(policy.timeout));
assert_eq!(capped, Some(policy.timeout));
}
#[test]
fn only_idempotent_methods_may_be_retried() {
for safe in ["GET", "HEAD", "PUT", "DELETE", "OPTIONS"] {
assert!(spec(safe).is_idempotent(), "{safe} is idempotent");
}
for unsafe_method in ["POST", "PATCH"] {
assert!(
!spec(unsafe_method).is_idempotent(),
"{unsafe_method} must never be repeated automatically"
);
let mut vouched = spec(unsafe_method);
vouched.retry = Some(Retry {
attempts: 2,
exponential: true,
idempotent: true,
});
assert!(
vouched.is_idempotent(),
"{unsafe_method} may be repeated when the caller vouches for it"
);
}
}
#[test]
fn a_mocked_error_fails_like_the_network() {
let doubles = crate::testing::Doubles::new();
doubles
.fetch()
.expect("lock")
.add(crate::testing::FetchRule {
method: None,
url: crate::testing::UrlMatch::Exact("https://example.com/".into()),
status: 200,
headers: Vec::new(),
body: Vec::new(),
times: None,
error: Some("connection reset".into()),
});
let Err(err) = mocked(&doubles, &spec("GET"), &FetchOptions::default()) else {
panic!("the mocked error must fail the call");
};
assert!(err.to_string().contains("connection reset"), "{err}");
assert!(is_transient(&err), "a mocked failure is retryable");
}
#[tokio::test]
async fn built_client_refuses_forbidden_addresses_without_check_url() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind");
let port = listener.local_addr().expect("addr").port();
let client = client_for(&FetchOptions::default()).expect("client");
let err = client
.get(format!("http://localhost:{port}/"))
.send()
.await
.expect_err("the guarded resolver must refuse loopback");
let mut chain = err.to_string();
let mut source = std::error::Error::source(&err);
while let Some(err) = source {
chain.push_str(": ");
chain.push_str(&err.to_string());
source = err.source();
}
assert!(
chain.contains("private or local"),
"unexpected error: {chain}"
);
}
}