use crate::{
cli::{ComputeMode, ServeArgs},
coordinator::JobConfig,
join::WorkerSetup,
serve::{self, ServeHandle},
};
use indicatrix::{
geometry::cuts::StandardGemCuts,
optics::{materials::GemMaterial, raytracer::LightingPreset},
renderer::gpu_backend::GpuBackend,
};
use indicatrix_net::{
SceneState,
messages::{PeerRole, RenderCapability},
};
use rustls::pki_types::ServerName;
use std::{
net::{Ipv4Addr, SocketAddr, TcpStream},
path::{Path, PathBuf},
sync::Arc,
time::{Duration, Instant},
};
use super::super::LivenessConfig;
pub use crate::serve::tests::fixtures::unique_temp_dir;
pub fn pki_with_server(label: &str) -> PathBuf {
let dir = unique_temp_dir(&format!("{label}-pki"));
crate::pki::init(&dir).unwrap();
crate::pki::issue_server(
&dir,
&["localhost".to_string()],
&["127.0.0.1".parse().unwrap()],
)
.unwrap();
dir
}
pub fn bundle(pki: &Path, name: &str, role: PeerRole) -> PathBuf {
let out = unique_temp_dir(&format!("bundle-{name}"));
crate::pki::issue_client_with_role(pki, name, &out, role).unwrap();
out
}
pub fn temp_db() -> PathBuf {
let path = unique_temp_dir("db").join("library.sqlite");
drop(indicatrix_vault::db::sqlite::Database::new(Some(path.to_str().unwrap())).unwrap());
path
}
pub fn coordinator_args(pki: &Path) -> ServeArgs {
let viewer_allowlist = crate::pki::viewer_allowlist_in(pki);
if !viewer_allowlist.exists() {
std::fs::write(&viewer_allowlist, "").unwrap();
}
ServeArgs {
bind: "127.0.0.1:0".to_string(),
threads: 2,
allow_remote: false,
ca: Some(pki.join(crate::pki::CA_CERT_FILE)),
cert: Some(pki.join(crate::pki::SERVER_CERT_FILE)),
key: Some(pki.join(crate::pki::SERVER_KEY_FILE)),
allowlist: None,
trust_any_client_cert: false,
insecure_no_tls: false,
compute_mode: ComputeMode::Hybrid,
render: false,
enroll_bind: Some("127.0.0.1:0".to_string()),
no_enroll: false,
worker_bind: Some("127.0.0.1:0".to_string()),
worker_enroll_bind: Some("127.0.0.1:0".to_string()),
no_workers: false,
worker_allowlist: None,
db: Some(temp_db()),
max_connections: 16,
max_preauth_per_ip: crate::cli::DEFAULT_MAX_PREAUTH_PER_IP,
interactive_workers: 0,
pin_interactive_worker: None,
max_job_memory_mib: crate::cli::DEFAULT_MAX_JOB_MEMORY_MIB,
whole_image_secs: crate::cli::DEFAULT_WHOLE_IMAGE_SECS,
whole_image_pixel_samples: crate::cli::DEFAULT_WHOLE_IMAGE_PIXEL_SAMPLES,
jobs_per_viewer: crate::cli::DEFAULT_JOBS_PER_VIEWER,
payload_encoding: indicatrix_net::messages::adaptive::PayloadChoice::Auto,
}
}
pub fn fan_out_config() -> JobConfig {
JobConfig {
whole_image_secs: 0.0,
whole_image_pixel_samples: 0,
..JobConfig::default()
}
}
pub const FAST_LIVENESS: LivenessConfig = LivenessConfig {
ping_interval: Duration::from_millis(100),
dead_after: Duration::from_secs(2),
tick: Duration::from_millis(20),
};
pub fn start(args: &ServeArgs, liveness: LivenessConfig) -> ServeHandle {
let handle = serve::start_with_liveness(args, liveness).unwrap();
if let Some(coordinator) = &handle.coordinator {
coordinator.set_job_config(fan_out_config());
}
handle
}
pub fn tls_client(
addr: SocketAddr,
bundle_dir: &Path,
) -> rustls::StreamOwned<rustls::ClientConnection, TcpStream> {
let ca = indicatrix_net::tls::load_ca(&bundle_dir.join(crate::pki::CA_CERT_FILE)).unwrap();
let certs =
indicatrix_net::tls::load_certs(&bundle_dir.join(crate::pki::CLIENT_CERT_FILE)).unwrap();
let key = indicatrix_net::tls::load_private_key(&bundle_dir.join(crate::pki::CLIENT_KEY_FILE))
.unwrap();
let config = indicatrix_net::tls::client_config(ca, certs, key).unwrap();
let tcp = TcpStream::connect(addr).unwrap();
tcp.set_read_timeout(Some(Duration::from_secs(20))).unwrap();
let conn = rustls::ClientConnection::new(
config,
ServerName::from(std::net::IpAddr::V4(Ipv4Addr::LOCALHOST)),
)
.unwrap();
rustls::StreamOwned::new(conn, tcp)
}
pub fn cpu_worker_setup() -> Arc<WorkerSetup> {
cpu_worker_setup_with_cache(true)
}
pub fn cpu_worker_setup_with_cache(cache: bool) -> Arc<WorkerSetup> {
let gpu = Arc::new(GpuBackend::disabled());
let assets = cache.then(|| {
let dir = unique_temp_dir("worker-assets");
Arc::new(crate::assets::AssetCache::open(&dir, 1 << 26).unwrap())
});
let capability = RenderCapability {
hdr: assets.is_some(),
..serve::local_render_capability(&gpu, 2)
};
Arc::new(WorkerSetup {
gpu,
threads: 2,
compute_mode: ComputeMode::OnlyCpu,
capability,
assets,
payload: indicatrix_net::messages::adaptive::PayloadChoice::Auto,
})
}
pub fn wait_for(timeout: Duration, mut condition: impl FnMut() -> bool) -> bool {
let deadline = Instant::now() + timeout;
while Instant::now() < deadline {
if condition() {
return true;
}
std::thread::sleep(Duration::from_millis(10));
}
condition()
}
pub 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,
}
}