mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-20 11:25:56 +00:00
526 lines
22 KiB
Rust
526 lines
22 KiB
Rust
use std::net::SocketAddr;
|
|
use std::sync::Arc;
|
|
|
|
use base64::Engine;
|
|
use coa_control_proto::relay::*;
|
|
|
|
use coa_registry_proto::RealmId;
|
|
use coa_relay::hub::{Hub, MemoryKeys};
|
|
use coa_relay::router;
|
|
use ed25519_dalek::SigningKey;
|
|
use futures_util::{SinkExt, StreamExt};
|
|
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
|
use tokio::net::{TcpListener, TcpStream};
|
|
use tokio_tungstenite::connect_async;
|
|
use tokio_tungstenite::tungstenite::Message;
|
|
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)
|
|
}
|
|
|
|
struct TestServer {
|
|
addr: SocketAddr,
|
|
hub: Arc<Hub<Arc<MemoryKeys>>>,
|
|
keys: Arc<MemoryKeys>,
|
|
}
|
|
|
|
async fn start_test_relay(min_port: u16, max_port: u16) -> TestServer {
|
|
let keys = Arc::new(MemoryKeys::default());
|
|
let hub = Arc::new(Hub::new(
|
|
"127.0.0.1".into(),
|
|
min_port,
|
|
max_port,
|
|
keys.clone(),
|
|
Arc::new(now),
|
|
));
|
|
let app = router(hub.clone());
|
|
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let addr = listener.local_addr().unwrap();
|
|
|
|
tokio::spawn(async move {
|
|
axum::serve(listener, app.into_make_service()).await.unwrap();
|
|
});
|
|
|
|
TestServer { addr, hub, keys }
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_health_endpoint() {
|
|
let srv = start_test_relay(45000, 45010).await;
|
|
let mut stream = TcpStream::connect(srv.addr).await.unwrap();
|
|
stream.write_all(b"GET /relay/v1/health HTTP/1.1\r\nHost: localhost\r\n\r\n").await.unwrap();
|
|
let mut resp = String::new();
|
|
let mut buf = [0u8; 512];
|
|
for _ in 0..5 {
|
|
let n = stream.read(&mut buf).await.unwrap();
|
|
if n == 0 { break; }
|
|
resp.push_str(&String::from_utf8_lossy(&buf[..n]));
|
|
if resp.contains("coa-relay") { break; }
|
|
}
|
|
assert!(resp.contains("HTTP/1.1 200 OK"));
|
|
assert!(resp.contains("coa-relay"));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_host_auth_and_allocation_and_game_traffic() {
|
|
let srv = start_test_relay(45100, 45110).await;
|
|
let realm_id = RealmId::new();
|
|
let signing_key = random_key();
|
|
srv.keys.set(realm_id, &signing_key.verifying_key());
|
|
|
|
// 1. Connect Host WebSocket to relay
|
|
let ws_url = format!("ws://{}/relay/v1/host", srv.addr);
|
|
let (ws_stream, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut ws_sink, mut ws_src) = ws_stream.split();
|
|
|
|
// 2. Receive challenge
|
|
let challenge_msg = ws_src.next().await.unwrap().unwrap();
|
|
let challenge_txt = challenge_msg.to_text().unwrap();
|
|
let challenge: RelayChallenge = serde_json::from_str(challenge_txt).unwrap();
|
|
|
|
// 3. Send HostHello
|
|
let sig = sign_relay_challenge(&signing_key, &realm_id, &challenge.nonce);
|
|
let hello = HostHello { realm_id, signature: sig };
|
|
ws_sink.send(Message::Text(serde_json::to_string(&hello).unwrap().into())).await.unwrap();
|
|
|
|
// 4. Receive welcome
|
|
let welcome_msg = ws_src.next().await.unwrap().unwrap();
|
|
let welcome: RelayWelcome = serde_json::from_str(welcome_msg.to_text().unwrap()).unwrap();
|
|
assert!(welcome.ok, "Host welcome should be ok");
|
|
|
|
// 5. Host asks for allocation
|
|
let player_id = Uuid::new_v4();
|
|
let alloc_req = TunnelMsg::Allocate { request_id: 1, player_id, expected_client_ip: None };
|
|
ws_sink.send(Message::Text(serde_json::to_string(&alloc_req).unwrap().into())).await.unwrap();
|
|
|
|
let alloc_msg = ws_src.next().await.unwrap().unwrap();
|
|
let TunnelMsg::AllocateOk { request_id, auth_port, world_port, token, .. } = serde_json::from_str(alloc_msg.to_text().unwrap()).unwrap() else {
|
|
panic!("expected AllocateOk");
|
|
};
|
|
assert_eq!(request_id, 1);
|
|
assert!(auth_port >= 45100 && auth_port <= 45110);
|
|
assert!(world_port >= 45100 && world_port <= 45110);
|
|
assert_ne!(auth_port, world_port);
|
|
|
|
// 7. Client connects to Relay AUTH port
|
|
|
|
let client_task = tokio::spawn(async move {
|
|
let mut client_auth = TcpStream::connect(format!("127.0.0.1:{auth_port}")).await.unwrap();
|
|
// Client sends auth packet
|
|
client_auth.write_all(b"CLIENT_AUTH_HELLO").await.unwrap();
|
|
|
|
// Read response (expected REALM_LIST rewritten)
|
|
let mut resp = vec![0u8; 1024];
|
|
let n = client_auth.read(&mut resp).await.unwrap();
|
|
resp.truncate(n);
|
|
resp
|
|
});
|
|
|
|
// 8. Host tunnel receives Connect for AUTH
|
|
let connect_msg = ws_src.next().await.unwrap().unwrap();
|
|
let TunnelMsg::Connect { stream_id, target, token: conn_token } = serde_json::from_str(connect_msg.to_text().unwrap()).unwrap() else {
|
|
panic!("expected Connect");
|
|
};
|
|
assert_eq!(target, RelayTarget::Auth);
|
|
assert_eq!(conn_token, token);
|
|
|
|
// Host acknowledges connect
|
|
ws_sink.send(Message::Text(serde_json::to_string(&TunnelMsg::ConnectOk { stream_id }).unwrap().into())).await.unwrap();
|
|
|
|
|
|
// Relay forwards client data to Host
|
|
let data_msg = ws_src.next().await.unwrap().unwrap();
|
|
let TunnelMsg::Data { chunk, .. } = serde_json::from_str(data_msg.to_text().unwrap()).unwrap() else {
|
|
panic!("expected Data");
|
|
};
|
|
let payload = base64::engine::general_purpose::STANDARD.decode(chunk).unwrap();
|
|
assert_eq!(payload, b"CLIENT_AUTH_HELLO");
|
|
|
|
// Local auth backend sends REALM_LIST packet
|
|
let mut pkt = Vec::new();
|
|
pkt.push(0x10); // Opcode
|
|
pkt.extend_from_slice(&[0, 0]); // Length
|
|
pkt.extend_from_slice(&[0, 0, 0, 0]); // Unused
|
|
pkt.extend_from_slice(&1u16.to_le_bytes()); // Realm count
|
|
pkt.push(1); pkt.push(0); pkt.push(0);
|
|
pkt.extend_from_slice(b"CoA\0");
|
|
pkt.extend_from_slice(b"127.0.0.1:8085\0"); // Old address
|
|
pkt.extend_from_slice(&0.5f32.to_le_bytes());
|
|
pkt.push(1); pkt.push(1); pkt.push(1);
|
|
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());
|
|
|
|
// Host sends this packet through tunnel to Relay
|
|
let b64_pkt = base64::engine::general_purpose::STANDARD.encode(&pkt);
|
|
ws_sink.send(Message::Text(serde_json::to_string(&TunnelMsg::Data { stream_id, chunk: b64_pkt }).unwrap().into())).await.unwrap();
|
|
|
|
// Client receives rewritten packet
|
|
let client_recvd = client_task.await.unwrap();
|
|
assert_eq!(client_recvd[0], 0x10);
|
|
// Must contain rewritten address (127.0.0.1:45101)
|
|
let expected_addr = format!("127.0.0.1:{world_port}").into_bytes();
|
|
assert!(client_recvd.windows(expected_addr.len()).any(|w| w == expected_addr), "client received rewritten world address");
|
|
|
|
// 9. Client connects to Relay WORLD port
|
|
let client_world_task = tokio::spawn(async move {
|
|
let mut client_world = TcpStream::connect(format!("127.0.0.1:{world_port}")).await.unwrap();
|
|
client_world.write_all(b"PING_WORLD_PACKET").await.unwrap();
|
|
let mut resp = [0u8; 17];
|
|
client_world.read_exact(&mut resp).await.unwrap();
|
|
resp
|
|
});
|
|
|
|
// Host receives Connect for WORLD (skipping any Close/Reset from stream 1)
|
|
let (world_sid, world_target) = loop {
|
|
let msg = ws_src.next().await.unwrap().unwrap();
|
|
match serde_json::from_str::<TunnelMsg>(msg.to_text().unwrap()).unwrap() {
|
|
TunnelMsg::Connect { stream_id, target, .. } => break (stream_id, target),
|
|
TunnelMsg::Close { .. } | TunnelMsg::Reset { .. } => continue,
|
|
other => panic!("unexpected msg awaiting Connect: {other:?}"),
|
|
}
|
|
};
|
|
assert_eq!(world_target, RelayTarget::World);
|
|
|
|
// Host acknowledges
|
|
ws_sink.send(Message::Text(serde_json::to_string(&TunnelMsg::ConnectOk { stream_id: world_sid }).unwrap().into())).await.unwrap();
|
|
|
|
// Host receives world data (skipping any Close/Reset from stream 1)
|
|
let world_chunk = loop {
|
|
let msg = ws_src.next().await.unwrap().unwrap();
|
|
match serde_json::from_str::<TunnelMsg>(msg.to_text().unwrap()).unwrap() {
|
|
TunnelMsg::Data { stream_id, chunk } if stream_id == world_sid => break chunk,
|
|
TunnelMsg::Close { .. } | TunnelMsg::Reset { .. } => continue,
|
|
other => panic!("unexpected msg awaiting Data: {other:?}"),
|
|
}
|
|
};
|
|
assert_eq!(base64::engine::general_purpose::STANDARD.decode(world_chunk).unwrap(), b"PING_WORLD_PACKET");
|
|
|
|
|
|
// Host echoes back
|
|
let pong_b64 = base64::engine::general_purpose::STANDARD.encode(b"PONG_WORLD_PACKET");
|
|
ws_sink.send(Message::Text(serde_json::to_string(&TunnelMsg::Data { stream_id: world_sid, chunk: pong_b64 }).unwrap().into())).await.unwrap();
|
|
|
|
let client_world_recvd = client_world_task.await.unwrap();
|
|
assert_eq!(&client_world_recvd, b"PONG_WORLD_PACKET");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_rejects_unauthorized_host() {
|
|
let srv = start_test_relay(45200, 45210).await;
|
|
let realm_id = RealmId::new();
|
|
let signing_key = random_key();
|
|
// Do NOT register realm in keys
|
|
|
|
let ws_url = format!("ws://{}/relay/v1/host", srv.addr);
|
|
let (ws_stream, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut ws_sink, mut ws_src) = ws_stream.split();
|
|
|
|
let challenge_msg = ws_src.next().await.unwrap().unwrap();
|
|
let challenge: RelayChallenge = serde_json::from_str(challenge_msg.to_text().unwrap()).unwrap();
|
|
|
|
let sig = sign_relay_challenge(&signing_key, &realm_id, &challenge.nonce);
|
|
let hello = HostHello { realm_id, signature: sig };
|
|
ws_sink.send(Message::Text(serde_json::to_string(&hello).unwrap().into())).await.unwrap();
|
|
|
|
match ws_src.next().await {
|
|
Some(Ok(welcome_msg)) => {
|
|
let welcome: RelayWelcome = serde_json::from_str(welcome_msg.to_text().unwrap()).unwrap();
|
|
assert!(!welcome.ok, "Unauthorized host must be rejected");
|
|
}
|
|
Some(Err(_)) | None => {
|
|
// Connection closed/terminated on rejection as expected
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_allocation_bounds() {
|
|
// Port pool has 4 ports
|
|
let srv = start_test_relay(45300, 45303).await;
|
|
let realm = RealmId::new();
|
|
|
|
let alloc1 = srv.hub.allocate(realm, Uuid::new_v4(), None).unwrap();
|
|
assert_eq!(srv.hub.pool.available_count(), 2);
|
|
|
|
let alloc2 = srv.hub.allocate(realm, Uuid::new_v4(), None).unwrap();
|
|
assert_eq!(srv.hub.pool.available_count(), 0);
|
|
|
|
// Third allocation exhausts ports
|
|
let alloc3 = srv.hub.allocate(realm, Uuid::new_v4(), None);
|
|
assert!(alloc3.is_err(), "must fail when ports exhausted");
|
|
|
|
// Releasing one port frees it
|
|
srv.hub.release_port(alloc1.auth_port);
|
|
assert_eq!(srv.hub.pool.available_count(), 1);
|
|
srv.hub.release_port(alloc1.world_port);
|
|
assert_eq!(srv.hub.pool.available_count(), 2);
|
|
srv.hub.release_port(alloc2.auth_port);
|
|
srv.hub.release_port(alloc2.world_port);
|
|
assert_eq!(srv.hub.pool.available_count(), 4);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_wrong_source_ip_rejected() {
|
|
let srv = start_test_relay(45400, 45410).await;
|
|
let realm_id = RealmId::new();
|
|
let signing_key = random_key();
|
|
srv.keys.set(realm_id, &signing_key.verifying_key());
|
|
|
|
let ws_url = format!("ws://{}/relay/v1/host", srv.addr);
|
|
let (ws_stream, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut ws_sink, mut ws_src) = ws_stream.split();
|
|
|
|
let challenge_msg = ws_src.next().await.unwrap().unwrap();
|
|
let challenge: RelayChallenge = serde_json::from_str(challenge_msg.to_text().unwrap()).unwrap();
|
|
let sig = sign_relay_challenge(&signing_key, &realm_id, &challenge.nonce);
|
|
ws_sink.send(Message::Text(serde_json::to_string(&HostHello { realm_id, signature: sig }).unwrap().into())).await.unwrap();
|
|
let _ = ws_src.next().await.unwrap().unwrap();
|
|
|
|
// Allocate with expected IP = 10.99.99.99 (different from 127.0.0.1)
|
|
let alloc_req = TunnelMsg::Allocate {
|
|
request_id: 1,
|
|
player_id: Uuid::new_v4(),
|
|
expected_client_ip: Some("10.99.99.99".into()),
|
|
};
|
|
ws_sink.send(Message::Text(serde_json::to_string(&alloc_req).unwrap().into())).await.unwrap();
|
|
|
|
let alloc_msg = ws_src.next().await.unwrap().unwrap();
|
|
let TunnelMsg::AllocateOk { auth_port, world_port: _, .. } = serde_json::from_str(alloc_msg.to_text().unwrap()).unwrap() else {
|
|
panic!("expected AllocateOk");
|
|
};
|
|
|
|
// Client connects from 127.0.0.1
|
|
let mut client = TcpStream::connect(format!("127.0.0.1:{auth_port}")).await.unwrap();
|
|
// Socket should be immediately closed by relay because source IP does not match expected_client_ip
|
|
let mut buf = [0u8; 16];
|
|
let n = match client.read(&mut buf).await {
|
|
Ok(n) => n,
|
|
Err(e) if e.kind() == std::io::ErrorKind::ConnectionReset => 0,
|
|
Err(e) => panic!("unexpected error: {e}"),
|
|
};
|
|
assert_eq!(n, 0, "connection must be closed immediately on source IP mismatch");
|
|
|
|
// The auth port should now be released
|
|
// Wait briefly for release task to settle
|
|
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
|
|
// World port is still reserved until it expires or is hit
|
|
assert!(srv.hub.pool.available_count() >= 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_host_disconnect_reclaims_all_ports() {
|
|
let srv = start_test_relay(45500, 45503).await;
|
|
let realm_id = RealmId::new();
|
|
let signing_key = random_key();
|
|
srv.keys.set(realm_id, &signing_key.verifying_key());
|
|
|
|
let ws_url = format!("ws://{}/relay/v1/host", srv.addr);
|
|
let (ws_stream, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut ws_sink, mut ws_src) = ws_stream.split();
|
|
|
|
let challenge_msg = ws_src.next().await.unwrap().unwrap();
|
|
let challenge: RelayChallenge = serde_json::from_str(challenge_msg.to_text().unwrap()).unwrap();
|
|
let sig = sign_relay_challenge(&signing_key, &realm_id, &challenge.nonce);
|
|
ws_sink.send(Message::Text(serde_json::to_string(&HostHello { realm_id, signature: sig }).unwrap().into())).await.unwrap();
|
|
let _ = ws_src.next().await.unwrap().unwrap();
|
|
|
|
// Allocate all 4 ports
|
|
for i in 1..=2 {
|
|
let alloc_req = TunnelMsg::Allocate {
|
|
request_id: i,
|
|
player_id: Uuid::new_v4(),
|
|
expected_client_ip: None,
|
|
};
|
|
ws_sink.send(Message::Text(serde_json::to_string(&alloc_req).unwrap().into())).await.unwrap();
|
|
let _ = ws_src.next().await.unwrap().unwrap();
|
|
}
|
|
assert_eq!(srv.hub.pool.available_count(), 0);
|
|
|
|
// Host disconnects (drop ws_sink)
|
|
drop(ws_sink);
|
|
drop(ws_src);
|
|
|
|
// Wait briefly for disconnect cleanup
|
|
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
|
|
|
// All 4 ports should be reclaimed immediately
|
|
assert_eq!(srv.hub.pool.available_count(), 4);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_expiration_reclaims_ports() {
|
|
let keys = Arc::new(MemoryKeys::default());
|
|
let current_time = Arc::new(std::sync::atomic::AtomicI64::new(1000));
|
|
let clock_time = current_time.clone();
|
|
let hub = Arc::new(Hub::new(
|
|
"127.0.0.1".into(),
|
|
45600,
|
|
45603,
|
|
keys,
|
|
Arc::new(move || clock_time.load(std::sync::atomic::Ordering::Relaxed)),
|
|
));
|
|
|
|
let realm = RealmId::new();
|
|
let _alloc = hub.allocate(realm, Uuid::new_v4(), None).unwrap();
|
|
assert_eq!(hub.pool.available_count(), 2);
|
|
|
|
// Advance clock past expiration (ALLOCATION_TIMEOUT is 120s)
|
|
current_time.fetch_add(200, std::sync::atomic::Ordering::Relaxed);
|
|
hub.reap_expired();
|
|
|
|
// Ports should be reclaimed
|
|
assert_eq!(hub.pool.available_count(), 4);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_strictly_forbids_mysql_and_ra() {
|
|
// Verify target enum only contains Auth and World
|
|
assert_eq!(RelayTarget::Auth.local_port(), 3724);
|
|
assert_eq!(RelayTarget::World.local_port(), 8085);
|
|
|
|
// Ensure deserializing unauthorized targets fails
|
|
let bad_json = r#"{"cmd":"connect","stream_id":1,"target":"mysql","token":"abc"}"#;
|
|
assert!(serde_json::from_str::<TunnelMsg>(bad_json).is_err());
|
|
let bad_json_ra = r#"{"cmd":"connect","stream_id":1,"target":"ra","token":"abc"}"#;
|
|
assert!(serde_json::from_str::<TunnelMsg>(bad_json_ra).is_err());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_cross_realm_isolation() {
|
|
let srv = start_test_relay(45700, 45710).await;
|
|
let realm_a = RealmId::new();
|
|
let realm_b = RealmId::new();
|
|
let key_a = random_key();
|
|
let key_b = random_key();
|
|
srv.keys.set(realm_a, &key_a.verifying_key());
|
|
srv.keys.set(realm_b, &key_b.verifying_key());
|
|
|
|
// Connect Host A
|
|
let ws_url = format!("ws://{}/relay/v1/host", srv.addr);
|
|
let (ws_stream_a, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut sink_a, mut src_a) = ws_stream_a.split();
|
|
let challenge_a: RelayChallenge = serde_json::from_str(src_a.next().await.unwrap().unwrap().to_text().unwrap()).unwrap();
|
|
let sig_a = sign_relay_challenge(&key_a, &realm_a, &challenge_a.nonce);
|
|
sink_a.send(Message::Text(serde_json::to_string(&HostHello { realm_id: realm_a, signature: sig_a }).unwrap().into())).await.unwrap();
|
|
let _ = src_a.next().await.unwrap().unwrap();
|
|
|
|
// Connect Host B
|
|
let (ws_stream_b, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut sink_b, mut src_b) = ws_stream_b.split();
|
|
let challenge_b: RelayChallenge = serde_json::from_str(src_b.next().await.unwrap().unwrap().to_text().unwrap()).unwrap();
|
|
let sig_b = sign_relay_challenge(&key_b, &realm_b, &challenge_b.nonce);
|
|
sink_b.send(Message::Text(serde_json::to_string(&HostHello { realm_id: realm_b, signature: sig_b }).unwrap().into())).await.unwrap();
|
|
let _ = src_b.next().await.unwrap().unwrap();
|
|
|
|
// Realm A allocates ports
|
|
let player_a = Uuid::new_v4();
|
|
sink_a.send(Message::Text(serde_json::to_string(&TunnelMsg::Allocate {
|
|
request_id: 1,
|
|
player_id: player_a,
|
|
expected_client_ip: None,
|
|
}).unwrap().into())).await.unwrap();
|
|
|
|
let alloc_msg = src_a.next().await.unwrap().unwrap();
|
|
let TunnelMsg::AllocateOk { auth_port, .. } = serde_json::from_str(alloc_msg.to_text().unwrap()).unwrap() else {
|
|
panic!("expected AllocateOk for Realm A");
|
|
};
|
|
|
|
// Client connects to Realm A's auth port
|
|
let mut client = TcpStream::connect(format!("127.0.0.1:{auth_port}")).await.unwrap();
|
|
client.write_all(b"ISOLATION_TEST_PAYLOAD").await.unwrap();
|
|
|
|
// Host A receives Connect
|
|
let connect_msg_a = src_a.next().await.unwrap().unwrap();
|
|
let TunnelMsg::Connect { stream_id, target, .. } = serde_json::from_str(connect_msg_a.to_text().unwrap()).unwrap() else {
|
|
panic!("expected Connect on Host A");
|
|
};
|
|
assert_eq!(target, RelayTarget::Auth);
|
|
sink_a.send(Message::Text(serde_json::to_string(&TunnelMsg::ConnectOk { stream_id }).unwrap().into())).await.unwrap();
|
|
|
|
// Host A receives Data
|
|
let data_msg_a = src_a.next().await.unwrap().unwrap();
|
|
let TunnelMsg::Data { chunk, .. } = serde_json::from_str(data_msg_a.to_text().unwrap()).unwrap() else {
|
|
panic!("expected Data on Host A");
|
|
};
|
|
assert_eq!(base64::engine::general_purpose::STANDARD.decode(chunk).unwrap(), b"ISOLATION_TEST_PAYLOAD");
|
|
|
|
// Host B must NOT have received any message for Realm A
|
|
tokio::select! {
|
|
msg = src_b.next() => {
|
|
panic!("Host B received unexpected message: {msg:?}");
|
|
}
|
|
_ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {
|
|
// Expected: Host B received nothing
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_relay_backpressure_and_slow_receiver() {
|
|
let srv = start_test_relay(45800, 45810).await;
|
|
let realm_id = RealmId::new();
|
|
let key = random_key();
|
|
srv.keys.set(realm_id, &key.verifying_key());
|
|
|
|
let ws_url = format!("ws://{}/relay/v1/host", srv.addr);
|
|
let (ws_stream, _) = connect_async(&ws_url).await.unwrap();
|
|
let (mut sink, mut src) = ws_stream.split();
|
|
let challenge: RelayChallenge = serde_json::from_str(src.next().await.unwrap().unwrap().to_text().unwrap()).unwrap();
|
|
let sig = sign_relay_challenge(&key, &realm_id, &challenge.nonce);
|
|
sink.send(Message::Text(serde_json::to_string(&HostHello { realm_id, signature: sig }).unwrap().into())).await.unwrap();
|
|
let _ = src.next().await.unwrap().unwrap();
|
|
|
|
sink.send(Message::Text(serde_json::to_string(&TunnelMsg::Allocate {
|
|
request_id: 1,
|
|
player_id: Uuid::new_v4(),
|
|
expected_client_ip: None,
|
|
}).unwrap().into())).await.unwrap();
|
|
|
|
let TunnelMsg::AllocateOk { world_port, .. } = serde_json::from_str(src.next().await.unwrap().unwrap().to_text().unwrap()).unwrap() else {
|
|
panic!("expected AllocateOk");
|
|
};
|
|
|
|
let client = TcpStream::connect(format!("127.0.0.1:{world_port}")).await.unwrap();
|
|
|
|
let connect_msg = loop {
|
|
let msg = src.next().await.unwrap().unwrap();
|
|
match serde_json::from_str::<TunnelMsg>(msg.to_text().unwrap()).unwrap() {
|
|
TunnelMsg::Connect { stream_id, target, .. } if target == RelayTarget::World => break stream_id,
|
|
_ => continue,
|
|
}
|
|
};
|
|
sink.send(Message::Text(serde_json::to_string(&TunnelMsg::ConnectOk { stream_id: connect_msg }).unwrap().into())).await.unwrap();
|
|
|
|
// Host sends 128 chunks (each 4KB) rapidly without client reading immediately
|
|
let chunk_data = vec![0x42u8; 4096];
|
|
let b64_chunk = base64::engine::general_purpose::STANDARD.encode(&chunk_data);
|
|
for _ in 0..128 {
|
|
sink.send(Message::Text(serde_json::to_string(&TunnelMsg::Data {
|
|
stream_id: connect_msg,
|
|
chunk: b64_chunk.clone(),
|
|
}).unwrap().into())).await.unwrap();
|
|
}
|
|
|
|
// Now client reads all chunks
|
|
let mut total_read = 0;
|
|
let mut read_buf = vec![0u8; 8192];
|
|
let mut reader = client;
|
|
while total_read < 128 * 4096 {
|
|
let n = reader.read(&mut read_buf).await.unwrap();
|
|
if n == 0 { break; }
|
|
total_read += n;
|
|
}
|
|
assert_eq!(total_read, 128 * 4096, "all buffered data received despite slow consumer");
|
|
}
|
|
|
|
|