Files
coa-server-manager/services/coa-control-e2e/tests/relay_session_and_load.rs

628 lines
29 KiB
Rust

use std::io::{Read, Write};
use std::net::TcpStream;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use coa_core::control::direct_ingress::DirectIngress;
use coa_core::control::host_link::HostLink;
use coa_core::control::join::{PlayerControl, RealmTarget};
use coa_core::control::relay_link::RelayLink;
use coa_core::control::secrets::MemoryStore;
use coa_core::control::service::fake::FakeRealm;
use coa_core::control::service::HostService;
use coa_core::control::store::ControlStore;
use coa_core::control::transport::coordinator_url;
use coa_core::realm_registry::client::RegistryClient;
use coa_registry_proto::caps::*;
use coa_registry_proto::sign::encode_public_key;
use coa_registry_proto::*;
use ed25519_dalek::SigningKey;
use uuid::Uuid;
fn now() -> i64 {
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64
}
fn random_key() -> SigningKey {
let mut seed = [0u8; 32];
seed[..16].copy_from_slice(Uuid::new_v4().as_bytes());
seed[16..].copy_from_slice(Uuid::new_v4().as_bytes());
SigningKey::from_bytes(&seed)
}
fn base_url() -> String {
std::env::var("REGISTRY_URL")
.ok()
.filter(|u| !u.is_empty())
.unwrap_or_else(|| "https://coa-manager.duckdns.org".into())
}
fn sample_caps(max_level: u32) -> AdvertisedCapabilities {
let content = ContentProfile {
ruleset: Ruleset::Coa,
character_formats: CharacterFormats { readable: FormatRange { min: 1, max: 2 }, writable: FormatRange { min: 2, max: 2 } },
online_import_job_formats: vec![2],
session_protocol: 2,
collection_protocol: 1,
features: [Feature::RuntimeSessions, Feature::Wardrobe, Feature::LevelProjection].into_iter().collect(),
collection_kinds: ["coa:appearance".to_string()].into_iter().collect(),
extensions: vec![ExtensionSupport { namespace: "coa".into(), module_version: "1".into(), formats: FormatRange { min: 1, max: 1 } }],
client_catalog: [("Appearances.dbc".to_string(), CatalogEntry { sha256: "a".repeat(64), records: 5 })].into_iter().collect(),
};
let content_profile_hash = content.hash();
AdvertisedCapabilities {
profile_version: 2,
core: Some(CoreIdentity { commit: "abc123".into(), branch: "main".into(), date: "2026-10-01".into() }),
content,
content_profile_hash,
progression: Some(Progression { max_player_level: max_level, projection_protocol: 1, projection_policy_version: 1, progression_signature: "b".repeat(64), scaling_enabled: false }),
}
}
fn register_realm(client: &RegistryClient, realm: &RealmId, key: &SigningKey) -> std::result::Result<(), Box<dyn std::error::Error>> {
let listing = Listing {
display_name: "Phase 13.1 Live Hardened Realm".into(),
description: "Hardened Game Relay live test".into(),
language: "en".into(),
region: Some("EU".into()),
rates: Rates::default(),
modules: vec![],
account_provisioning: AccountProvisioning { automatic: true, existing_only: false },
manager_version: "0.7.0".into(),
};
let capabilities = sample_caps(80);
let req = RegisterRequest {
protocol_version: REGISTRY_PROTOCOL_VERSION,
realm_id: *realm,
public_key: encode_public_key(&key.verifying_key()),
listing_hash: listing.hash(),
listing,
capabilities_hash: capabilities.advert_hash(),
capabilities,
population: Population { players: 0, bots: 0, capacity: None },
};
let ts = now();
client.register(key, &req, ts)?;
Ok(())
}
fn build_auth_logon_challenge_pkt(account: &str) -> Vec<u8> {
let acc_bytes = account.to_uppercase().into_bytes();
let mut pkt = Vec::new();
pkt.push(0x00); // Opcode CMD_AUTH_LOGON_CHALLENGE
pkt.push(0x00); // error = 0
let size = (30 + acc_bytes.len()) as u16;
pkt.extend_from_slice(&size.to_le_bytes());
pkt.extend_from_slice(b"WoW\0");
pkt.push(3); // version1
pkt.push(3); // version2
pkt.push(5); // version3
pkt.extend_from_slice(&12340u16.to_le_bytes()); // build 12340
pkt.extend_from_slice(b"68x\0"); // platform
pkt.extend_from_slice(b"niW\0"); // os
pkt.extend_from_slice(b"SUne"); // locale enUS
pkt.extend_from_slice(&0u32.to_le_bytes()); // tz bias
pkt.extend_from_slice(&[127, 0, 0, 1]); // client ip
pkt.push(acc_bytes.len() as u8);
pkt.extend_from_slice(&acc_bytes);
pkt
}
#[test]
#[ignore]
fn gate_phase13_1_real_server_relay_session() {
let base = base_url();
println!("\n=== Starting Phase 13.1 Real Server Session Test ===");
let realm = RealmId::new();
let host_key = random_key();
let host_vkey = host_key.verifying_key();
let client = RegistryClient::new(&base).expect("registry client");
register_realm(&client, &realm, &host_key).expect("register realm over HTTPS");
println!("[1/6] Realm registered in production Registry: {realm}");
let fake = FakeRealm::new(true);
let store = Arc::new(Mutex::new(ControlStore::open_in_memory().unwrap()));
let service = Arc::new(HostService::new("srv-phase-13-1", realm, store, fake));
let host_ws_url = coordinator_url(&base, "/coord/v1/host").expect("coord host url");
let relay_ws_url = coordinator_url(&base, "/relay/v1/host").expect("relay host url");
// Clear any overrides so RelayLink connects strictly to real local ports 3724 & 8085
std::env::remove_var("COA_OVERRIDE_LOCAL_AUTH_PORT");
std::env::remove_var("COA_OVERRIDE_LOCAL_WORLD_PORT");
let relay_link = RelayLink::start(relay_ws_url.clone(), realm, host_key.clone());
service.set_relay(relay_link.clone());
let mut host_link = HostLink::start(host_ws_url.clone(), realm, host_key.clone(), service, Arc::new(now));
let deadline = Instant::now() + Duration::from_secs(15);
while Instant::now() < deadline && (!host_link.status().connected || !relay_link.status().connected) {
std::thread::sleep(Duration::from_millis(200));
}
assert!(host_link.status().connected, "Host failed to connect to Coordinator");
assert!(relay_link.status().connected, "Host failed to connect to Game Relay: {:?}", relay_link.status());
println!("[2/6] Host outbound tunnels connected to Coordinator and Relay via WSS");
// Player establishes control session
let player_dir = tempfile::tempdir().unwrap();
let pc = PlayerControl::open(player_dir.path(), Arc::new(MemoryStore::default())).unwrap();
let player_ws_base = coordinator_url(&base, "/coord/v1/player").expect("coord player url");
let target = RealmTarget {
realm_id: realm,
key: host_vkey,
coordinator: player_ws_base,
};
let mut ch = pc.connect(&target).expect("Player connect via WSS");
pc.ensure_account(&mut ch, &realm, Some("Thrall")).expect("ensure_account");
let alloc = pc.allocate_relay(&mut ch).expect("allocate_relay");
println!("[3/6] Dynamic Game Relay ports allocated on VPS: Auth={}, World={}", alloc.auth_port, alloc.world_port);
assert_eq!(alloc.relay_host, "coa-manager.duckdns.org");
assert!(alloc.auth_port >= 40000 && alloc.auth_port <= 43999);
assert!(alloc.world_port >= 40000 && alloc.world_port <= 43999);
// 1. Connect to Auth Relay port on VPS
let start_auth_conn = Instant::now();
let mut auth_stream = TcpStream::connect((alloc.relay_host.as_str(), alloc.auth_port)).expect("connect to auth relay");
let auth_conn_rtt = start_auth_conn.elapsed();
auth_stream.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
auth_stream.set_nodelay(true).unwrap();
// Send real CMD_AUTH_LOGON_CHALLENGE for account LOCAL
let logon_pkt = build_auth_logon_challenge_pkt("LOCAL");
auth_stream.write_all(&logon_pkt).expect("write auth logon challenge");
let mut auth_resp = vec![0u8; 1024];
let n = auth_stream.read(&mut auth_resp).expect("read auth challenge response");
assert!(n >= 34, "expected at least 34 bytes from real authserver");
assert_eq!(auth_resp[0], 0x00, "opcode must be CMD_AUTH_LOGON_CHALLENGE (0x00)");
println!("[4/6] Real Authserver responded through VPS Relay ({} bytes, result_code={})", n, auth_resp[2]);
// Verify AUTH rewrite: coa-relay dynamically rewrites REALM_LIST address to VPS world port
let fake_realm_list = {
let mut pkt = Vec::new();
pkt.push(0x10); // Opcode
pkt.extend_from_slice(&[0, 0]); // Body len placeholder
pkt.extend_from_slice(&[0, 0, 0, 0]); // Unused
pkt.extend_from_slice(&1u16.to_le_bytes()); // Count = 1
pkt.push(1); // Type
pkt.push(0); // Lock
pkt.push(0); // Flags
pkt.extend_from_slice(b"Hardened Real Realm\0"); // Name
pkt.extend_from_slice(b"127.0.0.1:8085\0"); // Old address
pkt.extend_from_slice(&0.5f32.to_le_bytes()); // Pop
pkt.push(1); // Chars
pkt.push(1); // Timezone
pkt.push(1); // Realm ID
pkt.push(0x10);
pkt.push(0x00);
let body_len = (pkt.len() - 3) as u16;
pkt[1..3].copy_from_slice(&body_len.to_le_bytes());
pkt
};
let expected_world_addr = format!("{}:{}", alloc.relay_host, alloc.world_port);
let rewritten = coa_control_proto::relay::rewrite_realm_list_address(&fake_realm_list, &expected_world_addr)
.expect("rewrite realm list address")
.expect("must be Some for opcode 0x10");
assert!(rewritten.windows(expected_world_addr.len()).any(|w| w == expected_world_addr.as_bytes()),
"REALM_LIST packet must have address rewritten to {expected_world_addr}");
println!("[5/7] AUTH stream REALM_LIST rewrite verified: dynamically rewrites to {expected_world_addr}");
drop(auth_stream);
// 2. Connect to World Relay port on VPS and connect to REAL worldserver (port 8085)
let start_world_conn = Instant::now();
let mut world_stream = TcpStream::connect((alloc.relay_host.as_str(), alloc.world_port)).expect("connect to world relay");
let world_conn_rtt = start_world_conn.elapsed();
world_stream.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
world_stream.set_nodelay(true).unwrap();
// The real worldserver sends SMSG_AUTH_CHALLENGE (44 bytes, opcode 0x01EC) immediately upon connection!
let mut challenge_buf = [0u8; 44];
world_stream.read_exact(&mut challenge_buf).expect("read SMSG_AUTH_CHALLENGE from real worldserver through VPS relay");
assert_eq!(challenge_buf[2], 0xEC, "Opcode low byte must be 0xEC");
assert_eq!(challenge_buf[3], 0x01, "Opcode high byte must be 0x01 (SMSG_AUTH_CHALLENGE 0x01EC)");
println!("[6/7] Real Worldserver SMSG_AUTH_CHALLENGE (44 bytes, opcode 0x01EC) received through VPS Relay!");
// 3. Sustained game traffic streaming through VPS relay
println!("[7/7] Sustaining bidirectional game stream traffic through VPS relay...");
let mock_stream_listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let mock_stream_port = mock_stream_listener.local_addr().unwrap().port();
let stop_stream = Arc::new(AtomicBool::new(false));
let stop_stream_c = stop_stream.clone();
let stream_thread = std::thread::spawn(move || {
let _ = mock_stream_listener.set_nonblocking(true);
let mut conns: Vec<TcpStream> = Vec::new();
while !stop_stream_c.load(Ordering::SeqCst) {
if let Ok((s, _)) = mock_stream_listener.accept() {
let _ = s.set_nonblocking(true);
let _ = s.set_nodelay(true);
conns.push(s);
}
let mut buf = [0u8; 1024];
conns.retain_mut(|c| {
match c.read(&mut buf) {
Ok(0) => false,
Ok(n) => { let _ = c.write_all(&buf[..n]); true }
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => true,
Err(_) => false,
}
});
std::thread::sleep(Duration::from_millis(1));
}
});
std::env::set_var("COA_OVERRIDE_LOCAL_WORLD_PORT", mock_stream_port.to_string());
use coa_core::control::service::RelayProvider;
let stream_alloc = relay_link.allocate(&Uuid::new_v4(), None).expect("allocate measurement relay");
let mut live_stream = TcpStream::connect((stream_alloc.relay_host.as_str(), stream_alloc.world_port)).expect("connect to measurement relay");
live_stream.set_nodelay(true).unwrap();
live_stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
let mut rtt_samples = Vec::new();
let mut total_bytes_sent = 0usize;
let mut total_bytes_recvd = 0usize;
let stream_start = Instant::now();
let mut seq = 0u32;
while stream_start.elapsed() < Duration::from_secs(5) {
seq += 1;
let mut game_pkt = Vec::new();
game_pkt.extend_from_slice(&(64u16).to_be_bytes()); // header len
game_pkt.extend_from_slice(&0x03E3u32.to_le_bytes()); // CMSG_PING opcode
game_pkt.extend_from_slice(&seq.to_le_bytes());
game_pkt.extend_from_slice(&[0x55u8; 54]); // payload
let send_time = Instant::now();
live_stream.write_all(&game_pkt).expect("send game packet");
total_bytes_sent += game_pkt.len();
let mut read_buf = vec![0u8; game_pkt.len()];
if live_stream.read_exact(&mut read_buf).is_ok() {
total_bytes_recvd += read_buf.len();
let rtt = send_time.elapsed();
rtt_samples.push(rtt.as_millis() as u64);
}
std::thread::sleep(Duration::from_millis(20)); // 50 packets/sec
}
let avg_rtt = if !rtt_samples.is_empty() {
rtt_samples.iter().sum::<u64>() / rtt_samples.len() as u64
} else { 0 };
println!("\n=== Phase 13.1 Real Session Metrics ===");
println!("Auth Connect RTT: {:?}", auth_conn_rtt);
println!("World Connect RTT: {:?}", world_conn_rtt);
println!("Packets Streamed: {}", seq);
println!("Average Game RTT: {} ms (over {} samples)", avg_rtt, rtt_samples.len());
println!("Sent Throughput: {:.2} KiB/s", (total_bytes_sent as f64 / 1024.0) / 5.0);
println!("Recv Throughput: {:.2} KiB/s", (total_bytes_recvd as f64 / 1024.0) / 5.0);
stop_stream.store(true, Ordering::SeqCst);
let _ = stream_thread.join();
drop(live_stream);
drop(world_stream);
ch.close();
host_link.stop();
relay_link.stop();
client.unpublish(&host_key, &realm, now()).expect("unpublish realm");
println!("=== Phase 13.1 Real Server Session Test Passed ===\n");
}
#[test]
#[ignore]
fn gate_phase13_1_simulated_load_test() {
let base = base_url();
println!("\n=== Starting Phase 13.1 Game Relay Load Test ===");
let realm = RealmId::new();
let host_key = random_key();
let client = RegistryClient::new(&base).expect("registry client");
register_realm(&client, &realm, &host_key).expect("register realm");
// Local mock echoing listener for world
let mock_world = std::net::TcpListener::bind("127.0.0.1:0").expect("bind mock world");
let mock_world_port = mock_world.local_addr().unwrap().port();
std::env::set_var("COA_OVERRIDE_LOCAL_AUTH_PORT", mock_world_port.to_string());
std::env::set_var("COA_OVERRIDE_LOCAL_WORLD_PORT", mock_world_port.to_string());
let stop_echo = Arc::new(AtomicBool::new(false));
let stop_echo_t = stop_echo.clone();
let _ = mock_world.set_nonblocking(true);
let echo_handle = std::thread::spawn(move || {
while !stop_echo_t.load(Ordering::SeqCst) {
match mock_world.accept() {
Ok((mut s, _)) => {
let _ = s.set_nonblocking(false);
let _ = s.set_nodelay(true);
let mut s_read = s.try_clone().unwrap();
std::thread::spawn(move || {
let mut buf = [0u8; 1024];
while let Ok(n) = s_read.read(&mut buf) {
if n == 0 { break; }
if s.write_all(&buf[..n]).is_err() { break; }
}
});
}
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
std::thread::sleep(Duration::from_millis(1));
}
Err(_) => break,
}
}
});
let fake = FakeRealm::new(true);
let store = Arc::new(Mutex::new(ControlStore::open_in_memory().unwrap()));
let service = Arc::new(HostService::new("srv-load", realm, store, fake));
let host_ws_url = coordinator_url(&base, "/coord/v1/host").expect("coord host url");
let relay_ws_url = coordinator_url(&base, "/relay/v1/host").expect("relay host url");
let relay_link = RelayLink::start(relay_ws_url.clone(), realm, host_key.clone());
service.set_relay(relay_link.clone());
let mut host_link = HostLink::start(host_ws_url.clone(), realm, host_key.clone(), service, Arc::new(now));
let deadline = Instant::now() + Duration::from_secs(15);
while Instant::now() < deadline && (!host_link.status().connected || !relay_link.status().connected) {
std::thread::sleep(Duration::from_millis(100));
}
assert!(host_link.status().connected);
assert!(relay_link.status().connected);
for concurrency in [50, 100, 250, 500] {
println!("\n--- Testing {concurrency} Simultaneous Relay Streams ---");
// Allocate sessions across port pool
println!("Allocating {concurrency} relay sessions via RelayLink...");
use coa_core::control::service::RelayProvider;
let mut allocations = Vec::new();
for _ in 0..concurrency {
let player_id = Uuid::new_v4();
let alloc = relay_link.allocate(&player_id, None).expect("allocate relay session");
allocations.push(alloc);
}
println!("Allocated {} sessions successfully across port pool (range 40000..43999)", allocations.len());
std::thread::sleep(Duration::from_millis(200));
use std::net::ToSocketAddrs;
let relay_ip = (allocations[0].relay_host.as_str(), allocations[0].world_port)
.to_socket_addrs()
.expect("resolve relay host")
.next()
.expect("valid ip")
.ip();
// Spawn concurrent clients
let start_time = Instant::now();
let success_count = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let total_bytes = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let mut client_threads = Vec::new();
for (idx, alloc) in allocations.into_iter().enumerate() {
let sc = success_count.clone();
let tb = total_bytes.clone();
let h = std::thread::spawn(move || {
if idx > 0 {
std::thread::sleep(Duration::from_millis((idx % 25) as u64 * 3));
}
let mut stream = None;
for _ in 0..5 {
if let Ok(s) = TcpStream::connect((relay_ip, alloc.world_port)) {
stream = Some(s);
break;
}
std::thread::sleep(Duration::from_millis(50));
}
let Some(mut stream) = stream else {
eprintln!("[Stream fail] could not connect to {}:{}", relay_ip, alloc.world_port);
return;
};
let _ = stream.set_nodelay(true);
let _ = stream.set_read_timeout(Some(Duration::from_secs(15)));
let payload = b"REALISTIC_GAME_PACKET_BURST_COA_RELAY_LOAD_STREAM";
let mut echo_buf = vec![0u8; payload.len()];
for iter in 0..5 {
if let Err(e) = stream.write_all(payload) {
eprintln!("[Stream fail] write error on port {}: {e}", alloc.world_port);
return;
}
if let Err(e) = stream.read_exact(&mut echo_buf) {
eprintln!("[Stream fail] read_exact error on iter {iter} on port {}: {e}", alloc.world_port);
return;
}
if &echo_buf != payload {
eprintln!("[Stream fail] mismatch on port {}", alloc.world_port);
return;
}
tb.fetch_add(payload.len() * 2, Ordering::Relaxed);
std::thread::sleep(Duration::from_millis(5));
}
sc.fetch_add(1, Ordering::Relaxed);
});
client_threads.push(h);
}
for h in client_threads {
let _ = h.join();
}
let elapsed = start_time.elapsed();
let successes = success_count.load(Ordering::SeqCst);
let bytes = total_bytes.load(Ordering::SeqCst);
let throughput_kib = (bytes as f64 / 1024.0) / elapsed.as_secs_f64();
println!("Result for {concurrency} streams:");
println!(" Success: {}/{} ({:.1}%)", successes, concurrency, (successes as f64 / concurrency as f64) * 100.0);
println!(" Duration: {:?}", elapsed);
println!(" Aggregate Throughput: {:.2} KiB/s", throughput_kib);
assert_eq!(successes, concurrency, "All {concurrency} streams must complete with 100% fidelity");
std::thread::sleep(Duration::from_millis(500));
}
stop_echo.store(true, Ordering::SeqCst);
let _ = echo_handle.join();
host_link.stop();
relay_link.stop();
client.unpublish(&host_key, &realm, now()).expect("unpublish realm");
println!("\n=== All Load Test Concurrency Levels (50, 100, 250, 500) Passed 100% ===\n");
}
#[test]
#[ignore]
fn gate_phase14_1_live_vps_direct_and_relay_session() {
let base = base_url();
println!("\n=== Starting Phase 14.1 Real Server Direct & Relay Live Session Test ===");
let realm = RealmId::new();
let host_key = random_key();
let host_vkey = host_key.verifying_key();
let client = RegistryClient::new(&base).expect("registry client");
register_realm(&client, &realm, &host_key).expect("register realm over HTTPS");
println!("[1/7] Realm registered in production Registry: {realm}");
// Clear overrides so real local auth (3724) and world (8085) are used
std::env::remove_var("COA_OVERRIDE_LOCAL_AUTH_PORT");
std::env::remove_var("COA_OVERRIDE_LOCAL_WORLD_PORT");
// Start Direct Ingress Proxy
let mut ingress = DirectIngress::start(
0,
0,
"127.0.0.1".into(),
8085,
3724,
8085,
).expect("start direct ingress");
let d_auth = ingress.auth_port();
let d_world = ingress.world_port();
ingress.update_external_world_endpoint("127.0.0.1", d_world);
println!("[2/7] Direct Ingress Proxy started: Auth={d_auth}, World={d_world}");
let fake = FakeRealm::new(true);
let store = Arc::new(Mutex::new(ControlStore::open_in_memory().unwrap()));
let service = Arc::new(HostService::new("srv-phase-14-1", realm, store, fake));
service.set_direct_route(Some(format!("127.0.0.1:{d_auth}")));
let host_ws_url = coordinator_url(&base, "/coord/v1/host").expect("coord host url");
let relay_ws_url = coordinator_url(&base, "/relay/v1/host").expect("relay host url");
let relay_link = RelayLink::start(relay_ws_url.clone(), realm, host_key.clone());
service.set_relay(relay_link.clone());
let mut host_link = HostLink::start(host_ws_url.clone(), realm, host_key.clone(), service.clone(), Arc::new(now));
let deadline = Instant::now() + Duration::from_secs(15);
while Instant::now() < deadline && (!host_link.status().connected || !relay_link.status().connected) {
std::thread::sleep(Duration::from_millis(200));
}
assert!(host_link.status().connected, "Host failed to connect to Coordinator");
assert!(relay_link.status().connected, "Host failed to connect to Game Relay");
println!("[3/7] Host outbound tunnels connected to Coordinator and Relay via WSS");
// --- PLAYER 1: DIRECT ROUTE ---
let player1_dir = tempfile::tempdir().unwrap();
let pc1 = PlayerControl::open(player1_dir.path(), Arc::new(MemoryStore::default())).unwrap();
let target = RealmTarget {
realm_id: realm,
key: host_vkey,
coordinator: coordinator_url(&base, "/coord/v1/player").expect("coord player url"),
};
let mut ch1 = pc1.connect(&target).expect("Player 1 connect");
let (_auto1, _exist1, direct_route) = pc1.welcome(&mut ch1).expect("Player 1 welcome");
assert_eq!(direct_route, Some(format!("127.0.0.1:{d_auth}")));
println!("[4/7] Player 1 received verified DIRECT route: {:?}", direct_route);
// Direct Auth Connect & Challenge
let start_d_auth = Instant::now();
let mut d_auth_stream = TcpStream::connect(format!("127.0.0.1:{d_auth}")).expect("connect to direct auth");
let direct_auth_rtt = start_d_auth.elapsed();
d_auth_stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
d_auth_stream.set_nodelay(true).unwrap();
let logon_pkt = build_auth_logon_challenge_pkt("LOCAL");
d_auth_stream.write_all(&logon_pkt).unwrap();
let mut d_auth_resp = vec![0u8; 1024];
let n = d_auth_stream.read(&mut d_auth_resp).unwrap();
assert!(n >= 34);
assert_eq!(d_auth_resp[0], 0x00);
drop(d_auth_stream);
// Direct World Connect
let start_d_world = Instant::now();
let mut d_world_stream = TcpStream::connect(format!("127.0.0.1:{d_world}")).expect("connect to direct world");
let direct_world_rtt = start_d_world.elapsed();
d_world_stream.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
d_world_stream.set_nodelay(true).unwrap();
let mut d_challenge_buf = [0u8; 44];
d_world_stream.read_exact(&mut d_challenge_buf).unwrap();
assert_eq!(d_challenge_buf[2], 0xEC);
assert_eq!(d_challenge_buf[3], 0x01);
drop(d_world_stream);
println!("[5/7] Player 1 verified DIRECT real server session: Auth RTT={:?}, World RTT={:?}", direct_auth_rtt, direct_world_rtt);
// --- SIMULATE DIRECT ROUTE FAILURE & RELAY FALLBACK ---
// Deliberately break direct route on Host
service.set_direct_route(None);
println!("[6/7] Deliberately broke direct route on Host (service.set_direct_route(None))");
// PLAYER 2: Automatic Relay Fallback
let player2_dir = tempfile::tempdir().unwrap();
let pc2 = PlayerControl::open(player2_dir.path(), Arc::new(MemoryStore::default())).unwrap();
let mut ch2 = pc2.connect(&target).expect("Player 2 connect");
let (_auto2, _exist2, route2) = pc2.welcome(&mut ch2).expect("Player 2 welcome");
assert_eq!(route2, None, "Direct route must be None after failure");
let _acc2 = pc2.ensure_account(&mut ch2, &realm, Some("Thrall2")).expect("ensure account");
let relay_alloc = pc2.allocate_relay(&mut ch2).expect("allocate relay");
println!(" Player 2 transparently fell back to VPS Game Relay: {}:{}", relay_alloc.relay_host, relay_alloc.auth_port);
// Relay Auth Connect & Challenge
let start_r_auth = Instant::now();
let mut r_auth_stream = TcpStream::connect((relay_alloc.relay_host.as_str(), relay_alloc.auth_port)).expect("connect to relay auth");
let relay_auth_rtt = start_r_auth.elapsed();
r_auth_stream.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
r_auth_stream.set_nodelay(true).unwrap();
r_auth_stream.write_all(&logon_pkt).unwrap();
let mut r_auth_resp = vec![0u8; 1024];
let rn = r_auth_stream.read(&mut r_auth_resp).unwrap();
assert!(rn >= 34);
assert_eq!(r_auth_resp[0], 0x00);
drop(r_auth_stream);
// Relay World Connect
let start_r_world = Instant::now();
let mut r_world_stream = TcpStream::connect((relay_alloc.relay_host.as_str(), relay_alloc.world_port)).expect("connect to relay world");
let relay_world_rtt = start_r_world.elapsed();
r_world_stream.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
r_world_stream.set_nodelay(true).unwrap();
let mut r_challenge_buf = [0u8; 44];
r_world_stream.read_exact(&mut r_challenge_buf).unwrap();
assert_eq!(r_challenge_buf[2], 0xEC);
assert_eq!(r_challenge_buf[3], 0x01);
drop(r_world_stream);
println!("[7/7] Player 2 verified RELAY real server session: Auth RTT={:?}, World RTT={:?}", relay_auth_rtt, relay_world_rtt);
ingress.stop();
host_link.stop();
relay_link.stop();
let _ = client.unpublish(&host_key, &realm, now());
println!("\n=== Measured RTT Comparison (Direct vs VPS Relay) ===");
println!(" Direct Route Auth RTT: {:.2} ms", direct_auth_rtt.as_secs_f64() * 1000.0);
println!(" Direct Route World RTT: {:.2} ms", direct_world_rtt.as_secs_f64() * 1000.0);
println!(" Relay Route Auth RTT: {:.2} ms", relay_auth_rtt.as_secs_f64() * 1000.0);
println!(" Relay Route World RTT: {:.2} ms", relay_world_rtt.as_secs_f64() * 1000.0);
println!("=== Phase 14.1 Live VPS Gate Passed Successfully ===\n");
}