mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 19:25:56 +00:00
628 lines
29 KiB
Rust
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");
|
|
}
|
|
|