use crate::serve::{
connection::{BUILD_MISMATCH_CODE, VALIDATION_FAILED_CODE},
handle_connection,
};
use indicatrix::{
geometry::cuts::StandardGemCuts,
optics::{materials::GemMaterial, raytracer::LightingPreset},
};
use indicatrix_net::{
SceneState, handshake,
messages::{
Backend, Cancel, ClientMessage, Done, ErrorMsg, Hello, RenderRequest, StreamEvent, Welcome,
},
};
use indicatrix_vault::db::sqlite::Database;
use std::{
io::{Cursor, Read, Write},
net::TcpListener,
thread,
};
use crate::{render_core, stream_emit::TimeoutRead};
fn test_db() -> Database {
let path = std::env::temp_dir().join(format!(
"indicatrix-worker-serve-test-{}-{}.sqlite",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
Database::new(Some(path.to_str().unwrap())).unwrap()
}
fn tiny_scene() -> SceneState {
SceneState {
width: 4,
height: 4,
yaw: 0.4,
pitch: 0.3,
distance: 3.0,
light_yaw: 0.85,
light_pitch: 0.95,
exposure: 1.0,
max_bounces: 4,
lighting_preset: LightingPreset::Daylight,
material: GemMaterial::diamond(),
planes: StandardGemCuts::standard_round_brilliant(),
girdle_frosted: false,
}
}
#[cfg(feature = "gpu")]
fn tiny_scene_without_dispersion() -> SceneState {
let mut scene = tiny_scene();
scene.material.dispersion = indicatrix::optics::dispersion::DispersionModel::Cauchy {
a: 2.417,
b: 0.0,
c: 0.0,
};
scene
}
struct DuplexHalf {
in_: Cursor<Vec<u8>>,
out: Vec<u8>,
timeout_active: bool,
}
impl DuplexHalf {
const fn new(input: Vec<u8>) -> Self {
Self {
in_: Cursor::new(input),
out: Vec::new(),
timeout_active: false,
}
}
}
impl Read for DuplexHalf {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
let n = self.in_.read(buf)?;
if n == 0 && self.timeout_active {
return Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"DuplexHalf: no more scripted input (yet)",
));
}
Ok(n)
}
}
impl Write for DuplexHalf {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.out.write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl TimeoutRead for DuplexHalf {
fn set_read_timeout(&mut self, duration: Option<std::time::Duration>) -> std::io::Result<()> {
self.timeout_active = duration.is_some();
Ok(())
}
}
impl crate::stream_emit::TimeoutWrite for DuplexHalf {
fn set_write_timeout(&mut self, _duration: Option<std::time::Duration>) -> std::io::Result<()> {
Ok(())
}
}
struct BackpressureDuplex {
in_: Cursor<Vec<u8>>,
out: Vec<u8>,
capacity: usize,
read_timeout_active: bool,
write_timeout_active: bool,
timeout_kind: std::io::ErrorKind,
}
impl BackpressureDuplex {
const fn new(input: Vec<u8>, capacity: usize) -> Self {
Self::new_with_kind(input, capacity, std::io::ErrorKind::TimedOut)
}
const fn new_with_kind(input: Vec<u8>, capacity: usize, kind: std::io::ErrorKind) -> Self {
Self {
in_: Cursor::new(input),
out: Vec::new(),
capacity,
read_timeout_active: false,
write_timeout_active: false,
timeout_kind: kind,
}
}
}
impl Read for BackpressureDuplex {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
let n = self.in_.read(buf)?;
if n == 0 && self.read_timeout_active {
return Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"BackpressureDuplex: no more scripted input (yet)",
));
}
Ok(n)
}
}
impl Write for BackpressureDuplex {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
if self.write_timeout_active && self.out.len() + buf.len() > self.capacity {
return Err(std::io::Error::new(
self.timeout_kind,
"BackpressureDuplex: peer isn't draining -- write timed out",
));
}
self.out.write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
impl TimeoutRead for BackpressureDuplex {
fn set_read_timeout(&mut self, duration: Option<std::time::Duration>) -> std::io::Result<()> {
self.read_timeout_active = duration.is_some();
Ok(())
}
}
impl crate::stream_emit::TimeoutWrite for BackpressureDuplex {
fn set_write_timeout(&mut self, duration: Option<std::time::Duration>) -> std::io::Result<()> {
self.write_timeout_active = duration.is_some();
Ok(())
}
}
const fn live_progressive(cadence_ms: u32) -> indicatrix_net::messages::StreamConfig {
indicatrix_net::messages::StreamConfig {
transfer_mode: indicatrix_net::messages::TransferMode::LiveProgressive,
cadence_ms,
preview: None,
}
}
const fn final_only(cadence_ms: u32) -> indicatrix_net::messages::StreamConfig {
indicatrix_net::messages::StreamConfig {
transfer_mode: indicatrix_net::messages::TransferMode::FinalOnly,
cadence_ms,
preview: None,
}
}
fn read_stream_until_done<R: Read>(
reader: &mut R,
) -> Vec<(indicatrix_net::messages::StreamEvent, Option<Vec<u8>>)> {
let mut events = Vec::new();
loop {
let (event, payload) = indicatrix_net::messages::read_stream_event(reader).unwrap();
let terminal = matches!(
event,
indicatrix_net::messages::StreamEvent::Done(_)
| indicatrix_net::messages::StreamEvent::Error(_)
);
events.push((event, payload));
if terminal {
break;
}
}
events
}
#[test]
fn handle_connection_refuses_a_mismatched_build_hash() {
let mut input = Vec::new();
let bad_hello = Hello {
protocol_version: indicatrix_net::messages::PROTOCOL_VERSION,
build_hash: [0xAB; 8],
};
indicatrix_net::messages::write_message(&mut input, &bad_hello).unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 1, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let err: ErrorMsg = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
assert_eq!(err.code, BUILD_MISMATCH_CODE);
assert!(err.message.contains("refusing to pair"), "{}", err.message);
}
#[test]
fn handle_connection_accepts_a_matching_build_hash_and_sends_welcome() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 1, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
assert_eq!(welcome.build_hash, handshake::local_hello().build_hash);
assert!(matches!(
welcome.render.as_ref().unwrap().backend,
Backend::Cpu { .. }
));
}
#[test]
fn handle_connection_rejects_a_request_that_fails_validation_but_keeps_the_connection_open() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let mut bad_scene = tiny_scene();
bad_scene.planes[0].normal = [f32::NAN, 0.0, 0.0];
let bad_request = RenderRequest {
request_id: 1,
scene: bad_scene,
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(bad_request)),
)
.unwrap();
let good_request = RenderRequest {
request_id: 2,
scene: tiny_scene(),
first_sample: 0,
samples: 2,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(good_request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 1, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let bad_events = read_stream_until_done(&mut out_cursor);
assert_eq!(bad_events.len(), 1);
let StreamEvent::Error(err) = &bad_events[0].0 else {
panic!("expected StreamEvent::Error, got {:?}", bad_events[0].0);
};
assert_eq!(err.code, VALIDATION_FAILED_CODE);
let good_events = read_stream_until_done(&mut out_cursor);
let frames: Vec<_> = good_events
.iter()
.filter_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.collect();
assert_eq!(frames.len(), 1);
let (header, payload) = frames[0];
assert_eq!(header.request_id, 2);
assert_eq!(header.samples, 2);
assert_eq!(
payload.len(),
4 * 4 * indicatrix_net::radiance::BYTES_PER_PIXEL
);
assert!(matches!(
good_events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: false,
..
})
));
}
#[test]
fn serve_round_trip_over_a_loopback_socket_returns_a_correctly_sized_buffer() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
handle_connection(stream, 2, &test_db()).unwrap();
});
let mut client = std::net::TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
assert!(matches!(
welcome.render.as_ref().unwrap().backend,
Backend::Cpu { .. }
));
let scene = tiny_scene();
let request = RenderRequest {
request_id: 5,
scene,
first_sample: 10,
samples: 3,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let frames: Vec<_> = events
.iter()
.filter_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.collect();
assert_eq!(frames.len(), 1);
let (header, payload) = frames[0];
assert_eq!(header.request_id, 5);
assert_eq!(header.first_sample, 10);
assert_eq!(header.samples, 3);
assert_eq!(
payload.len(),
4 * 4 * indicatrix_net::radiance::BYTES_PER_PIXEL
);
drop(client); server.join().unwrap();
}
#[test]
fn serve_round_trip_result_matches_tracing_the_same_range_directly() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let scene = tiny_scene();
let scene_for_server = scene.clone();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
handle_connection(stream, 2, &test_db()).unwrap();
});
let mut client = std::net::TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let request = RenderRequest {
request_id: 6,
scene: scene.clone(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let (_header, payload) = events
.iter()
.find_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.unwrap();
drop(client);
server.join().unwrap();
let over_the_wire =
indicatrix_net::radiance::decode(payload, scene.width, scene.height).unwrap();
let direct = render_core::trace_samples(&scene_for_server, 0, 4, 2);
for (a, b) in over_the_wire.iter().zip(&direct) {
let diff = (*a - *b).abs();
let scale = a.abs().max(b.abs()).max(glam::Vec3::splat(1e-6));
assert!(
(diff / scale).max_element() < 1e-3,
"over_the_wire={a:?} direct={b:?}"
);
}
}
#[cfg(feature = "gpu")]
#[test]
fn serve_round_trip_over_gpu_reports_backend_gpu_and_a_correctly_sized_buffer() {
use crate::{cli::ComputeMode, serve::handle_connection_with_gpu};
use indicatrix::renderer::gpu_backend::GpuBackend;
use std::{net::TcpStream, sync::Arc};
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let scene = tiny_scene();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
let gpu = Arc::new(GpuBackend::acquire());
handle_connection_with_gpu(stream, 2, &gpu, &test_db(), ComputeMode::default()).unwrap();
});
let mut client = TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let request = RenderRequest {
request_id: 7,
scene: scene.clone(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let (header, payload) = events
.iter()
.find_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.unwrap();
assert_eq!(header.samples, 4);
assert_eq!(
payload.len(),
scene.width as usize * scene.height as usize * indicatrix_net::radiance::BYTES_PER_PIXEL
);
drop(client);
server.join().unwrap();
if let Some(Backend::Gpu { adapter }) = welcome.render.map(|r| r.backend) {
assert!(!adapter.is_empty(), "adapter label must be non-empty");
}
}
#[cfg(feature = "gpu")]
#[test]
fn hybrid_gpu_and_cpu_split_sums_to_the_same_result_as_tracing_the_range_directly() {
use crate::{cli::ComputeMode, serve::handle_connection_with_gpu};
use indicatrix::renderer::gpu_backend::GpuBackend;
use std::{net::TcpStream, sync::Arc};
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let scene = tiny_scene_without_dispersion();
let scene_for_direct = scene.clone();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
let gpu = Arc::new(GpuBackend::acquire());
handle_connection_with_gpu(stream, 2, &gpu, &test_db(), ComputeMode::Hybrid).unwrap();
});
let mut client = TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let request = RenderRequest {
request_id: 8,
scene: scene.clone(),
first_sample: 0,
samples: 32,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let events = read_stream_until_done(&mut client);
let (header, payload) = events
.iter()
.find_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.unwrap();
assert_eq!(header.samples, 32);
drop(client);
server.join().unwrap();
let over_the_wire =
indicatrix_net::radiance::decode(payload, scene.width, scene.height).unwrap();
let direct = render_core::trace_samples(&scene_for_direct, 0, 32, 2);
for (a, b) in over_the_wire.iter().zip(&direct) {
let diff = (*a - *b).abs();
let scale = a.abs().max(b.abs()).max(glam::Vec3::splat(1e-6));
let rel = (diff / scale).max_element();
assert!(rel < 1e-3, "over_the_wire={a:?} direct={b:?} rel={rel}");
}
}
fn heavier_scene() -> SceneState {
SceneState {
width: 24,
height: 24,
yaw: 0.4,
pitch: 0.3,
distance: 3.0,
light_yaw: 0.85,
light_pitch: 0.95,
exposure: 1.0,
max_bounces: 6,
lighting_preset: LightingPreset::Daylight,
material: GemMaterial::diamond(),
planes: StandardGemCuts::standard_round_brilliant(),
girdle_frosted: false,
}
}
fn event_request_id(event: &StreamEvent) -> u32 {
match event {
StreamEvent::Frame(h) => h.request_id,
StreamEvent::Preview(h) => h.request_id,
StreamEvent::Progress(p) => p.request_id,
StreamEvent::Done(d) => d.request_id,
StreamEvent::Error(e) => panic!("unexpected StreamEvent::Error: {e:?}"),
}
}
#[test]
fn delta_frames_tile_the_requested_sample_range_with_no_gaps_or_overlaps() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id: 11,
scene: heavier_scene(),
first_sample: 100,
samples: 64,
stream: live_progressive(0), };
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
let mut ranges: Vec<(u32, u32)> = events
.iter()
.filter_map(|(e, _)| match e {
StreamEvent::Frame(h) => Some((h.first_sample, h.samples)),
_ => None,
})
.collect();
assert!(!ranges.is_empty(), "expected at least one FRAME delta");
ranges.sort_by_key(|r| r.0);
let mut cursor = 100u32;
for (first, samples) in &ranges {
assert_eq!(
*first, cursor,
"gap or overlap: expected next delta to start at {cursor}, got {first}"
);
cursor += samples;
}
assert_eq!(
cursor,
100 + 64,
"deltas must tile the whole requested range exactly"
);
assert!(matches!(
events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: false,
..
})
));
}
#[test]
fn final_only_transfer_mode_still_emits_progress() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id: 12,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
let frame_count = events
.iter()
.filter(|(e, _)| matches!(e, StreamEvent::Frame(_)))
.count();
assert_eq!(
frame_count, 1,
"FinalOnly must send exactly one FRAME, covering the whole request"
);
let progress_count = events
.iter()
.filter(|(e, _)| matches!(e, StreamEvent::Progress(_)))
.count();
assert!(
progress_count >= 1,
"FinalOnly must still emit PROGRESS on the cadence even though FRAME only arrives once"
);
assert!(matches!(
events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: false,
..
})
));
}
#[test]
fn cancel_mid_stream_produces_done_cancelled_and_no_further_payload() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id: 13,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::Cancel(Cancel { request_id: 13 }),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
for (event, _) in &events {
assert_eq!(event_request_id(event), 13);
}
assert!(matches!(
events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: true,
..
})
));
assert_eq!(
out_cursor.position(),
out_cursor.get_ref().len() as u64,
"no bytes may follow DONE{{cancelled: true, ..}}"
);
}
#[test]
fn a_peer_that_never_drains_ends_the_connection_rather_than_hanging_forever() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id: 21,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = BackpressureDuplex::new(input, 8);
let result = handle_connection(&mut duplex, 2, &test_db());
let err = result.expect_err(
"a peer that never drains must end the connection with an error, not hang forever",
);
assert!(
matches!(
err,
indicatrix_net::messages::NetError::Framing(indicatrix_net::framing::FramingError::Io(ref e))
if e.kind() == std::io::ErrorKind::TimedOut
),
"expected the write-timeout error to surface as-is, got {err:?}"
);
}
#[test]
fn a_peer_that_never_drains_ends_the_connection_rather_than_hanging_forever_write_zero() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id: 23,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = BackpressureDuplex::new_with_kind(input, 8, std::io::ErrorKind::WriteZero);
let result = handle_connection(&mut duplex, 2, &test_db());
let err = result.expect_err(
"a peer that never drains must end the connection with an error, not hang forever, \
regardless of which io::ErrorKind the write failure carries",
);
assert!(
matches!(
err,
indicatrix_net::messages::NetError::Framing(indicatrix_net::framing::FramingError::Io(ref e))
if e.kind() == std::io::ErrorKind::WriteZero
),
"expected the WriteZero error to surface as-is, got {err:?}"
);
}
#[test]
fn cancel_still_completes_cleanly_against_a_finite_but_sufficient_peer() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id: 22,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::Cancel(Cancel { request_id: 22 }),
)
.unwrap();
let mut duplex = BackpressureDuplex::new(input, 1_000_000);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
assert!(matches!(
events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: true,
..
})
));
}
#[test]
fn stale_request_id_frames_are_identifiable() {
fn run_one_request(request_id: u32) -> Vec<(StreamEvent, Option<Vec<u8>>)> {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let request = RenderRequest {
request_id,
scene: tiny_scene(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 1, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
read_stream_until_done(&mut out_cursor)
}
let first_events = run_one_request(21);
let second_events = run_one_request(22);
assert_ne!(first_events.len(), 0);
for (event, _) in &first_events {
assert_eq!(event_request_id(event), 21);
assert_ne!(event_request_id(event), 22);
}
assert_ne!(second_events.len(), 0);
for (event, _) in &second_events {
assert_eq!(event_request_id(event), 22);
}
}
#[test]
fn pipelined_render_request_on_one_connection_is_queued_after_an_implicit_cancel() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let first_request = RenderRequest {
request_id: 41,
scene: heavier_scene(),
first_sample: 0,
samples: 64,
stream: live_progressive(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(first_request)),
)
.unwrap();
let second_request = RenderRequest {
request_id: 42,
scene: tiny_scene(),
first_sample: 0,
samples: 4,
stream: final_only(0),
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(second_request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 2, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let first_events = read_stream_until_done(&mut out_cursor);
for (event, _) in &first_events {
assert_eq!(event_request_id(event), 41);
}
assert!(
matches!(
first_events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: true,
..
})
),
"the superseded request must still get a proper DONE {{ cancelled: true }}, \
not be silently dropped"
);
let second_events = read_stream_until_done(&mut out_cursor);
let frames: Vec<_> = second_events
.iter()
.filter_map(|(e, p)| match e {
StreamEvent::Frame(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.collect();
assert_eq!(frames.len(), 1);
let (header, payload) = frames[0];
assert_eq!(header.request_id, 42);
assert_eq!(header.samples, 4);
assert_eq!(
payload.len(),
4 * 4 * indicatrix_net::radiance::BYTES_PER_PIXEL
);
for (event, _) in &second_events {
assert_eq!(event_request_id(event), 42);
}
assert!(matches!(
second_events.last().unwrap().0,
StreamEvent::Done(Done {
cancelled: false,
..
})
));
assert_eq!(
out_cursor.position(),
out_cursor.get_ref().len() as u64,
"no bytes may follow the second request's DONE"
);
}
#[test]
fn preview_frames_never_enter_the_full_resolution_accumulator_path() {
let mut input = Vec::new();
indicatrix_net::messages::write_message(&mut input, &handshake::local_hello()).unwrap();
let scene = tiny_scene(); let mut stream_cfg = live_progressive(0);
stream_cfg.preview = Some(indicatrix_net::messages::PreviewConfig {
width: 2,
height: 2,
});
let request = RenderRequest {
request_id: 31,
scene: scene.clone(),
first_sample: 0,
samples: 8,
stream: stream_cfg,
};
indicatrix_net::messages::write_message(
&mut input,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
let mut duplex = DuplexHalf::new(input);
handle_connection(&mut duplex, 1, &test_db()).unwrap();
let mut out_cursor = Cursor::new(duplex.out);
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut out_cursor).unwrap();
let events = read_stream_until_done(&mut out_cursor);
let previews: Vec<_> = events
.iter()
.filter_map(|(e, p)| match e {
StreamEvent::Preview(h) => Some((h, p.as_ref().unwrap())),
_ => None,
})
.collect();
assert!(
!previews.is_empty(),
"expected at least one PREVIEW with a preview configured"
);
for (header, payload) in &previews {
assert_eq!(header.width, 2);
assert_eq!(header.height, 2);
let full_res_attempt = indicatrix_net::radiance::decode(payload, scene.width, scene.height);
assert!(
matches!(
full_res_attempt,
Err(indicatrix_net::radiance::RadianceError::LengthMismatch { .. })
),
"{full_res_attempt:?}"
);
assert!(indicatrix_net::radiance::decode(payload, header.width, header.height).is_ok());
}
}
#[test]
#[ignore = "manual repro: real sockets + sleeps, prints timing to demonstrate the write-blocks-the-poll-loop theory"]
fn repro_slow_reader_blocks_the_emitter_and_delays_cancel() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let server = thread::spawn(move || {
let (stream, _) = listener.accept().unwrap();
handle_connection(stream, 0, &test_db())
});
let mut client = std::net::TcpStream::connect(addr).unwrap();
indicatrix_net::messages::write_message(&mut client, &handshake::local_hello()).unwrap();
let _welcome: Welcome = indicatrix_net::messages::read_message(&mut client).unwrap();
let scene = SceneState {
width: 1200,
height: 1200,
max_bounces: 2,
..tiny_scene()
};
let request = RenderRequest {
request_id: 99,
scene,
first_sample: 0,
samples: 65_536,
stream: indicatrix_net::messages::StreamConfig {
transfer_mode: indicatrix_net::messages::TransferMode::LiveProgressive,
cadence_ms: 100,
preview: None,
},
};
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::RenderRequest(Box::new(request)),
)
.unwrap();
eprintln!("not reading for 8s -- letting FRAME writes pile up unread");
thread::sleep(std::time::Duration::from_secs(8));
eprintln!("sending CANCEL now, still not reading FRAME payload");
let cancel_sent_at = std::time::Instant::now();
indicatrix_net::messages::write_message(
&mut client,
&ClientMessage::Cancel(Cancel { request_id: 99 }),
)
.unwrap();
client
.set_read_timeout(Some(std::time::Duration::from_secs(30)))
.unwrap();
let drain_start = std::time::Instant::now();
let mut frame_count = 0u32;
let mut progress_count = 0u32;
loop {
let event: Result<(StreamEvent, Option<Vec<u8>>), _> =
indicatrix_net::messages::read_stream_event(&mut client);
match event {
Ok((StreamEvent::Done(done), _)) => {
eprintln!(
"DONE{{cancelled={}, samples_done={}, effective_cadence_ms={}}} arrived \
{:?} after CANCEL was sent ({:?} to drain from when reading resumed); \
saw {frame_count} FRAMEs and {progress_count} PROGRESSes total",
done.cancelled,
done.stats.samples_done,
done.stats.effective_cadence_ms,
cancel_sent_at.elapsed(),
drain_start.elapsed()
);
break;
}
Ok((StreamEvent::Frame(_), _)) => frame_count += 1,
Ok((StreamEvent::Progress(_), _)) => progress_count += 1,
Ok(_) => {}
Err(e) => {
eprintln!("stream ended before DONE: {e:?}");
break;
}
}
}
drop(client);
let _ = server.join();
}
mod mtls;