WEB: share immutable profiles + decoys across exact host lists

This commit is contained in:
Alexey
2026-10-15 07:05:36 +03:00
parent 05a367259a
commit 831cd0f1a7
51 changed files with 1661 additions and 343 deletions
+2 -2
View File
@@ -401,10 +401,10 @@ async fn prefixed_decoy_request_keeps_its_original_path_and_query() {
host: "proxy.example.com".to_string(),
base: "/relay/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
decoy: WebRuntimeDecoy::HttpUpstream {
decoy: Arc::new(WebRuntimeDecoy::HttpUpstream {
addr: site_addr,
authority: "decoy.internal".to_string(),
},
}),
decoy_header_secs: 1,
profiles: vec![Arc::clone(&profile)],
capabilities: vec![capability].into_boxed_slice(),
+4 -4
View File
@@ -66,10 +66,10 @@ async fn every_authentic_credential_placement_stays_out_of_the_upstream() {
host: "proxy.example.com".to_string(),
base: "/relay/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
decoy: WebRuntimeDecoy::HttpUpstream {
decoy: Arc::new(WebRuntimeDecoy::HttpUpstream {
addr: site_addr,
authority: "decoy.internal".to_string(),
},
}),
decoy_header_secs: 1,
profiles: vec![profile.clone()],
capabilities: vec![capability].into_boxed_slice(),
@@ -81,10 +81,10 @@ async fn every_authentic_credential_placement_stays_out_of_the_upstream() {
host: "other.example.com".to_string(),
base: "/other/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
decoy: WebRuntimeDecoy::HttpUpstream {
decoy: Arc::new(WebRuntimeDecoy::HttpUpstream {
addr: site_addr,
authority: "decoy.internal".to_string(),
},
}),
decoy_header_secs: 1,
profiles: Vec::new(),
capabilities: Vec::new().into_boxed_slice(),
+2 -2
View File
@@ -198,10 +198,10 @@ async fn decoy_forwarding_preserves_every_reference_request_target() {
host: previous.host.clone(),
base: previous.base.clone(),
decoy_fasttrack_mode: previous.decoy_fasttrack_mode,
decoy: WebRuntimeDecoy::HttpUpstream {
decoy: Arc::new(WebRuntimeDecoy::HttpUpstream {
addr: site_addr,
authority: "decoy.internal".to_string(),
},
}),
decoy_header_secs: 1,
profiles: previous.profiles.clone(),
capabilities: previous.capabilities.clone(),
+1 -1
View File
@@ -46,7 +46,7 @@ where
.boxed_unsync()
};
let request = Request::from_parts(parts, body);
match &vhost.decoy {
match vhost.decoy.as_ref() {
WebRuntimeDecoy::StaticDirectory(site) => {
let mut response = serve_static(request, site);
if sanitize_transport {
+2 -2
View File
@@ -16,10 +16,10 @@ async fn decoy_dns_pinned_socket_keeps_configured_hostname_in_actual_http_reques
let snapshot = Arc::get_mut(config.web.runtime.as_mut().unwrap()).unwrap();
let vhost = Arc::get_mut(snapshot.vhosts.get_mut("proxy.example.com").unwrap()).unwrap();
// A public hostname deliberately paired with a loopback socket proves no request-time lookup.
vhost.decoy = WebRuntimeDecoy::HttpUpstream {
vhost.decoy = Arc::new(WebRuntimeDecoy::HttpUpstream {
addr: origin.local_addr().unwrap(),
authority: "bsi.bund.de:8080".to_string(),
};
});
let generation = test_runtime_generation(1, config);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+2 -2
View File
@@ -67,10 +67,10 @@ async fn observe_http_origin(
let mut config = runtime_config_with_fasttrack(capability, WebCarrier::Https, mode);
let runtime_config = Arc::get_mut(config.web.runtime.as_mut().unwrap()).unwrap();
let vhost = Arc::get_mut(runtime_config.vhosts.get_mut("proxy.example.com").unwrap()).unwrap();
vhost.decoy = WebRuntimeDecoy::HttpUpstream {
vhost.decoy = Arc::new(WebRuntimeDecoy::HttpUpstream {
addr: origin.local_addr().unwrap(),
authority: "decoy.example".to_string(),
};
});
let generation = test_runtime_generation(1, config);
let active_runtime = Arc::new(ArcSwap::from(Arc::clone(&generation)));
let runtime = WebProcessRuntime::start(active_runtime);
+71
View File
@@ -0,0 +1,71 @@
use super::*;
use std::hint::black_box;
use std::time::Instant;
fn memory() -> (u64, u64) {
let smaps = std::fs::read_to_string("/proc/self/smaps_rollup").unwrap();
let value = |name: &str| {
smaps
.lines()
.find_map(|line| line.strip_prefix(name))
.unwrap()
.split_whitespace()
.next()
.unwrap()
.parse::<u64>()
.unwrap()
};
(value("Rss:"), value("Anonymous:"))
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "manual matched before/after source-snapshot measurement"]
async fn matched_host_group_probe() {
let path = std::env::var("TELEMT_F1_PROBE_CONFIG").unwrap();
let before = memory();
let started = Instant::now();
let mut config = ProxyConfig::load(std::path::Path::new(&path)).unwrap();
let load_us = started.elapsed().as_micros();
black_box(&config);
let after = memory();
let snapshot = config.web.runtime.as_ref().unwrap();
let host_count = snapshot.vhosts.len();
let profile_count = snapshot.profiles.len();
let profile = &snapshot.profiles[0];
let host = profile.host.clone();
let cap = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(profile.capability);
let base = snapshot.vhosts[&host].base.clone();
config.web.limits.max_bootstraps_per_ip = 512;
let generation = test_runtime_generation(1, config);
generation.proxy_shared.apply_user_config(
&generation.config().access.users,
&std::collections::HashMap::new(),
);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let raw = format!("GET {base}?bridge={cap} HTTP/1.1\r\nHost: {host}\r\nX-Forwarded-For: 192.0.2.10\r\nConnection: close\r\n\r\n").into_bytes();
let mut samples = Vec::new();
for index in 0..110 {
let started = Instant::now();
let response = request(&listener, &runtime, raw.clone()).await;
let elapsed = started.elapsed().as_micros();
assert!(response.starts_with(b"HTTP/1.1 200"));
if index >= 10 {
samples.push(elapsed);
}
}
samples.sort_unstable();
println!(
"F1_PROBE {}",
serde_json::json!({
"load_us": load_us, "rss_kib": after.0, "anonymous_kib": after.1,
"rss_delta_kib": after.0 as i64 - before.0 as i64,
"anonymous_delta_kib": after.1 as i64 - before.1 as i64,
"hosts": host_count, "profiles": profile_count,
"bridge_p50_us": samples[50], "bridge_p95_us": samples[95]
})
);
runtime.shutdown().await;
generation.stop_sessions().await;
generation.stop_background_tasks().await;
}
+350
View File
@@ -0,0 +1,350 @@
use super::*;
use crate::maestro::generation::RuntimeGeneration;
use crate::web::manager::{BridgeDiagnosticEvent, CarrierRequest, ManagerError, TokenHash};
use sha2::{Digest, Sha256};
use std::collections::HashMap;
// Admission and generation identity use the same parsed configuration as HTTP routing.
#[path = "host_list_tests/sessions.rs"]
mod sessions;
const HOSTS: [&str; 2] = ["a.example.com", "b.example.com"];
const SELECTOR: &str = "hosts = [\"a.example.com\", \"b.example.com\"]";
fn source(selector: &str, origin: std::net::SocketAddr) -> String {
format!(
r#"
[access.users]
alice = "000102030405060708090a0b0c0d0e0f"
[[server.listeners]]
ip = "127.0.0.1"
port = 18080
transport = "web"
web_trusted_proxy_cidrs = ["127.0.0.1/32"]
[web]
enabled = true
carrier = "https"
[[web.vhosts]]
{selector}
base_path = "relay"
public_addr = "203.0.113.10:443"
[web.vhosts.decoy]
mode = "http_upstream"
upstream = "http://{origin}"
[[web.vhosts.profiles]]
user = "alice"
secret_mode = "plain"
max_sessions = 1
max_streams = 1
max_streams_per_session = 1
"#
)
}
fn generation(id: u64, text: &str) -> Arc<RuntimeGeneration> {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("config.toml");
std::fs::write(&path, text).unwrap();
let generation = test_runtime_generation(id, ProxyConfig::load(&path).unwrap());
generation
.proxy_shared
.apply_user_config(&generation.config().access.users, &HashMap::new());
generation
}
fn profile(runtime: &WebProcessRuntime, host: &str) -> Arc<WebRuntimeProfile> {
runtime
.active_generation()
.config()
.web
.runtime
.as_ref()
.unwrap()
.vhosts[host]
.profiles[0]
.clone()
}
fn token_hash(token: &str) -> TokenHash {
Sha256::digest(
base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(token)
.unwrap(),
)
.into()
}
fn raw_request(method: &str, path: &str, host: &str, headers: &str, body: &[u8]) -> Vec<u8> {
let mut raw = format!(
"{method} {path} HTTP/1.1\r\nHost: {host}\r\nX-Forwarded-For: 192.0.2.10\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n", body.len()
).into_bytes();
raw.extend_from_slice(body);
raw
}
fn bootstrap(runtime: &Arc<WebProcessRuntime>, host: &str) -> String {
runtime
.issue_bootstrap(profile(runtime, host), "192.0.2.10".parse().unwrap())
.unwrap()
.token
}
fn create(
runtime: &Arc<WebProcessRuntime>,
host: &str,
bootstrap: &str,
) -> Result<String, ManagerError> {
runtime
.create_session(
token_hash(bootstrap),
host,
"192.0.2.10".parse().unwrap(),
&frame::encode(FrameType::Hello, 0, &[1]),
CarrierRequest::legacy([0; 32]),
false,
)
.map(|created| created.token)
}
fn assert_private(response: &[u8]) {
let (headers, body) = split_response(response);
assert!(
headers.starts_with(b"HTTP/1.1 404"),
"{}",
String::from_utf8_lossy(response)
);
assert_eq!(response_header(headers, "cache-control"), "no-store");
assert_eq!(body, b"not found\n");
}
async fn stop(runtime: Arc<WebProcessRuntime>, generations: &[Arc<RuntimeGeneration>]) {
runtime.shutdown().await;
for generation in generations {
generation.stop_sessions().await;
generation.stop_background_tasks().await;
}
}
#[tokio::test]
async fn grouped_hosts_contain_credentials_in_every_fasttrack_mode() {
for mode in ["off", "shadow", "enforce"] {
let site = TcpListener::bind("127.0.0.1:0").await.unwrap();
let text = source(SELECTOR, site.local_addr().unwrap()).replace(
"enabled = true",
&format!("enabled = true\ndecoy_fasttrack_mode = \"{mode}\""),
);
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
for (owner, other) in [(HOSTS[0], HOSTS[1]), (HOSTS[1], HOSTS[0])] {
let capability = base64::engine::general_purpose::URL_SAFE_NO_PAD
.encode(profile(&runtime, owner).capability);
let response = request(
&listener,
&runtime,
raw_request(
"GET",
&format!("/relay/?bridge={capability}"),
owner,
"",
&[],
),
)
.await;
assert!(response.starts_with(b"HTTP/1.1 200"));
let body = std::str::from_utf8(split_response(&response).1).unwrap();
let bootstrap = body
.split_once("bootstrap=\"")
.unwrap()
.1
.split_once('"')
.unwrap()
.0
.to_string();
let hello = frame::encode(FrameType::Hello, 0, &[1]);
let auth = format!(
"Authorization: Bearer {bootstrap}\r\nContent-Type: application/octet-stream\r\n"
);
assert_private(
&request(
&listener,
&runtime,
raw_request("POST", "/relay/api/v1/session", other, &auth, &hello),
)
.await,
);
let response = request(
&listener,
&runtime,
raw_request("POST", "/relay/api/v1/session", owner, &auth, &hello),
)
.await;
assert!(response.starts_with(b"HTTP/1.1 200"));
let session =
response_header(split_response(&response).0, "x-session-token").to_string();
assert!(matches!(
runtime.get_session(token_hash(&session), other),
Err(ManagerError::Authentication)
));
assert_eq!(
runtime.close_token(token_hash(&session), other, None),
Err(ManagerError::Authentication)
);
assert!(
runtime
.bootstrap_trace_identity(token_hash(&bootstrap), other)
.is_none()
);
assert_eq!(
runtime.claim_bridge_diagnostic(
token_hash(&bootstrap),
other,
BridgeDiagnosticEvent::RuntimeStarted
),
Err(ManagerError::Authentication)
);
for secret in [&capability, &bootstrap, &session] {
let encoded = secret
.bytes()
.map(|byte| format!("%{byte:02X}"))
.collect::<String>();
for path in [
format!("/relay/?bridge={secret}"),
format!("/wrong/{secret}"),
format!("/wrong/{encoded}"),
format!("/wrong?opaque={secret}"),
] {
assert_private(
&request(
&listener,
&runtime,
raw_request("GET", &path, other, "", &[]),
)
.await,
);
}
let head = request(
&listener,
&runtime,
raw_request(
"HEAD",
"/relay/",
other,
&format!("X-Opaque: {secret}\r\n"),
&[],
),
)
.await;
assert!(head.starts_with(b"HTTP/1.1 404"));
assert_eq!(
response_header(split_response(&head).0, "cache-control"),
"no-store"
);
}
for (method, path, headers, body) in [
(
"POST",
"/relay/api/v1/up",
"X-Up-Seq: 0\r\n",
hello.as_ref(),
),
(
"POST",
"/relay/api/v1/down",
"X-Down-Cursor: 0\r\n",
&[][..],
),
("DELETE", "/relay/api/v1/session", "", &[][..]),
(
"POST",
"/relay/api/v1/diagnostic",
"Content-Type: application/json\r\n",
b"{}".as_ref(),
),
] {
let auth = format!("Authorization: Bearer {session}\r\n{headers}");
assert_private(
&request(
&listener,
&runtime,
raw_request(method, path, other, &auth, body),
)
.await,
);
}
}
for host in ["unknown.example.com", "A.EXAMPLE.COM", "a.example.com:444"] {
let response =
request(&listener, &runtime, raw_request("GET", "/", host, "", &[])).await;
assert!(response.starts_with(b"HTTP/1.1 404"));
}
assert!(
tokio::time::timeout(std::time::Duration::from_millis(30), site.accept())
.await
.is_err()
);
// A positive control ensures the origin would observe an actual fallback request.
let site_task = tokio::spawn(async move {
let (mut socket, _) = site.accept().await.unwrap();
let mut head = [0; 2048];
let read = socket.read(&mut head).await.unwrap();
assert!(
std::str::from_utf8(&head[..read])
.unwrap()
.contains("/ordinary")
);
socket
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\nConnection: close\r\n\r\nsite")
.await
.unwrap();
});
let ordinary = request(
&listener,
&runtime,
raw_request("GET", "/ordinary", HOSTS[0], "", &[]),
)
.await;
assert_eq!(split_response(&ordinary).1, b"site");
site_task.await.unwrap();
stop(runtime, &[generation]).await;
}
}
#[tokio::test]
async fn alias_recovery_cannot_retire_a_foreign_session() {
let generation = generation(1, &source(SELECTOR, "127.0.0.1:18081".parse().unwrap()));
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let a = create(&runtime, HOSTS[0], &bootstrap(&runtime, HOSTS[0])).unwrap();
let cap = base64::engine::general_purpose::URL_SAFE_NO_PAD
.encode(profile(&runtime, HOSTS[1]).capability);
let response = request(
&listener,
&runtime,
raw_request(
"GET",
&format!("/relay/?bridge={cap}"),
HOSTS[1],
&format!(
"Accept: application/vnd.telemt.web-recovery+json\r\nAuthorization: Bearer {a}\r\n"
),
&[],
),
)
.await;
assert!(
response.starts_with(b"HTTP/1.1 200"),
"{}",
String::from_utf8_lossy(&response)
);
let value: serde_json::Value = serde_json::from_slice(split_response(&response).1).unwrap();
let recovered = value["bootstrap"].as_str().unwrap();
assert_eq!(
create(&runtime, HOSTS[0], recovered),
Err(ManagerError::Authentication)
);
let b = create(&runtime, HOSTS[1], recovered).unwrap();
assert!(runtime.get_session(token_hash(&a), HOSTS[0]).is_ok());
assert!(runtime.get_session(token_hash(&b), HOSTS[1]).is_ok());
stop(runtime, &[generation]).await;
}
+211
View File
@@ -0,0 +1,211 @@
use super::*;
use tokio::sync::Barrier;
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn per_host_quotas_survive_concurrent_creation_and_generation_swaps() {
let source = source(SELECTOR, "127.0.0.1:18081".parse().unwrap());
let initial = generation(1, &source);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(initial.clone())));
let mut generations = vec![initial];
for id in 2..=9 {
let selector = if id % 2 == 0 {
"hosts = [\"b.example.com\", \"a.example.com\"]"
} else {
SELECTOR
};
generations.push(generation(id, &source.replace(SELECTOR, selector)));
}
let barrier = Arc::new(Barrier::new(34));
let mut tasks = Vec::new();
for host in HOSTS {
for _ in 0..16 {
let token = bootstrap(&runtime, host);
let runtime = runtime.clone();
let barrier = barrier.clone();
tasks.push(tokio::spawn(async move {
barrier.wait().await;
(host, create(&runtime, host, &token))
}));
}
}
let reloader = {
let runtime = runtime.clone();
let barrier = barrier.clone();
let generations = generations[1..].to_vec();
tokio::spawn(async move {
barrier.wait().await;
for generation in generations {
runtime.activate_generation(generation);
tokio::task::yield_now().await;
}
})
};
barrier.wait().await;
let mut accepted = Vec::new();
for task in tasks {
let (host, result) = task.await.unwrap();
match result {
Ok(token) => accepted.push((host, token)),
Err(error) => assert_eq!(error, ManagerError::Limit),
}
}
reloader.await.unwrap();
assert_eq!(accepted.len(), 2);
for host in HOSTS {
assert_eq!(
accepted.iter().filter(|(owner, _)| *owner == host).count(),
1
);
}
let sessions: Vec<_> = accepted
.iter()
.map(|(host, token)| runtime.get_session(token_hash(token), host).unwrap())
.collect();
assert_ne!(sessions[0].profile_key(), sessions[1].profile_key());
assert_eq!(
serde_json::to_value(runtime.try_status()).unwrap()["manager"]["profiles"],
2
);
let barrier = Arc::new(Barrier::new(33));
let mut tasks = Vec::new();
let ip = "192.0.2.10".parse().unwrap();
let addr = "203.0.113.10:443".parse().unwrap();
for session in &sessions {
let key = session.profile_key();
for _ in 0..16 {
let runtime = runtime.clone();
let barrier = barrier.clone();
tasks.push(tokio::spawn(async move {
barrier.wait().await;
(key, runtime.try_acquire_stream(key, 1, ip, addr))
}));
}
}
barrier.wait().await;
let mut ports = Vec::new();
for task in tasks {
let (key, result) = task.await.unwrap();
match result {
Ok(port) => ports.push((key, port)),
Err(error) => assert_eq!(error, ManagerError::Limit),
}
}
assert_eq!(ports.len(), 2);
assert_ne!(ports[0].0, ports[1].0);
assert_eq!(
serde_json::to_value(runtime.try_status()).unwrap()["streams"]["profiles"],
2
);
for (key, port) in ports {
runtime.release_stream(key, ip, addr, port);
}
assert_eq!(
serde_json::to_value(runtime.try_status()).unwrap()["streams"]["profiles"],
0
);
stop(runtime, &generations).await;
}
#[tokio::test]
async fn regrouping_preserves_live_quota_and_bootstrap_when_limits_change() {
let grouped = source(SELECTOR, "127.0.0.1:18081".parse().unwrap());
let (prefix, group) = grouped.split_once("[[web.vhosts]]").unwrap();
let separate = format!(
"{prefix}[[web.vhosts]]{}\n[[web.vhosts]]{}",
group.replace(SELECTOR, "host = \"a.example.com\""),
group.replace(SELECTOR, "host = \"b.example.com\"")
);
let initial = generation(1, &separate);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(initial.clone())));
let a = create(&runtime, HOSTS[0], &bootstrap(&runtime, HOSTS[0])).unwrap();
let key = runtime
.get_session(token_hash(&a), HOSTS[0])
.unwrap()
.profile_key();
let unused_b = bootstrap(&runtime, HOSTS[1]);
let next = generation(
2,
&grouped
.replace(SELECTOR, "hosts = [\"b.example.com\", \"a.example.com\"]")
.replace("max_sessions = 1", "max_sessions = 2"),
);
runtime.activate_generation(next.clone());
let b = create(&runtime, HOSTS[1], &unused_b).unwrap();
assert_eq!(
runtime
.get_session(token_hash(&a), HOSTS[0])
.unwrap()
.profile_key(),
key
);
let second_a = create(&runtime, HOSTS[0], &bootstrap(&runtime, HOSTS[0])).unwrap();
assert_eq!(
runtime
.get_session(token_hash(&second_a), HOSTS[0])
.unwrap()
.profile_key(),
key
);
assert_eq!(
create(&runtime, HOSTS[0], &bootstrap(&runtime, HOSTS[0])),
Err(ManagerError::Limit)
);
let stale_b = bootstrap(&runtime, HOSTS[1]);
let removed = generation(
3,
&grouped
.replace(SELECTOR, "hosts = [\"a.example.com\"]")
.replace("max_sessions = 1", "max_sessions = 2"),
);
runtime.activate_generation(removed.clone());
assert_eq!(
create(&runtime, HOSTS[1], &stale_b),
Err(ManagerError::Authentication)
);
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let response = request(
&listener,
&runtime,
raw_request("GET", "/relay/", HOSTS[1], "", &[]),
)
.await;
assert!(response.starts_with(b"HTTP/1.1 404"));
assert!(runtime.get_session(token_hash(&a), HOSTS[0]).is_ok());
assert!(runtime.get_session(token_hash(&b), HOSTS[1]).is_ok());
assert_eq!(
create(&runtime, HOSTS[0], &bootstrap(&runtime, HOSTS[0])),
Err(ManagerError::Limit)
);
stop(runtime, &[initial, next, removed]).await;
}
#[tokio::test]
async fn grouped_profiles_keep_process_and_ip_session_limits() {
for global in [1, 2] {
let text = format!(
"{}\n[web.limits]\nmax_sessions_global = {global}\nmax_sessions_per_ip = 1\n",
source(SELECTOR, "127.0.0.1:18081".parse().unwrap())
);
let generation = generation(1, &text);
let runtime = WebProcessRuntime::start(Arc::new(ArcSwap::from(generation.clone())));
create(&runtime, HOSTS[0], &bootstrap(&runtime, HOSTS[0])).unwrap();
let b = bootstrap(&runtime, HOSTS[1]);
assert_eq!(create(&runtime, HOSTS[1], &b), Err(ManagerError::Limit));
let result = runtime.create_session(
token_hash(&b),
HOSTS[1],
"192.0.2.11".parse().unwrap(),
&frame::encode(FrameType::Hello, 0, &[1]),
CarrierRequest::legacy([0; 32]),
false,
);
if global == 1 {
assert!(matches!(result, Err(ManagerError::Limit)));
} else {
assert!(result.is_ok());
}
stop(runtime, &[generation]).await;
}
}
+4 -4
View File
@@ -83,7 +83,7 @@ pub(super) fn response(
carrier_batch_bytes: limits.carrier_batch_bytes,
pending_bytes_per_session: limits.pending_bytes_per_session,
pending_items_per_session: limits.pending_items_per_session,
max_streams_per_session: profile.max_streams_per_session,
max_streams_per_session: profile.shared.max_streams_per_session,
},
timeouts: RecoveryTimeouts {
long_poll_secs: timeouts.long_poll_secs,
@@ -94,9 +94,9 @@ pub(super) fn response(
reconnect_grace_secs: timeouts.reconnect_grace_secs,
},
negotiation: RecoveryNegotiation {
enabled: profile.carrier_negotiation_enabled,
candidate_count: profile.carriers.len(),
deadlines_secs: profile.carrier_negotiation_deadlines_secs,
enabled: profile.shared.carrier_negotiation_enabled,
candidate_count: profile.shared.carriers.len(),
deadlines_secs: profile.shared.carrier_negotiation_deadlines_secs,
carrier_probe_coalesce_ms: timeouts.carrier_probe_coalesce_ms,
},
};
+25 -15
View File
@@ -127,20 +127,22 @@ fn runtime_config_with_carriers_and_deadlines(
) -> ProxyConfig {
let profile = Arc::new(WebRuntimeProfile {
host: "proxy.example.com".to_string(),
public_addr: "203.0.113.10:443".parse().unwrap(),
user: "alice".to_string(),
secret_mode: WebSecretMode::Plain,
carrier,
carrier_negotiation_enabled,
carrier_learning,
carriers: Arc::clone(&carriers),
carrier_negotiation_deadlines_secs,
capability,
credential_id: [0; 16],
key_fingerprint: "0000000000000000".to_string(),
max_sessions: 4,
max_streams: 16,
max_streams_per_session: 4,
shared: Arc::new(crate::config::WebRuntimeProfileShared {
public_addr: "203.0.113.10:443".parse().unwrap(),
user: "alice".to_string(),
secret_mode: WebSecretMode::Plain,
carrier,
carrier_negotiation_enabled,
carrier_learning,
carriers: Arc::clone(&carriers),
carrier_negotiation_deadlines_secs,
credential_id: [0; 16],
key_fingerprint: "0000000000000000".to_string(),
max_sessions: 4,
max_streams: 16,
max_streams_per_session: 4,
}),
});
let mut assets = BTreeMap::new();
assets.insert(
@@ -159,7 +161,7 @@ fn runtime_config_with_carriers_and_deadlines(
host: "proxy.example.com".to_string(),
base: base.to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
decoy: WebRuntimeDecoy::StaticDirectory(Arc::clone(&site)),
decoy: Arc::new(WebRuntimeDecoy::StaticDirectory(Arc::clone(&site))),
decoy_header_secs: 1,
profiles: vec![Arc::clone(&profile)],
capabilities: vec![capability].into_boxed_slice(),
@@ -172,7 +174,7 @@ fn runtime_config_with_carriers_and_deadlines(
host: "other.example.com".to_string(),
base: "/".to_string(),
decoy_fasttrack_mode: WebDecoyFastTrackMode::Off,
decoy: WebRuntimeDecoy::StaticDirectory(site),
decoy: Arc::new(WebRuntimeDecoy::StaticDirectory(site)),
decoy_header_secs: 1,
profiles: Vec::new(),
capabilities: Vec::new().into_boxed_slice(),
@@ -547,3 +549,11 @@ async fn https_lanes_is_advertised_and_requires_canonical_lane_headers() {
generation.stop_sessions().await;
generation.stop_background_tasks().await;
}
// Exercise loaded host groups through real HTTP and process-owned admission.
#[path = "host_list_tests.rs"]
mod host_list_tests;
// Manual matched measurements keep timing assertions out of deterministic regressions.
#[path = "host_list_benchmarks.rs"]
mod host_list_benchmarks;