use crate::{serve::library::LibraryHandle, stream_emit::TimeoutRead};
use indicatrix::{
geometry::cuts::StandardGemCuts,
optics::{materials::GemMaterial, raytracer::LightingPreset},
};
use indicatrix_net::{SceneState, messages::StreamEvent};
use indicatrix_vault::db::sqlite::Database;
use std::io::{Cursor, Read, Write};
fn unique_db_path() -> std::path::PathBuf {
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()
))
}
pub(super) fn test_db_file() -> std::path::PathBuf {
let path = unique_db_path();
drop(Database::new(Some(path.to_str().unwrap())).unwrap());
path
}
pub(super) fn test_db() -> LibraryHandle {
let path = unique_db_path();
LibraryHandle::open(Database::new(Some(path.to_str().unwrap())).unwrap())
}
pub fn unique_temp_dir(label: &str) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!(
"indicatrix-worker-test-{label}-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(&dir).unwrap();
dir
}
pub(super) 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,
backdrop: 0.0,
environment: indicatrix_net::scene::SceneEnvironment::Studio,
surface_glare: 1.0,
tools: Vec::new(),
fluorescence: indicatrix::optics::fluorescence::Fluorescence::default(),
head_shadow_deg: 16.0,
}
}
#[cfg(feature = "gpu")]
pub(super) 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
}
pub(super) 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,
backdrop: 0.0,
environment: indicatrix_net::scene::SceneEnvironment::Studio,
surface_glare: 1.0,
tools: Vec::new(),
fluorescence: indicatrix::optics::fluorescence::Fluorescence::default(),
head_shadow_deg: 16.0,
}
}
pub(super) struct DuplexHalf {
in_: Cursor<Vec<u8>>,
pub(super) out: Vec<u8>,
timeout_active: bool,
}
impl DuplexHalf {
pub(super) 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(())
}
}
pub(super) struct BackpressureDuplex {
in_: Cursor<Vec<u8>>,
pub(super) out: Vec<u8>,
capacity: usize,
read_timeout_active: bool,
write_timeout_active: bool,
timeout_kind: std::io::ErrorKind,
}
impl BackpressureDuplex {
pub(super) const fn new(input: Vec<u8>, capacity: usize) -> Self {
Self::new_with_kind(input, capacity, std::io::ErrorKind::TimedOut)
}
pub(super) 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(())
}
}
pub(super) 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,
}
}
pub(super) 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,
}
}
pub(super) 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
}
pub(super) fn event_request_id(event: &StreamEvent) -> u32 {
event
.request_id()
.unwrap_or_else(|| panic!("unexpected request-less StreamEvent: {event:?}"))
}