use super::{NO_RENDER_CAPACITY_CODE, handle_non_render_message};
use crate::{
assets::{self, AssetCache, Fetched, HdrRoute, HeldAsset},
cli::ComputeMode,
coordinator::{self, CapabilityWatch, ViewerSession},
serve::library::LibraryHandle,
stream_emit::{self, StreamOutcome, TimeoutRead, TimeoutWrite, is_stream_timeout},
validate,
};
use indicatrix::renderer::gpu_backend::GpuBackend;
use indicatrix_net::{
framing::{FramingError, IDLE_READ_TIMEOUT},
messages::{
ClientMessage, ErrorMsg, FinalImageRequest, NetError, PayloadEncoding, RenderRequest,
StreamEvent, TiltCurvesRequest, TransferMode, adaptive::PeerLink, error_codes,
},
};
use std::{
io::{Read, Write},
sync::Arc,
};
pub const VALIDATION_FAILED_CODE: u32 = error_codes::VALIDATION_FAILED;
pub const TRACE_PANIC_CODE: u32 = error_codes::TRACE_PANIC;
pub struct RequestContext<'a> {
pub threads: usize,
pub gpu: &'a Arc<GpuBackend>,
pub db: Option<&'a LibraryHandle>,
pub compute_mode: ComputeMode,
pub payload_encoding: PayloadEncoding,
pub link: Option<&'a Arc<PeerLink>>,
pub own_lane: bool,
pub session: Option<&'a ViewerSession>,
pub assets: Option<&'a AssetCache>,
}
fn refuse_unsupported<S: Write>(
stream: &mut S,
what: &str,
request_id: u32,
) -> Result<(), NetError> {
tracing::info!("refusing an unsupported request: {what}");
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Error(ErrorMsg {
code: error_codes::UNSUPPORTED_REQUEST,
message: format!("{what} is not supported by this server (a plain worker)"),
request_id: Some(request_id),
}),
None,
)
}
fn refuse_without_own_lane<S: Write>(stream: &mut S, request_id: u32) -> Result<(), NetError> {
let error = ErrorMsg {
code: NO_RENDER_CAPACITY_CODE,
message: format!(
"RenderRequest (request_id={request_id}): this server has no render lane; its WELCOME \
advertised no render capability"
),
request_id: Some(request_id),
};
tracing::info!("{}", error.message);
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Error(error), None)
}
pub fn serve_requests<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
ctx: &RequestContext<'_>,
) -> Result<(), NetError> {
let mut pending_request: Option<RenderRequest> = None;
let mut watch = ctx.session.and_then(CapabilityWatch::new);
loop {
let next = match pending_request.take() {
Some(r) => NextRequest::Render(r),
None => match read_next_message(stream, ctx.db, watch.as_mut())? {
Some(n) => n,
None => return Ok(()),
},
};
let hdr_pin = match prepare_hdr(stream, &next, ctx)? {
Prepared::Serve(pin) => pin,
Prepared::Skip(next_request) => {
pending_request = next_request.map(|next| *next);
continue;
}
Prepared::Closed => return Ok(()),
};
pending_request = match (next, ctx.session) {
(NextRequest::Render(request), Some(session)) => {
coordinator::serve_render(stream, request, session, hdr_pin.held.clone())?
}
(NextRequest::Render(request), None) if ctx.own_lane => {
serve_one_render(stream, request, ctx)?
}
(NextRequest::Render(request), None) => {
refuse_without_own_lane(stream, request.request_id)?;
None
}
(NextRequest::FinalImage(request), Some(session)) => {
coordinator::serve_final_image(stream, &request, session, hdr_pin.held.clone())?
}
(NextRequest::FinalImage(request), None) => {
refuse_unsupported(
stream,
&format!("FinalImageRequest (request_id={})", request.request_id),
request.request_id,
)?;
None
}
(NextRequest::TiltCurves(tilt_request), Some(session)) => {
coordinator::serve_tilt(stream, &tilt_request, session)?;
None
}
(NextRequest::TiltCurves(tilt_request), None) => {
crate::serve::tilt::handle_tilt_curves_request(stream, &tilt_request)?;
None
}
};
drop(hdr_pin);
}
}
fn serve_one_render<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
mut request: RenderRequest,
ctx: &RequestContext<'_>,
) -> Result<Option<RenderRequest>, NetError> {
if request.stream.transfer_mode == TransferMode::DisplayOnly {
refuse_unsupported(
stream,
&format!(
"TransferMode::DisplayOnly (request_id={})",
request.request_id
),
request.request_id,
)?;
return Ok(None);
}
if let Err(msg) =
validate::validate_request(&request.scene, request.first_sample, request.samples)
.and_then(|()| validate::validate_stream_config(&mut request.stream, &request.scene))
{
indicatrix_net::messages::write_stream_event(
stream,
&StreamEvent::Error(ErrorMsg {
code: VALIDATION_FAILED_CODE,
message: msg,
request_id: Some(request.request_id),
}),
None,
)?;
return Ok(None);
}
let started = std::time::Instant::now();
let (outcome, next) = stream_emit::run_stream(
stream,
&request,
ctx.threads,
ctx.gpu,
ctx.compute_mode,
ctx.payload_encoding,
ctx.link,
)?;
tracing::info!(
request_id = request.request_id,
intent = ?request.intent,
size = %format_args!("{}x{}", request.scene.width, request.scene.height),
samples = request.samples,
route = "plain worker",
elapsed = ?started.elapsed(),
%outcome,
"worker: served a render request"
);
let error = match outcome {
StreamOutcome::Completed => None,
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
);
Some(ErrorMsg {
code: TRACE_PANIC_CODE,
message: "internal error while tracing this request".to_string(),
request_id: Some(request.request_id),
})
}
StreamOutcome::Failed(error) => Some(error),
};
if let Some(error) = error {
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Error(error), None)?;
}
Ok(next)
}
struct HdrPin {
_map: Option<Arc<indicatrix::renderer::env_map::EnvironmentMap>>,
held: Option<Arc<HeldAsset>>,
}
impl HdrPin {
const NONE: Self = Self {
_map: None,
held: None,
};
const fn map(map: Arc<indicatrix::renderer::env_map::EnvironmentMap>) -> Self {
Self {
_map: Some(map),
held: None,
}
}
const fn held(held: Arc<HeldAsset>) -> Self {
Self {
_map: None,
held: Some(held),
}
}
}
enum Prepared {
Serve(HdrPin),
Skip(Option<Box<RenderRequest>>),
Closed,
}
fn prepare_hdr<S: Read + Write + TimeoutRead + TimeoutWrite>(
stream: &mut S,
next: &NextRequest,
ctx: &RequestContext<'_>,
) -> Result<Prepared, NetError> {
let (request_id, scene, first_sample, samples, cadence_ms) = match next {
NextRequest::Render(_) if ctx.session.is_none() && !ctx.own_lane => {
return Ok(Prepared::Serve(HdrPin::NONE));
}
NextRequest::FinalImage(_) if ctx.session.is_none() => {
return Ok(Prepared::Serve(HdrPin::NONE));
}
NextRequest::Render(r) => (
r.request_id,
&r.scene,
r.first_sample,
r.samples,
r.stream.cadence_ms,
),
NextRequest::FinalImage(r) => (r.request_id, &r.scene, r.first_sample, r.samples, 1000),
NextRequest::TiltCurves(_) => return Ok(Prepared::Serve(HdrPin::NONE)),
};
let Some(hdr) = scene.hdr() else {
return Ok(Prepared::Serve(HdrPin::NONE));
};
if validate::validate_request(scene, first_sample, samples).is_err() {
return Ok(Prepared::Serve(HdrPin::NONE));
}
match assets::hdr_route(scene, ctx.assets, ctx.session) {
HdrRoute::NotHdr => return Ok(Prepared::Serve(HdrPin::NONE)),
HdrRoute::Refuse(error) => {
tracing::info!("request {request_id}: {}", error.message);
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Error(error), None)?;
return Ok(Prepared::Skip(None));
}
HdrRoute::Serve => {}
}
let pending = assets::Pending {
request_id,
cadence_ms,
hdr,
};
match (ctx.session, ctx.assets) {
(Some(session), _) => {
let coordinator = &session.coordinator;
let Some(cache) = coordinator.assets() else {
return Ok(Prepared::Serve(HdrPin::NONE)); };
let decode = coordinator.own().is_some();
let fetched = assets::ensure_held(stream, cache, pending, decode)?;
finish_prepare(stream, fetched, HdrPin::held)
}
(None, Some(cache)) => {
let fetched = assets::ensure_environment(stream, cache, pending)?;
finish_prepare(stream, fetched, HdrPin::map)
}
(None, None) => Ok(Prepared::Serve(HdrPin::NONE)),
}
}
fn finish_prepare<S: Write, T>(
stream: &mut S,
fetched: Fetched<T>,
pin: impl FnOnce(T) -> HdrPin,
) -> Result<Prepared, NetError> {
Ok(match fetched {
Fetched::Ready(value) => Prepared::Serve(pin(value)),
Fetched::Failed(error) => {
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Error(error), None)?;
Prepared::Skip(None)
}
Fetched::Superseded(next_request) => Prepared::Skip(next_request),
Fetched::Closed => Prepared::Closed,
})
}
pub fn write_pong<S: Write>(stream: &mut S, nonce: u64) -> Result<(), NetError> {
indicatrix_net::messages::write_stream_event(stream, &StreamEvent::Pong { nonce }, None)
}
enum NextRequest {
Render(RenderRequest),
TiltCurves(TiltCurvesRequest),
FinalImage(FinalImageRequest),
}
fn read_next_message<S: Read + Write + TimeoutRead>(
stream: &mut S,
db: Option<&LibraryHandle>,
mut watch: Option<&mut CapabilityWatch>,
) -> Result<Option<NextRequest>, NetError> {
loop {
let read = if let Some(watch) = watch.as_deref_mut() {
coordinator::read_message_watching(stream, watch)
} else {
let idle = db.is_some().then_some(IDLE_READ_TIMEOUT);
let _ = stream.set_read_timeout(idle);
indicatrix_net::messages::read_control_message(stream).map(Some)
};
let msg: ClientMessage = match read {
Ok(Some(m)) => m,
Ok(None) => return Ok(None),
Err(NetError::Framing(FramingError::Io(e)))
if e.kind() == std::io::ErrorKind::UnexpectedEof =>
{
return Ok(None);
}
Err(NetError::Framing(FramingError::Io(e))) if is_stream_timeout(&e) => {
tracing::info!(
"closing a connection that sent nothing for {} s (idle timeout)",
IDLE_READ_TIMEOUT.as_secs()
);
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)));
}
ClientMessage::FinalImageRequest(r) => {
return Ok(Some(NextRequest::FinalImage(*r)));
}
ClientMessage::Ping { nonce } => write_pong(stream, nonce)?,
ClientMessage::Asset(header) => assets::discard_asset(stream, &header)?,
ClientMessage::Contribution(header) => {
indicatrix_net::messages::discard_contribution_payload(stream, &header)?;
}
other @ (ClientMessage::Cancel(_) | ClientMessage::Library(_)) => {
handle_non_render_message(stream, &other, db)?;
}
}
}
}