mirror of
https://github.com/telemt/telemt.git
synced 2026-11-22 07:16:38 +03:00
WEB: share immutable profiles + decoys across exact host lists
This commit is contained in:
@@ -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(),
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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;
|
||||
|
||||
Reference in New Issue
Block a user