use std::{
net::{SocketAddr, TcpListener},
sync::Arc,
thread,
};
#[cfg(feature = "worker")]
use crate::{cli::ComputeMode, coordinator};
use crate::{cli::ServeArgs, enroll};
use indicatrix_net::messages::PeerRole;
mod accept;
mod connection;
mod handshake;
pub mod library;
mod limiter;
mod socket;
#[cfg(feature = "worker")]
mod tilt;
mod tls;
#[cfg(all(test, feature = "worker"))]
pub(crate) mod tests;
#[cfg(feature = "worker")]
pub(crate) use connection::refuse_for_capacity;
#[cfg(feature = "worker")]
pub(crate) use limiter::PRE_AUTH_HANDSHAKE_MULTIPLIER;
pub use limiter::{ConnectionLimiter, ConnectionSlot};
pub(crate) use socket::HANDSHAKE_TIMEOUT;
pub(crate) use socket::{DeadlineIo, DeadlineSocket};
#[cfg(feature = "worker")]
pub(crate) use socket::{apply_handshake_timeout, tune_accepted_socket};
pub(crate) use tls::Auth;
#[cfg(feature = "worker")]
pub(crate) use tls::{TlsStream, accept_tls};
#[cfg(not(feature = "worker"))]
pub use connection::handle_connection;
#[cfg(feature = "worker")]
pub(crate) use connection::{
LinkSettings, RequestContext, is_loopback_peer, local_render_capability,
refuse_incompatible_handshake, serve_requests,
};
#[cfg(feature = "worker")]
pub use connection::{handle_connection, handle_connection_with_gpu};
#[cfg(feature = "worker")]
pub(crate) use handshake::{HelloCheck, read_and_check_hello, send_refusal};
#[cfg(feature = "worker")]
pub(crate) use socket::payload_preference_for;
#[cfg(feature = "worker")]
pub(crate) use tilt::{CancelPoll, handle_tilt_curves_request, poll_for_cancel};
pub struct ServeHandle {
pub viewer_addr: SocketAddr,
pub viewer_enroll_addr: Option<SocketAddr>,
pub worker_addr: Option<SocketAddr>,
pub worker_enroll_addr: Option<SocketAddr>,
#[cfg(feature = "worker")]
pub registry: Option<Arc<coordinator::Registry>>,
#[cfg(feature = "worker")]
pub coordinator: Option<Arc<coordinator::Coordinator>>,
accept_thread: thread::JoinHandle<()>,
}
impl ServeHandle {
pub fn wait(self) {
if self.accept_thread.join().is_err() {
tracing::error!("indicatrix-worker serve: the viewer accept loop panicked");
}
}
}
pub fn run(args: &ServeArgs) -> Result<(), String> {
start(args)?.wait();
Ok(())
}
pub fn start(args: &ServeArgs) -> Result<ServeHandle, String> {
start_inner(
args,
#[cfg(feature = "worker")]
coordinator::LivenessConfig::default(),
)
}
#[cfg(all(test, feature = "worker"))]
pub(crate) fn start_with_liveness(
args: &ServeArgs,
liveness: coordinator::LivenessConfig,
) -> Result<ServeHandle, String> {
start_inner(args, liveness)
}
fn start_inner(
args: &ServeArgs,
#[cfg(feature = "worker")] liveness: coordinator::LivenessConfig,
) -> Result<ServeHandle, String> {
let bind_addr = checked_addr(&args.bind, "--bind", args.allow_remote)?;
let transport = tls::build_transport(args, bind_addr)?;
let db_path = socket::resolve_library_db_path(args);
drop(socket::open_library_database(&db_path)?);
let limiter = ConnectionLimiter::new(args.max_connections);
let handshake_limiter = ConnectionLimiter::new(
args.max_connections
.saturating_mul(limiter::PRE_AUTH_HANDSHAKE_MULTIPLIER),
);
let listener =
TcpListener::bind(bind_addr).map_err(|e| format!("failed to bind {bind_addr}: {e}"))?;
let viewer_addr = listener
.local_addr()
.map_err(|e| format!("viewer listener bound but local_addr() failed: {e}"))?;
tracing::info!(
"indicatrix-worker serve: viewers on {viewer_addr} ({}; {})",
transport_summary(&transport),
capability_summary(args),
);
let viewer_auth = match &transport {
tls::Transport::Tls { auth, .. } => Some(auth.clone()),
tls::Transport::Insecure => None,
};
let viewer_enroll_addr = start_enrollment(
args,
args.enroll_bind.as_deref(),
bind_addr,
1,
viewer_auth.as_ref(),
)?;
#[cfg(feature = "worker")]
let (worker, render) = start_worker_side(args, bind_addr, &transport, liveness, &db_path)?;
#[cfg(not(feature = "worker"))]
let worker = WorkerSide::default();
let shared = Arc::new(accept::ViewerListener {
transport,
limiter,
handshake_limiter,
pre_auth_addresses: accept::PreAuthAddresses::new(args.max_preauth_per_ip),
db_path,
max_connections: args.max_connections,
#[cfg(feature = "worker")]
render,
});
let accept_thread = thread::spawn(move || accept::run_accept_loop(&listener, &shared));
Ok(ServeHandle {
viewer_addr,
viewer_enroll_addr,
worker_addr: worker.addr,
worker_enroll_addr: worker.enroll_addr,
#[cfg(feature = "worker")]
registry: worker.registry,
#[cfg(feature = "worker")]
coordinator: worker.coordinator,
accept_thread,
})
}
#[derive(Default)]
struct WorkerSide {
addr: Option<SocketAddr>,
enroll_addr: Option<SocketAddr>,
#[cfg(feature = "worker")]
registry: Option<Arc<coordinator::Registry>>,
#[cfg(feature = "worker")]
coordinator: Option<Arc<coordinator::Coordinator>>,
}
#[cfg(feature = "worker")]
fn start_worker_side(
args: &ServeArgs,
bind_addr: SocketAddr,
transport: &tls::Transport,
liveness: coordinator::LivenessConfig,
db_path: &std::path::Path,
) -> Result<(WorkerSide, accept::RenderSetup), String> {
use indicatrix::renderer::gpu_backend::GpuBackend;
let gpu = Arc::new(
if args.render && args.compute_mode != ComputeMode::OnlyCpu {
GpuBackend::acquire()
} else {
GpuBackend::disabled()
},
);
if args.render && args.compute_mode == ComputeMode::Hybrid && gpu.adapter_label().is_some() {
crate::render_core::hybrid::calibrate_now(
&gpu,
&probe_scene(),
args.threads,
args.compute_mode,
);
}
let mut side = WorkerSide::default();
match transport {
_ if args.no_workers => {
tracing::info!("indicatrix-worker serve: --no-workers -- no worker port");
}
tls::Transport::Insecure => tracing::warn!(
"indicatrix-worker serve: --insecure-no-tls -- no worker port (joining workers always need mutual TLS \
and a worker certificate)"
),
tls::Transport::Tls { config, .. } => {
let worker_bind = derived_addr(
args.worker_bind.as_deref(),
bind_addr,
crate::cli::WORKER_PORT_OFFSET,
"--worker-bind",
args.allow_remote,
)?;
let auth = tls::worker_auth(args)?;
let worker_limiter = ConnectionLimiter::new(args.max_connections);
let registry = coordinator::Registry::new(liveness);
coordinator::Registry::spawn_liveness(®istry);
let addr = coordinator::spawn_worker_listener(coordinator::WorkerListenerConfig {
bind_addr: worker_bind,
tls_config: Arc::clone(config),
auth: auth.clone(),
limiter: worker_limiter,
max_connections: args.max_connections,
registry: Arc::clone(®istry),
})?;
side.enroll_addr = start_enrollment(
args,
args.worker_enroll_bind.as_deref(),
worker_bind,
1,
Some(&auth),
)?;
side.addr = Some(addr);
side.registry = Some(registry);
}
}
let own = args.render.then(|| coordinator::OwnLaneSetup {
gpu: Arc::clone(&gpu),
threads: args.threads,
compute_mode: args.compute_mode,
});
let assets = if args.render || side.registry.is_some() {
crate::assets::open_configured(db_path)
} else {
None
};
let coordinator = coordinator::Coordinator::new(
side.registry.clone(),
own,
args.interactive_workers,
u64::from(args.max_job_memory_mib) * 1024 * 1024,
)
.with_interactive_pin(args.pin_interactive_worker.clone())
.with_small_pictures(
args.whole_image_secs,
args.whole_image_pixel_samples,
args.jobs_per_viewer,
)
.with_assets(assets.clone());
if let Some(pin) = coordinator.interactive_pin() {
tracing::info!(
"indicatrix-worker serve: live-view requests that take joined workers use worker {:?} \
first while it is available (--pin-interactive-worker)",
pin.label()
);
}
let coordinator = Arc::new(coordinator);
side.coordinator = Some(Arc::clone(&coordinator));
let render = accept::RenderSetup {
threads: args.threads,
gpu,
compute_mode: args.compute_mode,
own_lane: args.render,
registry: side.registry.clone(),
coordinator,
assets,
payload: args.payload_encoding,
};
Ok((side, render))
}
#[cfg(feature = "worker")]
fn probe_scene() -> indicatrix_net::SceneState {
use indicatrix::{
geometry::cuts::StandardGemCuts,
optics::{materials::GemMaterial, raytracer::LightingPreset},
};
indicatrix_net::SceneState {
width: 512,
height: 512,
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,
}
}
fn start_enrollment(
args: &ServeArgs,
explicit: Option<&str>,
base: SocketAddr,
offset: u16,
auth: Option<&Auth>,
) -> Result<Option<SocketAddr>, String> {
let Some(auth) = auth else {
return Ok(None);
};
if args.no_enroll {
return Ok(None);
}
let (Some(ca), Some(cert), Some(key)) = (&args.ca, &args.cert, &args.key) else {
return Ok(None); };
let flag = match auth.role {
PeerRole::Viewer => "--enroll-bind",
PeerRole::Worker => "--worker-enroll-bind",
};
let bind = derived_addr(explicit, base, offset, flag, args.allow_remote)?;
let config =
enroll::EnrollConfig::build(bind, ca, cert, key, auth.allowlist.clone(), auth.role)?;
enroll::spawn_enroll_listener(config).map(Some)
}
fn checked_addr(addr: &str, flag: &str, allow_remote: bool) -> Result<SocketAddr, String> {
let parsed: SocketAddr = addr
.parse()
.map_err(|e| format!("invalid {flag} address {addr:?}: {e}"))?;
if !parsed.ip().is_loopback() && !allow_remote {
return Err(format!(
"refusing to bind non-loopback address {parsed} ({flag}) without --allow-remote -- exposing this \
server beyond localhost must be explicit (see --help)"
));
}
Ok(parsed)
}
fn derived_addr(
explicit: Option<&str>,
base: SocketAddr,
offset: u16,
flag: &str,
allow_remote: bool,
) -> Result<SocketAddr, String> {
let addr = if let Some(explicit) = explicit {
explicit.to_string()
} else {
let port = if base.port() == 0 {
0
} else {
base.port().checked_add(offset).ok_or_else(|| {
format!(
"{flag}: port {} + {offset} overflows; pass {flag} explicitly",
base.port()
)
})?
};
SocketAddr::new(base.ip(), port).to_string()
};
checked_addr(&addr, flag, allow_remote)
}
const fn transport_summary(transport: &tls::Transport) -> &'static str {
match transport {
tls::Transport::Tls {
auth: Auth {
allowlist: Some(_), ..
},
..
} => "mutual TLS, allowlist enforced",
tls::Transport::Tls { .. } => "mutual TLS, ANY CA-signed client of the right role trusted",
tls::Transport::Insecure => "PLAINTEXT, no TLS",
}
}
#[cfg(feature = "worker")]
fn capability_summary(args: &ServeArgs) -> String {
if !args.render {
return "library + coordinator for joined workers; no own render lane (add --render to render here)"
.to_string();
}
match args.compute_mode {
ComputeMode::OnlyCpu => "library + render (CPU only, --only-cpu)".to_string(),
ComputeMode::OnlyGpu => "library + render (GPU only, --only-gpu)".to_string(),
ComputeMode::Hybrid => "library + render (--render)".to_string(),
}
}
#[cfg(not(feature = "worker"))]
fn capability_summary(_args: &ServeArgs) -> String {
"library only (no render capacity and no worker port -- build with --features worker to add them)"
.to_string()
}