use std::time::Duration;
use pb_mapper_client::sdk::{
Client, ConnectOptions, ConnectRequest, DirectStage, DirectTransport, FallbackReason,
LanTransport, PathPolicy, RegisterOptions, RelayTransport, Transport, TunnelEventKind,
};
use pb_mapper_protocol::direct::{SessionPath, SessionState};
use pb_mapper_server::RelayServerOptions;
use pb_mapper_testkit::{
READY_TIMEOUT, Relay, admin_client, loopback_direct, loopback_quic, publish, subscribe,
tcp_echo, udp_echo,
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpStream, UdpSocket};
async fn roundtrip(socket: &mut TcpStream) {
tokio::time::timeout(READY_TIMEOUT, async {
let payload = vec![0x37; 32_000];
socket.write_all(&payload).await.unwrap();
let mut got = vec![0; payload.len()];
socket.read_exact(&mut got).await.unwrap();
assert_eq!(got, payload);
})
.await
.unwrap();
}
fn allow_direct() -> RegisterOptions {
RegisterOptions {
allow_direct: true,
..Default::default()
}
}
fn auto_path() -> ConnectOptions {
ConnectOptions {
path: PathPolicy::Auto,
..Default::default()
}
}
#[tokio::test]
async fn direct_tcp_survives_server_restart_and_local_stop_closes_it() {
direct_survives_coordinator_loss(RelayTransport::Tcp).await;
}
#[cfg(feature = "relay-quic")]
#[tokio::test]
async fn direct_sessions_survive_quic_coordinator_loss() {
direct_survives_coordinator_loss(RelayTransport::Quic).await;
}
async fn direct_survives_coordinator_loss(carrier: RelayTransport) {
let mut relay = Relay::start_with_options(
"direct-tcp",
RelayServerOptions {
direct: Some(loopback_direct()),
quic: (carrier == RelayTransport::Quic).then(loopback_quic),
},
)
.await;
let client = admin_client(relay.addr())
.with_relay_transport(carrier)
.unwrap();
let backend = tcp_echo(None).await;
let registration = publish(
&client,
"echo",
backend.addr(),
Transport::Tcp,
true,
allow_direct(),
)
.await;
let (connection, addr) = subscribe(&client, "echo", Transport::Tcp, auto_path()).await;
let mut socket = TcpStream::connect(addr).await.unwrap();
roundtrip(&mut socket).await;
assert_eq!(connection.diagnostics().direct.unwrap().active_direct, 1);
let seen = connection.diagnostics();
assert_eq!(seen.direct.as_ref().unwrap().attempt, None);
assert!(
seen.events
.iter()
.any(|event| matches!(event.kind, TunnelEventKind::DirectEstablished { .. }))
);
assert_eq!(registration.diagnostics().direct.unwrap().active_direct, 1);
assert_eq!(backend.reached(), 1, "exactly one backend connection");
let mut sibling = TcpStream::connect(addr).await.unwrap();
let payload = vec![0x63; 256_000];
sibling.write_all(&payload).await.unwrap();
sibling.shutdown().await.unwrap();
let mut response = Vec::new();
tokio::time::timeout(READY_TIMEOUT, sibling.read_to_end(&mut response))
.await
.unwrap()
.unwrap();
assert_eq!(response.len(), payload.len());
assert!(response == payload);
relay.stop_server().await;
roundtrip(&mut socket).await;
relay.restart_server(Some(loopback_direct())).await;
let restored = tokio::time::timeout(Duration::from_secs(25), async {
loop {
let sessions_result = client.sessions().await;
if let Ok(sessions) = sessions_result
&& let Some(session) = sessions.into_iter().find(|s| {
s.restored
&& !s.stale
&& s.consumer
.as_ref()
.is_some_and(|r| r.report.state == SessionState::Active)
&& s.provider
.as_ref()
.is_some_and(|r| r.report.state == SessionState::Active)
})
{
break session;
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
})
.await
.unwrap();
assert!(!restored.conflicting);
roundtrip(&mut socket).await;
registration.stop().await.unwrap();
let result = tokio::time::timeout(READY_TIMEOUT, socket.read_u8())
.await
.unwrap();
assert!(
result.is_err(),
"provider stop must close the direct session"
);
connection.stop().await.unwrap();
}
#[tokio::test]
async fn udp_direct_preserves_datagrams_and_revocation_leaves_active_session_owned_by_client() {
udp_direct(LanTransport::Quic).await;
}
#[tokio::test]
async fn udp_direct_over_lan_tcp_preserves_datagrams() {
udp_direct(LanTransport::Tcp).await;
}
async fn udp_direct(lan_transport: LanTransport) {
let relay = Relay::start_with_direct("direct-udp", Some(loopback_direct())).await;
let (id, credential) = relay
.issue_credential(Duration::from_secs(600), "direct-udp")
.await;
let client = Client::from_credential(relay.addr().to_string(), credential, false, None);
let backend = udp_echo(None).await;
let registration = publish(
&client,
"udp",
backend.addr(),
Transport::Udp,
true,
allow_direct(),
)
.await;
let (connection, addr) = subscribe(
&client,
"udp",
Transport::Udp,
ConnectOptions {
path: PathPolicy::Auto,
lan_transport,
..Default::default()
},
)
.await;
let application = UdpSocket::bind("127.0.0.1:0").await.unwrap();
application.connect(addr).await.unwrap();
let mut sizes = vec![1, 1200];
if loopback_carries(8000).await {
sizes.push(8000);
} else {
eprintln!(
"loopback drops an 8000-byte UDP datagram on this host (WSL's mirrored \
networking routes 127.0.0.1 over a 1500-byte link that drops fragments); \
the case sends nothing it cannot carry"
);
}
for size in sizes {
let payload = vec![size as u8; size];
application.send(&payload).await.unwrap();
let mut response = vec![0; 65536];
let len = tokio::time::timeout(READY_TIMEOUT, application.recv(&mut response))
.await
.unwrap()
.unwrap();
assert_eq!(&response[..len], &payload);
}
let direct = connection.diagnostics().direct.unwrap();
assert_eq!(direct.active_direct, 1);
let transport = match lan_transport {
LanTransport::Quic => DirectTransport::Quic,
LanTransport::Tcp => DirectTransport::Tcp,
};
assert_eq!(direct.link.unwrap().transport, transport);
let observation = tokio::time::timeout(READY_TIMEOUT, async {
loop {
let sessions = client.sessions().await.unwrap();
if let Some(s) = sessions.into_iter().find(|s| !s.stale) {
break s;
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
})
.await
.unwrap();
assert!(!observation.conflicting);
assert_eq!(
observation.consumer.unwrap().report.path,
SessionPath::Direct
);
let outsider = admin_client(relay.addr());
assert!(outsider.sessions().await.unwrap().is_empty());
relay.revoke(id).await;
let rejected = client
.connect_with_options(
ConnectRequest {
key: "udp".into(),
local_addr: "127.0.0.1:0".into(),
transport: Transport::Udp,
},
auto_path(),
)
.await
.unwrap();
let error = tokio::time::timeout(READY_TIMEOUT, rejected.wait_ready())
.await
.expect("permanent authentication failure must terminate readiness")
.unwrap_err();
assert!(matches!(
error,
pb_mapper_client::sdk::Error::TunnelFailed { .. }
));
rejected.stop().await.unwrap();
application.send(b"still direct").await.unwrap();
let mut response = [0; 100];
let len = tokio::time::timeout(READY_TIMEOUT, application.recv(&mut response))
.await
.unwrap()
.unwrap();
assert_eq!(&response[..len], b"still direct");
connection.stop().await.unwrap();
registration.stop().await.unwrap();
}
async fn loopback_carries(size: usize) -> bool {
let sender = UdpSocket::bind("127.0.0.1:0").await.unwrap();
let receiver = UdpSocket::bind("127.0.0.1:0").await.unwrap();
let payload = vec![0x5a; size];
sender
.send_to(&payload, receiver.local_addr().unwrap())
.await
.unwrap();
let mut got = vec![0; size + 1];
matches!(
tokio::time::timeout(Duration::from_secs(1), receiver.recv(&mut got)).await,
Ok(Ok(len)) if got[..len] == payload[..]
)
}
#[tokio::test]
async fn either_side_can_keep_connections_on_the_existing_relay_path() {
for server_direct in [false, true] {
let relay =
Relay::start_with_direct("direct-disabled", server_direct.then(loopback_direct)).await;
let client = admin_client(relay.addr());
let backend = tcp_echo(None).await;
let registration = publish(
&client,
"relay",
backend.addr(),
Transport::Tcp,
true,
RegisterOptions {
allow_direct: !server_direct,
..Default::default()
},
)
.await;
let (connection, addr) = subscribe(&client, "relay", Transport::Tcp, auto_path()).await;
let mut socket = TcpStream::connect(addr).await.unwrap();
roundtrip(&mut socket).await;
assert_eq!(connection.diagnostics().direct.unwrap().direct_sessions, 0);
let stage = if server_direct {
DirectStage::Discovering
} else {
DirectStage::Negotiating
};
let seen = connection.diagnostics();
assert_eq!(seen.direct.as_ref().unwrap().attempt, None);
assert!(seen.events.iter().any(|event| event.kind
== TunnelEventKind::DirectFallback {
stage,
reason: FallbackReason::NotOffered
}));
let shared = registration.diagnostics().direct.unwrap();
assert_eq!((shared.relay_sessions, shared.direct_sessions), (1, 0));
assert_eq!(backend.reached(), 1);
connection.stop().await.unwrap();
registration.stop().await.unwrap();
}
}