use indicatrix_net::messages::{ClientMessage, ErrorMsg, NetError};
#[cfg(not(feature = "worker"))]
use indicatrix_net::messages::{Hello, PROTOCOL_VERSION, Welcome};
use indicatrix_vault::db::sqlite::Database;
#[cfg(feature = "worker")]
use std::io::Write;
#[cfg(not(feature = "worker"))]
use std::io::{Read, Write};
use std::net::SocketAddr;
pub(super) fn report_connection_result(
peer: Option<SocketAddr>,
result: std::thread::Result<Result<(), NetError>>,
) {
match result {
Ok(Ok(())) => {}
Ok(Err(e)) => tracing::warn!("connection {peer:?} ended with an error: {e}"),
Err(_) => tracing::warn!("connection {peer:?} panicked and was dropped"),
}
}
pub(super) const BUILD_MISMATCH_CODE: u32 = 1;
pub(super) const NO_RENDER_CAPACITY_CODE: u32 = 2;
pub(super) const CONNECTION_LIMIT_REACHED_CODE: u32 = 4;
pub(super) fn refuse_for_capacity<S: Write>(
stream: &mut S,
peer: Option<SocketAddr>,
active: usize,
max: usize,
) {
tracing::info!(
"connection {peer:?}: refusing -- at capacity ({active}/{max} active connections; see --max-connections)"
);
let _ = indicatrix_net::messages::write_message(
stream,
&ErrorMsg {
code: CONNECTION_LIMIT_REACHED_CODE,
message: format!(
"this worker is already handling {max} concurrent connection(s) (--max-connections); try again \
later"
),
},
);
}
#[allow(
unreachable_patterns,
clippy::match_wildcard_for_single_variants,
reason = "the final arm must stay a wildcard: it matches ClientMessage::RenderRequest and \
ClientMessage::TiltCurvesRequest only when indicatrix-net's `render` feature is on. \
That is a DIFFERENT crate's flag from this one's `worker` -- this crate has no \
feature of its own named `render` at all, so `#[cfg(feature = \"render\")]` inside \
THIS crate is always false regardless of whether indicatrix-net's variants actually \
exist (cargo unifies features workspace-wide, so `apps/indicatrix-cut` turning \
indicatrix-net's `render` on can leave this crate's own `worker` feature off while the \
variants are still genuinely in scope -- confirmed by `cargo check -p indicatrix-worker \
--features worker`, which fails to compile a two-cfg-arm version of this match with \
exactly the \"unexpected cfg condition value: render\" + \"non-exhaustive patterns\" \
pair this comment replaces). Spelling the variants out, as clippy suggests, fails to \
compile in a true library-only build (no other workspace member pulling `render` in \
at all) where neither variant exists; the wildcard is correct in every build. Kept \
as `allow` (not `expect`) because firing is conditional on that feature -- \
unconditionally expecting it would warn on every build where the variants ARE \
nameable."
)]
fn handle_non_render_message<S: Write>(
stream: &mut S,
msg: &ClientMessage,
db: &Database,
) -> Result<(), NetError> {
match msg {
ClientMessage::Cancel(c) => {
tracing::debug!(
"received CANCEL for request_id={} with no request currently streaming on this connection -- ignoring",
c.request_id
);
Ok(())
}
ClientMessage::Library(req) => {
let response = super::library::handle_request(req, db);
indicatrix_net::messages::write_message(stream, &response)
}
_ => {
tracing::warn!(
"received a RenderRequest or TiltCurvesRequest, but this worker advertises no \
render/tilt-curve capacity (built without its `worker` feature) -- replying \
with a protocol error"
);
indicatrix_net::messages::write_message(
stream,
&indicatrix_net::messages::StreamEvent::Error(indicatrix_net::messages::ErrorMsg {
code: NO_RENDER_CAPACITY_CODE,
message: "this worker serves the design library only and cannot render or \
compute tilt curves; its WELCOME advertises both capacities as \
absent"
.to_string(),
}),
)
}
}
}
#[cfg(not(feature = "worker"))]
fn serve_until_render_request_or_eof<S: Read + Write>(
stream: &mut S,
db: &Database,
) -> Result<Option<std::convert::Infallible>, NetError> {
loop {
let msg: ClientMessage = match indicatrix_net::messages::read_message(stream) {
Ok(m) => m,
Err(NetError::Framing(indicatrix_net::framing::FramingError::Io(e)))
if e.kind() == std::io::ErrorKind::UnexpectedEof =>
{
return Ok(None);
}
Err(e) => return Err(e),
};
handle_non_render_message(stream, &msg, db)?;
}
}
#[cfg(not(feature = "worker"))]
pub trait ClearHandshakeTimeout {
fn clear_handshake_timeout(&mut self);
}
#[cfg(not(feature = "worker"))]
impl ClearHandshakeTimeout for std::net::TcpStream {
fn clear_handshake_timeout(&mut self) {
let _ = self.set_read_timeout(None);
let _ = self.set_write_timeout(None);
}
}
#[cfg(not(feature = "worker"))]
impl ClearHandshakeTimeout for rustls::StreamOwned<rustls::ServerConnection, std::net::TcpStream> {
fn clear_handshake_timeout(&mut self) {
let _ = self.sock.set_read_timeout(None);
let _ = self.sock.set_write_timeout(None);
}
}
#[cfg(not(feature = "worker"))]
pub fn handle_connection<S: Read + Write + ClearHandshakeTimeout>(
mut stream: S,
db: &Database,
) -> Result<(), NetError> {
let remote_hello: Hello = indicatrix_net::messages::read_message(&mut stream)?;
stream.clear_handshake_timeout();
if remote_hello.protocol_version != PROTOCOL_VERSION {
let message = format!(
"refusing to pair: this worker speaks protocol_version={PROTOCOL_VERSION}, peer speaks \
protocol_version={}",
remote_hello.protocol_version
);
tracing::warn!("{message}");
let _ = indicatrix_net::messages::write_message(
&mut stream,
&ErrorMsg {
code: BUILD_MISMATCH_CODE,
message,
},
);
return Ok(());
}
let welcome = Welcome {
protocol_version: PROTOCOL_VERSION,
build_hash: indicatrix_net::handshake::UNKNOWN_BUILD_HASH,
render: None,
library: true,
tilt_curves: false,
};
indicatrix_net::messages::write_message(&mut stream, &welcome)?;
serve_until_render_request_or_eof(&mut stream, db)?.map_or(Ok(()), |never| match never {})
}
#[cfg(feature = "worker")]
mod worker {
use super::{BUILD_MISMATCH_CODE, Database, handle_non_render_message};
use crate::{
cli::ComputeMode,
render_core,
stream_emit::{self, StreamOutcome, TimeoutRead, TimeoutWrite},
validate,
};
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_net::{
framing::FramingError,
handshake,
messages::{
Backend, ClientMessage, ErrorMsg, Hello, NetError, PROTOCOL_VERSION, RenderCapability,
RenderRequest, StreamEvent, TiltCurvesRequest, Welcome,
},
};
use std::{
io::{Read, Write},
sync::Arc,
};
pub fn handle_connection<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: S,
threads: usize,
db: &Database,
) -> Result<(), NetError> {
handle_connection_with_gpu(
stream,
threads,
&Arc::new(GpuBackend::disabled()),
db,
ComputeMode::OnlyCpu,
)
}
pub fn handle_connection_with_gpu<S: Read + Write + TimeoutRead + TimeoutWrite>(
mut stream: S,
threads: usize,
gpu: &Arc<GpuBackend>,
db: &Database,
compute_mode: ComputeMode,
) -> Result<(), NetError> {
let remote_hello: Hello = indicatrix_net::messages::read_message(&mut stream)?;
let _ = stream.set_read_timeout(None);
let _ = stream.set_write_timeout(None);
let local_hello = handshake::local_hello();
if let Err(incompatible) = handshake::verify_compatible(&local_hello, &remote_hello) {
let message = format!(
"refusing to pair: worker build_hash={:02x?} protocol_version={}, viewer build_hash={:02x?} \
protocol_version={} ({incompatible})",
local_hello.build_hash,
local_hello.protocol_version,
remote_hello.build_hash,
remote_hello.protocol_version
);
tracing::warn!("{message}");
let _ = indicatrix_net::messages::write_message(
&mut stream,
&ErrorMsg {
code: BUILD_MISMATCH_CODE,
message,
},
);
return Ok(());
}
let backend = gpu.adapter_label().map_or_else(
|| Backend::Cpu {
threads: render_core::effective_thread_count(threads) as u32,
},
|adapter| Backend::Gpu { adapter },
);
let welcome = Welcome {
protocol_version: PROTOCOL_VERSION,
build_hash: local_hello.build_hash,
render: Some(RenderCapability {
backend,
max_pixels: validate::MAX_PIXELS,
min_cadence_ms: stream_emit::MIN_CADENCE_FLOOR_MS,
}),
library: true,
tilt_curves: true,
};
indicatrix_net::messages::write_message(&mut stream, &welcome)?;
let mut pending_request: Option<RenderRequest> = None;
loop {
let next = match pending_request.take() {
Some(r) => NextRequest::Render(r),
None => match read_next_message(&mut stream, db)? {
Some(n) => n,
None => return Ok(()),
},
};
let request: RenderRequest = match next {
NextRequest::Render(r) => r,
NextRequest::TiltCurves(tilt_request) => {
crate::serve::tilt::handle_tilt_curves_request(&mut stream, &tilt_request)?;
continue;
}
};
if let Err(msg) =
validate::validate_request(&request.scene, request.first_sample, request.samples)
.and_then(|()| {
validate::validate_stream_config(&request.stream, &request.scene)
})
{
indicatrix_net::messages::write_stream_event(
&mut stream,
&StreamEvent::Error(ErrorMsg {
code: VALIDATION_FAILED_CODE,
message: msg,
}),
None,
)?;
continue;
}
let (outcome, next) =
stream_emit::run_stream(&mut stream, &request, threads, gpu, compute_mode)?;
pending_request = next;
match outcome {
StreamOutcome::Completed => {}
StreamOutcome::TracePanicked => {
tracing::warn!(
"tracing panicked for a request that passed validation (request_id={}, first_sample={}, samples={})",
request.request_id,
request.first_sample,
request.samples
);
indicatrix_net::messages::write_stream_event(
&mut stream,
&StreamEvent::Error(ErrorMsg {
code: TRACE_PANIC_CODE,
message: "internal error while tracing this request".to_string(),
}),
None,
)?;
}
}
}
}
enum NextRequest {
Render(RenderRequest),
TiltCurves(TiltCurvesRequest),
}
fn read_next_message<S: Read + Write>(
stream: &mut S,
db: &Database,
) -> Result<Option<NextRequest>, NetError> {
loop {
let msg: ClientMessage = match indicatrix_net::messages::read_message(stream) {
Ok(m) => m,
Err(NetError::Framing(FramingError::Io(e)))
if e.kind() == std::io::ErrorKind::UnexpectedEof =>
{
return Ok(None);
}
Err(e) => return Err(e),
};
match msg {
ClientMessage::RenderRequest(r) => return Ok(Some(NextRequest::Render(*r))),
ClientMessage::TiltCurvesRequest(r) => {
return Ok(Some(NextRequest::TiltCurves(*r)));
}
other @ (ClientMessage::Cancel(_) | ClientMessage::Library(_)) => {
handle_non_render_message(stream, &other, db)?;
}
}
}
}
pub(in crate::serve) const VALIDATION_FAILED_CODE: u32 = 2;
pub(in crate::serve) const TRACE_PANIC_CODE: u32 = 3;
}
#[cfg(feature = "worker")]
pub(super) use worker::{TRACE_PANIC_CODE, VALIDATION_FAILED_CODE};
#[cfg(feature = "worker")]
pub use worker::{handle_connection, handle_connection_with_gpu};